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
PrintReclaimPriorityList()55 static void PrintReclaimPriorityList()
56 {
57 ReclaimPriorityManager::BunldeCopySet bundleSet;
58 ReclaimPriorityManager::GetInstance().GetBundlePrioSet(bundleSet);
59 printf("begin print reclaim priority list. \n");
60 printf(" uid name priority accountId\n");
61 for (auto bi : bundleSet) {
62 printf("%3d\t%42s\t%5d\t%3d\n", bi.uid_, bi.name_.c_str(), bi.priority_, bi.accountId_);
63 for (auto piPair : bi.procs_) {
64 ProcessPriorityInfo &pi = piPair.second;
65 printf("\tuid_=%3d, pid_=%5d, priority_=%5d, isFg=%d, isBgTsk=%d, isSusDelay=%d, isDistDevConn=%d, "
66 "extensionBindStatus=%d\n",
67 pi.uid_, pi.pid_, pi.priority_, pi.isFreground, pi.isBackgroundRunning, pi.isSuspendDelay,
68 pi.isDistDeviceConnected, pi.extensionBindStatus);
69 }
70 }
71 printf("-------------------------------------------------------------------------------\n");
72 }
73
74 HWTEST_F(ReclaimPriorityManagerTest, AddOsAccountInfo, TestSize.Level1)
75 {
76 int account_id = 0;
77 std::shared_ptr<AccountBundleInfo> account = std::make_shared<AccountBundleInfo>(account_id);
78 ReclaimPriorityManager::GetInstance().AddOsAccountInfo(account);
79
80 bool isAccountExist = ReclaimPriorityManager::GetInstance().IsOsAccountExist(account_id);
81 EXPECT_EQ(isAccountExist, true);
82 }
83
84 HWTEST_F(ReclaimPriorityManagerTest, RemoveOsAccountById, TestSize.Level1)
85 {
86 int account_id = 0;
87 std::shared_ptr<AccountBundleInfo> account = std::make_shared<AccountBundleInfo>(account_id);
88 ReclaimPriorityManager::GetInstance().AddOsAccountInfo(account);
89
90 bool isAccountExist = ReclaimPriorityManager::GetInstance().IsOsAccountExist(account_id);
91 EXPECT_EQ(isAccountExist, true);
92
93 ReclaimPriorityManager::GetInstance().RemoveOsAccountById(account_id);
94 isAccountExist = ReclaimPriorityManager::GetInstance().IsOsAccountExist(account_id);
95 EXPECT_EQ(isAccountExist, false);
96 }
97
98 HWTEST_F(ReclaimPriorityManagerTest, IsProcExist, TestSize.Level1)
99 {
100 int pid = 10001;
101 int uid = 20010001;
102 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
103 EXPECT_EQ(account_id, 100);
104
105 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
106 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
107
108 bool isProcExist = ReclaimPriorityManager::GetInstance().IsProcExist(pid, uid, account_id);
109 EXPECT_EQ(isProcExist, true);
110 isProcExist = ReclaimPriorityManager::GetInstance().IsProcExist(pid+1, uid, account_id);
111 EXPECT_EQ(isProcExist, false);
112
113 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
114 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
115 }
116
117 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityProcessCreate, TestSize.Level1)
118 {
119 int pid = 10002;
120 int uid = 20010002;
121 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
122 EXPECT_EQ(account_id, 100);
123
124 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
125 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
126
127 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
128 bool hasBundle = account->HasBundle(uid);
129 EXPECT_EQ(hasBundle, true);
130
131 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
132 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
133
134 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
135 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
136 }
137
138 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityProcessTerminate, TestSize.Level1)
139 {
140 int pid_1 = 10003;
141 int pid_2 = 10004;
142 int uid = 20010003;
143 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid_1, uid,
144 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
145 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid_2, uid,
146 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
147 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid_2, uid,
148 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
149
150 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
151 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
152 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
153 bool hasProc_1 = bundle->HasProc(pid_1);
154 EXPECT_EQ(hasProc_1, true);
155 bool hasProc_2 = bundle->HasProc(pid_2);
156 EXPECT_EQ(hasProc_2, false);
157
158 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid_1, uid,
159 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
160 }
161
162 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBackground, TestSize.Level1)
163 {
164 int pid = 10006;
165 int uid = 20010006;
166 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
167 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
168 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
169 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
170
171 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
172 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
173 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
174 int priority = bundle->priority_;
175 EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND);
176
177 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
178 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
179 }
180
181 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPrioritySuspendDelayStart, TestSize.Level1)
182 {
183 int pid = 10007;
184 int uid = 20010007;
185 printf("process created!");
186 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
187 "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::CREATE_PROCESS);
188 PrintReclaimPriorityList();
189
190 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
191 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
192 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
193 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
194
195 printf("process suspend delay start!");
196 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
197 "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::SUSPEND_DELAY_START);
198 PrintReclaimPriorityList();
199 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
200
201 printf("process go to background!");
202 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
203 "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::BACKGROUND);
204 PrintReclaimPriorityList();
205 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_SUSPEND_DELAY);
206
207 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
208 "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::PROCESS_TERMINATED);
209 }
210
211 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPrioritySuspendDelayEnd, TestSize.Level1)
212 {
213 int pid = 10008;
214 int uid = 20010008;
215 const std::string bundleName = "com.ohos.reclaim_suspend_delay_end";
216
217 printf("process created!\n");
218 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName,
219 AppStateUpdateReason::CREATE_PROCESS);
220 printf("process go to background!\n");
221 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName,
222 AppStateUpdateReason::BACKGROUND);
223 PrintReclaimPriorityList();
224
225 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
226 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
227 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
228 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
229
230 printf("process suspend delay start!\n");
231 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName,
232 AppStateUpdateReason::SUSPEND_DELAY_START);
233 PrintReclaimPriorityList();
234 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_SUSPEND_DELAY);
235
236 printf("process suspend delay end!\n");
237 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName,
238 AppStateUpdateReason::SUSPEND_DELAY_END);
239 sleep(5);
240 PrintReclaimPriorityList();
241 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
242
243 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName,
244 AppStateUpdateReason::PROCESS_TERMINATED);
245 }
246
247 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBgRunningStart, TestSize.Level1)
248 {
249 int pid = 10009;
250 int uid = 20010009;
251 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
252 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
253 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
254 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND_RUNNING_START);
255
256 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
257 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
258 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
259 int priority = bundle->priority_;
260 EXPECT_EQ(priority, RECLAIM_PRIORITY_FOREGROUND);
261
262 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
263 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
264 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
265 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND_RUNNING_START);
266 priority = bundle->priority_;
267 EXPECT_EQ(priority, RECLAIM_PRIORITY_BG_PERCEIVED);
268
269 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
270 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
271 }
272
273 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBgRunningEnd, TestSize.Level1)
274 {
275 int pid = 10010;
276 int uid = 20010010;
277
278 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
279 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
280 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
281 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
282
283 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
284 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
285 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
286 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
287
288 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
289 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND_RUNNING_START);
290 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED);
291
292
293 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
294 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND_RUNNING_END);
295 sleep(5);
296 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
297
298 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
299 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
300 }
301
302 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventStart, TestSize.Level1)
303 {
304 int pid = 10011;
305 int uid = 20010011;
306 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
307 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
308 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
309 "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_START);
310
311 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
312 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
313 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
314 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
315
316 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
317 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
318 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
319 "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_START);
320 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED);
321
322 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
323 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
324 }
325
326 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventEnd, TestSize.Level1)
327 {
328 int pid = 10012;
329 int uid = 20010012;
330 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
331 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
332 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
333 "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND);
334
335 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
336 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
337 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
338 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
339
340 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
341 "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_START);
342 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED);
343
344 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
345 "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_END);
346 sleep(5);
347 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
348
349 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
350 "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED);
351 }
352
353 HWTEST_F(ReclaimPriorityManagerTest, GetBundlePrioSet, TestSize.Level1)
354 {
355 int pid = 10015;
356 int uid = 20010015;
357 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
358 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
359 ReclaimPriorityManager::BunldeCopySet bundleSet;
360 ReclaimPriorityManager::GetInstance().GetBundlePrioSet(bundleSet);
361 bool isEmpty = bundleSet.size() == 0;
362 EXPECT_EQ(isEmpty, false);
363 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test",
364 AppStateUpdateReason::PROCESS_TERMINATED);
365 }
366
367 HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityApplicationSuspend, TestSize.Level1)
368 {
369 int pid = 10016;
370 int uid = 20010016;
371 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid,
372 "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS);
373 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(IGNORE_PID, uid,
374 "com.ohos.reclaim_test", AppStateUpdateReason::APPLICATION_SUSPEND);
375
376 int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid);
377 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id);
378 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(uid);
379 EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_SUSPEND);
380 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test",
381 AppStateUpdateReason::PROCESS_TERMINATED);
382 }
383
384 HWTEST_F(ReclaimPriorityManagerTest, DistDeviceCase, TestSize.Level1)
385 {
386 // Preconditions: create one bundle with two freground processes
387 printf("Preconditions: create one bundle with two freground processes\n");
388 int pid1 = 10017;
389 int pid2 = 10018;
390 int bundleUid = 20010017;
391 const std::string bundleName1 = "com.ohos.reclaim_dist_device_test.process1";
392 const std::string bundleName2 = "com.ohos.reclaim_dist_device_test.process2";
393 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid1, bundleUid, bundleName1,
394 AppStateUpdateReason::CREATE_PROCESS);
395 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2,
396 AppStateUpdateReason::CREATE_PROCESS);
397
398 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(bundleUid);
399 bool isProc1Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid1, bundleUid, accountId);
400 ASSERT_EQ(isProc1Exist, true);
401 bool isProc2Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid2, bundleUid, accountId);
402 ASSERT_EQ(isProc2Exist, true);
403 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
404 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(bundleUid);
405 ProcessPriorityInfo &proc1 = bundle->FindProcByPid(pid1);
406 ProcessPriorityInfo &proc2 = bundle->FindProcByPid(pid2);
407 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
408 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FOREGROUND);
409 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
410 PrintReclaimPriorityList();
411
412 // process#1 keep freground, process#2 go to background
413 printf("process#1 keep freground, process#2 go to background\n");
414 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2,
415 AppStateUpdateReason::BACKGROUND);
416 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
417 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
418 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
419 PrintReclaimPriorityList();
420
421 // process#2 is connected to a distribute device
422 printf("process#1 is connected to a distribute device\n");
423 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2,
424 AppStateUpdateReason::DIST_DEVICE_CONNECTED);
425 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
426 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
427 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
428 PrintReclaimPriorityList();
429
430 // process#1 go to background
431 printf("process#1 go to background\n");
432 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid1, bundleUid, bundleName1,
433 AppStateUpdateReason::BACKGROUND);
434 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
435 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
436 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE);
437 PrintReclaimPriorityList();
438
439 // process#2 is disconnected to a distribute device
440 printf("process#2 is disconnected to a distribute device\n");
441 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2,
442 AppStateUpdateReason::DIST_DEVICE_DISCONNECTED);
443 sleep(5);
444 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
445 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
446 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND);
447 PrintReclaimPriorityList();
448
449 // clean up the mess
450 printf("clean up the mess\n");
451 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid1, bundleUid, bundleName1,
452 AppStateUpdateReason::PROCESS_TERMINATED);
453 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2,
454 AppStateUpdateReason::PROCESS_TERMINATED);
455 PrintReclaimPriorityList();
456 }
457
458 HWTEST_F(ReclaimPriorityManagerTest, ExtensionBindCase, TestSize.Level1)
459 {
460 // Preconditions: create one bundle with two freground processes
461 printf("Preconditions: create one bundle with two freground processes\n");
462 int pid1 = 10019;
463 int pid2 = 10020;
464 int bundleUid = 20010019;
465 const std::string bundleName1 = "com.ohos.exten_bind_test.main";
466 const std::string bundleName2 = "com.ohos.exten_bind_test.extension";
467 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid1, bundleUid, bundleName1,
468 AppStateUpdateReason::CREATE_PROCESS);
469 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2,
470 AppStateUpdateReason::CREATE_PROCESS);
471
472 int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(bundleUid);
473 bool isProc1Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid1, bundleUid, accountId);
474 ASSERT_EQ(isProc1Exist, true);
475 bool isProc2Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid2, bundleUid, accountId);
476 ASSERT_EQ(isProc2Exist, true);
477 std::shared_ptr<AccountBundleInfo> account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId);
478 std::shared_ptr<BundlePriorityInfo> bundle = account->FindBundleById(bundleUid);
479 ProcessPriorityInfo &proc1 = bundle->FindProcByPid(pid1);
480 ProcessPriorityInfo &proc2 = bundle->FindProcByPid(pid2);
481 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
482 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FOREGROUND);
483 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
484 PrintReclaimPriorityList();
485
486 // process#1 keep freground, process#2 go to background
487 printf("process#1 keep freground, process#2 go to background\n");
488 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2,
489 AppStateUpdateReason::BACKGROUND);
490 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
491 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND);
492 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
493 PrintReclaimPriorityList();
494
495 int callerPid = 99999;
496 int callerUid = 20099999;
497 std::string caller = "com.ohos.caller";
498
499 // process#2 is bind to a process
500 printf("process#2 is bind to a process\n");
501 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityWithCallerInner(callerPid, callerUid, caller, pid2,
502 bundleUid, bundleName2, AppStateUpdateReason::BIND_EXTENSION);
503 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND);
504 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
505 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND);
506 PrintReclaimPriorityList();
507
508 // process#1 go to background
509 printf("process#1 go to background\n");
510 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid1, bundleUid, bundleName1,
511 AppStateUpdateReason::BACKGROUND);
512 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
513 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
514 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FG_BIND_EXTENSION);
515 PrintReclaimPriorityList();
516
517 // process#2 is unbind to a process
518 printf("process#2 is no bind to any process\n");
519 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityWithCallerInner(callerPid, callerUid, caller, pid2,
520 bundleUid, bundleName2, AppStateUpdateReason::UNBIND_EXTENSION);
521 sleep(5);
522 ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND);
523 ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_NO_BIND_EXTENSION);
524 ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_NO_BIND_EXTENSION);
525 PrintReclaimPriorityList();
526
527 // clean up the mess
528 printf("clean up the mess\n");
529 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid1, bundleUid, bundleName1,
530 AppStateUpdateReason::PROCESS_TERMINATED);
531 ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2,
532 AppStateUpdateReason::PROCESS_TERMINATED);
533 PrintReclaimPriorityList();
534 }
535 }
536 }
537