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 
165     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
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_FOREGROUND);
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 HWTEST_F(ReclaimPriorityManagerTest, CheckCreateProcPriorityDelay_test1, TestSize.Level1)
454 {
455     int pid = 10023;
456     int uid = 20010023;
457     UpdateRequest request1 = CreateUpdateRequest(pid, uid,
458                                 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
459     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
460 
461     int accountId = GetOsAccountIdByUid(uid);
462     std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
463     std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
464     ProcessPriorityInfo& proc = bundle->FindProcByPid(pid);
465     EXPECT_EQ(proc.priority_, RECLAIM_PRIORITY_FOREGROUND);
466     UpdateRequest request2 = CreateUpdateRequest(pid, uid,
467                                 "com.ohos.reclaim_test", AppStateUpdateReason::UNBIND_EXTENSION);
468     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
469     EXPECT_EQ(proc.priority_, RECLAIM_PRIORITY_NO_BIND_EXTENSION);
470     UpdateRequest request3 = CreateUpdateRequest(pid, uid,
471                                 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
472 }
473 
474 HWTEST_F(ReclaimPriorityManagerTest, CheckCreateProcPriorityDelay_test2, TestSize.Level1)
475 {
476     int pid = 10024;
477     int uid = 20010024;
478     UpdateRequest request1 = CreateUpdateRequest(pid, uid,
479                                 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
480     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
481 
482     int accountId = GetOsAccountIdByUid(uid);
483     std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
484     std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
485     ProcessPriorityInfo& proc = bundle->FindProcByPid(pid);
486     EXPECT_EQ(proc.priority_, RECLAIM_PRIORITY_FOREGROUND);
487     Sleep(20);
488     EXPECT_EQ(proc.priority_, RECLAIM_PRIORITY_BACKGROUND);
489 }
490 
491 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityApplicationSuspend, TestSize.Level1)
492 {
493     int pid = 10016;
494     int uid = 20010016;
495     UpdateRequest request1 = CreateUpdateRequest(pid, uid,
496                                 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
497     UpdateRequest request2 = CreateUpdateRequest(pid, uid,
498                                 "com.ohos.reclaim_test", AppStateUpdateReason::APPLICATION_SUSPEND);
499     UpdateRequest request3 = CreateUpdateRequest(pid, uid,
500                                 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
501     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request1);
502     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request2);
503 
504     int accountId = GetOsAccountIdByUid(uid);
505     std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
506     std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
507     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_SUSPEND);
508     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(request3);
509 }
510 
GetBundle(int pid1,int pid2,int bundleUid,std::string bundleName1,std::string bundleName2)511 std::shared_ptr<BundlePriorityInfo> GetBundle(int pid1, int pid2, int bundleUid, std::string bundleName1,
512     std::string bundleName2)
513 {
514     int accountId = GetOsAccountIdByUid(bundleUid);
515     bool isProc1Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid1, bundleUid, accountId);
516     bool isProc2Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid2, bundleUid, accountId);
517     if (!isProc1Exist || !isProc2Exist) {
518         return nullptr;
519     }
520     std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
521     std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(bundleUid);
522     return bundle;
523 }
524 
525 HWTEST_F(ReclaimPriorityManagerTest, DistDeviceCase, TestSize.Level1)
526 {
527     // Preconditions: create one bundle with two freground processes
528     int pid1 = 10017;
529     int pid2 = 10018;
530     int bundleUid = 20010017;
531     const std::string bundleName1 = "com.ohos.reclaim_dist_device_test.process1";
532     const std::string bundleName2 = "com.ohos.reclaim_dist_device_test.process2";
533     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid1, bundleUid,
534         bundleName1, AppStateUpdateReason::CREATE_PROCESS));
535     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
536         bundleName2, AppStateUpdateReason::CREATE_PROCESS));
537 
538     std::shared_ptr<BundlePriorityInfo> bundle = GetBundle(pid1, pid2, bundleUid, bundleName1, bundleName2);
539     ASSERT_EQ(bundle == nullptr, false);
540     ProcessPriorityInfo &proc1 = bundle->FindProcByPid(pid1);
541     ProcessPriorityInfo &proc2 = bundle->FindProcByPid(pid2);
542     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
543     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FOREGROUND);
544     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
545 
546     // process#1 keep freground, process#2 go to background
547     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
548         bundleName2, AppStateUpdateReason::BACKGROUND));
549     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
550     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
551     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
552 
553     // process#2 is connected to a distribute device
554     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
555         bundleName2, AppStateUpdateReason::DIST_DEVICE_CONNECTED));
556     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
557     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
558     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
559 
560     // process#1 go to background
561     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid1, bundleUid,
562         bundleName1, AppStateUpdateReason::BACKGROUND));
563     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
564     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
565     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
566 
567     // process#2 is disconnected to a distribute device
568     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
569         bundleName2, AppStateUpdateReason::DIST_DEVICE_DISCONNECTED));
570     sleep(5);
571     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
572     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
573     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
574 
575     // clean up the mess
576     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid1, bundleUid,
577         bundleName1, AppStateUpdateReason::PROCESS_TERMINATED));
578     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(pid2, bundleUid,
579         bundleName2, AppStateUpdateReason::PROCESS_TERMINATED));
580 }
581 
582 HWTEST_F(ReclaimPriorityManagerTest, ExtensionBindCase, TestSize.Level1)
583 {
584     // Preconditions: create one bundle with two freground processes
585     ProcUpdateInfo caller = {99999, 20099999, "com.ohos.caller"};
586     ProcUpdateInfo targets1 = {10019, 20010019, "com.ohos.exten_bind_test.main"};
587     ProcUpdateInfo targets2 = {10020, 20010019, "com.ohos.exten_bind_test.extension"};
588 
589     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(targets1.pid, targets1.uid,
590         targets1.bundleName, AppStateUpdateReason::CREATE_PROCESS));
591     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(targets2.pid, targets2.uid,
592         targets2.bundleName, AppStateUpdateReason::CREATE_PROCESS));
593 
594     std::shared_ptr<BundlePriorityInfo> bundle = GetBundle(targets1.pid, targets2.pid, targets1.uid,
595         targets1.bundleName, targets2.bundleName);
596     ASSERT_EQ(bundle == nullptr, false);
597     ProcessPriorityInfo &proc1 = bundle->FindProcByPid(targets1.pid);
598     ProcessPriorityInfo &proc2 = bundle->FindProcByPid(targets2.pid);
599     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
600     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FOREGROUND);
601     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
602 
603     // process#1 keep freground, process#2 go to background
604     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(targets2.pid, targets2.uid,
605         targets2.bundleName, AppStateUpdateReason::BACKGROUND));
606     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
607     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
608     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
609 
610     // process#2 is bind to a process
611     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequestForExtension(
612         caller, targets2, AppStateUpdateReason::BIND_EXTENSION));
613     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
614     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
615     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
616 
617     // process#1 go to background
618     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(targets1.pid, targets1.uid,
619         targets1.bundleName, AppStateUpdateReason::BACKGROUND));
620     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
621     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
622     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
623 
624     // process#2 is unbind to a process
625     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequestForExtension(
626         caller, targets2, AppStateUpdateReason::UNBIND_EXTENSION));
627     sleep(5);
628     ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
629     ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_NO_BIND_EXTENSION);
630     ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
631 
632     // clean up the mess
633     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(targets1.pid, targets1.uid,
634         targets1.bundleName, AppStateUpdateReason::PROCESS_TERMINATED));
635     ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(CreateUpdateRequest(targets2.pid, targets2.uid,
636         targets2.bundleName, AppStateUpdateReason::PROCESS_TERMINATED));
637 }
638 
639 /**
640  * @tc.name: OsAccountChanged
641  * @tc.desc: Test the value of initialized_ equals to false
642  * @tc.desc: Test the branch of bundle equals to nullptr
643  * @tc.desc: Test the return value
644  * @tc.type: FUNC
645  */
646 HWTEST_F(ReclaimPriorityManagerTest, OsAccountChangedTest, TestSize.Level1)
647 {
648     ReclaimPriorityManager reclPri;
649     reclPri.initialized_ = false;
650     int accountId = 100;
651 
652     // Test the value of initialized_ equals to false
653     AccountSA::OS_ACCOUNT_SWITCH_MOD switchMod = AccountSA::OsAccountManager::GetOsAccountSwitchMod();
654     bool accChan = reclPri.OsAccountChanged(accountId, switchMod);
655     EXPECT_EQ(accChan, false);
656 
657     // Test the branch of bundle equals to nullptr
658     reclPri.initialized_ = true;
659     accountId = -1;
660     accChan = ReclaimPriorityManager::GetInstance().OsAccountChanged(accountId, switchMod);
661     EXPECT_EQ(accChan, false);
662 
663     // Test the return value
664     accountId = 100;
665     accChan = ReclaimPriorityManager::GetInstance().OsAccountChanged(accountId, switchMod);
666     EXPECT_EQ(accChan, true);
667 }
668 
669 /**
670  * @tc.name: AddBundleInfoToSet
671  * @tc.desc: Test the branch into "if"
672  * @tc.type: FUNC
673  */
674 HWTEST_F(ReclaimPriorityManagerTest, AddBundleInfoToSetTest, TestSize.Level1)
675 {
676     int accountId = 100;
677     std::shared_ptr<BundlePriorityInfo> bundle = std::make_shared<BundlePriorityInfo>("app",
678             accountId * USER_ID_SHIFT + 1, 100);
679     ProcessPriorityInfo proc1(1001, bundle->uid_, bundle->priority_);
680     ProcessPriorityInfo proc2(1002, bundle->uid_, bundle->priority_);
681     ProcessPriorityInfo proc3(1003, bundle->uid_, bundle->priority_);
682     ProcessPriorityInfo proc4(1004, bundle->uid_, bundle->priority_);
683     bundle->AddProc(proc1);
684     bundle->AddProc(proc2);
685     bundle->AddProc(proc3);
686     bundle->AddProc(proc4);
687     ReclaimPriorityManager::GetInstance().AddBundleInfoToSet(bundle);
688     ReclaimPriorityManager totBun;
689     auto ret = totBun.totalBundlePrioSet_.insert(bundle);
690     EXPECT_EQ(ret.second, true);
691 }
692 
693 /**
694  * @tc.name: UpdateBundlePriority
695  * @tc.desc: Test Update the value of bundle
696  * @tc.type: FUNC
697  */
698 HWTEST_F(ReclaimPriorityManagerTest, UpdateBundlePriorityTest, TestSize.Level1)
699 {
700     int accountId = 100;
701     std::shared_ptr<BundlePriorityInfo> bundle = std::make_shared<BundlePriorityInfo>("app",
702             accountId * USER_ID_SHIFT + 1, 100);
703     ProcessPriorityInfo proc1(1001, bundle->uid_, bundle->priority_);
704     ProcessPriorityInfo proc2(1002, bundle->uid_, bundle->priority_);
705     ProcessPriorityInfo proc3(1003, bundle->uid_, bundle->priority_);
706     ProcessPriorityInfo proc4(1004, bundle->uid_, bundle->priority_);
707     bundle->AddProc(proc1);
708     bundle->AddProc(proc2);
709     bundle->AddProc(proc3);
710     bundle->AddProc(proc4);
711     ReclaimPriorityManager::GetInstance().UpdateBundlePriority(bundle);
712     ReclaimPriorityManager totBun;
713     auto ret = totBun.totalBundlePrioSet_.insert(bundle);
714     EXPECT_EQ(ret.second, true);
715 }
716 
717 /**
718  * @tc.name: DeleteBundleInfoFromSet
719  * @tc.desc: Test Delete the value of bundle
720  * @tc.type: FUNC
721  */
722 HWTEST_F(ReclaimPriorityManagerTest, DeleteBundleInfoFromSetTest, TestSize.Level1)
723 {
724     int accountId = 100;
725     std::shared_ptr<BundlePriorityInfo> bundle1 = std::make_shared<BundlePriorityInfo>("app",
726             accountId * USER_ID_SHIFT + 1, 100);
727     std::shared_ptr<BundlePriorityInfo> bundle2 = std::make_shared<BundlePriorityInfo>("app",
728             accountId * USER_ID_SHIFT + 1, 100);
729     ReclaimPriorityManager::GetInstance().DeleteBundleInfoFromSet(bundle2);
730     EXPECT_NE(bundle1, bundle2);
731 }
732 
733 /**
734  * @tc.name: GetOneKillableBundle
735  * @tc.desc: Test the branch into "for"
736  * @tc.desc: Test the branch into bundle->priority_ < minPrio
737  * @tc.desc: Test the branch into bundle->GetState() == STATE_WAITING_FOR_KILL
738  * @tc.type: FUNC
739  */
740 HWTEST_F(ReclaimPriorityManagerTest, GetOneKillableBundleTest, TestSize.Level1)
741 {
742     ReclaimPriorityManager tolBun1;
743     ReclaimPriorityManager tolBun2;
744     ReclaimPriorityManager::BunldeCopySet bundleSet;
745     int accountId = 100;
746     int minPrio = 200;
747     std::shared_ptr<BundlePriorityInfo> bundle1 = std::make_shared<BundlePriorityInfo>("app",
748             accountId * USER_ID_SHIFT + 1, 100);
749     std::shared_ptr<BundlePriorityInfo> bundle2 = std::make_shared<BundlePriorityInfo>("app",
750             accountId * USER_ID_SHIFT + 1, 100, 1, BundleState::STATE_WAITING_FOR_KILL);
751     tolBun1.totalBundlePrioSet_.insert(bundle1);
752     auto itrBundle1 = tolBun1.totalBundlePrioSet_.rbegin();
753 
754     // Test the branch into "for"
755     ReclaimPriorityManager::GetInstance().GetOneKillableBundle(minPrio, bundleSet);
756     EXPECT_NE(itrBundle1, tolBun1.totalBundlePrioSet_.rend());
757 
758     tolBun2.totalBundlePrioSet_.insert(bundle2);
759     auto itrBundle2 = tolBun2.totalBundlePrioSet_.rbegin();
760     std::shared_ptr<BundlePriorityInfo> bundle3 = *itrBundle2;
761 
762     // Test the branch into priority_ < minPrio
763     ReclaimPriorityManager::GetInstance().GetOneKillableBundle(minPrio, bundleSet);
764     EXPECT_EQ(bundle3->GetState(), BundleState::STATE_WAITING_FOR_KILL);
765 
766     // Test the branch into GetState() equals to STATE_WAITING_FOR_KILL
767     ReclaimPriorityManager::GetInstance().GetOneKillableBundle(minPrio, bundleSet);
768     EXPECT_LT(bundle3->priority_, minPrio);
769 }
770 
771 /**
772  * @tc.name: AppStateUpdateResonToString
773  * @tc.desc: Test the branch into "if == true"
774  * @tc.desc: Test the branch into "else"
775  * @tc.type: FUNC
776  */
777 HWTEST_F(ReclaimPriorityManagerTest, AppStateUpdateResonToStringTest, TestSize.Level1)
778 {
779     ReclaimPriorityManager appState;
780     AppStateUpdateReason reason1 = AppStateUpdateReason::CREATE_PROCESS;
781     int reason2 = -1;
782 
783     // Test the branch into "if == true"
784     ReclaimPriorityManager::GetInstance().AppStateUpdateResonToString(reason1);
785     auto ptr = appState.updateReasonStrMapping_.find(static_cast<int32_t>(reason1));
786     EXPECT_NE(ptr, appState.updateReasonStrMapping_.end());
787 
788     // Test the branch into "else"
789     ReclaimPriorityManager::GetInstance().AppStateUpdateResonToString(static_cast<AppStateUpdateReason>(reason2));
790     ptr = appState.updateReasonStrMapping_.find(reason2);
791     EXPECT_EQ(ptr, appState.updateReasonStrMapping_.end());
792 }
793 
794 HWTEST_F(ReclaimPriorityManagerTest, UpdateRecalimPrioritySyncWithLockTest1, TestSize.Level1)
795 {
796     ReclaimPriorityManager manager;
797     manager.Init();
798     std::string bundleName = "test1_for_ability_start_sync";
799     int32_t callerPid = -1;
800     int32_t callerUid = -1;
801     int32_t pid = 11667;
802     int32_t bundleUid = 20090001;
803     AppStateUpdateReason stateReason = AppStateUpdateReason::CREATE_PROCESS;
804     manager.UpdateReclaimPriorityInner(SingleRequest({pid, bundleUid, "", bundleName}, stateReason));
805     manager.Dump(1);
806 
807 
808     int accountId = GetOsAccountIdByUid(bundleUid);
809     std::shared_ptr<AccountBundleInfo> account = manager.FindOsAccountById(accountId);
810     bool hasBundle = account->HasBundle(bundleUid);
811     EXPECT_EQ(hasBundle, true);
812     std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(bundleUid);
813 
814     stateReason = AppStateUpdateReason::BACKGROUND;
815     manager.UpdateReclaimPriorityInner(SingleRequest({pid, bundleUid, "", bundleName}, stateReason));
816     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
817     manager.Dump(1);
818 
819     stateReason = AppStateUpdateReason::ABILITY_START;
820     manager.UpdateRecalimPrioritySyncWithLock(CallerRequest({callerPid, callerUid, "", ""},
821         {pid, bundleUid, "", bundleName}, stateReason));
822     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
823     manager.Dump(1);
824 
825     Sleep(15);
826     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
827     manager.Dump(1);
828 }
829 
830 HWTEST_F(ReclaimPriorityManagerTest, UpdateRecalimPrioritySyncWithLockTest2, TestSize.Level1)
831 {
832     ReclaimPriorityManager manager;
833     manager.Init();
834     std::string bundleName = "test2_for_ability_start_sync";
835     int32_t callerPid = -1;
836     int32_t callerUid = -1;
837     int32_t pid = 11669;
838     int32_t bundleUid = 20290001;
839     AppStateUpdateReason stateReason = AppStateUpdateReason::CREATE_PROCESS;
840     manager.UpdateReclaimPriorityInner(SingleRequest({pid, bundleUid, "", bundleName}, stateReason));
841     manager.Dump(1);
842 
843     int accountId = GetOsAccountIdByUid(bundleUid);
844     std::shared_ptr<AccountBundleInfo> account = manager.FindOsAccountById(accountId);
845     bool hasBundle = account->HasBundle(bundleUid);
846     EXPECT_EQ(hasBundle, true);
847     std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(bundleUid);
848 
849     stateReason = AppStateUpdateReason::SUSPEND_DELAY_START;
850     manager.UpdateReclaimPriorityInner(SingleRequest({pid, bundleUid, "", bundleName}, stateReason));
851     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_SUSPEND_DELAY);
852     manager.Dump(1);
853 
854     stateReason = AppStateUpdateReason::ABILITY_START;
855     manager.UpdateRecalimPrioritySyncWithLock(CallerRequest({callerPid, callerUid, "", ""},
856         {pid, bundleUid, "", bundleName}, stateReason));
857     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
858     manager.Dump(1);
859 
860     Sleep(15);
861     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_SUSPEND_DELAY);
862     manager.Dump(1);
863 }
864 
865 HWTEST_F(ReclaimPriorityManagerTest, NotifyProcessStateChangedAsyncTest, TestSize.Level1)
866 {
867     ReclaimPriorityManager manager;
868     manager.Init();
869     std::string bundleName = "test1_for_ability_start_async";
870     int32_t callerPid = -1;
871     int32_t callerUid = -1;
872     int32_t pid = 11998;
873     int32_t bundleUid = 20040004;
874     AppStateUpdateReason stateReason = AppStateUpdateReason::CREATE_PROCESS;
875     manager.UpdateReclaimPriorityInner(SingleRequest({pid, bundleUid, "", bundleName}, stateReason));
876     manager.Dump(1);
877 
878     int accountId = GetOsAccountIdByUid(bundleUid);
879     std::shared_ptr<AccountBundleInfo> account = manager.FindOsAccountById(accountId);
880     bool hasBundle = account->HasBundle(bundleUid);
881     EXPECT_EQ(hasBundle, true);
882     std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(bundleUid);
883 
884     stateReason = AppStateUpdateReason::BACKGROUND;
885     manager.UpdateReclaimPriorityInner(SingleRequest({pid, bundleUid, "", bundleName}, stateReason));
886     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
887     manager.Dump(1);
888 
889     stateReason = AppStateUpdateReason::ABILITY_START;
890     manager.UpdateReclaimPriority(CallerRequest({callerPid, callerUid, "", ""},
891         {pid, bundleUid, "", bundleName}, stateReason));
892     Sleep(4);
893     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
894     manager.Dump(1);
895 
896     Sleep(15);
897     EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
898     manager.Dump(1);
899 }
900 }
901 }