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 #include "gmock/gmock.h"
19
20 #include "work_scheduler_service.h"
21 #include "work_policy_manager.h"
22 #include "work_status.h"
23 #include "work_sched_errors.h"
24 #include "work_sched_utils.h"
25 #include "work_sched_constants.h"
26 #include "watchdog.h"
27
28
29 using namespace testing::ext;
30 using ::testing::Return;
31
32 namespace OHOS {
33 namespace WorkScheduler {
34 class WorkPolicyManagerTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
TearDownTestCase()37 static void TearDownTestCase() {}
SetUp()38 void SetUp() {}
TearDown()39 void TearDown() {}
40 static std::shared_ptr<WorkPolicyManager> workPolicyManager_;
41 };
42
43 class MockPolicyFilter : public IPolicyFilter {
44 public:
MockPolicyFilter(std::shared_ptr<WorkPolicyManager> workPolicyManager)45 explicit MockPolicyFilter(std::shared_ptr<WorkPolicyManager> workPolicyManager){};
~MockPolicyFilter()46 ~MockPolicyFilter(){};
47 int32_t maxRunningCount;
48
GetPolicyMaxRunning(WorkSchedSystemPolicy & systemPolicy)49 int32_t GetPolicyMaxRunning(WorkSchedSystemPolicy& systemPolicy) override
50 {
51 return maxRunningCount;
52 }
53 };
54
55 std::shared_ptr<WorkPolicyManager> WorkPolicyManagerTest::workPolicyManager_ = nullptr;
56
SetUpTestCase()57 void WorkPolicyManagerTest::SetUpTestCase()
58 {
59 std::shared_ptr<WorkSchedulerService> workSchedulerService_ = std::make_shared<WorkSchedulerService>();
60 workPolicyManager_ = std::make_shared<WorkPolicyManager>(workSchedulerService_);
61 workPolicyManager_->workConnManager_ = std::make_shared<WorkConnManager>();
62 }
63
64 /**
65 * @tc.name: RealStartWork_001
66 * @tc.desc: Test WorkPolicyManagerTest RealStartWork.
67 * @tc.type: FUNC
68 * @tc.require: I8OLHT
69 */
70 HWTEST_F(WorkPolicyManagerTest, RealStartWork_001, TestSize.Level1)
71 {
72 WorkInfo workinfo;
73 int32_t uid;
74 std::shared_ptr<WorkStatus> topWork = std::make_shared<WorkStatus>(workinfo, uid);
75 workPolicyManager_->RealStartWork(topWork);
76 EXPECT_FALSE(topWork->IsRunning());
77 }
78
79 /**
80 * @tc.name: CheckWorkToRun_001
81 * @tc.desc: Test WorkPolicyManagerTest CheckWorkToRun.
82 * @tc.type: FUNC
83 * @tc.require: I9J0A7
84 */
85 HWTEST_F(WorkPolicyManagerTest, CheckWorkToRun_001, TestSize.Level1)
86 {
87 workPolicyManager_->conditionReadyQueue_->ClearAll();
88 workPolicyManager_->CheckWorkToRun();
89 EXPECT_TRUE(workPolicyManager_->conditionReadyQueue_->GetSize() == 0);
90 }
91
92 /**
93 * @tc.name: AddWork_001
94 * @tc.desc: Test WorkPolicyManagerTest AddWork.
95 * @tc.type: FUNC
96 * @tc.require: I9J0A7
97 */
98 HWTEST_F(WorkPolicyManagerTest, AddWork_001, TestSize.Level1)
99 {
100 workPolicyManager_->uidQueueMap_.clear();
101 WorkInfo workinfo;
102 workinfo.SetWorkId(10000);
103 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
104 workinfo.RequestBatteryLevel(80);
105 int32_t uid = 10000;
106 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
107 int32_t ret = workPolicyManager_->AddWork(workStatus, uid);
108 EXPECT_EQ(ret, ERR_OK);
109 }
110
111 /**
112 * @tc.name: AddWork_002
113 * @tc.desc: Test WorkPolicyManagerTest AddWork.
114 * @tc.type: FUNC
115 * @tc.require: I9J0A7
116 */
117 HWTEST_F(WorkPolicyManagerTest, AddWork_002, TestSize.Level1)
118 {
119 workPolicyManager_->uidQueueMap_.clear();
120 WorkInfo workinfo;
121 workinfo.SetWorkId(10000);
122 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
123 workinfo.RequestBatteryLevel(80);
124 int32_t uid = 10000;
125 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
126 workPolicyManager_->AddWork(workStatus, uid);
127
128 WorkInfo workinfo1;
129 workinfo1.SetWorkId(10000);
130 workinfo1.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
131 workinfo1.RequestBatteryLevel(80);
132 std::shared_ptr<WorkStatus> workStatus1 = std::make_shared<WorkStatus>(workinfo1, uid);
133 int32_t ret = workPolicyManager_->AddWork(workStatus1, uid);
134
135 EXPECT_EQ(ret, E_ADD_REPEAT_WORK_ERR);
136 }
137
138 /**
139 * @tc.name: AddWork_003
140 * @tc.desc: Test WorkPolicyManagerTest AddWork.
141 * @tc.type: FUNC
142 * @tc.require: I9J0A7
143 */
144 HWTEST_F(WorkPolicyManagerTest, AddWork_003, TestSize.Level1)
145 {
146 workPolicyManager_->uidQueueMap_.clear();
147 int32_t uid = 10000;
148 for (int32_t i = 0; i < 10; i++) {
149 WorkInfo workinfo;
150 workinfo.SetWorkId(10000 + i);
151 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
152 workinfo.RequestBatteryLevel(80);
153 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
154 workPolicyManager_->AddWork(workStatus, uid);
155 }
156
157 WorkInfo workinfo1;
158 workinfo1.SetWorkId(10010);
159 workinfo1.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
160 workinfo1.RequestBatteryLevel(80);
161 std::shared_ptr<WorkStatus> workStatus1 = std::make_shared<WorkStatus>(workinfo1, uid);
162 int32_t ret = workPolicyManager_->AddWork(workStatus1, uid);
163
164 EXPECT_EQ(ret, E_WORK_EXCEED_UPPER_LIMIT);
165 }
166
167 /**
168 * @tc.name: RemoveWork_001
169 * @tc.desc: Test WorkPolicyManagerTest RemoveWork.
170 * @tc.type: FUNC
171 * @tc.require: I9J0A7
172 */
173 HWTEST_F(WorkPolicyManagerTest, RemoveWork_001, TestSize.Level1)
174 {
175 workPolicyManager_->uidQueueMap_.clear();
176 WorkInfo workinfo;
177 workinfo.SetWorkId(10000);
178 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
179 workinfo.RequestBatteryLevel(80);
180 int32_t uid = 10000;
181 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
182 bool ret = workPolicyManager_->RemoveWork(workStatus, uid);
183 EXPECT_FALSE(ret);
184 }
185
186 /**
187 * @tc.name: RemoveWork_002
188 * @tc.desc: Test WorkPolicyManagerTest RemoveWork.
189 * @tc.type: FUNC
190 * @tc.require: I9J0A7
191 */
192 HWTEST_F(WorkPolicyManagerTest, RemoveWork_002, TestSize.Level1)
193 {
194 workPolicyManager_->uidQueueMap_.clear();
195 WorkInfo workinfo;
196 workinfo.SetWorkId(10000);
197 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
198 workinfo.RequestBatteryLevel(80);
199 int32_t uid = 10000;
200 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
201 workPolicyManager_->AddWork(workStatus, uid);
202
203 bool ret = workPolicyManager_->RemoveWork(workStatus, uid);
204 EXPECT_TRUE(ret);
205 }
206
207 /**
208 * @tc.name: RemoveWork_003
209 * @tc.desc: Test WorkPolicyManagerTest RemoveWork.
210 * @tc.type: FUNC
211 * @tc.require: I9J0A7
212 */
213 HWTEST_F(WorkPolicyManagerTest, RemoveWork_003, TestSize.Level1)
214 {
215 workPolicyManager_->uidQueueMap_.clear();
216 WorkInfo workinfo;
217 workinfo.SetWorkId(10000);
218 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
219 workinfo.RequestBatteryLevel(80);
220 int32_t uid1 = 10001;
221 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid1);
222 workPolicyManager_->AddWork(workStatus, uid1);
223
224 int32_t uid2 = 10002;
225 bool ret = workPolicyManager_->RemoveWork(workStatus, uid2);
226 EXPECT_FALSE(ret);
227 }
228
229 /**
230 * @tc.name: PauseRunningWorks_001
231 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
232 * @tc.type: FUNC
233 * @tc.require: I9J0A7
234 */
235 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_001, TestSize.Level1)
236 {
237 workPolicyManager_->watchdogIdMap_.clear();
238 int32_t uid = 10000;
239 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
240 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
241 }
242
243 /**
244 * @tc.name: PauseRunningWorks_002
245 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
246 * @tc.type: FUNC
247 * @tc.require: I9J0A7
248 */
249 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_002, TestSize.Level1)
250 {
251 workPolicyManager_->watchdogIdMap_.clear();
252 uint32_t watchdogId = 1;
253 WorkInfo workinfo;
254 workinfo.SetWorkId(10000);
255 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
256 workinfo.RequestBatteryLevel(80);
257 int32_t uid = 10000;
258 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
259 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
260 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
261 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
262 }
263
264 /**
265 * @tc.name: PauseRunningWorks_003
266 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
267 * @tc.type: FUNC
268 * @tc.require: I9J0A7
269 */
270 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_003, TestSize.Level1)
271 {
272 workPolicyManager_->watchdogIdMap_.clear();
273 uint32_t watchdogId = 1;
274 WorkInfo workinfo;
275 workinfo.SetWorkId(10000);
276 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
277 workinfo.RequestBatteryLevel(80);
278 int32_t uid = 10000;
279 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
280 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
281 workStatus->paused_ = true;
282 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
283 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
284 EXPECT_EQ(ret, ERR_OK);
285 }
286
287 /**
288 * @tc.name: PauseRunningWorks_004
289 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
290 * @tc.type: FUNC
291 * @tc.require: I9J0A7
292 */
293 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_004, TestSize.Level1)
294 {
295 workPolicyManager_->watchdogIdMap_.clear();
296 uint32_t watchdogId = 1;
297 WorkInfo workinfo;
298 workinfo.SetWorkId(10000);
299 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
300 workinfo.RequestBatteryLevel(80);
301 int32_t uid = 10000;
302 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
303 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
304 workStatus->paused_ = false;
305 workStatus->workWatchDogTime_ = 120000;
306 workStatus->workStartTime_ = WorkSchedUtils::GetCurrentTimeMs();
307 std::shared_ptr<WorkSchedulerService> workSchedulerService = DelayedSingleton<WorkSchedulerService>::GetInstance();
308 std::shared_ptr<AppExecFwk::EventRunner> runner;
309 std::shared_ptr<Watchdog> watchdog_ =
310 std::make_shared<Watchdog>(workSchedulerService->GetWorkPolicyManager(), runner);
311 workPolicyManager_->watchdog_ = watchdog_;
312 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
313 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
314 EXPECT_EQ(ret, ERR_OK);
315 }
316
317 /**
318 * @tc.name: ResumePausedWorks_001
319 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
320 * @tc.type: FUNC
321 * @tc.require: I9J0A7
322 */
323 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_001, TestSize.Level1)
324 {
325 workPolicyManager_->watchdogIdMap_.clear();
326 int32_t uid = 10000;
327 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
328 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
329 }
330
331 /**
332 * @tc.name: ResumePausedWorks_002
333 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
334 * @tc.type: FUNC
335 * @tc.require: I9J0A7
336 */
337 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_002, TestSize.Level1)
338 {
339 workPolicyManager_->watchdogIdMap_.clear();
340 uint32_t watchdogId = 1;
341 WorkInfo workinfo;
342 workinfo.SetWorkId(10000);
343 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
344 workinfo.RequestBatteryLevel(80);
345 int32_t uid = 10000;
346 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
347 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
348 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
349 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
350 }
351
352 /**
353 * @tc.name: ResumePausedWorks_003
354 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
355 * @tc.type: FUNC
356 * @tc.require: I9J0A7
357 */
358 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_003, TestSize.Level1)
359 {
360 workPolicyManager_->watchdogIdMap_.clear();
361 uint32_t watchdogId = 1;
362 WorkInfo workinfo;
363 workinfo.SetWorkId(10000);
364 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
365 workinfo.RequestBatteryLevel(80);
366 int32_t uid = 10000;
367 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
368 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
369 workStatus->paused_ = false;
370 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
371 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
372 EXPECT_EQ(ret, ERR_OK);
373 }
374
375 /**
376 * @tc.name: ResumePausedWorks_004
377 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
378 * @tc.type: FUNC
379 * @tc.require: I9J0A7
380 */
381 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_004, TestSize.Level1)
382 {
383 workPolicyManager_->watchdogIdMap_.clear();
384 uint32_t watchdogId = 1;
385 WorkInfo workinfo;
386 workinfo.SetWorkId(10000);
387 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
388 workinfo.RequestBatteryLevel(80);
389 int32_t uid = 10000;
390 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
391 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
392 workStatus->paused_ = true;
393 workStatus->workWatchDogTime_ = 120000;
394 workStatus->workStartTime_ = WorkSchedUtils::GetCurrentTimeMs();
395 std::shared_ptr<WorkSchedulerService> workSchedulerService = DelayedSingleton<WorkSchedulerService>::GetInstance();
396 std::shared_ptr<AppExecFwk::EventRunner> runner;
397 std::shared_ptr<Watchdog> watchdog_ =
398 std::make_shared<Watchdog>(workSchedulerService->GetWorkPolicyManager(), runner);
399 workPolicyManager_->watchdog_ = watchdog_;
400 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
401 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
402 EXPECT_EQ(ret, ERR_OK);
403 }
404
405 /**
406 * @tc.name: GetConditionString_001
407 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
408 * @tc.type: FUNC
409 * @tc.require: I9J0A7
410 */
411 HWTEST_F(WorkPolicyManagerTest, GetConditionString_001, TestSize.Level1)
412 {
413 WorkInfo workinfo;
414 workinfo.SetWorkId(10000);
415 int32_t uid = 10000;
416 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
417 std::string ret = workPolicyManager_->GetConditionString(workStatus);
418 EXPECT_TRUE(ret.empty());
419 }
420
421 /**
422 * @tc.name: GetConditionString_002
423 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
424 * @tc.type: FUNC
425 * @tc.require: I9J0A7
426 */
427 HWTEST_F(WorkPolicyManagerTest, GetConditionString_002, TestSize.Level1)
428 {
429 WorkInfo workinfo;
430 workinfo.SetWorkId(10000);
431 workinfo.RequestNetworkType(WorkCondition::Network::NETWORK_TYPE_ANY);
432 int32_t uid = 10000;
433 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
434 std::string ret = workPolicyManager_->GetConditionString(workStatus);
435 EXPECT_FALSE(ret.empty());
436 }
437
438 /**
439 * @tc.name: GetConditionString_003
440 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
441 * @tc.type: FUNC
442 * @tc.require: I9J0A7
443 */
444 HWTEST_F(WorkPolicyManagerTest, GetConditionString_003, TestSize.Level1)
445 {
446 WorkInfo workinfo;
447 workinfo.SetWorkId(10000);
448 workinfo.RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
449 int32_t uid = 10000;
450 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
451 std::string ret = workPolicyManager_->GetConditionString(workStatus);
452 EXPECT_FALSE(ret.empty());
453 }
454
455 /**
456 * @tc.name: GetConditionString_004
457 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
458 * @tc.type: FUNC
459 * @tc.require: I9J0A7
460 */
461 HWTEST_F(WorkPolicyManagerTest, GetConditionString_004, TestSize.Level1)
462 {
463 WorkInfo workinfo;
464 workinfo.SetWorkId(10000);
465 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW_OR_OKAY);
466 int32_t uid = 10000;
467 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
468 std::string ret = workPolicyManager_->GetConditionString(workStatus);
469 EXPECT_FALSE(ret.empty());
470 }
471
472 /**
473 * @tc.name: GetConditionString_005
474 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
475 * @tc.type: FUNC
476 * @tc.require: I9J0A7
477 */
478 HWTEST_F(WorkPolicyManagerTest, GetConditionString_005, TestSize.Level1)
479 {
480 WorkInfo workinfo;
481 workinfo.SetWorkId(10000);
482 workinfo.RequestBatteryLevel(29);
483 int32_t uid = 10000;
484 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
485 std::string ret = workPolicyManager_->GetConditionString(workStatus);
486 EXPECT_FALSE(ret.empty());
487 }
488
489 /**
490 * @tc.name: GetConditionString_006
491 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
492 * @tc.type: FUNC
493 * @tc.require: I9J0A7
494 */
495 HWTEST_F(WorkPolicyManagerTest, GetConditionString_006, TestSize.Level1)
496 {
497 WorkInfo workinfo;
498 workinfo.SetWorkId(10000);
499 workinfo.RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_LOW);
500 int32_t uid = 10000;
501 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
502 std::string ret = workPolicyManager_->GetConditionString(workStatus);
503 EXPECT_FALSE(ret.empty());
504 }
505
506 /**
507 * @tc.name: GetConditionString_007
508 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
509 * @tc.type: FUNC
510 * @tc.require: I9J0A7
511 */
512 HWTEST_F(WorkPolicyManagerTest, GetConditionString_007, TestSize.Level1)
513 {
514 WorkInfo workinfo;
515 workinfo.SetWorkId(10000);
516 workinfo.RequestRepeatCycle(1200000);
517 int32_t uid = 10000;
518 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
519 std::string ret = workPolicyManager_->GetConditionString(workStatus);
520 EXPECT_FALSE(ret.empty());
521 }
522
523 /**
524 * @tc.name: GetConditionString_008
525 * @tc.desc: Test WorkPolicyManagerTest GetConditionString.
526 * @tc.type: FUNC
527 * @tc.require: I9J0A7
528 */
529 HWTEST_F(WorkPolicyManagerTest, GetConditionString_008, TestSize.Level1)
530 {
531 WorkInfo workinfo;
532 workinfo.SetWorkId(10000);
533 workinfo.RequestDeepIdle(true);
534 int32_t uid = 10000;
535 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
536 std::string ret = workPolicyManager_->GetConditionString(workStatus);
537 EXPECT_FALSE(ret.empty());
538 }
539
540 /**
541 * @tc.name: FindWorkStatus_001
542 * @tc.desc: Test WorkPolicyManagerTest FindWorkStatus.
543 * @tc.type: FUNC
544 * @tc.require: I9J0A7
545 */
546 HWTEST_F(WorkPolicyManagerTest, FindWorkStatus_001, TestSize.Level1)
547 {
548 workPolicyManager_->uidQueueMap_.clear();
549 WorkInfo workinfo;
550 workinfo.SetWorkId(10000);
551 workinfo.RequestDeepIdle(true);
552 int32_t uid = 10000;
553 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
554 workPolicyManager_->AddWork(workStatus, uid);
555 std::shared_ptr<WorkStatus> ret = workPolicyManager_->FindWorkStatus(workinfo, uid);
556 EXPECT_FALSE(ret == nullptr);
557 }
558
559 /**
560 * @tc.name: FindWorkStatus_002
561 * @tc.desc: Test WorkPolicyManagerTest FindWorkStatus.
562 * @tc.type: FUNC
563 * @tc.require: I9J0A7
564 */
565 HWTEST_F(WorkPolicyManagerTest, FindWorkStatus_002, TestSize.Level1)
566 {
567 workPolicyManager_->uidQueueMap_.clear();
568 WorkInfo workinfo;
569 workinfo.SetWorkId(10000);
570 workinfo.RequestDeepIdle(true);
571 int32_t uid = 10000;
572 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
573 workPolicyManager_->AddWork(workStatus, uid);
574
575 int32_t uid1 = 10001;
576 std::shared_ptr<WorkStatus> ret = workPolicyManager_->FindWorkStatus(workinfo, uid1);
577 EXPECT_TRUE(ret == nullptr);
578 }
579
580 /**
581 * @tc.name: StopWork_001
582 * @tc.desc: Test WorkPolicyManagerTest StopWork.
583 * @tc.type: FUNC
584 * @tc.require: I9J0A7
585 */
586 HWTEST_F(WorkPolicyManagerTest, StopWork_001, TestSize.Level1)
587 {
588 workPolicyManager_->uidQueueMap_.clear();
589 WorkInfo workinfo;
590 workinfo.SetWorkId(10000);
591 workinfo.RequestDeepIdle(true);
592 int32_t uid = 10000;
593 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
594 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
595 bool ret = workPolicyManager_->StopWork(workStatus, uid, false, false);
596 EXPECT_TRUE(ret);
597 }
598
599 /**
600 * @tc.name: StopWork_002
601 * @tc.desc: Test WorkPolicyManagerTest StopWork.
602 * @tc.type: FUNC
603 * @tc.require: I9J0A7
604 */
605 HWTEST_F(WorkPolicyManagerTest, StopWork_002, TestSize.Level1)
606 {
607 workPolicyManager_->uidQueueMap_.clear();
608 WorkInfo workinfo;
609 workinfo.SetWorkId(10000);
610 workinfo.RequestRepeatCycle(1200000);
611 int32_t uid = 10000;
612 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
613 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
614 bool ret = workPolicyManager_->StopWork(workStatus, uid, true, false);
615 EXPECT_TRUE(ret);
616 }
617
618 /**
619 * @tc.name: StopWork_003
620 * @tc.desc: Test WorkPolicyManagerTest StopWork.
621 * @tc.type: FUNC
622 * @tc.require: I9J0A7
623 */
624 HWTEST_F(WorkPolicyManagerTest, StopWork_003, TestSize.Level1)
625 {
626 workPolicyManager_->uidQueueMap_.clear();
627 WorkInfo workinfo;
628 workinfo.SetWorkId(10000);
629 workinfo.RequestRepeatCycle(1200000);
630 int32_t uid = 10000;
631 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
632 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
633 bool ret = workPolicyManager_->StopWork(workStatus, uid, true, false);
634 EXPECT_TRUE(ret);
635 }
636
637 /**
638 * @tc.name: StopWork_004
639 * @tc.desc: Test WorkPolicyManagerTest StopWork.
640 * @tc.type: FUNC
641 * @tc.require: I9J0A7
642 */
643 HWTEST_F(WorkPolicyManagerTest, StopWork_004, TestSize.Level1)
644 {
645 workPolicyManager_->uidQueueMap_.clear();
646 WorkInfo workinfo;
647 workinfo.SetWorkId(10000);
648 workinfo.RequestDeepIdle(true);
649 int32_t uid = 10000;
650 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
651 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
652 bool ret = workPolicyManager_->StopWork(workStatus, uid, false, true);
653 EXPECT_TRUE(ret);
654 }
655
656 /**
657 * @tc.name: StopAndClearWorks_001
658 * @tc.desc: Test WorkPolicyManagerTest StopAndClearWorks.
659 * @tc.type: FUNC
660 * @tc.require: I9J0A7
661 */
662 HWTEST_F(WorkPolicyManagerTest, StopAndClearWorks_001, TestSize.Level1)
663 {
664 workPolicyManager_->uidQueueMap_.clear();
665 WorkInfo workinfo;
666 workinfo.SetWorkId(10000);
667 workinfo.RequestDeepIdle(true);
668 int32_t uid = 10000;
669 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
670 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
671 workPolicyManager_->AddWork(workStatus, uid);
672
673 bool ret = workPolicyManager_->StopAndClearWorks(uid);
674 EXPECT_TRUE(ret);
675 }
676
677 /**
678 * @tc.name: IsLastWorkTimeout_001
679 * @tc.desc: Test WorkPolicyManagerTest IsLastWorkTimeout.
680 * @tc.type: FUNC
681 * @tc.require: I9J0A7
682 */
683 HWTEST_F(WorkPolicyManagerTest, IsLastWorkTimeout_001, TestSize.Level1)
684 {
685 workPolicyManager_->uidQueueMap_.clear();
686 WorkInfo workinfo;
687 int32_t workId = 10000;
688 workinfo.SetWorkId(workId);
689 workinfo.RequestDeepIdle(true);
690 int32_t uid = 10000;
691 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
692 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
693 workStatus->lastTimeout_ = true;
694 workPolicyManager_->AddWork(workStatus, uid);
695
696 bool ret = false;
697 ret = workPolicyManager_->IsLastWorkTimeout(workId, uid, ret);
698 EXPECT_TRUE(ret);
699 }
700
701 /**
702 * @tc.name: OnConditionReady_001
703 * @tc.desc: Test WorkPolicyManagerTest OnConditionReady.
704 * @tc.type: FUNC
705 * @tc.require: I9J0A7
706 */
707 HWTEST_F(WorkPolicyManagerTest, OnConditionReady_001, TestSize.Level1)
708 {
709 std::vector<std::shared_ptr<WorkStatus>> readyWorkVector = {};
710 std::shared_ptr<std::vector<std::shared_ptr<WorkStatus>>> readyWork =
711 std::make_shared<std::vector<std::shared_ptr<WorkStatus>>>(readyWorkVector);
712 workPolicyManager_->OnConditionReady(readyWork);
713 EXPECT_TRUE(readyWork != nullptr);
714 }
715
716 /**
717 * @tc.name: OnConditionReady_002
718 * @tc.desc: Test WorkPolicyManagerTest OnConditionReady.
719 * @tc.type: FUNC
720 * @tc.require: I9J0A7
721 */
722 HWTEST_F(WorkPolicyManagerTest, OnConditionReady_002, TestSize.Level1)
723 {
724 std::vector<std::shared_ptr<WorkStatus>> readyWorkVector;
725 WorkInfo workinfo;
726 int32_t workId = 10000;
727 workinfo.SetWorkId(workId);
728 workinfo.RequestDeepIdle(true);
729 int32_t uid = 10000;
730 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
731 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
732 workStatus->lastTimeout_ = true;
733 readyWorkVector.emplace_back(workStatus);
734 std::shared_ptr<std::vector<std::shared_ptr<WorkStatus>>> readyWork =
735 std::make_shared<std::vector<std::shared_ptr<WorkStatus>>>(readyWorkVector);
736 workPolicyManager_->OnConditionReady(readyWork);
737 EXPECT_FALSE(readyWork == nullptr);
738 }
739
740 /**
741 * @tc.name: OnConditionReady_003
742 * @tc.desc: Test WorkPolicyManagerTest OnConditionReady.
743 * @tc.type: FUNC
744 * @tc.require: I9J0A7
745 */
746 HWTEST_F(WorkPolicyManagerTest, OnConditionReady_003, TestSize.Level1)
747 {
748 std::shared_ptr<std::vector<std::shared_ptr<WorkStatus>>> readyWork = nullptr;
749 workPolicyManager_->OnConditionReady(readyWork);
750 EXPECT_TRUE(readyWork == nullptr);
751 }
752
753 /**
754 * @tc.name: AddToReadyQueue_001
755 * @tc.desc: Test WorkPolicyManagerTest AddToReadyQueue.
756 * @tc.type: FUNC
757 * @tc.require: I9J0A7
758 */
759 HWTEST_F(WorkPolicyManagerTest, AddToReadyQueue_001, TestSize.Level1)
760 {
761 std::vector<std::shared_ptr<WorkStatus>> readyWorkVector;
762 WorkInfo workinfo;
763 int32_t workId = 10000;
764 workinfo.SetWorkId(workId);
765 workinfo.RequestDeepIdle(true);
766 int32_t uid = 10000;
767 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
768 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
769 workStatus->lastTimeout_ = true;
770 readyWorkVector.emplace_back(workStatus);
771 std::shared_ptr<std::vector<std::shared_ptr<WorkStatus>>> readyWork =
772 std::make_shared<std::vector<std::shared_ptr<WorkStatus>>>(readyWorkVector);
773 workPolicyManager_->AddToReadyQueue(readyWork);
774 EXPECT_FALSE(readyWork == nullptr);
775 }
776
777 /**
778 * @tc.name: GetMaxRunningCount_001
779 * @tc.desc: Test WorkPolicyManagerTest GetMaxRunningCount.
780 * @tc.type: FUNC
781 * @tc.require: I9J0A7
782 */
783 HWTEST_F(WorkPolicyManagerTest, GetMaxRunningCount_001, TestSize.Level1)
784 {
785 workPolicyManager_->dumpSetMaxRunningCount_ = 2;
786 WorkSchedSystemPolicy systemPolicy;
787 int32_t ret = workPolicyManager_->GetMaxRunningCount(systemPolicy);
788 EXPECT_TRUE(ret == workPolicyManager_->dumpSetMaxRunningCount_);
789 }
790
791 /**
792 * @tc.name: GetMaxRunningCount_002
793 * @tc.desc: Test WorkPolicyManagerTest GetMaxRunningCount.
794 * @tc.type: FUNC
795 * @tc.require: I9J0A7
796 */
797 HWTEST_F(WorkPolicyManagerTest, GetMaxRunningCount_002, TestSize.Level1)
798 {
799 workPolicyManager_->dumpSetMaxRunningCount_ = 0;
800 WorkSchedSystemPolicy systemPolicy;
801 int32_t ret = workPolicyManager_->GetMaxRunningCount(systemPolicy);
802 EXPECT_TRUE(ret >= workPolicyManager_->dumpSetMaxRunningCount_);
803 }
804
805 /**
806 * @tc.name: GetMaxRunningCount_003
807 * @tc.desc: Test WorkPolicyManagerTest GetMaxRunningCount.
808 * @tc.type: FUNC
809 * @tc.require: I9J0A7
810 */
811 HWTEST_F(WorkPolicyManagerTest, GetMaxRunningCount_003, TestSize.Level1)
812 {
813 WorkSchedSystemPolicy systemPolicy;
814 workPolicyManager_->SetMaxRunningCountByDump(5);
815 int32_t result = workPolicyManager_->GetMaxRunningCount(systemPolicy);
816
817 EXPECT_EQ(5, result);
818 workPolicyManager_->policyFilters_.clear();
819 }
820
821 /**
822 * @tc.name: GetMaxRunningCount_004
823 * @tc.desc: Test WorkPolicyManagerTest GetMaxRunningCount.
824 * @tc.type: FUNC
825 * @tc.require: I9J0A7
826 */
827 HWTEST_F(WorkPolicyManagerTest, GetMaxRunningCount_004, TestSize.Level1)
828 {
829 WorkSchedSystemPolicy systemPolicy;
830 workPolicyManager_->SetMaxRunningCountByDump(0);
831
832 auto filter1 = std::make_shared<MockPolicyFilter>(workPolicyManager_);
833 filter1->maxRunningCount = 2;
834
835 auto filter2 = std::make_shared<MockPolicyFilter>(workPolicyManager_);
836 filter2->maxRunningCount = 4;
837
838 workPolicyManager_->AddPolicyFilter(filter1);
839 workPolicyManager_->AddPolicyFilter(filter2);
840
841 int32_t result = workPolicyManager_->GetMaxRunningCount(systemPolicy);
842
843 EXPECT_EQ(2, result);
844 workPolicyManager_->policyFilters_.clear();
845 }
846
847 /**
848 * @tc.name: GetMaxRunningCount_005
849 * @tc.desc: Test WorkPolicyManagerTest GetMaxRunningCount.
850 * @tc.type: FUNC
851 * @tc.require: I9J0A7
852 */
853 HWTEST_F(WorkPolicyManagerTest, GetMaxRunningCount_005, TestSize.Level1)
854 {
855 WorkSchedSystemPolicy systemPolicy;
856 workPolicyManager_->SetMaxRunningCountByDump(0);
857
858 auto filter1 = std::make_shared<MockPolicyFilter>(workPolicyManager_);
859 filter1->maxRunningCount = 5;
860
861 auto filter2 = std::make_shared<MockPolicyFilter>(workPolicyManager_);
862 filter2->maxRunningCount = 3;
863
864 auto filter3 = std::make_shared<MockPolicyFilter>(workPolicyManager_);
865 filter3->maxRunningCount = 7;
866
867 workPolicyManager_->AddPolicyFilter(filter1);
868 workPolicyManager_->AddPolicyFilter(filter2);
869 workPolicyManager_->AddPolicyFilter(filter3);
870
871 int32_t result = workPolicyManager_->GetMaxRunningCount(systemPolicy);
872
873 EXPECT_EQ(3, result);
874 workPolicyManager_->policyFilters_.clear();
875 }
876
877 /**
878 * @tc.name: GetMaxRunningCount_006
879 * @tc.desc: Test WorkPolicyManagerTest GetMaxRunningCount.
880 * @tc.type: FUNC
881 * @tc.require: I9J0A7
882 */
883 HWTEST_F(WorkPolicyManagerTest, GetMaxRunningCount_006, TestSize.Level1)
884 {
885 WorkSchedSystemPolicy systemPolicy;
886 workPolicyManager_->SetMaxRunningCountByDump(0);
887
888 int32_t result = workPolicyManager_->GetMaxRunningCount(systemPolicy);
889
890 EXPECT_EQ(3, result);
891 workPolicyManager_->policyFilters_.clear();
892 }
893
894 /**
895 * @tc.name: GetMaxRunningCount_007
896 * @tc.desc: Test WorkPolicyManagerTest GetMaxRunningCount.
897 * @tc.type: FUNC
898 * @tc.require: I9J0A7
899 */
900 HWTEST_F(WorkPolicyManagerTest, GetMaxRunningCount_007, TestSize.Level1)
901 {
902 WorkSchedSystemPolicy systemPolicy;
903 workPolicyManager_->SetMaxRunningCountByDump(0);
904
905 auto filter1 = std::make_shared<MockPolicyFilter>(workPolicyManager_);
906 filter1->maxRunningCount = 10;
907
908 auto filter2 = std::make_shared<MockPolicyFilter>(workPolicyManager_);
909 filter2->maxRunningCount = 5;
910
911 auto filter3 = std::make_shared<MockPolicyFilter>(workPolicyManager_);
912 filter3->maxRunningCount = 8;
913
914 auto filter4 = std::make_shared<MockPolicyFilter>(workPolicyManager_);
915 filter4->maxRunningCount = 3;
916
917 workPolicyManager_->AddPolicyFilter(filter1);
918 workPolicyManager_->AddPolicyFilter(filter2);
919 workPolicyManager_->AddPolicyFilter(filter3);
920 workPolicyManager_->AddPolicyFilter(filter4);
921
922 int32_t result = workPolicyManager_->GetMaxRunningCount(systemPolicy);
923
924 EXPECT_EQ(3, result);
925 workPolicyManager_->policyFilters_.clear();
926 }
927
928 /**
929 * @tc.name: GetRunningCount_001
930 * @tc.desc: Test WorkPolicyManagerTest GetRunningCount.
931 * @tc.type: FUNC
932 * @tc.require: I9J0A7
933 */
934 HWTEST_F(WorkPolicyManagerTest, GetRunningCount_001, TestSize.Level1)
935 {
936 workPolicyManager_->uidQueueMap_.clear();
937 WorkInfo workinfo;
938 int32_t workId = 10000;
939 workinfo.SetWorkId(workId);
940 workinfo.RequestDeepIdle(true);
941 int32_t uid = 10000;
942 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
943 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
944 workPolicyManager_->AddWork(workStatus, uid);
945
946 int32_t ret = workPolicyManager_->GetRunningCount();
947 EXPECT_TRUE(ret == 1);
948 }
949
950 /**
951 * @tc.name: FindWork_001
952 * @tc.desc: Test WorkPolicyManagerTest FindWork.
953 * @tc.type: FUNC
954 * @tc.require: I9J0A7
955 */
956 HWTEST_F(WorkPolicyManagerTest, FindWork_001, TestSize.Level1)
957 {
958 workPolicyManager_->uidQueueMap_.clear();
959 WorkInfo workinfo;
960 int32_t workId = 10000;
961 workinfo.SetWorkId(workId);
962 workinfo.RequestDeepIdle(true);
963 int32_t uid = 10000;
964 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
965 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
966 workPolicyManager_->AddWork(workStatus, uid);
967
968 bool ret = workPolicyManager_->FindWork(uid);
969 EXPECT_TRUE(ret);
970 }
971
972 /**
973 * @tc.name: FindWork_002
974 * @tc.desc: Test WorkPolicyManagerTest FindWork.
975 * @tc.type: FUNC
976 * @tc.require: I9J0A7
977 */
978 HWTEST_F(WorkPolicyManagerTest, FindWork_002, TestSize.Level1)
979 {
980 workPolicyManager_->uidQueueMap_.clear();
981 WorkInfo workinfo;
982 workinfo.bundleName_ = "com.test.demo";
983 int32_t workId = 10000;
984 workinfo.SetWorkId(workId);
985 workinfo.RequestDeepIdle(true);
986 int32_t uid = 10000;
987 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
988 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
989 workStatus->userId_ = 100;
990 workPolicyManager_->AddWork(workStatus, uid);
991
992 bool ret = workPolicyManager_->FindWork(workStatus->userId_, workStatus->bundleName_);
993 EXPECT_TRUE(ret);
994 }
995
996 /**
997 * @tc.name: FindWork_003
998 * @tc.desc: Test WorkPolicyManagerTest FindWork.
999 * @tc.type: FUNC
1000 * @tc.require: I9J0A7
1001 */
1002 HWTEST_F(WorkPolicyManagerTest, FindWork_003, TestSize.Level1)
1003 {
1004 workPolicyManager_->uidQueueMap_.clear();
1005 WorkInfo workinfo;
1006 workinfo.bundleName_ = "com.test.demo";
1007 int32_t workId = 10000;
1008 workinfo.SetWorkId(workId);
1009 workinfo.RequestDeepIdle(true);
1010 int32_t uid = 10000;
1011 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
1012 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
1013 workStatus->userId_ = 100;
1014
1015 bool ret = workPolicyManager_->FindWork(workStatus->userId_, workStatus->bundleName_);
1016 EXPECT_FALSE(ret);
1017 }
1018
1019 /**
1020 * @tc.name: GetDeepIdleWorks_001
1021 * @tc.desc: Test WorkPolicyManagerTest GetDeepIdleWorks.
1022 * @tc.type: FUNC
1023 * @tc.require: I9J0A7
1024 */
1025 HWTEST_F(WorkPolicyManagerTest, GetDeepIdleWorks_001, TestSize.Level1)
1026 {
1027 workPolicyManager_->uidQueueMap_.clear();
1028 WorkInfo workinfo;
1029 workinfo.bundleName_ = "com.test.demo";
1030 int32_t workId = 10000;
1031 workinfo.SetWorkId(workId);
1032 workinfo.RequestDeepIdle(true);
1033 int32_t uid = 10000;
1034 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
1035 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
1036 workStatus->userId_ = 100;
1037 workPolicyManager_->AddWork(workStatus, uid);
1038
1039 std::list<std::shared_ptr<WorkStatus>> ret = workPolicyManager_->GetDeepIdleWorks();
1040 EXPECT_TRUE(ret.size() > 0);
1041 }
1042
1043 /**
1044 * @tc.name: DumpTriggerWork_001
1045 * @tc.desc: Test WorkPolicyManagerTest DumpTriggerWork.
1046 * @tc.type: FUNC
1047 * @tc.require: IC5H77
1048 */
1049 HWTEST_F(WorkPolicyManagerTest, DumpTriggerWork_001, TestSize.Level1)
1050 {
1051 int32_t uId = 1;
1052 int32_t workId = 1;
1053 std::string result;
1054 workPolicyManager_->DumpTriggerWork(uId, workId, result);
1055 EXPECT_EQ(result, "the work is not exist\n");
1056 }
1057
1058 /**
1059 * @tc.name: DumpTriggerWork_002
1060 * @tc.desc: Test WorkPolicyManagerTest DumpTriggerWork.
1061 * @tc.type: FUNC
1062 * @tc.require: IC5H77
1063 */
1064 HWTEST_F(WorkPolicyManagerTest, DumpTriggerWork_002, TestSize.Level1)
1065 {
1066 workPolicyManager_->uidQueueMap_.clear();
1067 int32_t uId = 1;
1068 int32_t workId = 1;
1069 WorkInfo workinfo;
1070 workinfo.SetWorkId(workId);
1071 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
1072 workinfo.RequestBatteryLevel(80);
1073 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uId);
1074 workStatus->MarkStatus(WorkStatus::RUNNING);
1075 int32_t ret = workPolicyManager_->AddWork(workStatus, uId);
1076 std::string result;
1077 workPolicyManager_->DumpTriggerWork(uId, workId, result);
1078 EXPECT_EQ(result, "the work is running\n");
1079 }
1080
1081 /**
1082 * @tc.name: DumpTriggerWork_003
1083 * @tc.desc: Test WorkPolicyManagerTest DumpTriggerWork.
1084 * @tc.type: FUNC
1085 * @tc.require: IC5H77
1086 */
1087 HWTEST_F(WorkPolicyManagerTest, DumpTriggerWork_003, TestSize.Level1)
1088 {
1089 workPolicyManager_->uidQueueMap_.clear();
1090 int32_t uId = 1;
1091 int32_t workId = 1;
1092 WorkInfo workinfo;
1093 workinfo.SetWorkId(workId);
1094 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
1095 workinfo.RequestBatteryLevel(80);
1096 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uId);
1097 workStatus->MarkStatus(WorkStatus::WAIT_CONDITION);
1098 int32_t ret = workPolicyManager_->AddWork(workStatus, uId);
1099 std::string result;
1100 workPolicyManager_->DumpTriggerWork(uId, workId, result);
1101 EXPECT_EQ(result, "the work trigger error\n");
1102 }
1103
1104 /**
1105 * @tc.name: OnPolicyChanged_001
1106 * @tc.desc: Test WorkPolicyManagerTest OnPolicyChanged.
1107 * @tc.type: FUNC
1108 * @tc.require: https://gitee.com/openharmony/resourceschedule_work_scheduler/issues/ICBI5I
1109 */
1110 HWTEST_F(WorkPolicyManagerTest, OnPolicyChanged_001, TestSize.Level1)
1111 {
1112 std::shared_ptr<DetectorValue> detectorVal = std::make_shared<DetectorValue>(0, 0, false, "preinstalled_app");
1113 std::shared_ptr<WorkSchedulerService> workSchedulerService = std::make_shared<WorkSchedulerService>();
1114 workPolicyManager_ = std::make_shared<WorkPolicyManager>(workSchedulerService);
1115 workPolicyManager_->OnPolicyChanged(PolicyType::APP_ADDED, detectorVal);
1116
1117 EXPECT_FALSE(workPolicyManager_->wss_.lock() == nullptr);
1118 }
1119
1120 /**
1121 * @tc.name: OnPolicyChanged_002
1122 * @tc.desc: Test WorkPolicyManagerTest OnPolicyChanged.
1123 * @tc.type: FUNC
1124 * @tc.require: https://gitee.com/openharmony/resourceschedule_work_scheduler/issues/ICBI5I
1125 */
1126 HWTEST_F(WorkPolicyManagerTest, OnPolicyChanged_002, TestSize.Level1)
1127 {
1128 std::shared_ptr<WorkSchedulerService> workSchedulerService = std::make_shared<WorkSchedulerService>();
1129 workPolicyManager_ = std::make_shared<WorkPolicyManager>(workSchedulerService);
1130 workPolicyManager_->OnPolicyChanged(static_cast<PolicyType>(999), std::make_shared<DetectorValue>(0, 0, false, ""));
1131 EXPECT_FALSE(workPolicyManager_->wss_.lock() == nullptr);
1132 }
1133
1134 /**
1135 * @tc.name: UpdateWatchdogTime_001
1136 * @tc.desc: Test WorkPolicyManagerTest UpdateWatchdogTime.
1137 * @tc.type: FUNC
1138 * @tc.require: https://gitee.com/openharmony/resourceschedule_work_scheduler/issues/ICBI5I
1139 */
1140 HWTEST_F(WorkPolicyManagerTest, UpdateWatchdogTime_001, TestSize.Level1)
1141 {
1142 WorkInfo workInfo;
1143 int32_t workId = 10000;
1144 int32_t uid = 20200;
1145 workInfo.SetWorkId(workId);
1146 workInfo.RequestDeepIdle(true);
1147 workInfo.RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
1148 std::shared_ptr<WorkStatus> topWork = std::make_shared<WorkStatus>(workInfo, uid);
1149 std::shared_ptr<WorkSchedulerService> workSchedulerService = std::make_shared<WorkSchedulerService>();
1150 workPolicyManager_ = std::make_shared<WorkPolicyManager>(workSchedulerService);
1151 workPolicyManager_->UpdateWatchdogTime(workSchedulerService, topWork);
1152 EXPECT_EQ(workPolicyManager_->GetWatchdogTime(), LONG_WATCHDOG_TIME);
1153 }
1154
1155 /**
1156 * @tc.name: UpdateWatchdogTime_002
1157 * @tc.desc: Test WorkPolicyManagerTest UpdateWatchdogTime.
1158 * @tc.type: FUNC
1159 * @tc.require: https://gitee.com/openharmony/resourceschedule_work_scheduler/issues/ICBI5I
1160 */
1161 HWTEST_F(WorkPolicyManagerTest, UpdateWatchdogTime_002, TestSize.Level1)
1162 {
1163 WorkInfo workInfo;
1164 int32_t workId = 10000;
1165 int32_t uid = 20200;
1166 workInfo.SetWorkId(workId);
1167 workInfo.RequestDeepIdle(false);
1168 workInfo.RequestChargerType(true, WorkCondition::Charger::CHARGING_UNKNOWN);
1169 std::shared_ptr<WorkStatus> topWork = std::make_shared<WorkStatus>(workInfo, uid);
1170 std::shared_ptr<WorkSchedulerService> workSchedulerService = std::make_shared<WorkSchedulerService>();
1171 workPolicyManager_ = std::make_shared<WorkPolicyManager>(workSchedulerService);
1172 workSchedulerService->UpdateEffiResApplyInfo(uid, false);
1173
1174 workPolicyManager_->UpdateWatchdogTime(workSchedulerService, topWork);
1175 EXPECT_EQ(workPolicyManager_->GetWatchdogTime(), g_lastWatchdogTime);
1176 }
1177
1178 /**
1179 * @tc.name: UpdateWatchdogTime_003
1180 * @tc.desc: Test WorkPolicyManagerTest UpdateWatchdogTime.
1181 * @tc.type: FUNC
1182 * @tc.require: https://gitee.com/openharmony/resourceschedule_work_scheduler/issues/ICBI5I
1183 */
1184 HWTEST_F(WorkPolicyManagerTest, UpdateWatchdogTime_003, TestSize.Level1)
1185 {
1186 WorkInfo workInfo;
1187 int32_t workId = 10000;
1188 int32_t uid = 20200;
1189 workInfo.SetWorkId(workId);
1190 workInfo.RequestDeepIdle(false);
1191 workInfo.RequestChargerType(true, WorkCondition::Charger::CHARGING_UNKNOWN);
1192 std::shared_ptr<WorkStatus> topWork = std::make_shared<WorkStatus>(workInfo, uid);
1193
1194 auto workCondition = std::make_shared<Condition>();
1195 workCondition->enumVal = static_cast<int32_t>(WorkCondition::Charger::CHARGING_UNKNOWN);
1196 topWork->conditionMap_.emplace(WorkCondition::Type::CHARGER, workCondition);
1197
1198 std::shared_ptr<WorkSchedulerService> workSchedulerService = std::make_shared<WorkSchedulerService>();
1199 workPolicyManager_ = std::make_shared<WorkPolicyManager>(workSchedulerService);
1200 workSchedulerService->UpdateEffiResApplyInfo(uid, true);
1201
1202 workPolicyManager_->UpdateWatchdogTime(workSchedulerService, topWork);
1203 EXPECT_EQ(workPolicyManager_->GetWatchdogTime(), MEDIUM_WATCHDOG_TIME);
1204 }
1205
1206 /**
1207 * @tc.name: UpdateWatchdogTime_004
1208 * @tc.desc: Test WorkPolicyManagerTest UpdateWatchdogTime.
1209 * @tc.type: FUNC
1210 * @tc.require: https://gitee.com/openharmony/resourceschedule_work_scheduler/issues/ICBI5I
1211 */
1212 HWTEST_F(WorkPolicyManagerTest, UpdateWatchdogTime_004, TestSize.Level1)
1213 {
1214 WorkInfo workInfo;
1215 int32_t workId = 10000;
1216 int32_t uid = 20200;
1217 workInfo.SetWorkId(workId);
1218 workInfo.RequestDeepIdle(false);
1219 workInfo.RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
1220 std::shared_ptr<WorkStatus> topWork = std::make_shared<WorkStatus>(workInfo, uid);
1221
1222 auto workCondition = std::make_shared<Condition>();
1223 workCondition->enumVal = static_cast<int32_t>(WorkCondition::Charger::CHARGING_PLUGGED_AC);
1224 topWork->conditionMap_.emplace(WorkCondition::Type::CHARGER, workCondition);
1225
1226 std::shared_ptr<WorkSchedulerService> workSchedulerService = std::make_shared<WorkSchedulerService>();
1227 workPolicyManager_ = std::make_shared<WorkPolicyManager>(workSchedulerService);
1228 workSchedulerService->UpdateEffiResApplyInfo(uid, true);
1229
1230 workPolicyManager_->UpdateWatchdogTime(workSchedulerService, topWork);
1231 EXPECT_EQ(workPolicyManager_->GetWatchdogTime(), LONG_WATCHDOG_TIME);
1232 }
1233
1234 /**
1235 * @tc.name: WatchdogTimeOut_001
1236 * @tc.desc: Test WorkPolicyManagerTest WatchdogTimeOut.
1237 * @tc.type: FUNC
1238 * @tc.require: https://gitee.com/openharmony/resourceschedule_work_scheduler/issues/ICBI5I
1239 */
1240 HWTEST_F(WorkPolicyManagerTest, WatchdogTimeOut_001, TestSize.Level1)
1241 {
1242 std::shared_ptr<WorkSchedulerService> workSchedulerService = std::make_shared<WorkSchedulerService>();
1243 workPolicyManager_ = std::make_shared<WorkPolicyManager>(workSchedulerService);
1244 workPolicyManager_->watchdogIdMap_.clear();
1245 uint32_t watchdogId = 1;
1246 workPolicyManager_->WatchdogTimeOut(watchdogId);
1247 EXPECT_EQ(workPolicyManager_->watchdogIdMap_.size(), 0);
1248 }
1249 }
1250 }