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 }
47
48 /**
49 * @tc.name: RealStartWork_001
50 * @tc.desc: Test WorkPolicyManagerTest RealStartWork.
51 * @tc.type: FUNC
52 * @tc.require: I8OLHT
53 */
54 HWTEST_F(WorkPolicyManagerTest, RealStartWork_001, TestSize.Level1)
55 {
56 WorkInfo workinfo;
57 int32_t uid;
58 std::shared_ptr<WorkStatus> topWork = std::make_shared<WorkStatus>(workinfo, uid);
59 workPolicyManager_->RealStartWork(topWork);
60 EXPECT_FALSE(topWork->IsRunning());
61 }
62
63 /**
64 * @tc.name: CheckWorkToRun_001
65 * @tc.desc: Test WorkPolicyManagerTest CheckWorkToRun.
66 * @tc.type: FUNC
67 * @tc.require: I9J0A7
68 */
69 HWTEST_F(WorkPolicyManagerTest, CheckWorkToRun_001, TestSize.Level1)
70 {
71 workPolicyManager_->conditionReadyQueue_->ClearAll();
72 workPolicyManager_->CheckWorkToRun();
73 EXPECT_TRUE(workPolicyManager_->conditionReadyQueue_->GetSize() == 0);
74 }
75
76 /**
77 * @tc.name: AddWork_001
78 * @tc.desc: Test WorkPolicyManagerTest AddWork.
79 * @tc.type: FUNC
80 * @tc.require: I9J0A7
81 */
82 HWTEST_F(WorkPolicyManagerTest, AddWork_001, TestSize.Level1)
83 {
84 workPolicyManager_->uidQueueMap_.clear();
85 WorkInfo workinfo;
86 workinfo.SetWorkId(10000);
87 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
88 workinfo.RequestBatteryLevel(80);
89 int32_t uid = 10000;
90 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
91 int32_t ret = workPolicyManager_->AddWork(workStatus, uid);
92 EXPECT_EQ(ret, ERR_OK);
93 }
94
95 /**
96 * @tc.name: AddWork_002
97 * @tc.desc: Test WorkPolicyManagerTest AddWork.
98 * @tc.type: FUNC
99 * @tc.require: I9J0A7
100 */
101 HWTEST_F(WorkPolicyManagerTest, AddWork_002, TestSize.Level1)
102 {
103 workPolicyManager_->uidQueueMap_.clear();
104 WorkInfo workinfo;
105 workinfo.SetWorkId(10000);
106 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
107 workinfo.RequestBatteryLevel(80);
108 int32_t uid = 10000;
109 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
110 workPolicyManager_->AddWork(workStatus, uid);
111
112 WorkInfo workinfo1;
113 workinfo1.SetWorkId(10000);
114 workinfo1.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
115 workinfo1.RequestBatteryLevel(80);
116 std::shared_ptr<WorkStatus> workStatus1 = std::make_shared<WorkStatus>(workinfo1, uid);
117 int32_t ret = workPolicyManager_->AddWork(workStatus1, uid);
118
119 EXPECT_EQ(ret, E_ADD_REPEAT_WORK_ERR);
120 }
121
122 /**
123 * @tc.name: AddWork_003
124 * @tc.desc: Test WorkPolicyManagerTest AddWork.
125 * @tc.type: FUNC
126 * @tc.require: I9J0A7
127 */
128 HWTEST_F(WorkPolicyManagerTest, AddWork_003, TestSize.Level1)
129 {
130 workPolicyManager_->uidQueueMap_.clear();
131 int32_t uid = 10000;
132 for (int32_t i = 0; i < 10; i++) {
133 WorkInfo workinfo;
134 workinfo.SetWorkId(10000 + i);
135 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
136 workinfo.RequestBatteryLevel(80);
137 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
138 workPolicyManager_->AddWork(workStatus, uid);
139 }
140
141 WorkInfo workinfo1;
142 workinfo1.SetWorkId(10010);
143 workinfo1.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
144 workinfo1.RequestBatteryLevel(80);
145 std::shared_ptr<WorkStatus> workStatus1 = std::make_shared<WorkStatus>(workinfo1, uid);
146 int32_t ret = workPolicyManager_->AddWork(workStatus1, uid);
147
148 EXPECT_EQ(ret, E_WORK_EXCEED_UPPER_LIMIT);
149 }
150
151 /**
152 * @tc.name: RemoveWork_001
153 * @tc.desc: Test WorkPolicyManagerTest RemoveWork.
154 * @tc.type: FUNC
155 * @tc.require: I9J0A7
156 */
157 HWTEST_F(WorkPolicyManagerTest, RemoveWork_001, TestSize.Level1)
158 {
159 workPolicyManager_->uidQueueMap_.clear();
160 WorkInfo workinfo;
161 workinfo.SetWorkId(10000);
162 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
163 workinfo.RequestBatteryLevel(80);
164 int32_t uid = 10000;
165 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
166 bool ret = workPolicyManager_->RemoveWork(workStatus, uid);
167 EXPECT_FALSE(ret);
168 }
169
170 /**
171 * @tc.name: RemoveWork_002
172 * @tc.desc: Test WorkPolicyManagerTest RemoveWork.
173 * @tc.type: FUNC
174 * @tc.require: I9J0A7
175 */
176 HWTEST_F(WorkPolicyManagerTest, RemoveWork_002, TestSize.Level1)
177 {
178 workPolicyManager_->uidQueueMap_.clear();
179 WorkInfo workinfo;
180 workinfo.SetWorkId(10000);
181 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
182 workinfo.RequestBatteryLevel(80);
183 int32_t uid = 10000;
184 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
185 workPolicyManager_->AddWork(workStatus, uid);
186
187 bool ret = workPolicyManager_->RemoveWork(workStatus, uid);
188 EXPECT_TRUE(ret);
189 }
190
191 /**
192 * @tc.name: PauseRunningWorks_001
193 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
194 * @tc.type: FUNC
195 * @tc.require: I9J0A7
196 */
197 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_001, TestSize.Level1)
198 {
199 workPolicyManager_->watchdogIdMap_.clear();
200 int32_t uid = 10000;
201 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
202 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
203 }
204
205 /**
206 * @tc.name: PauseRunningWorks_002
207 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
208 * @tc.type: FUNC
209 * @tc.require: I9J0A7
210 */
211 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_002, TestSize.Level1)
212 {
213 workPolicyManager_->watchdogIdMap_.clear();
214 uint32_t watchdogId = 1;
215 WorkInfo workinfo;
216 workinfo.SetWorkId(10000);
217 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
218 workinfo.RequestBatteryLevel(80);
219 int32_t uid = 10000;
220 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
221 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
222 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
223 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
224 }
225
226 /**
227 * @tc.name: PauseRunningWorks_003
228 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
229 * @tc.type: FUNC
230 * @tc.require: I9J0A7
231 */
232 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_003, TestSize.Level1)
233 {
234 workPolicyManager_->watchdogIdMap_.clear();
235 uint32_t watchdogId = 1;
236 WorkInfo workinfo;
237 workinfo.SetWorkId(10000);
238 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
239 workinfo.RequestBatteryLevel(80);
240 int32_t uid = 10000;
241 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
242 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
243 workStatus->paused_ = true;
244 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
245 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
246 EXPECT_EQ(ret, ERR_OK);
247 }
248
249 /**
250 * @tc.name: PauseRunningWorks_004
251 * @tc.desc: Test WorkPolicyManagerTest PauseRunningWorks.
252 * @tc.type: FUNC
253 * @tc.require: I9J0A7
254 */
255 HWTEST_F(WorkPolicyManagerTest, PauseRunningWorks_004, 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_ = false;
267 workStatus->workStartTime_ = 120000;
268 workStatus->workWatchDogTime_ = WorkSchedUtils::GetCurrentTimeMs();
269 std::shared_ptr<WorkSchedulerService> workSchedulerService = DelayedSingleton<WorkSchedulerService>::GetInstance();
270 std::shared_ptr<AppExecFwk::EventRunner> runner;
271 std::shared_ptr<Watchdog> watchdog_ =
272 std::make_shared<Watchdog>(workSchedulerService->GetWorkPolicyManager(), runner);
273 workPolicyManager_->watchdog_ = watchdog_;
274 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
275 int32_t ret = workPolicyManager_->PauseRunningWorks(uid);
276 EXPECT_EQ(ret, ERR_OK);
277 }
278
279 /**
280 * @tc.name: ResumePausedWorks_001
281 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
282 * @tc.type: FUNC
283 * @tc.require: I9J0A7
284 */
285 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_001, TestSize.Level1)
286 {
287 workPolicyManager_->watchdogIdMap_.clear();
288 int32_t uid = 10000;
289 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
290 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
291 }
292
293 /**
294 * @tc.name: ResumePausedWorks_002
295 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
296 * @tc.type: FUNC
297 * @tc.require: I9J0A7
298 */
299 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_002, TestSize.Level1)
300 {
301 workPolicyManager_->watchdogIdMap_.clear();
302 uint32_t watchdogId = 1;
303 WorkInfo workinfo;
304 workinfo.SetWorkId(10000);
305 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
306 workinfo.RequestBatteryLevel(80);
307 int32_t uid = 10000;
308 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
309 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
310 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
311 EXPECT_EQ(ret, E_UID_NO_MATCHING_WORK_ERR);
312 }
313
314 /**
315 * @tc.name: ResumePausedWorks_003
316 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
317 * @tc.type: FUNC
318 * @tc.require: I9J0A7
319 */
320 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_003, TestSize.Level1)
321 {
322 workPolicyManager_->watchdogIdMap_.clear();
323 uint32_t watchdogId = 1;
324 WorkInfo workinfo;
325 workinfo.SetWorkId(10000);
326 workinfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
327 workinfo.RequestBatteryLevel(80);
328 int32_t uid = 10000;
329 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workinfo, uid);
330 workStatus->MarkStatus(WorkStatus::Status::RUNNING);
331 workStatus->paused_ = false;
332 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
333 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
334 EXPECT_EQ(ret, ERR_OK);
335 }
336
337 /**
338 * @tc.name: ResumePausedWorks_004
339 * @tc.desc: Test WorkPolicyManagerTest ResumePausedWorks.
340 * @tc.type: FUNC
341 * @tc.require: I9J0A7
342 */
343 HWTEST_F(WorkPolicyManagerTest, ResumePausedWorks_004, 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_ = true;
355 workStatus->workStartTime_ = 120000;
356 workStatus->workWatchDogTime_ = WorkSchedUtils::GetCurrentTimeMs();
357 std::shared_ptr<WorkSchedulerService> workSchedulerService = DelayedSingleton<WorkSchedulerService>::GetInstance();
358 std::shared_ptr<AppExecFwk::EventRunner> runner;
359 std::shared_ptr<Watchdog> watchdog_ =
360 std::make_shared<Watchdog>(workSchedulerService->GetWorkPolicyManager(), runner);
361 workPolicyManager_->watchdog_ = watchdog_;
362 workPolicyManager_->watchdogIdMap_.emplace(watchdogId, workStatus);
363 int32_t ret = workPolicyManager_->ResumePausedWorks(uid);
364 EXPECT_EQ(ret, ERR_OK);
365 }
366 }
367 }