1 /*
2 * Copyright (c) 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_scheduler_service.h"
20 #include "work_policy_manager.h"
21 #include "work_status.h"
22 #include "work_sched_errors.h"
23 #include "work_sched_utils.h"
24 #include "watchdog.h"
25
26
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace WorkScheduler {
31 class WorkPolicyManagerTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
TearDownTestCase()34 static void TearDownTestCase() {}
SetUp()35 void SetUp() {}
TearDown()36 void TearDown() {}
37 static std::shared_ptr<WorkPolicyManager> workPolicyManager_;
38 };
39
40 std::shared_ptr<WorkPolicyManager> WorkPolicyManagerTest::workPolicyManager_ = nullptr;
41
SetUpTestCase()42 void WorkPolicyManagerTest::SetUpTestCase()
43 {
44 std::shared_ptr<WorkSchedulerService> workSchedulerService_ = std::make_shared<WorkSchedulerService>();
45 workPolicyManager_ = std::make_shared<WorkPolicyManager>(workSchedulerService_);
46 workPolicyManager_->workConnManager_ = std::make_shared<WorkConnManager>();
47 }
48
49 /**
50 * @tc.name: RealStartWork_001
51 * @tc.desc: Test WorkPolicyManagerTest RealStartWork.
52 * @tc.type: FUNC
53 * @tc.require: I8OLHT
54 */
55 HWTEST_F(WorkPolicyManagerTest, RealStartWork_001, TestSize.Level1)
56 {
57 WorkInfo workinfo;
58 int32_t uid;
59 std::shared_ptr<WorkStatus> topWork = std::make_shared<WorkStatus>(workinfo, uid);
60 workPolicyManager_->RealStartWork(topWork);
61 EXPECT_FALSE(topWork->IsRunning());
62 }
63
64 /**
65 * @tc.name: CheckWorkToRun_001
66 * @tc.desc: Test WorkPolicyManagerTest CheckWorkToRun.
67 * @tc.type: FUNC
68 * @tc.require: I9J0A7
69 */
70 HWTEST_F(WorkPolicyManagerTest, CheckWorkToRun_001, TestSize.Level1)
71 {
72 workPolicyManager_->conditionReadyQueue_->ClearAll();
73 workPolicyManager_->CheckWorkToRun();
74 EXPECT_TRUE(workPolicyManager_->conditionReadyQueue_->GetSize() == 0);
75 }
76
77 /**
78 * @tc.name: AddWork_001
79 * @tc.desc: Test WorkPolicyManagerTest AddWork.
80 * @tc.type: FUNC
81 * @tc.require: I9J0A7
82 */
83 HWTEST_F(WorkPolicyManagerTest, AddWork_001, TestSize.Level1)
84 {
85 workPolicyManager_->uidQueueMap_.clear();
86 WorkInfo workinfo;
87 workinfo.SetWorkId(10000);
88 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
89 workinfo.RequestBatteryLevel(80);
90 int32_t uid = 10000;
91 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
92 int32_t ret = workPolicyManager_->AddWork(workStatus, uid);
93 EXPECT_EQ(ret, ERR_OK);
94 }
95
96 /**
97 * @tc.name: AddWork_002
98 * @tc.desc: Test WorkPolicyManagerTest AddWork.
99 * @tc.type: FUNC
100 * @tc.require: I9J0A7
101 */
102 HWTEST_F(WorkPolicyManagerTest, AddWork_002, TestSize.Level1)
103 {
104 workPolicyManager_->uidQueueMap_.clear();
105 WorkInfo workinfo;
106 workinfo.SetWorkId(10000);
107 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
108 workinfo.RequestBatteryLevel(80);
109 int32_t uid = 10000;
110 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
111 workPolicyManager_->AddWork(workStatus, uid);
112
113 WorkInfo workinfo1;
114 workinfo1.SetWorkId(10000);
115 workinfo1.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
116 workinfo1.RequestBatteryLevel(80);
117 std::shared_ptr<WorkStatus> workStatus1 = std::make_shared<WorkStatus>(workinfo1, uid);
118 int32_t ret = workPolicyManager_->AddWork(workStatus1, uid);
119
120 EXPECT_EQ(ret, E_ADD_REPEAT_WORK_ERR);
121 }
122
123 /**
124 * @tc.name: AddWork_003
125 * @tc.desc: Test WorkPolicyManagerTest AddWork.
126 * @tc.type: FUNC
127 * @tc.require: I9J0A7
128 */
129 HWTEST_F(WorkPolicyManagerTest, AddWork_003, TestSize.Level1)
130 {
131 workPolicyManager_->uidQueueMap_.clear();
132 int32_t uid = 10000;
133 for (int32_t i = 0; i < 10; i++) {
134 WorkInfo workinfo;
135 workinfo.SetWorkId(10000 + i);
136 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
137 workinfo.RequestBatteryLevel(80);
138 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
139 workPolicyManager_->AddWork(workStatus, uid);
140 }
141
142 WorkInfo workinfo1;
143 workinfo1.SetWorkId(10010);
144 workinfo1.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
145 workinfo1.RequestBatteryLevel(80);
146 std::shared_ptr<WorkStatus> workStatus1 = std::make_shared<WorkStatus>(workinfo1, uid);
147 int32_t ret = workPolicyManager_->AddWork(workStatus1, uid);
148
149 EXPECT_EQ(ret, E_WORK_EXCEED_UPPER_LIMIT);
150 }
151
152 /**
153 * @tc.name: RemoveWork_001
154 * @tc.desc: Test WorkPolicyManagerTest RemoveWork.
155 * @tc.type: FUNC
156 * @tc.require: I9J0A7
157 */
158 HWTEST_F(WorkPolicyManagerTest, RemoveWork_001, TestSize.Level1)
159 {
160 workPolicyManager_->uidQueueMap_.clear();
161 WorkInfo workinfo;
162 workinfo.SetWorkId(10000);
163 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
164 workinfo.RequestBatteryLevel(80);
165 int32_t uid = 10000;
166 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
167 bool ret = workPolicyManager_->RemoveWork(workStatus, uid);
168 EXPECT_FALSE(ret);
169 }
170
171 /**
172 * @tc.name: RemoveWork_002
173 * @tc.desc: Test WorkPolicyManagerTest RemoveWork.
174 * @tc.type: FUNC
175 * @tc.require: I9J0A7
176 */
177 HWTEST_F(WorkPolicyManagerTest, RemoveWork_002, TestSize.Level1)
178 {
179 workPolicyManager_->uidQueueMap_.clear();
180 WorkInfo workinfo;
181 workinfo.SetWorkId(10000);
182 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
183 workinfo.RequestBatteryLevel(80);
184 int32_t uid = 10000;
185 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
186 workPolicyManager_->AddWork(workStatus, uid);
187
188 bool ret = workPolicyManager_->RemoveWork(workStatus, uid);
189 EXPECT_TRUE(ret);
190 }
191
192 /**
193 * @tc.name: RemoveWork_003
194 * @tc.desc: Test WorkPolicyManagerTest RemoveWork.
195 * @tc.type: FUNC
196 * @tc.require: I9J0A7
197 */
198 HWTEST_F(WorkPolicyManagerTest, RemoveWork_003, TestSize.Level1)
199 {
200 workPolicyManager_->uidQueueMap_.clear();
201 WorkInfo workinfo;
202 workinfo.SetWorkId(10000);
203 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
204 workinfo.RequestBatteryLevel(80);
205 int32_t uid1 = 10001;
206 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid1);
207 workPolicyManager_->AddWork(workStatus, uid1);
208
209 int32_t uid2 = 10002;
210 bool ret = workPolicyManager_->RemoveWork(workStatus, uid2);
211 EXPECT_FALSE(ret);
212 }
213
214 /**
215 * @tc.name: PauseRunningWorks_001
216 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
217 * @tc.type: FUNC
218 * @tc.require: I9J0A7
219 */
220 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_001, TestSize.Level1)
221 {
222 workPolicyManager_->watchdogIdMap_.clear();
223 int32_t uid = 10000;
224 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
225 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
226 }
227
228 /**
229 * @tc.name: PauseRunningWorks_002
230 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
231 * @tc.type: FUNC
232 * @tc.require: I9J0A7
233 */
234 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_002, TestSize.Level1)
235 {
236 workPolicyManager_->watchdogIdMap_.clear();
237 uint32_t watchdogId = 1;
238 WorkInfo workinfo;
239 workinfo.SetWorkId(10000);
240 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
241 workinfo.RequestBatteryLevel(80);
242 int32_t uid = 10000;
243 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
244 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
245 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
246 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
247 }
248
249 /**
250 * @tc.name: PauseRunningWorks_003
251 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
252 * @tc.type: FUNC
253 * @tc.require: I9J0A7
254 */
255 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_003, TestSize.Level1)
256 {
257 workPolicyManager_->watchdogIdMap_.clear();
258 uint32_t watchdogId = 1;
259 WorkInfo workinfo;
260 workinfo.SetWorkId(10000);
261 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
262 workinfo.RequestBatteryLevel(80);
263 int32_t uid = 10000;
264 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
265 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
266 workStatus->paused_ = true;
267 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
268 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
269 EXPECT_EQ(ret, ERR_OK);
270 }
271
272 /**
273 * @tc.name: PauseRunningWorks_004
274 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
275 * @tc.type: FUNC
276 * @tc.require: I9J0A7
277 */
278 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_004, TestSize.Level1)
279 {
280 workPolicyManager_->watchdogIdMap_.clear();
281 uint32_t watchdogId = 1;
282 WorkInfo workinfo;
283 workinfo.SetWorkId(10000);
284 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
285 workinfo.RequestBatteryLevel(80);
286 int32_t uid = 10000;
287 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
288 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
289 workStatus->paused_ = false;
290 workStatus->workWatchDogTime_ = 120000;
291 workStatus->workStartTime_ = WorkSchedUtils::GetCurrentTimeMs();
292 std::shared_ptr<WorkSchedulerService> workSchedulerService = DelayedSingleton<WorkSchedulerService>::GetInstance();
293 std::shared_ptr<AppExecFwk::EventRunner> runner;
294 std::shared_ptr<Watchdog> watchdog_ =
295 std::make_shared<Watchdog>(workSchedulerService->GetWorkPolicyManager(), runner);
296 workPolicyManager_->watchdog_ = watchdog_;
297 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
298 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
299 EXPECT_EQ(ret, ERR_OK);
300 }
301
302 /**
303 * @tc.name: ResumePausedWorks_001
304 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
305 * @tc.type: FUNC
306 * @tc.require: I9J0A7
307 */
308 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_001, TestSize.Level1)
309 {
310 workPolicyManager_->watchdogIdMap_.clear();
311 int32_t uid = 10000;
312 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
313 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
314 }
315
316 /**
317 * @tc.name: ResumePausedWorks_002
318 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
319 * @tc.type: FUNC
320 * @tc.require: I9J0A7
321 */
322 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_002, TestSize.Level1)
323 {
324 workPolicyManager_->watchdogIdMap_.clear();
325 uint32_t watchdogId = 1;
326 WorkInfo workinfo;
327 workinfo.SetWorkId(10000);
328 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
329 workinfo.RequestBatteryLevel(80);
330 int32_t uid = 10000;
331 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
332 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
333 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
334 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
335 }
336
337 /**
338 * @tc.name: ResumePausedWorks_003
339 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
340 * @tc.type: FUNC
341 * @tc.require: I9J0A7
342 */
343 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_003, TestSize.Level1)
344 {
345 workPolicyManager_->watchdogIdMap_.clear();
346 uint32_t watchdogId = 1;
347 WorkInfo workinfo;
348 workinfo.SetWorkId(10000);
349 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
350 workinfo.RequestBatteryLevel(80);
351 int32_t uid = 10000;
352 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
353 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
354 workStatus->paused_ = false;
355 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
356 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
357 EXPECT_EQ(ret, ERR_OK);
358 }
359
360 /**
361 * @tc.name: ResumePausedWorks_004
362 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
363 * @tc.type: FUNC
364 * @tc.require: I9J0A7
365 */
366 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_004, TestSize.Level1)
367 {
368 workPolicyManager_->watchdogIdMap_.clear();
369 uint32_t watchdogId = 1;
370 WorkInfo workinfo;
371 workinfo.SetWorkId(10000);
372 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
373 workinfo.RequestBatteryLevel(80);
374 int32_t uid = 10000;
375 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
376 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
377 workStatus->paused_ = true;
378 workStatus->workWatchDogTime_ = 120000;
379 workStatus->workStartTime_ = WorkSchedUtils::GetCurrentTimeMs();
380 std::shared_ptr<WorkSchedulerService> workSchedulerService = DelayedSingleton<WorkSchedulerService>::GetInstance();
381 std::shared_ptr<AppExecFwk::EventRunner> runner;
382 std::shared_ptr<Watchdog> watchdog_ =
383 std::make_shared<Watchdog>(workSchedulerService->GetWorkPolicyManager(), runner);
384 workPolicyManager_->watchdog_ = watchdog_;
385 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
386 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
387 EXPECT_EQ(ret, ERR_OK);
388 }
389
390 /**
391 * @tc.name: GetConditionString_001
392 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
393 * @tc.type: FUNC
394 * @tc.require: I9J0A7
395 */
396 HWTEST_F(WorkPolicyManagerTest, GetConditionString_001, TestSize.Level1)
397 {
398 WorkInfo workinfo;
399 workinfo.SetWorkId(10000);
400 int32_t uid = 10000;
401 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
402 std::string ret = workPolicyManager_->GetConditionString(workStatus);
403 EXPECT_TRUE(ret.empty());
404 }
405
406 /**
407 * @tc.name: GetConditionString_002
408 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
409 * @tc.type: FUNC
410 * @tc.require: I9J0A7
411 */
412 HWTEST_F(WorkPolicyManagerTest, GetConditionString_002, TestSize.Level1)
413 {
414 WorkInfo workinfo;
415 workinfo.SetWorkId(10000);
416 workinfo.RequestNetworkType(WorkCondition::Network::NETWORK_TYPE_ANY);
417 int32_t uid = 10000;
418 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
419 std::string ret = workPolicyManager_->GetConditionString(workStatus);
420 EXPECT_FALSE(ret.empty());
421 }
422
423 /**
424 * @tc.name: GetConditionString_003
425 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
426 * @tc.type: FUNC
427 * @tc.require: I9J0A7
428 */
429 HWTEST_F(WorkPolicyManagerTest, GetConditionString_003, TestSize.Level1)
430 {
431 WorkInfo workinfo;
432 workinfo.SetWorkId(10000);
433 workinfo.RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
434 int32_t uid = 10000;
435 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
436 std::string ret = workPolicyManager_->GetConditionString(workStatus);
437 EXPECT_FALSE(ret.empty());
438 }
439
440 /**
441 * @tc.name: GetConditionString_004
442 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
443 * @tc.type: FUNC
444 * @tc.require: I9J0A7
445 */
446 HWTEST_F(WorkPolicyManagerTest, GetConditionString_004, TestSize.Level1)
447 {
448 WorkInfo workinfo;
449 workinfo.SetWorkId(10000);
450 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW_OR_OKAY);
451 int32_t uid = 10000;
452 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
453 std::string ret = workPolicyManager_->GetConditionString(workStatus);
454 EXPECT_FALSE(ret.empty());
455 }
456
457 /**
458 * @tc.name: GetConditionString_005
459 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
460 * @tc.type: FUNC
461 * @tc.require: I9J0A7
462 */
463 HWTEST_F(WorkPolicyManagerTest, GetConditionString_005, TestSize.Level1)
464 {
465 WorkInfo workinfo;
466 workinfo.SetWorkId(10000);
467 workinfo.RequestBatteryLevel(29);
468 int32_t uid = 10000;
469 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
470 std::string ret = workPolicyManager_->GetConditionString(workStatus);
471 EXPECT_FALSE(ret.empty());
472 }
473
474 /**
475 * @tc.name: GetConditionString_006
476 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
477 * @tc.type: FUNC
478 * @tc.require: I9J0A7
479 */
480 HWTEST_F(WorkPolicyManagerTest, GetConditionString_006, TestSize.Level1)
481 {
482 WorkInfo workinfo;
483 workinfo.SetWorkId(10000);
484 workinfo.RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_LOW);
485 int32_t uid = 10000;
486 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
487 std::string ret = workPolicyManager_->GetConditionString(workStatus);
488 EXPECT_FALSE(ret.empty());
489 }
490
491 /**
492 * @tc.name: GetConditionString_007
493 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
494 * @tc.type: FUNC
495 * @tc.require: I9J0A7
496 */
497 HWTEST_F(WorkPolicyManagerTest, GetConditionString_007, TestSize.Level1)
498 {
499 WorkInfo workinfo;
500 workinfo.SetWorkId(10000);
501 workinfo.RequestRepeatCycle(1200000);
502 int32_t uid = 10000;
503 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
504 std::string ret = workPolicyManager_->GetConditionString(workStatus);
505 EXPECT_FALSE(ret.empty());
506 }
507
508 /**
509 * @tc.name: GetConditionString_008
510 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
511 * @tc.type: FUNC
512 * @tc.require: I9J0A7
513 */
514 HWTEST_F(WorkPolicyManagerTest, GetConditionString_008, TestSize.Level1)
515 {
516 WorkInfo workinfo;
517 workinfo.SetWorkId(10000);
518 workinfo.RequestDeepIdle(true);
519 int32_t uid = 10000;
520 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
521 std::string ret = workPolicyManager_->GetConditionString(workStatus);
522 EXPECT_FALSE(ret.empty());
523 }
524
525 /**
526 * @tc.name: FindWorkStatus_001
527 * @tc.desc: Test WorkPolicyManagerTest FindWorkStatus.
528 * @tc.type: FUNC
529 * @tc.require: I9J0A7
530 */
531 HWTEST_F(WorkPolicyManagerTest, FindWorkStatus_001, TestSize.Level1)
532 {
533 workPolicyManager_->uidQueueMap_.clear();
534 WorkInfo workinfo;
535 workinfo.SetWorkId(10000);
536 workinfo.RequestDeepIdle(true);
537 int32_t uid = 10000;
538 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
539 workPolicyManager_->AddWork(workStatus, uid);
540 std::shared_ptr<WorkStatus> ret = workPolicyManager_->FindWorkStatus(workinfo, uid);
541 EXPECT_FALSE(ret == nullptr);
542 }
543
544 /**
545 * @tc.name: FindWorkStatus_002
546 * @tc.desc: Test WorkPolicyManagerTest FindWorkStatus.
547 * @tc.type: FUNC
548 * @tc.require: I9J0A7
549 */
550 HWTEST_F(WorkPolicyManagerTest, FindWorkStatus_002, TestSize.Level1)
551 {
552 workPolicyManager_->uidQueueMap_.clear();
553 WorkInfo workinfo;
554 workinfo.SetWorkId(10000);
555 workinfo.RequestDeepIdle(true);
556 int32_t uid = 10000;
557 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
558 workPolicyManager_->AddWork(workStatus, uid);
559
560 int32_t uid1 = 10001;
561 std::shared_ptr<WorkStatus> ret = workPolicyManager_->FindWorkStatus(workinfo, uid1);
562 EXPECT_TRUE(ret == nullptr);
563 }
564
565 /**
566 * @tc.name: StopWork_001
567 * @tc.desc: Test WorkPolicyManagerTest StopWork.
568 * @tc.type: FUNC
569 * @tc.require: I9J0A7
570 */
571 HWTEST_F(WorkPolicyManagerTest, StopWork_001, TestSize.Level1)
572 {
573 workPolicyManager_->uidQueueMap_.clear();
574 WorkInfo workinfo;
575 workinfo.SetWorkId(10000);
576 workinfo.RequestDeepIdle(true);
577 int32_t uid = 10000;
578 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
579 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
580 bool ret = workPolicyManager_->StopWork(workStatus, uid, false, false);
581 EXPECT_TRUE(ret);
582 }
583
584 /**
585 * @tc.name: StopWork_002
586 * @tc.desc: Test WorkPolicyManagerTest StopWork.
587 * @tc.type: FUNC
588 * @tc.require: I9J0A7
589 */
590 HWTEST_F(WorkPolicyManagerTest, StopWork_002, TestSize.Level1)
591 {
592 workPolicyManager_->uidQueueMap_.clear();
593 WorkInfo workinfo;
594 workinfo.SetWorkId(10000);
595 workinfo.RequestRepeatCycle(1200000);
596 int32_t uid = 10000;
597 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
598 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
599 bool ret = workPolicyManager_->StopWork(workStatus, uid, true, false);
600 EXPECT_TRUE(ret);
601 }
602
603 /**
604 * @tc.name: StopWork_003
605 * @tc.desc: Test WorkPolicyManagerTest StopWork.
606 * @tc.type: FUNC
607 * @tc.require: I9J0A7
608 */
609 HWTEST_F(WorkPolicyManagerTest, StopWork_003, TestSize.Level1)
610 {
611 workPolicyManager_->uidQueueMap_.clear();
612 WorkInfo workinfo;
613 workinfo.SetWorkId(10000);
614 workinfo.RequestRepeatCycle(1200000);
615 int32_t uid = 10000;
616 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
617 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
618 bool ret = workPolicyManager_->StopWork(workStatus, uid, true, false);
619 EXPECT_TRUE(ret);
620 }
621
622 /**
623 * @tc.name: StopWork_004
624 * @tc.desc: Test WorkPolicyManagerTest StopWork.
625 * @tc.type: FUNC
626 * @tc.require: I9J0A7
627 */
628 HWTEST_F(WorkPolicyManagerTest, StopWork_004, TestSize.Level1)
629 {
630 workPolicyManager_->uidQueueMap_.clear();
631 WorkInfo workinfo;
632 workinfo.SetWorkId(10000);
633 workinfo.RequestDeepIdle(true);
634 int32_t uid = 10000;
635 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
636 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
637 bool ret = workPolicyManager_->StopWork(workStatus, uid, false, true);
638 EXPECT_TRUE(ret);
639 }
640
641 /**
642 * @tc.name: StopAndClearWorks_001
643 * @tc.desc: Test WorkPolicyManagerTest StopAndClearWorks.
644 * @tc.type: FUNC
645 * @tc.require: I9J0A7
646 */
647 HWTEST_F(WorkPolicyManagerTest, StopAndClearWorks_001, TestSize.Level1)
648 {
649 workPolicyManager_->uidQueueMap_.clear();
650 WorkInfo workinfo;
651 workinfo.SetWorkId(10000);
652 workinfo.RequestDeepIdle(true);
653 int32_t uid = 10000;
654 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
655 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
656 workPolicyManager_->AddWork(workStatus, uid);
657
658 bool ret = workPolicyManager_->StopAndClearWorks(uid);
659 EXPECT_TRUE(ret);
660 }
661
662 /**
663 * @tc.name: IsLastWorkTimeout_001
664 * @tc.desc: Test WorkPolicyManagerTest IsLastWorkTimeout.
665 * @tc.type: FUNC
666 * @tc.require: I9J0A7
667 */
668 HWTEST_F(WorkPolicyManagerTest, IsLastWorkTimeout_001, TestSize.Level1)
669 {
670 workPolicyManager_->uidQueueMap_.clear();
671 WorkInfo workinfo;
672 int32_t workId = 10000;
673 workinfo.SetWorkId(workId);
674 workinfo.RequestDeepIdle(true);
675 int32_t uid = 10000;
676 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
677 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
678 workStatus->lastTimeout_ = true;
679 workPolicyManager_->AddWork(workStatus, uid);
680
681 bool ret = false;
682 ret = workPolicyManager_->IsLastWorkTimeout(workId, uid, ret);
683 EXPECT_TRUE(ret);
684 }
685
686 /**
687 * @tc.name: OnConditionReady_001
688 * @tc.desc: Test WorkPolicyManagerTest OnConditionReady.
689 * @tc.type: FUNC
690 * @tc.require: I9J0A7
691 */
692 HWTEST_F(WorkPolicyManagerTest, OnConditionReady_001, TestSize.Level1)
693 {
694 std::vector<std::shared_ptr<WorkStatus>> readyWorkVector = {};
695 std::shared_ptr<std::vector<std::shared_ptr<WorkStatus>>> readyWork =
696 std::make_shared<std::vector<std::shared_ptr<WorkStatus>>>(readyWorkVector);
697 workPolicyManager_->OnConditionReady(readyWork);
698 EXPECT_TRUE(readyWork != nullptr);
699 }
700
701 /**
702 * @tc.name: OnConditionReady_002
703 * @tc.desc: Test WorkPolicyManagerTest OnConditionReady.
704 * @tc.type: FUNC
705 * @tc.require: I9J0A7
706 */
707 HWTEST_F(WorkPolicyManagerTest, OnConditionReady_002, TestSize.Level1)
708 {
709 std::vector<std::shared_ptr<WorkStatus>> readyWorkVector;
710 WorkInfo workinfo;
711 int32_t workId = 10000;
712 workinfo.SetWorkId(workId);
713 workinfo.RequestDeepIdle(true);
714 int32_t uid = 10000;
715 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
716 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
717 workStatus->lastTimeout_ = true;
718 readyWorkVector.emplace_back(workStatus);
719 std::shared_ptr<std::vector<std::shared_ptr<WorkStatus>>> readyWork =
720 std::make_shared<std::vector<std::shared_ptr<WorkStatus>>>(readyWorkVector);
721 workPolicyManager_->OnConditionReady(readyWork);
722 EXPECT_FALSE(readyWork == nullptr);
723 }
724
725 /**
726 * @tc.name: AddToReadyQueue_001
727 * @tc.desc: Test WorkPolicyManagerTest AddToReadyQueue.
728 * @tc.type: FUNC
729 * @tc.require: I9J0A7
730 */
731 HWTEST_F(WorkPolicyManagerTest, AddToReadyQueue_001, TestSize.Level1)
732 {
733 std::vector<std::shared_ptr<WorkStatus>> readyWorkVector;
734 WorkInfo workinfo;
735 int32_t workId = 10000;
736 workinfo.SetWorkId(workId);
737 workinfo.RequestDeepIdle(true);
738 int32_t uid = 10000;
739 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
740 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
741 workStatus->lastTimeout_ = true;
742 readyWorkVector.emplace_back(workStatus);
743 std::shared_ptr<std::vector<std::shared_ptr<WorkStatus>>> readyWork =
744 std::make_shared<std::vector<std::shared_ptr<WorkStatus>>>(readyWorkVector);
745 workPolicyManager_->AddToReadyQueue(readyWork);
746 EXPECT_FALSE(readyWork == nullptr);
747 }
748
749 /**
750 * @tc.name: GetMaxRunningCount_001
751 * @tc.desc: Test WorkPolicyManagerTest GetMaxRunningCount.
752 * @tc.type: FUNC
753 * @tc.require: I9J0A7
754 */
755 HWTEST_F(WorkPolicyManagerTest, GetMaxRunningCount_001, TestSize.Level1)
756 {
757 workPolicyManager_->dumpSetMaxRunningCount_ = 2;
758 std::string policyName;
759 int32_t ret = workPolicyManager_->GetMaxRunningCount(policyName);
760 EXPECT_TRUE(ret == workPolicyManager_->dumpSetMaxRunningCount_);
761 }
762
763 /**
764 * @tc.name: GetMaxRunningCount_002
765 * @tc.desc: Test WorkPolicyManagerTest GetMaxRunningCount.
766 * @tc.type: FUNC
767 * @tc.require: I9J0A7
768 */
769 HWTEST_F(WorkPolicyManagerTest, GetMaxRunningCount_002, TestSize.Level1)
770 {
771 workPolicyManager_->dumpSetMaxRunningCount_ = 0;
772 std::string policyName;
773 int32_t ret = workPolicyManager_->GetMaxRunningCount(policyName);
774 EXPECT_TRUE(ret >= workPolicyManager_->dumpSetMaxRunningCount_);
775 }
776
777 /**
778 * @tc.name: GetRunningCount_001
779 * @tc.desc: Test WorkPolicyManagerTest GetRunningCount.
780 * @tc.type: FUNC
781 * @tc.require: I9J0A7
782 */
783 HWTEST_F(WorkPolicyManagerTest, GetRunningCount_001, TestSize.Level1)
784 {
785 workPolicyManager_->uidQueueMap_.clear();
786 WorkInfo workinfo;
787 int32_t workId = 10000;
788 workinfo.SetWorkId(workId);
789 workinfo.RequestDeepIdle(true);
790 int32_t uid = 10000;
791 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
792 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
793 workPolicyManager_->AddWork(workStatus, uid);
794
795 int32_t ret = workPolicyManager_->GetRunningCount();
796 EXPECT_TRUE(ret == 1);
797 }
798
799 /**
800 * @tc.name: FindWork_001
801 * @tc.desc: Test WorkPolicyManagerTest FindWork.
802 * @tc.type: FUNC
803 * @tc.require: I9J0A7
804 */
805 HWTEST_F(WorkPolicyManagerTest, FindWork_001, TestSize.Level1)
806 {
807 workPolicyManager_->uidQueueMap_.clear();
808 WorkInfo workinfo;
809 int32_t workId = 10000;
810 workinfo.SetWorkId(workId);
811 workinfo.RequestDeepIdle(true);
812 int32_t uid = 10000;
813 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
814 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
815 workPolicyManager_->AddWork(workStatus, uid);
816
817 bool ret = workPolicyManager_->FindWork(uid);
818 EXPECT_TRUE(ret);
819 }
820
821 /**
822 * @tc.name: FindWork_002
823 * @tc.desc: Test WorkPolicyManagerTest FindWork.
824 * @tc.type: FUNC
825 * @tc.require: I9J0A7
826 */
827 HWTEST_F(WorkPolicyManagerTest, FindWork_002, TestSize.Level1)
828 {
829 workPolicyManager_->uidQueueMap_.clear();
830 WorkInfo workinfo;
831 workinfo.bundleName_ = "com.test.demo";
832 int32_t workId = 10000;
833 workinfo.SetWorkId(workId);
834 workinfo.RequestDeepIdle(true);
835 int32_t uid = 10000;
836 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
837 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
838 workStatus->userId_ = 100;
839 workPolicyManager_->AddWork(workStatus, uid);
840
841 bool ret = workPolicyManager_->FindWork(workStatus->userId_, workStatus->bundleName_);
842 EXPECT_TRUE(ret);
843 }
844
845 /**
846 * @tc.name: FindWork_003
847 * @tc.desc: Test WorkPolicyManagerTest FindWork.
848 * @tc.type: FUNC
849 * @tc.require: I9J0A7
850 */
851 HWTEST_F(WorkPolicyManagerTest, FindWork_003, TestSize.Level1)
852 {
853 workPolicyManager_->uidQueueMap_.clear();
854 WorkInfo workinfo;
855 workinfo.bundleName_ = "com.test.demo";
856 int32_t workId = 10000;
857 workinfo.SetWorkId(workId);
858 workinfo.RequestDeepIdle(true);
859 int32_t uid = 10000;
860 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
861 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
862 workStatus->userId_ = 100;
863
864 bool ret = workPolicyManager_->FindWork(workStatus->userId_, workStatus->bundleName_);
865 EXPECT_FALSE(ret);
866 }
867
868 /**
869 * @tc.name: GetDeepIdleWorks_001
870 * @tc.desc: Test WorkPolicyManagerTest GetDeepIdleWorks.
871 * @tc.type: FUNC
872 * @tc.require: I9J0A7
873 */
874 HWTEST_F(WorkPolicyManagerTest, GetDeepIdleWorks_001, TestSize.Level1)
875 {
876 workPolicyManager_->uidQueueMap_.clear();
877 WorkInfo workinfo;
878 workinfo.bundleName_ = "com.test.demo";
879 int32_t workId = 10000;
880 workinfo.SetWorkId(workId);
881 workinfo.RequestDeepIdle(true);
882 int32_t uid = 10000;
883 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
884 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
885 workStatus->userId_ = 100;
886 workPolicyManager_->AddWork(workStatus, uid);
887
888 std::list<std::shared_ptr<WorkStatus>> ret = workPolicyManager_->GetDeepIdleWorks();
889 EXPECT_TRUE(ret.size() > 0);
890 }
891 }
892 }