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