1 /*
2 * Copyright (c) 2022 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 "gtest/gtest.h"
17
18 #include "utils.h"
19
20 #define private public
21 #define protected public
22 #include "reclaim_priority_manager.h"
23 #undef private
24 #undef protected
25
26 namespace OHOS {
27 namespace Memory {
28 using namespace testing;
29 using namespace testing::ext;
30
31 class ReclaimPriorityManagerTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void ReclaimPriorityManagerTest::SetUpTestCase()
40 {
41 }
42
TearDownTestCase()43 void ReclaimPriorityManagerTest::TearDownTestCase()
44 {
45 }
46
SetUp()47 void ReclaimPriorityManagerTest::SetUp()
48 {
49 }
50
TearDown()51 void ReclaimPriorityManagerTest::TearDown()
52 {
53 }
54
55 HWTEST_F(ReclaimPriorityManagerTest, InitTest, TestSize.Level1)
56 {
57 EXPECT_EQ(ReclaimPriorityManager::GetInstance().Init(), true);
58 }
59
PrintReclaimPriorityList()60 static void PrintReclaimPriorityList()
61 {
62 ReclaimPriorityManager::BunldeCopySet bundleSet;
63 ReclaimPriorityManager::GetInstance().GetBundlePrioSet(bundleSet);
64 printf("begin print reclaim priority list. \n");
65 printf(" uid name priority accountId\n");
66 for (auto bi : bundleSet) {
67 printf("%3d\t%42s\t%5d\t%3d\n", bi.uid_, bi.name_.c_str(), bi.priority_, bi.accountId_);
68 for (auto piPair : bi.procs_) {
69 ProcessPriorityInfo &pi = piPair.second;
70 printf("\tuid_=%3d, pid_=%5d, priority_=%5d, isFg=%d, isBgTsk=%d, isSusDelay=%d, isDistDevConn=%d, "
71 "extensionBindStatus=%d\n",
72 pi.uid_, pi.pid_, pi.priority_, pi.isFreground, pi.isBackgroundRunning, pi.isSuspendDelay,
73 pi.isDistDeviceConnected, pi.extensionBindStatus);
74 }
75 }
76 printf("-------------------------------------------------------------------------------\n");
77 }
78
79 struct ReqExtInfo {
80 int callerPid;
81 int callerUid;
82 int pid;
83 int uid;
84 };
85
CreateUpdateRequestForExtension(ReqExtInfo reqExtInfo,std::string callerBundleName,std::string bundleName,AppStateUpdateReason reason)86 static inline UpdateRequest CreateUpdateRequestForExtension(ReqExtInfo reqExtInfo, std::string callerBundleName,
87 std::string bundleName, AppStateUpdateReason reason)
88 {
89 return CallerRequest({reqExtInfo.callerPid, reqExtInfo.callerUid, callerBundleName},
90 {reqExtInfo.pid, reqExtInfo.uid, bundleName}, reason);
91 }
92
CreateUpdateRequest(int pid,int uid,std::string bundleName,AppStateUpdateReason reason)93 static inline UpdateRequest CreateUpdateRequest(int pid, int uid,
94 std::string bundleName, AppStateUpdateReason reason)
95 {
96 return SingleRequest({pid, uid, "", bundleName}, reason);
97 }
98
99 HWTEST_F(ReclaimPriorityManagerTest, AddOsAccountInfo, TestSize.Level1)
100 {
101 int accountId = 0;
102 std::shared_ptr<AccountBundleInfo> account = std::make_shared<AccountBundleInfo>(accountId);
103 ReclaimPriorityManager::GetInstance().AddOsAccountInfo(account);
104
105 bool isAccountExist = ReclaimPriorityManager::GetInstance().IsOsAccountExist(accountId);
106 EXPECT_EQ(isAccountExist, true);
107 }
108
109 HWTEST_F(ReclaimPriorityManagerTest, RemoveOsAccountById, TestSize.Level1)
110 {
111 int accountId = 0;
112 std::shared_ptr<AccountBundleInfo> account = std::make_shared<AccountBundleInfo>(accountId);
113 ReclaimPriorityManager::GetInstance().AddOsAccountInfo(account);
114
115 bool isAccountExist = ReclaimPriorityManager::GetInstance().IsOsAccountExist(accountId);
116 EXPECT_EQ(isAccountExist, true);
117
118 ReclaimPriorityManager::GetInstance().RemoveOsAccountById(accountId);
119 isAccountExist = ReclaimPriorityManager::GetInstance().IsOsAccountExist(accountId);
120 EXPECT_EQ(isAccountExist, false);
121 }
122
123 HWTEST_F(ReclaimPriorityManagerTest, IsProcExist, TestSize.Level1)
124 {
125 int pid = 10001;
126 int uid = 20010001;
127 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
128 EXPECT_EQ(accountId, 100);
129
130 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
131 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
132 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
133
134 bool isProcExist = ReclaimPriorityManager::GetInstance().IsProcExist(pid, uid, accountId);
135 EXPECT_EQ(isProcExist, true);
136 isProcExist = ReclaimPriorityManager::GetInstance().IsProcExist(pid+1, uid, accountId);
137 EXPECT_EQ(isProcExist, false);
138
139 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
140 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
141 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
142 }
143
144 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityProcessCreate, TestSize.Level1)
145 {
146 int pid = 10002;
147 int uid = 20010002;
148 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
149 EXPECT_EQ(accountId, 100);
150
151 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
152 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
153 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
154
155 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
156 bool hasBundle = account->HasBundle(uid);
157 EXPECT_EQ(hasBundle, true);
158
159 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
160 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
161
162 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
163 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
164 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
165 }
166
167 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityProcessTerminate, TestSize.Level1)
168 {
169 int pid1 = 10003;
170 int pid2 = 10004;
171 int uid = 20010003;
172 UpdateRequest request1 = CreateUpdateRequest(pid1, uid,
173 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
174 UpdateRequest request2 = CreateUpdateRequest(pid2, uid,
175 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
176 UpdateRequest request3 = CreateUpdateRequest(pid2, uid,
177 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
178 UpdateRequest request4 = CreateUpdateRequest(pid1, uid,
179 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
180 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
181 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
182 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
183
184 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
185 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
186 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
187 bool hasProc1 = bundle->HasProc(pid1);
188 EXPECT_EQ(hasProc1, true);
189 bool hasProc2 = bundle->HasProc(pid2);
190 EXPECT_EQ(hasProc2, false);
191
192 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request4);
193 }
194
195 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBackground, TestSize.Level1)
196 {
197 int pid = 10006;
198 int uid = 20010006;
199 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
200 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
201 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
202 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
203 UpdateRequest request3 = CreateUpdateRequest(pid, uid,
204 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
205 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
206 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
207
208 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
209 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
210 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
211 int priority = bundle->priority_;
212 EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND);
213
214 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
215 }
216
217 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPrioritySuspendDelayStart, TestSize.Level1)
218 {
219 int pid = 10007;
220 int uid = 20010007;
221 printf("process created!");
222 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
223 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
224 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
225 "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::SUSPEND_DELAY_START);
226 UpdateRequest request3 = CreateUpdateRequest(pid, uid,
227 "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::BACKGROUND);
228 UpdateRequest request4 = CreateUpdateRequest(pid, uid,
229 "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::PROCESS_TERMINATED);
230 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
231 PrintReclaimPriorityList();
232
233 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
234 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
235 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
236 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
237
238 printf("process suspend delay start!");
239 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
240 PrintReclaimPriorityList();
241 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_SUSPEND_DELAY);
242
243 printf("process go to background!");
244 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
245 PrintReclaimPriorityList();
246 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_SUSPEND_DELAY);
247
248 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request4);
249 }
250
251 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPrioritySuspendDelayEnd, TestSize.Level1)
252 {
253 int pid = 10008;
254 int uid = 20010008;
255 const std::string bundleName = "com.ohos.reclaim_suspend_delay_end";
256
257 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
258 bundleName, AppStateUpdateReason::CREATE_PROCESS);
259 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
260 bundleName, AppStateUpdateReason::BACKGROUND);
261 UpdateRequest request3 = CreateUpdateRequest(pid, uid,
262 bundleName, AppStateUpdateReason::SUSPEND_DELAY_START);
263 UpdateRequest request4 = CreateUpdateRequest(pid, uid,
264 bundleName, AppStateUpdateReason::SUSPEND_DELAY_END);
265 UpdateRequest request5 = CreateUpdateRequest(pid, uid,
266 bundleName, AppStateUpdateReason::PROCESS_TERMINATED);
267
268 printf("process created!\n");
269 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
270 printf("process go to background!\n");
271 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
272 PrintReclaimPriorityList();
273
274 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
275 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
276 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
277 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
278
279 printf("process suspend delay start!\n");
280 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
281 PrintReclaimPriorityList();
282 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_SUSPEND_DELAY);
283
284 printf("process suspend delay end!\n");
285 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request4);
286 sleep(5);
287 PrintReclaimPriorityList();
288 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
289
290 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request5);
291 }
292
293 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBgRunningStart, TestSize.Level1)
294 {
295 int pid = 10009;
296 int uid = 20010009;
297 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
298 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
299 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
300 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND_RUNNING_START);
301 UpdateRequest request3 = CreateUpdateRequest(pid, uid,
302 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
303 UpdateRequest request4 = CreateUpdateRequest(pid, uid,
304 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
305 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
306 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
307
308 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
309 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
310 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
311 int priority = bundle->priority_;
312 EXPECT_EQ(priority, RECLAIM_PRIORITY_BG_PERCEIVED);
313
314 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
315 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
316 priority = bundle->priority_;
317 EXPECT_EQ(priority, RECLAIM_PRIORITY_BG_PERCEIVED);
318
319 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request4);
320 }
321
322 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBgRunningEnd, TestSize.Level1)
323 {
324 int pid = 10010;
325 int uid = 20010010;
326 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
327 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
328 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
329 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
330 UpdateRequest request3 = CreateUpdateRequest(pid, uid,
331 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND_RUNNING_START);
332 UpdateRequest request4 = CreateUpdateRequest(pid, uid,
333 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND_RUNNING_END);
334 UpdateRequest request5 = CreateUpdateRequest(pid, uid,
335 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
336 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
337 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
338
339 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
340 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
341 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
342 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
343
344 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
345 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED);
346
347
348 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request4);
349 sleep(5);
350 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
351
352 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request5);
353 }
354
355 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventStart, TestSize.Level1)
356 {
357 int pid = 10011;
358 int uid = 20010011;
359 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
360 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
361 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
362 "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_START);
363 UpdateRequest request3 = CreateUpdateRequest(pid, uid,
364 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
365 UpdateRequest request4 = CreateUpdateRequest(pid, uid,
366 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
367 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
368 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
369
370 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
371 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
372 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
373 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED);
374
375 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
376 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
377 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED);
378
379 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request4);
380 }
381
382 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventEnd, TestSize.Level1)
383 {
384 int pid = 10012;
385 int uid = 20010012;
386 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
387 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
388 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
389 "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_START);
390 UpdateRequest request3 = CreateUpdateRequest(pid, uid,
391 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
392 UpdateRequest request4 = CreateUpdateRequest(pid, uid,
393 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
394 UpdateRequest request5 = CreateUpdateRequest(pid, uid,
395 "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_END);
396 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
397 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
398
399 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
400 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
401 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
402 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
403
404 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
405 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED);
406
407 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request5);
408 sleep(5);
409 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
410
411 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request4);
412 }
413
414 HWTEST_F(ReclaimPriorityManagerTest, GetBundlePrioSet, TestSize.Level1)
415 {
416 int pid = 10015;
417 int uid = 20010015;
418 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
419 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
420 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
421 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
422 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
423 ReclaimPriorityManager::BunldeCopySet bundleSet;
424 ReclaimPriorityManager::GetInstance().GetBundlePrioSet(bundleSet);
425 bool isEmpty = bundleSet.size() == 0;
426 EXPECT_EQ(isEmpty, false);
427 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
428 }
429
430 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityApplicationSuspend, TestSize.Level1)
431 {
432 int pid = 10016;
433 int uid = 20010016;
434 UpdateRequest request1 = CreateUpdateRequest(pid, uid,
435 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
436 UpdateRequest request2 = CreateUpdateRequest(pid, uid,
437 "com.ohos.reclaim_test", AppStateUpdateReason::APPLICATION_SUSPEND);
438 UpdateRequest request3 = CreateUpdateRequest(pid, uid,
439 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
440 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
441 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
442
443 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
444 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
445 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
446 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_SUSPEND);
447 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
448 }
449
GetBundle(int pid1,int pid2,int bundleUid,std::string bundleName1,std::string bundleName2)450 std::shared_ptr<BundlePriorityInfo> GetBundle(int pid1, int pid2, int bundleUid, std::string bundleName1,
451 std::string bundleName2)
452 {
453 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(bundleUid);
454 bool isProc1Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid1, bundleUid, accountId);
455 bool isProc2Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid2, bundleUid, accountId);
456 if (!isProc1Exist || !isProc2Exist) {
457 return nullptr;
458 }
459 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
460 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(bundleUid);
461 return bundle;
462 }
463
464 HWTEST_F(ReclaimPriorityManagerTest, DistDeviceCase, TestSize.Level1)
465 {
466 // Preconditions: create one bundle with two freground processes
467 int pid1 = 10017;
468 int pid2 = 10018;
469 int bundleUid = 20010017;
470 const std::string bundleName1 = "com.ohos.reclaim_dist_device_test.process1";
471 const std::string bundleName2 = "com.ohos.reclaim_dist_device_test.process2";
472 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid1, bundleUid,
473 bundleName1, AppStateUpdateReason::CREATE_PROCESS));
474 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
475 bundleName2, AppStateUpdateReason::CREATE_PROCESS));
476
477 std::shared_ptr<BundlePriorityInfo> bundle = GetBundle(pid1, pid2, bundleUid, bundleName1, bundleName2);
478 ASSERT_EQ(bundle == nullptr, false);
479 ProcessPriorityInfo &proc1 = bundle->FindProcByPid(pid1);
480 ProcessPriorityInfo &proc2 = bundle->FindProcByPid(pid2);
481 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
482 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
483 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
484
485 // process#1 keep freground, process#2 go to background
486 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
487 bundleName2, AppStateUpdateReason::BACKGROUND));
488 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
489 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
490 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
491
492 // process#2 is connected to a distribute device
493 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
494 bundleName2, AppStateUpdateReason::DIST_DEVICE_CONNECTED));
495 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
496 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
497 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
498
499 // process#1 go to background
500 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid1, bundleUid,
501 bundleName1, AppStateUpdateReason::BACKGROUND));
502 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
503 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
504 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
505
506 // process#2 is disconnected to a distribute device
507 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
508 bundleName2, AppStateUpdateReason::DIST_DEVICE_DISCONNECTED));
509 sleep(5);
510 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
511 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
512 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
513
514 // clean up the mess
515 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid1, bundleUid,
516 bundleName1, AppStateUpdateReason::PROCESS_TERMINATED));
517 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
518 bundleName2, AppStateUpdateReason::PROCESS_TERMINATED));
519 }
520
521 HWTEST_F(ReclaimPriorityManagerTest, ExtensionBindCase, TestSize.Level1)
522 {
523 // Preconditions: create one bundle with two freground processes
524 ReqExtInfo reqExtInfo1 = {99999, 20099999, 10019, 20010019};
525 ReqExtInfo reqExtInfo2 = {99999, 20099999, 10020, 20010019};
526 int bundleUid = 20010019;
527 std::string caller = "com.ohos.caller";
528 const std::string bundleName1 = "com.ohos.exten_bind_test.main";
529 const std::string bundleName2 = "com.ohos.exten_bind_test.extension";
530
531 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(reqExtInfo1.pid, bundleUid,
532 bundleName1, AppStateUpdateReason::CREATE_PROCESS));
533 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(reqExtInfo2.pid, bundleUid,
534 bundleName2, AppStateUpdateReason::CREATE_PROCESS));
535
536 std::shared_ptr<BundlePriorityInfo> bundle = GetBundle(reqExtInfo1.pid, reqExtInfo2.pid,
537 bundleUid, bundleName1, bundleName2);
538 ASSERT_EQ(bundle == nullptr, false);
539 ProcessPriorityInfo &proc1 = bundle->FindProcByPid(reqExtInfo1.pid);
540 ProcessPriorityInfo &proc2 = bundle->FindProcByPid(reqExtInfo2.pid);
541 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
542 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
543 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
544
545 // process#1 keep freground, process#2 go to background
546 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(reqExtInfo2.pid, bundleUid,
547 bundleName2, AppStateUpdateReason::BACKGROUND));
548 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
549 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
550 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
551
552 // process#2 is bind to a process
553 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequestForExtension(
554 reqExtInfo2, caller, bundleName2, AppStateUpdateReason::BIND_EXTENSION));
555 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
556 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
557 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
558
559 // process#1 go to background
560 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(reqExtInfo1.pid, bundleUid,
561 bundleName1, AppStateUpdateReason::BACKGROUND));
562 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
563 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
564 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
565
566 // process#2 is unbind to a process
567 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequestForExtension(
568 reqExtInfo2, caller, bundleName2, AppStateUpdateReason::UNBIND_EXTENSION));
569 sleep(5);
570 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
571 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_NO_BIND_EXTENSION);
572 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
573
574 // clean up the mess
575 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(reqExtInfo1.pid, bundleUid,
576 bundleName1, AppStateUpdateReason::PROCESS_TERMINATED));
577 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(reqExtInfo2.pid, bundleUid,
578 bundleName2, AppStateUpdateReason::PROCESS_TERMINATED));
579 }
580
581 /**
582 * @tc.name: OsAccountChanged
583 * @tc.desc: Test the value of initialized_ equals to false
584 * @tc.desc: Test the branch of bundle equals to nullptr
585 * @tc.desc: Test the return value
586 * @tc.type: FUNC
587 */
588 HWTEST_F(ReclaimPriorityManagerTest, OsAccountChangedTest, TestSize.Level1)
589 {
590 ReclaimPriorityManager reclPri;
591 reclPri.initialized_ = false;
592 int accountId = 100;
593
594 // Test the value of initialized_ equals to false
595 AccountSA::OS_ACCOUNT_SWITCH_MOD switchMod = AccountSA::OsAccountManager::GetOsAccountSwitchMod();
596 bool accChan = reclPri.OsAccountChanged(accountId, switchMod);
597 EXPECT_EQ(accChan, false);
598
599 // Test the branch of bundle equals to nullptr
600 reclPri.initialized_ = true;
601 accountId = -1;
602 accChan = ReclaimPriorityManager::GetInstance().OsAccountChanged(accountId, switchMod);
603 EXPECT_EQ(accChan, false);
604
605 // Test the return value
606 accountId = 100;
607 accChan = ReclaimPriorityManager::GetInstance().OsAccountChanged(accountId, switchMod);
608 EXPECT_EQ(accChan, true);
609 }
610
611 /**
612 * @tc.name: AddBundleInfoToSet
613 * @tc.desc: Test the branch into "if"
614 * @tc.type: FUNC
615 */
616 HWTEST_F(ReclaimPriorityManagerTest, AddBundleInfoToSetTest, TestSize.Level1)
617 {
618 int accountId = 100;
619 std::shared_ptr<BundlePriorityInfo> bundle = std::make_shared<BundlePriorityInfo>("app",
620 accountId * USER_ID_SHIFT + 1, 100);
621 ProcessPriorityInfo proc1(1001, bundle->uid_, bundle->priority_);
622 ProcessPriorityInfo proc2(1002, bundle->uid_, bundle->priority_);
623 ProcessPriorityInfo proc3(1003, bundle->uid_, bundle->priority_);
624 ProcessPriorityInfo proc4(1004, bundle->uid_, bundle->priority_);
625 bundle->AddProc(proc1);
626 bundle->AddProc(proc2);
627 bundle->AddProc(proc3);
628 bundle->AddProc(proc4);
629 ReclaimPriorityManager::GetInstance().AddBundleInfoToSet(bundle);
630 ReclaimPriorityManager totBun;
631 auto ret = totBun.totalBundlePrioSet_.insert(bundle);
632 EXPECT_EQ(ret.second, true);
633 }
634
635 /**
636 * @tc.name: UpdateBundlePriority
637 * @tc.desc: Test Update the value of bundle
638 * @tc.type: FUNC
639 */
640 HWTEST_F(ReclaimPriorityManagerTest, UpdateBundlePriorityTest, TestSize.Level1)
641 {
642 int accountId = 100;
643 std::shared_ptr<BundlePriorityInfo> bundle = std::make_shared<BundlePriorityInfo>("app",
644 accountId * USER_ID_SHIFT + 1, 100);
645 ProcessPriorityInfo proc1(1001, bundle->uid_, bundle->priority_);
646 ProcessPriorityInfo proc2(1002, bundle->uid_, bundle->priority_);
647 ProcessPriorityInfo proc3(1003, bundle->uid_, bundle->priority_);
648 ProcessPriorityInfo proc4(1004, bundle->uid_, bundle->priority_);
649 bundle->AddProc(proc1);
650 bundle->AddProc(proc2);
651 bundle->AddProc(proc3);
652 bundle->AddProc(proc4);
653 ReclaimPriorityManager::GetInstance().UpdateBundlePriority(bundle);
654 ReclaimPriorityManager totBun;
655 auto ret = totBun.totalBundlePrioSet_.insert(bundle);
656 EXPECT_EQ(ret.second, true);
657 }
658
659 /**
660 * @tc.name: DeleteBundleInfoFromSet
661 * @tc.desc: Test Delete the value of bundle
662 * @tc.type: FUNC
663 */
664 HWTEST_F(ReclaimPriorityManagerTest, DeleteBundleInfoFromSetTest, TestSize.Level1)
665 {
666 int accountId = 100;
667 std::shared_ptr<BundlePriorityInfo> bundle1 = std::make_shared<BundlePriorityInfo>("app",
668 accountId * USER_ID_SHIFT + 1, 100);
669 std::shared_ptr<BundlePriorityInfo> bundle2 = std::make_shared<BundlePriorityInfo>("app",
670 accountId * USER_ID_SHIFT + 1, 100);
671 ReclaimPriorityManager::GetInstance().DeleteBundleInfoFromSet(bundle2);
672 EXPECT_NE(bundle1, bundle2);
673 }
674
675 /**
676 * @tc.name: GetOneKillableBundle
677 * @tc.desc: Test the branch into "for"
678 * @tc.desc: Test the branch into bundle->priority_ < minPrio
679 * @tc.desc: Test the branch into bundle->GetState() == STATE_WAITING_FOR_KILL
680 * @tc.type: FUNC
681 */
682 HWTEST_F(ReclaimPriorityManagerTest, GetOneKillableBundleTest, TestSize.Level1)
683 {
684 ReclaimPriorityManager tolBun1;
685 ReclaimPriorityManager tolBun2;
686 ReclaimPriorityManager::BunldeCopySet bundleSet;
687 int accountId = 100;
688 int minPrio = 200;
689 std::shared_ptr<BundlePriorityInfo> bundle1 = std::make_shared<BundlePriorityInfo>("app",
690 accountId * USER_ID_SHIFT + 1, 100);
691 std::shared_ptr<BundlePriorityInfo> bundle2 = std::make_shared<BundlePriorityInfo>("app",
692 accountId * USER_ID_SHIFT + 1, 100, 1, BundleState::STATE_WAITING_FOR_KILL);
693 tolBun1.totalBundlePrioSet_.insert(bundle1);
694 auto itrBundle1 = tolBun1.totalBundlePrioSet_.rbegin();
695
696 // Test the branch into "for"
697 ReclaimPriorityManager::GetInstance().GetOneKillableBundle(minPrio, bundleSet);
698 EXPECT_NE(itrBundle1, tolBun1.totalBundlePrioSet_.rend());
699
700 tolBun2.totalBundlePrioSet_.insert(bundle2);
701 auto itrBundle2 = tolBun2.totalBundlePrioSet_.rbegin();
702 std::shared_ptr<BundlePriorityInfo> bundle3 = *itrBundle2;
703
704 // Test the branch into priority_ < minPrio
705 ReclaimPriorityManager::GetInstance().GetOneKillableBundle(minPrio, bundleSet);
706 EXPECT_EQ(bundle3->GetState(), BundleState::STATE_WAITING_FOR_KILL);
707
708 // Test the branch into GetState() equals to STATE_WAITING_FOR_KILL
709 ReclaimPriorityManager::GetInstance().GetOneKillableBundle(minPrio, bundleSet);
710 EXPECT_LT(bundle3->priority_, minPrio);
711 }
712
713 /**
714 * @tc.name: AppStateUpdateResonToString
715 * @tc.desc: Test the branch into "if == true"
716 * @tc.desc: Test the branch into "else"
717 * @tc.type: FUNC
718 */
719 HWTEST_F(ReclaimPriorityManagerTest, AppStateUpdateResonToStringTest, TestSize.Level1)
720 {
721 ReclaimPriorityManager appState;
722 AppStateUpdateReason reason1 = AppStateUpdateReason::CREATE_PROCESS;
723 int reason2 = -1;
724
725 // Test the branch into "if == true"
726 ReclaimPriorityManager::GetInstance().AppStateUpdateResonToString(reason1);
727 auto ptr = appState.updateReasonStrMapping_.find(static_cast<int32_t>(reason1));
728 EXPECT_NE(ptr, appState.updateReasonStrMapping_.end());
729
730 // Test the branch into "else"
731 ReclaimPriorityManager::GetInstance().AppStateUpdateResonToString(static_cast<AppStateUpdateReason>(reason2));
732 ptr = appState.updateReasonStrMapping_.find(reason2);
733 EXPECT_EQ(ptr, appState.updateReasonStrMapping_.end());
734 }
735
736 }
737 }
738