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