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 class WorkStatusTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
TearDownTestCase()31 static void TearDownTestCase() {}
SetUp()32 void SetUp() {}
TearDown()33 void TearDown() {}
34 static std::shared_ptr<WorkStatus> workStatus_;
35 static std::shared_ptr<WorkInfo> workInfo_;
36 };
37
38 std::shared_ptr<WorkStatus> WorkStatusTest::workStatus_ = nullptr;
39 std::shared_ptr<WorkInfo> WorkStatusTest::workInfo_ = nullptr;
40
SetUpTestCase()41 void WorkStatusTest::SetUpTestCase()
42 {
43 workInfo_ = std::make_shared<WorkInfo>();
44 workInfo_->SetWorkId(-1);
45 std::string bundleName = "com.example.workStatus";
46 std::string abilityName = "workStatusAbility";
47 workInfo_->SetElement(bundleName, abilityName);
48 workInfo_->RequestPersisted(false);
49 time_t baseTime;
50 (void)time(&baseTime);
51 workInfo_->RequestBaseTime(baseTime);
52 workStatus_ = std::make_shared<WorkStatus>(*(workInfo_.get()), -1);
53 }
54
55 /**
56 * @tc.name: makeWorkId_001
57 * @tc.desc: Test WorkStatus MakeWorkId.
58 * @tc.type: FUNC
59 * @tc.require: I95QHG
60 */
61 HWTEST_F(WorkStatusTest, makeWorkId_001, TestSize.Level1)
62 {
63 std::string result = workStatus_->MakeWorkId(1, 1);
64 EXPECT_EQ(result, "u1_1");
65 }
66
67 /**
68 * @tc.name: isSameUser_001
69 * @tc.desc: Test WorkStatus IsSameUser.
70 * @tc.type: FUNC
71 * @tc.require: I95QHG
72 */
73 HWTEST_F(WorkStatusTest, isSameUser_001, TestSize.Level1)
74 {
75 workStatus_->uid_ = -1;
76 bool result = workStatus_->IsSameUser();
77 EXPECT_TRUE(result);
78 }
79
80 /**
81 * @tc.name: isSameUser_002
82 * @tc.desc: Test WorkStatus IsSameUser.
83 * @tc.type: FUNC
84 * @tc.require: I95QHG
85 */
86 HWTEST_F(WorkStatusTest, isSameUser_002, TestSize.Level1)
87 {
88 workStatus_->uid_ = 1;
89 bool result = workStatus_->IsSameUser();
90 EXPECT_TRUE(result);
91 }
92
93 /**
94 * @tc.name: isUriKeySwitchOn_001
95 * @tc.desc: Test WorkStatus IsUriKeySwitchOn.
96 * @tc.type: FUNC
97 * @tc.require: I95QHG
98 */
99 HWTEST_F(WorkStatusTest, isUriKeySwitchOn_001, TestSize.Level1)
100 {
101 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
102 workInfo_->SetPreinstalled(false);
103 workStatus_->workInfo_ = workInfo_;
104 bool result = workStatus_->IsUriKeySwitchOn();
105 EXPECT_TRUE(result);
106 }
107
108 /**
109 * @tc.name: isUriKeySwitchOn_002
110 * @tc.desc: Test WorkStatus IsUriKeySwitchOn.
111 * @tc.type: FUNC
112 * @tc.require: I95QHG
113 */
114 HWTEST_F(WorkStatusTest, isUriKeySwitchOn_002, TestSize.Level1)
115 {
116 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
117 workInfo_->SetPreinstalled(true);
118 workInfo_->workId_ = 1;
119 workStatus_->workInfo_ = workInfo_;
120 bool result = workStatus_->IsUriKeySwitchOn();
121 EXPECT_FALSE(result);
122 }
123
124 /**
125 * @tc.name: isUriKeySwitchOn_003
126 * @tc.desc: Test WorkStatus IsUriKeySwitchOn.
127 * @tc.type: FUNC
128 * @tc.require: I95QHG
129 */
130 HWTEST_F(WorkStatusTest, isUriKeySwitchOn_003, TestSize.Level1)
131 {
132 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
133 workInfo_->workId_ = 1;
134 workInfo_->SetPreinstalled(true);
135 workInfo_->uriKey_ = "key";
136 workStatus_->workInfo_ = workInfo_;
137 bool result = workStatus_->IsUriKeySwitchOn();
138 EXPECT_FALSE(result);
139 }
140
141 /**
142 * @tc.name: isReady_001
143 * @tc.desc: Test WorkStatus IsReady.
144 * @tc.type: FUNC
145 * @tc.require: I95QHG
146 */
147 HWTEST_F(WorkStatusTest, isReady_001, TestSize.Level1)
148 {
149 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
150 workInfo_->workId_ = -1;
151 workStatus_->MarkStatus(WorkStatus::Status::RUNNING);
152 workStatus_->workInfo_ = workInfo_;
153 bool result = workStatus_->IsReady();
154 EXPECT_FALSE(result);
155 }
156
157 /**
158 * @tc.name: isReady_002
159 * @tc.desc: Test WorkStatus IsReady.
160 * @tc.type: FUNC
161 * @tc.require: I95QHG
162 */
163 HWTEST_F(WorkStatusTest, isReady_002, TestSize.Level1)
164 {
165 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
166 workInfo_->workId_ = -1;
167 workInfo_->RequestNetworkType(WorkCondition::Network::NETWORK_UNKNOWN);
168 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
169 workStatus_->workInfo_ = workInfo_;
170 bool result = workStatus_->IsReady();
171 EXPECT_FALSE(result);
172 }
173
174 /**
175 * @tc.name: isReady_003
176 * @tc.desc: Test WorkStatus IsReady.
177 * @tc.type: FUNC
178 * @tc.require: I95QHG
179 */
180 HWTEST_F(WorkStatusTest, isReady_003, TestSize.Level1)
181 {
182 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
183 workInfo_->workId_ = -1;
184 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
185 workInfo_->RequestNetworkType(WorkCondition::Network::NETWORK_TYPE_BLUETOOTH);
186 std::shared_ptr<Condition> networkCondition = std::make_shared<Condition>();
187 networkCondition->enumVal = WorkCondition::Network::NETWORK_TYPE_ETHERNET;
188 workStatus_->conditionMap_.emplace(WorkCondition::Type::NETWORK, networkCondition);
189 workStatus_->workInfo_ = workInfo_;
190 bool result = workStatus_->IsReady();
191 EXPECT_FALSE(result);
192 }
193
194 /**
195 * @tc.name: isReady_004
196 * @tc.desc: Test WorkStatus IsReady.
197 * @tc.type: FUNC
198 * @tc.require: I95QHG
199 */
200 HWTEST_F(WorkStatusTest, isReady_004, TestSize.Level1)
201 {
202 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
203 workInfo_->workId_ = -1;
204 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
205 workInfo_->RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
206 std::shared_ptr<Condition> batteryCondition = std::make_shared<Condition>();
207 batteryCondition->enumVal = WorkCondition::BatteryStatus::BATTERY_STATUS_OKAY;
208 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_STATUS, batteryCondition);
209 workStatus_->workInfo_ = workInfo_;
210 bool result = workStatus_->IsReady();
211 EXPECT_FALSE(result);
212 }
213
214 /**
215 * @tc.name: isReady_005
216 * @tc.desc: Test WorkStatus IsReady.
217 * @tc.type: FUNC
218 * @tc.require: I95QHG
219 */
220 HWTEST_F(WorkStatusTest, isReady_005, TestSize.Level1)
221 {
222 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
223 workInfo_->workId_ = -1;
224 workInfo_->RequestBatteryLevel(80);
225 std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
226 batteryLevelCondition->intVal = 70;
227 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
228 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
229 workStatus_->workInfo_ = workInfo_;
230 bool result = workStatus_->IsReady();
231 EXPECT_FALSE(result);
232 }
233
234 /**
235 * @tc.name: isReady_006
236 * @tc.desc: Test WorkStatus IsReady.
237 * @tc.type: FUNC
238 * @tc.require: I95QHG
239 */
240 HWTEST_F(WorkStatusTest, isReady_006, TestSize.Level1)
241 {
242 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
243 workInfo_->workId_ = -1;
244 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
245 workInfo_->RequestBatteryLevel(60);
246 workInfo_->SetPreinstalled(true);
247 std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
248 batteryLevelCondition->intVal = 70;
249 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
250 workStatus_->workInfo_ = workInfo_;
251 bool result = workStatus_->IsReady();
252 EXPECT_FALSE(result);
253 }
254
255 /**
256 * @tc.name: isReady_007
257 * @tc.desc: Test WorkStatus IsReady.
258 * @tc.type: FUNC
259 * @tc.require: I95QHG
260 */
261 HWTEST_F(WorkStatusTest, isReady_007, TestSize.Level1)
262 {
263 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
264 workInfo_->workId_ = -1;
265 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
266 workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
267 std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
268 storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_LOW;
269 workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
270 workStatus_->workInfo_ = workInfo_;
271 bool result = workStatus_->IsReady();
272 EXPECT_FALSE(result);
273 }
274
275 /**
276 * @tc.name: isReady_008
277 * @tc.desc: Test WorkStatus IsReady.
278 * @tc.type: FUNC
279 * @tc.require: I95QHG
280 */
281 HWTEST_F(WorkStatusTest, isReady_008, TestSize.Level1)
282 {
283 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
284 workInfo_->workId_ = -1;
285 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
286 uint32_t timeInterval = 1200;
287 workInfo_->RequestRepeatCycle(timeInterval);
288 workInfo_->SetPreinstalled(true);
289 workStatus_->workInfo_ = workInfo_;
290
291 std::shared_ptr<Condition> timerCondition = std::make_shared<Condition>();
292 timerCondition->boolVal = true;
293 timerCondition->uintVal = 7200001;
294 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition);
295 bool result = workStatus_->IsReady();
296 EXPECT_FALSE(result);
297 }
298
299 /**
300 * @tc.name: isReady_009
301 * @tc.desc: Test WorkStatus IsReady.
302 * @tc.type: FUNC
303 * @tc.require: I95QHG
304 */
305 HWTEST_F(WorkStatusTest, isReady_009, TestSize.Level1)
306 {
307 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
308 workInfo_->workId_ = -1;
309 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
310 workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
311 std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
312 storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_OKAY;
313 workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
314 workStatus_->workInfo_ = workInfo_;
315 bool result = workStatus_->IsReady();
316 EXPECT_FALSE(result);
317 }
318
319 /**
320 * @tc.name: isReady_0010
321 * @tc.desc: Test WorkStatus IsReady.
322 * @tc.type: FUNC
323 * @tc.require: I95QHG
324 */
325 HWTEST_F(WorkStatusTest, isReady_0010, TestSize.Level1)
326 {
327 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
328 workInfo_->workId_ = -1;
329 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
330 workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
331 workStatus_->workInfo_ = workInfo_;
332 bool result = workStatus_->IsReady();
333 EXPECT_FALSE(result);
334 }
335
336 /**
337 * @tc.name: isReady_0011
338 * @tc.desc: Test WorkStatus IsReady.
339 * @tc.type: FUNC
340 * @tc.require: I95QHG
341 */
342 HWTEST_F(WorkStatusTest, isReady_0011, TestSize.Level1)
343 {
344 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
345 workInfo_->workId_ = -1;
346 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
347 workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
348 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
349 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
350 chargingCondition->boolVal = false;
351 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
352 workStatus_->workInfo_ = workInfo_;
353 bool result = workStatus_->IsReady();
354 EXPECT_FALSE(result);
355 }
356
357 /**
358 * @tc.name: isReady_0012
359 * @tc.desc: Test WorkStatus IsReady.
360 * @tc.type: FUNC
361 * @tc.require: I95QHG
362 */
363 HWTEST_F(WorkStatusTest, isReady_0012, TestSize.Level1)
364 {
365 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
366 workInfo_->workId_ = -1;
367 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
368 workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
369 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
370 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
371 chargingCondition->boolVal = true;
372 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
373 workStatus_->workInfo_ = workInfo_;
374 bool result = workStatus_->IsReady();
375 EXPECT_FALSE(result);
376 }
377
378 /**
379 * @tc.name: isReady_0013
380 * @tc.desc: Test WorkStatus IsReady.
381 * @tc.type: FUNC
382 * @tc.require: I95QHG
383 */
384 HWTEST_F(WorkStatusTest, isReady_0013, TestSize.Level1)
385 {
386 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
387 workInfo_->workId_ = -1;
388 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
389 workInfo_->RequestChargerType(false, WorkCondition::Charger::CHARGING_PLUGGED_AC);
390 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
391 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
392 chargingCondition->boolVal = false;
393 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
394 workStatus_->workInfo_ = workInfo_;
395 bool result = workStatus_->IsReady();
396 EXPECT_FALSE(result);
397 }
398
399 /**
400 * @tc.name: isReady_0014
401 * @tc.desc: Test WorkStatus IsReady.
402 * @tc.type: FUNC
403 * @tc.require: I95QHG
404 */
405 HWTEST_F(WorkStatusTest, isReady_0014, TestSize.Level1)
406 {
407 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
408 workInfo_->workId_ = -1;
409 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
410 workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
411 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
412 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_AC;
413 chargingCondition->boolVal = true;
414 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
415 workStatus_->workInfo_ = workInfo_;
416 bool result = workStatus_->IsReady();
417 EXPECT_FALSE(result);
418 }
419
420 /**
421 * @tc.name: dump_001
422 * @tc.desc: Test WorkStatus Dump.
423 * @tc.type: FUNC
424 * @tc.require: I95QHG
425 */
426 HWTEST_F(WorkStatusTest, dump_001, TestSize.Level1)
427 {
428 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
429 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_AC;
430 chargingCondition->boolVal = true;
431 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
432
433 std::shared_ptr<Condition> networkCondition = std::make_shared<Condition>();
434 networkCondition->enumVal = WorkCondition::Network::NETWORK_TYPE_ANY;
435 workStatus_->conditionMap_.emplace(WorkCondition::Type::NETWORK, networkCondition);
436
437 std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
438 batteryLevelCondition->intVal = 66;
439 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
440
441 std::shared_ptr<Condition> batteryStatusCondition = std::make_shared<Condition>();
442 batteryStatusCondition->enumVal = WorkCondition::BatteryStatus::BATTERY_STATUS_OKAY;
443 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_STATUS, batteryStatusCondition);
444
445 std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
446 storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_OKAY;
447 workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
448
449 std::shared_ptr<Condition> timerCondition = std::make_shared<Condition>();
450 timerCondition->boolVal = false;
451 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition);
452
453 std::string result;
454 workStatus_->Dump(result);
455 bool ret = result.empty();
456 EXPECT_FALSE(ret);
457 }
458
459 /**
460 * @tc.name: dump_002
461 * @tc.desc: Test WorkStatus Dump.
462 * @tc.type: FUNC
463 * @tc.require: I95QHG
464 */
465 HWTEST_F(WorkStatusTest, dump_002, TestSize.Level1)
466 {
467 workStatus_->workInfo_->saId_ = 1000;
468 workStatus_->workInfo_->residentSa_ = true;
469
470 std::string result;
471 workStatus_->Dump(result);
472 EXPECT_TRUE(workStatus_->workInfo_->IsSA());
473 }
474
475 /**
476 * @tc.name: getMinInterval_001
477 * @tc.desc: Test WorkStatus GetMinInterval.
478 * @tc.type: FUNC
479 * @tc.require: I95QHG
480 */
481 HWTEST_F(WorkStatusTest, getMinInterval_001, TestSize.Level1)
482 {
483 int64_t interval = 7200000;
484 workStatus_->SetMinIntervalByDump(interval);
485 int64_t ret = workStatus_->GetMinInterval();
486 EXPECT_TRUE(ret == interval);
487 }
488
489 /**
490 * @tc.name: isRepeating_001
491 * @tc.desc: Test WorkStatus IsRepeating.
492 * @tc.type: FUNC
493 * @tc.require: I95QHG
494 */
495 HWTEST_F(WorkStatusTest, isRepeating_001, TestSize.Level1)
496 {
497 workStatus_->conditionMap_.erase(WorkCondition::Type::TIMER);
498 bool ret = workStatus_->IsRepeating();
499 EXPECT_FALSE(ret);
500
501 std::shared_ptr<Condition> timerCondition = std::make_shared<Condition>();
502 timerCondition->boolVal = true;
503 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition);
504 bool ret1 = workStatus_->IsRepeating();
505 EXPECT_TRUE(ret1);
506
507 std::shared_ptr<Condition> timerCondition1 = std::make_shared<Condition>();
508 timerCondition1->boolVal = false;
509 timerCondition1->intVal = 1200;
510 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition1);
511 bool ret2 = workStatus_->IsRepeating();
512 EXPECT_TRUE(ret2);
513 }
514
515 /**
516 * @tc.name: IsReadyStatus_001
517 * @tc.desc: Test WorkStatus IsReadyStatus.
518 * @tc.type: FUNC
519 * @tc.require: IAJSVG
520 */
521 HWTEST_F(WorkStatusTest, IsReadyStatus_001, TestSize.Level1)
522 {
523 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
524 bool ret = workStatus_->IsReadyStatus();
525 EXPECT_FALSE(ret);
526 }
527
528 /**
529 * @tc.name: IsRemoved_001
530 * @tc.desc: Test WorkStatus IsRemoved.
531 * @tc.type: FUNC
532 * @tc.require: IAJSVG
533 */
534 HWTEST_F(WorkStatusTest, IsRemoved_001, TestSize.Level1)
535 {
536 workStatus_->MarkStatus(WorkStatus::Status::REMOVED);
537 bool ret = workStatus_->IsRemoved();
538 EXPECT_TRUE(ret);
539 workStatus_->MarkRound();
540 }
541
542 /**
543 * @tc.name: NeedRemove_001
544 * @tc.desc: Test WorkStatus NeedRemove.
545 * @tc.type: FUNC
546 * @tc.require: IAJSVG
547 */
548 HWTEST_F(WorkStatusTest, NeedRemove_001, TestSize.Level1)
549 {
550 workStatus_->conditionMap_.clear();
551 bool ret = workStatus_->NeedRemove();
552 EXPECT_TRUE(ret);
553 }
554
555 /**
556 * @tc.name: NeedRemove_002
557 * @tc.desc: Test WorkStatus NeedRemove.
558 * @tc.type: FUNC
559 * @tc.require: IAJSVG
560 */
561 HWTEST_F(WorkStatusTest, NeedRemove_002, TestSize.Level1)
562 {
563 workStatus_->conditionMap_.clear();
564 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
565 repeatCycle->boolVal = true;
566 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
567 bool ret = workStatus_->NeedRemove();
568 EXPECT_FALSE(ret);
569 }
570
571 /**
572 * @tc.name: NeedRemove_003
573 * @tc.desc: Test WorkStatus NeedRemove.
574 * @tc.type: FUNC
575 * @tc.require: IAJSVG
576 */
577 HWTEST_F(WorkStatusTest, NeedRemove_003, TestSize.Level1)
578 {
579 workStatus_->conditionMap_.clear();
580 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
581 repeatCycle->boolVal = false;
582 repeatCycle->intVal = 0;
583 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
584 bool ret = workStatus_->NeedRemove();
585 EXPECT_TRUE(ret);
586 }
587
588 /**
589 * @tc.name: NeedRemove_004
590 * @tc.desc: Test WorkStatus NeedRemove.
591 * @tc.type: FUNC
592 * @tc.require: IAJSVG
593 */
594 HWTEST_F(WorkStatusTest, NeedRemove_004, TestSize.Level1)
595 {
596 workStatus_->conditionMap_.clear();
597 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
598 repeatCycle->boolVal = false;
599 repeatCycle->intVal = 1;
600 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
601 bool ret = workStatus_->NeedRemove();
602 EXPECT_FALSE(ret);
603 }
604
605 /**
606 * @tc.name: UpdateTimerIfNeed_001
607 * @tc.desc: Test WorkStatus UpdateTimerIfNeed.
608 * @tc.type: FUNC
609 * @tc.require: IAJSVG
610 */
611 HWTEST_F(WorkStatusTest, UpdateTimerIfNeed_001, TestSize.Level1)
612 {
613 workStatus_->conditionMap_.clear();
614 workStatus_->UpdateTimerIfNeed();
615
616 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
617 repeatCycle->boolVal = false;
618 repeatCycle->intVal = 1;
619 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
620 workStatus_->UpdateTimerIfNeed();
621 EXPECT_TRUE(repeatCycle->intVal == 0);
622 }
623
624 /**
625 * @tc.name: UpdateTimerIfNeed_002
626 * @tc.desc: Test WorkStatus UpdateTimerIfNeed.
627 * @tc.type: FUNC
628 * @tc.require: IAJSVG
629 */
630 HWTEST_F(WorkStatusTest, UpdateTimerIfNeed_002, TestSize.Level1)
631 {
632 workStatus_->conditionMap_.clear();
633 workStatus_->UpdateTimerIfNeed();
634
635 std::shared_ptr<Condition> repeatCycle = std::make_shared<Condition>();
636 repeatCycle->boolVal = true;
637 repeatCycle->intVal = 1;
638 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, repeatCycle);
639 workStatus_->UpdateTimerIfNeed();
640 EXPECT_TRUE(repeatCycle->intVal == 1);
641 }
642
643 /**
644 * @tc.name: MarkTimeout_001
645 * @tc.desc: Test WorkStatus MarkTimeout.
646 * @tc.type: FUNC
647 * @tc.require: IAJSVG
648 */
649 HWTEST_F(WorkStatusTest, MarkTimeout_001, TestSize.Level1)
650 {
651 workStatus_->MarkTimeout();
652 bool ret = workStatus_->IsLastWorkTimeout();
653 EXPECT_TRUE(ret);
654 }
655
656 /**
657 * @tc.name: IsNapReady_001
658 * @tc.desc: Test WorkStatus IsNapReady.
659 * @tc.type: FUNC
660 * @tc.require: IAJSVG
661 */
662 HWTEST_F(WorkStatusTest, IsNapReady_001, TestSize.Level1)
663 {
664 WorkInfo workInfo = WorkInfo();
665 std::shared_ptr<Condition> repeatCycle1 = std::make_shared<Condition>();
666 repeatCycle1->boolVal = true;
667 workInfo.conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle1);
668 workStatus_->workInfo_ = std::make_shared<WorkInfo>(workInfo);
669
670 std::shared_ptr<Condition> repeatCycle2 = std::make_shared<Condition>();
671 repeatCycle2->boolVal = false;
672 workStatus_->conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle2);
673
674 bool ret = workStatus_->IsNapReady(WorkCondition::Type::DEEP_IDLE);
675 EXPECT_FALSE(ret);
676 }
677
678 /**
679 * @tc.name: IsNapReady_002
680 * @tc.desc: Test WorkStatus IsNapReady.
681 * @tc.type: FUNC
682 * @tc.require: IAJSVG
683 */
684 HWTEST_F(WorkStatusTest, IsNapReady_002, TestSize.Level1)
685 {
686 WorkInfo workInfo = WorkInfo();
687 std::shared_ptr<Condition> repeatCycle1 = std::make_shared<Condition>();
688 repeatCycle1->boolVal = true;
689 workInfo.conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle1);
690 workStatus_->workInfo_ = std::make_shared<WorkInfo>(workInfo);
691
692 std::shared_ptr<Condition> repeatCycle2 = std::make_shared<Condition>();
693 repeatCycle2->boolVal = true;
694 workStatus_->conditionMap_.emplace(WorkCondition::Type::DEEP_IDLE, repeatCycle2);
695
696 bool ret = workStatus_->IsNapReady(WorkCondition::Type::DEEP_IDLE);
697 EXPECT_FALSE(ret);
698 }
699
700 /**
701 * @tc.name: UpdateUidLastTimeMap_001
702 * @tc.desc: Test WorkStatus UpdateUidLastTimeMap.
703 * @tc.type: FUNC
704 * @tc.require: IAJSVG
705 */
706 HWTEST_F(WorkStatusTest, UpdateUidLastTimeMap_001, TestSize.Level1)
707 {
708 workStatus_->s_uid_last_time_map.clear();
709 workStatus_->uid_ = 1;
710 workStatus_->UpdateUidLastTimeMap();
711 workStatus_->ClearUidLastTimeMap(1);
712 EXPECT_TRUE(workStatus_->s_uid_last_time_map.empty());
713 }
714
715 /**
716 * @tc.name: GetStatus_001
717 * @tc.desc: Test WorkStatus GetStatus.
718 * @tc.type: FUNC
719 * @tc.require: IAJSVG
720 */
721 HWTEST_F(WorkStatusTest, GetStatus_001, TestSize.Level1)
722 {
723 workStatus_->MarkStatus(WorkStatus::Status::RUNNING);
724 EXPECT_EQ(workStatus_->GetStatus(), WorkStatus::Status::RUNNING);
725 }
726
727 /**
728 * @tc.name: IsSAReady_001
729 * @tc.desc: Test WorkStatus IsSAReady.
730 * @tc.type: FUNC
731 * @tc.require: I95QHG
732 */
733 HWTEST_F(WorkStatusTest, IsSAReady_001, TestSize.Level1)
734 {
735 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
736 workInfo_->workId_ = -1;
737 workStatus_->MarkStatus(WorkStatus::Status::RUNNING);
738 workStatus_->workInfo_ = workInfo_;
739 bool result = workStatus_->IsSAReady();
740 EXPECT_TRUE(result);
741 }
742
743 /**
744 * @tc.name: IsSAReady_002
745 * @tc.desc: Test WorkStatus IsSAReady.
746 * @tc.type: FUNC
747 * @tc.require: I95QHG
748 */
749 HWTEST_F(WorkStatusTest, IsSAReady_002, TestSize.Level1)
750 {
751 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
752 workInfo_->workId_ = -1;
753 workInfo_->RequestNetworkType(WorkCondition::Network::NETWORK_UNKNOWN);
754 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
755 workStatus_->workInfo_ = workInfo_;
756 bool result = workStatus_->IsSAReady();
757 EXPECT_FALSE(result);
758 }
759
760 /**
761 * @tc.name: IsSAReady_003
762 * @tc.desc: Test WorkStatus IsSAReady.
763 * @tc.type: FUNC
764 * @tc.require: I95QHG
765 */
766 HWTEST_F(WorkStatusTest, IsSAReady_003, TestSize.Level1)
767 {
768 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
769 workInfo_->workId_ = -1;
770 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
771 workInfo_->RequestNetworkType(WorkCondition::Network::NETWORK_TYPE_BLUETOOTH);
772 std::shared_ptr<Condition> networkCondition = std::make_shared<Condition>();
773 networkCondition->enumVal = WorkCondition::Network::NETWORK_TYPE_ETHERNET;
774 workStatus_->conditionMap_.emplace(WorkCondition::Type::NETWORK, networkCondition);
775 workStatus_->workInfo_ = workInfo_;
776 bool result = workStatus_->IsSAReady();
777 EXPECT_FALSE(result);
778 }
779
780 /**
781 * @tc.name: IsSAReady_004
782 * @tc.desc: Test WorkStatus IsSAReady.
783 * @tc.type: FUNC
784 * @tc.require: I95QHG
785 */
786 HWTEST_F(WorkStatusTest, IsSAReady_004, TestSize.Level1)
787 {
788 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
789 workInfo_->workId_ = -1;
790 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
791 workInfo_->RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
792 std::shared_ptr<Condition> batteryCondition = std::make_shared<Condition>();
793 batteryCondition->enumVal = WorkCondition::BatteryStatus::BATTERY_STATUS_OKAY;
794 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_STATUS, batteryCondition);
795 workStatus_->workInfo_ = workInfo_;
796 bool result = workStatus_->IsSAReady();
797 EXPECT_FALSE(result);
798 }
799
800 /**
801 * @tc.name: IsSAReady_005
802 * @tc.desc: Test WorkStatus IsSAReady.
803 * @tc.type: FUNC
804 * @tc.require: I95QHG
805 */
806 HWTEST_F(WorkStatusTest, IsSAReady_005, TestSize.Level1)
807 {
808 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
809 workInfo_->workId_ = -1;
810 workInfo_->RequestBatteryLevel(80);
811 std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
812 batteryLevelCondition->intVal = 70;
813 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
814 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
815 workStatus_->workInfo_ = workInfo_;
816 bool result = workStatus_->IsSAReady();
817 EXPECT_FALSE(result);
818 }
819
820 /**
821 * @tc.name: IsSAReady_006
822 * @tc.desc: Test WorkStatus IsSAReady.
823 * @tc.type: FUNC
824 * @tc.require: I95QHG
825 */
826 HWTEST_F(WorkStatusTest, IsSAReady_006, TestSize.Level1)
827 {
828 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
829 workInfo_->workId_ = -1;
830 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
831 workInfo_->RequestBatteryLevel(60);
832 workInfo_->SetPreinstalled(true);
833 std::shared_ptr<Condition> batteryLevelCondition = std::make_shared<Condition>();
834 batteryLevelCondition->intVal = 70;
835 workStatus_->conditionMap_.emplace(WorkCondition::Type::BATTERY_LEVEL, batteryLevelCondition);
836 workStatus_->workInfo_ = workInfo_;
837 bool result = workStatus_->IsSAReady();
838 EXPECT_TRUE(result);
839 }
840
841 /**
842 * @tc.name: IsSAReady_007
843 * @tc.desc: Test WorkStatus IsSAReady.
844 * @tc.type: FUNC
845 * @tc.require: I95QHG
846 */
847 HWTEST_F(WorkStatusTest, IsSAReady_007, TestSize.Level1)
848 {
849 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
850 workInfo_->workId_ = -1;
851 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
852 workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
853 std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
854 storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_LOW;
855 workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
856 workStatus_->workInfo_ = workInfo_;
857 bool result = workStatus_->IsSAReady();
858 EXPECT_FALSE(result);
859 }
860
861 /**
862 * @tc.name: IsSAReady_008
863 * @tc.desc: Test WorkStatus IsSAReady.
864 * @tc.type: FUNC
865 * @tc.require: I95QHG
866 */
867 HWTEST_F(WorkStatusTest, IsSAReady_008, TestSize.Level1)
868 {
869 workStatus_->s_uid_last_time_map.clear();
870 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
871 workInfo_->workId_ = -1;
872 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
873 uint32_t timeInterval = 1200;
874 workInfo_->RequestRepeatCycle(timeInterval);
875 workInfo_->SetPreinstalled(true);
876 workStatus_->workInfo_ = workInfo_;
877
878 std::shared_ptr<Condition> timerCondition = std::make_shared<Condition>();
879 timerCondition->boolVal = true;
880 timerCondition->uintVal = 7200001;
881 workStatus_->conditionMap_.emplace(WorkCondition::Type::TIMER, timerCondition);
882 bool result = workStatus_->IsSAReady();
883 EXPECT_TRUE(result);
884 }
885
886 /**
887 * @tc.name: IsSAReady_009
888 * @tc.desc: Test WorkStatus IsSAReady.
889 * @tc.type: FUNC
890 * @tc.require: I95QHG
891 */
892 HWTEST_F(WorkStatusTest, IsSAReady_009, TestSize.Level1)
893 {
894 workStatus_->s_uid_last_time_map.clear();
895 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
896 workInfo_->workId_ = -1;
897 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
898 workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
899 std::shared_ptr<Condition> storageCondition = std::make_shared<Condition>();
900 storageCondition->enumVal = WorkCondition::Storage::STORAGE_LEVEL_OKAY;
901 workStatus_->conditionMap_.emplace(WorkCondition::Type::STORAGE, storageCondition);
902 workStatus_->workInfo_ = workInfo_;
903 bool result = workStatus_->IsSAReady();
904 EXPECT_FALSE(result);
905 }
906
907 /**
908 * @tc.name: IsSAReady_0010
909 * @tc.desc: Test WorkStatus IsSAReady.
910 * @tc.type: FUNC
911 * @tc.require: I95QHG
912 */
913 HWTEST_F(WorkStatusTest, IsSAReady_0010, TestSize.Level1)
914 {
915 workStatus_->s_uid_last_time_map.clear();
916 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
917 workInfo_->workId_ = -1;
918 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
919 workInfo_->RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_OKAY);
920 workStatus_->workInfo_ = workInfo_;
921 bool result = workStatus_->IsSAReady();
922 EXPECT_FALSE(result);
923 }
924
925 /**
926 * @tc.name: IsSAReady_0011
927 * @tc.desc: Test WorkStatus IsSAReady.
928 * @tc.type: FUNC
929 * @tc.require: I95QHG
930 */
931 HWTEST_F(WorkStatusTest, IsSAReady_0011, TestSize.Level1)
932 {
933 workStatus_->s_uid_last_time_map.clear();
934 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
935 workInfo_->workId_ = -1;
936 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
937 workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
938 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
939 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
940 chargingCondition->boolVal = false;
941 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
942 workStatus_->workInfo_ = workInfo_;
943 bool result = workStatus_->IsSAReady();
944 EXPECT_FALSE(result);
945 }
946
947 /**
948 * @tc.name: IsSAReady_0012
949 * @tc.desc: Test WorkStatus IsSAReady.
950 * @tc.type: FUNC
951 * @tc.require: I95QHG
952 */
953 HWTEST_F(WorkStatusTest, IsSAReady_0012, TestSize.Level1)
954 {
955 workStatus_->s_uid_last_time_map.clear();
956 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
957 workInfo_->workId_ = -1;
958 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
959 workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
960 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
961 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
962 chargingCondition->boolVal = true;
963 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
964 workStatus_->workInfo_ = workInfo_;
965 bool result = workStatus_->IsSAReady();
966 EXPECT_FALSE(result);
967 }
968
969 /**
970 * @tc.name: IsSAReady_0013
971 * @tc.desc: Test WorkStatus IsSAReady.
972 * @tc.type: FUNC
973 * @tc.require: I95QHG
974 */
975 HWTEST_F(WorkStatusTest, IsSAReady_0013, TestSize.Level1)
976 {
977 workStatus_->s_uid_last_time_map.clear();
978 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
979 workInfo_->workId_ = -1;
980 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
981 workInfo_->RequestChargerType(false, WorkCondition::Charger::CHARGING_PLUGGED_AC);
982 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
983 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_USB;
984 chargingCondition->boolVal = false;
985 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
986 workStatus_->workInfo_ = workInfo_;
987 bool result = workStatus_->IsSAReady();
988 EXPECT_FALSE(result);
989 }
990
991 /**
992 * @tc.name: IsSAReady_0014
993 * @tc.desc: Test WorkStatus IsSAReady.
994 * @tc.type: FUNC
995 * @tc.require: I95QHG
996 */
997 HWTEST_F(WorkStatusTest, IsSAReady_0014, TestSize.Level1)
998 {
999 workStatus_->s_uid_last_time_map.clear();
1000 std::shared_ptr<WorkInfo> workInfo_ = std::make_shared<WorkInfo>();
1001 workInfo_->workId_ = -1;
1002 workStatus_->MarkStatus(WorkStatus::Status::WAIT_CONDITION);
1003 workInfo_->RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
1004 std::shared_ptr<Condition> chargingCondition = std::make_shared<Condition>();
1005 chargingCondition->enumVal = WorkCondition::Charger::CHARGING_PLUGGED_AC;
1006 chargingCondition->boolVal = true;
1007 workStatus_->conditionMap_.emplace(WorkCondition::Type::CHARGER, chargingCondition);
1008 workStatus_->workInfo_ = workInfo_;
1009 bool result = workStatus_->IsSAReady();
1010 EXPECT_FALSE(result);
1011 }
1012
1013 /**
1014 * @tc.name: ToString_001
1015 * @tc.desc: Test WorkStatus ToString.
1016 * @tc.type: FUNC
1017 * @tc.require: I95QHG
1018 */
1019 HWTEST_F(WorkStatusTest, ToString_001, TestSize.Level1)
1020 {
1021 workStatus_->conditionStatus_.clear();
1022 workStatus_->ToString(WorkCondition::Type::TIMER);
1023 EXPECT_TRUE(workStatus_->conditionStatus_.empty());
1024 }
1025
1026 /**
1027 * @tc.name: ToString_002
1028 * @tc.desc: Test WorkStatus ToString.
1029 * @tc.type: FUNC
1030 * @tc.require: I95QHG
1031 */
1032 HWTEST_F(WorkStatusTest, ToString_002, TestSize.Level1)
1033 {
1034 workStatus_->conditionStatus_.clear();
1035 workStatus_->conditionStatus_ = "TIMER&ready";
1036 workStatus_->workInfo_->saId_ = 1000;
1037 workStatus_->workInfo_->residentSa_ = true;
1038 workStatus_->ToString(WorkCondition::Type::TIMER);
1039 EXPECT_FALSE(workStatus_->conditionStatus_.empty());
1040 }
1041
1042 /**
1043 * @tc.name: ToString_003
1044 * @tc.desc: Test WorkStatus ToString.
1045 * @tc.type: FUNC
1046 * @tc.require: I95QHG
1047 */
1048 HWTEST_F(WorkStatusTest, ToString_003, TestSize.Level1)
1049 {
1050 workStatus_->conditionStatus_.clear();
1051 workStatus_->conditionStatus_ = "TIMER&ready";
1052 workStatus_->ToString(WorkCondition::Type::TIMER);
1053 EXPECT_FALSE(workStatus_->conditionStatus_.empty());
1054 }
1055 }
1056 }