1 /*
2 * Copyright (c) 2025 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 #define private public
19 #include "app_running_manager.h"
20 #include "app_running_record.h"
21 #include "ability_record.h"
22 #include "ability_running_record.h"
23 #include "module_running_record.h"
24 #undef private
25
26 #include "app_mgr_service_dump_error_code.h"
27 #include "hilog_tag_wrapper.h"
28 #include "mock_ability_token.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace AppExecFwk {
35 namespace {
36 const std::string BUNDLE_NAME = "testBundleName";
37 const std::string PROCESS_NAME = "testProcessName";
38 const std::string MODULE_NAME = "testModuleName";
39 const std::string APP_NAME = "appName";
40 const std::string APP_NAME_EMPTY = "appName";
41 constexpr int32_t TEST_BASE_USER_RANGE = 200000;
42 constexpr int32_t TEST_UID = 200000;
43 constexpr int32_t TEST_PID = 100;
44 constexpr int32_t ONE = 1;
45 constexpr int32_t TWO = 2;
46 constexpr int32_t THREE = 3;
47 constexpr int32_t RECORD_ID = 1;
48 }
49 class AppRunningManagerFourthTest : public testing::Test {
50 public:
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp() override;
54 void TearDown() override;
55 static std::shared_ptr<ApplicationInfo> appInfo_;
56 std::shared_ptr<AppRunningManager> appRunningManager_ = nullptr;
57 };
58
59 std::shared_ptr<ApplicationInfo> AppRunningManagerFourthTest::appInfo_ = nullptr;
60
SetUpTestCase(void)61 void AppRunningManagerFourthTest::SetUpTestCase(void)
62 {
63 appInfo_ = std::make_shared<ApplicationInfo>();
64 appInfo_->bundleName = BUNDLE_NAME;
65 appInfo_->uid = TEST_UID;
66 }
67
TearDownTestCase(void)68 void AppRunningManagerFourthTest::TearDownTestCase(void)
69 {}
70
SetUp()71 void AppRunningManagerFourthTest::SetUp()
72 {
73 appRunningManager_ = std::make_shared<AppRunningManager>();
74 ASSERT_NE(appRunningManager_, nullptr);
75 }
76
TearDown()77 void AppRunningManagerFourthTest::TearDown()
78 {
79 appRunningManager_.reset();
80 }
81
GetTestAbilityToken()82 sptr<Token> GetTestAbilityToken()
83 {
84 sptr<Token> token = nullptr;
85 AbilityRequest abilityRequest;
86 abilityRequest.appInfo.bundleName = "com.example.utTest";
87 abilityRequest.abilityInfo.name = "MainAbility";
88 abilityRequest.abilityInfo.type = AbilityType::DATA;
89 std::shared_ptr<AbilityRecord> abilityRecord =
90 AbilityRecord::CreateAbilityRecord(abilityRequest);
91 if (abilityRecord) {
92 token = abilityRecord->GetToken();
93 }
94 return token;
95 }
96
GetTestAbilityRuningRecord()97 std::shared_ptr<AbilityRunningRecord> GetTestAbilityRuningRecord()
98 {
99 auto token = GetTestAbilityToken();
100 auto abilityInfo = std::make_shared<AbilityInfo>();
101 auto abilityRunningRecord =
102 std::make_shared<AbilityRunningRecord>(abilityInfo, token, ONE);
103 return abilityRunningRecord;
104 }
105
106 /**
107 * @tc.name: AppRunningManager_CheckAppRunningRecordIsExist_0100
108 * @tc.desc: NA
109 * @tc.type: FUNC
110 */
111 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_CheckAppRunningRecordIsExist_0100, TestSize.Level1)
112 {
113 int uid = 0;
114 BundleInfo bundleInfo;
115 bool *isProCache = nullptr;
116 std::string instanceKey = "instanceKey";
117 std::string processName;
118 std::string customProcessFlag;
119 std::string specifiedProcessFlag = "specifiedProcessFlag";
120
121 bundleInfo.jointUserId = "joint456";
122 auto ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, processName,
123 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
124 EXPECT_EQ(ret, nullptr);
125
126 bundleInfo.jointUserId = "";
127 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, processName,
128 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
129
130 std::shared_ptr<AppRunningRecord> record =
131 appRunningManager_->CreateAppRunningRecord(appInfo_, processName, bundleInfo, "");
132 appRunningManager_->appRunningRecordMap_.clear();
133 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
134 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
135 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
136 EXPECT_EQ(ret, nullptr);
137
138 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
139 appRunningManager_->appRunningRecordMap_.clear();
140 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
141 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, processName,
142 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
143 EXPECT_EQ(ret, nullptr);
144
145 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
146 appRunningManager_->appRunningRecordMap_.clear();
147 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
148 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
149 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
150 EXPECT_EQ(ret, nullptr);
151
152 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
153 appRunningManager_->appRunningRecordMap_.clear();
154 record->SetInstanceKey(instanceKey);
155 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
156 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
157 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
158 EXPECT_EQ(ret, nullptr);
159 }
160
161 /**
162 * @tc.name: AppRunningManager_CheckAppRunningRecordIsExist_0200
163 * @tc.desc: NA
164 * @tc.type: FUNC
165 */
166 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_CheckAppRunningRecordIsExist_0200, TestSize.Level1)
167 {
168 int uid = 0;
169 BundleInfo bundleInfo;
170 bool *isProCache = nullptr;
171 std::string instanceKey;
172 std::string customProcessFlag;
173 std::string specifiedProcessFlag = "specifiedProcessFlag";
174
175 std::shared_ptr<AppRunningRecord> record =
176 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
177 appRunningManager_->appRunningRecordMap_.clear();
178 record->SetSpecifiedProcessFlag(specifiedProcessFlag);
179 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
180 auto ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
181 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
182 EXPECT_EQ(ret, nullptr);
183
184 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
185 appRunningManager_->appRunningRecordMap_.clear();
186 record->SetSpecifiedProcessFlag(specifiedProcessFlag);
187 record->SetCustomProcessFlag("customProcessFlag");
188 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
189 std::string specifiedProcessFlag1 = "";
190 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
191 uid, bundleInfo, specifiedProcessFlag1, isProCache, instanceKey, customProcessFlag);
192 EXPECT_EQ(ret, nullptr);
193
194 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
195 appRunningManager_->appRunningRecordMap_.clear();
196 record->SetTerminating();
197 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
198 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
199 uid, bundleInfo, specifiedProcessFlag1, isProCache, instanceKey, customProcessFlag);
200 EXPECT_EQ(ret, nullptr);
201
202 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
203 appRunningManager_->appRunningRecordMap_.clear();
204 record->SetKilling();
205 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
206 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
207 uid, bundleInfo, specifiedProcessFlag1, isProCache, instanceKey, customProcessFlag);
208 EXPECT_EQ(ret, nullptr);
209
210 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
211 appRunningManager_->appRunningRecordMap_.clear();
212 record->SetRestartAppFlag(true);
213 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
214 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
215 uid, bundleInfo, specifiedProcessFlag1, isProCache, instanceKey, customProcessFlag);
216 EXPECT_EQ(ret, nullptr);
217 }
218
219 /**
220 * @tc.name: AppRunningManager_CheckAppRunningRecordIsExist_0300
221 * @tc.desc: NA
222 * @tc.type: FUNC
223 */
224 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_CheckAppRunningRecordIsExist_0300, TestSize.Level1)
225 {
226 int uid = 0;
227 BundleInfo bundleInfo;
228 bool *isProCache = nullptr;
229 std::string instanceKey;
230 std::string customProcessFlag;
231 std::string specifiedProcessFlag;
232
233 std::shared_ptr<AppRunningRecord> record =
234 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
235 appRunningManager_->appRunningRecordMap_.clear();
236 record->SetUserRequestCleaning();
237 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
238 auto ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
239 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
240 EXPECT_EQ(ret, nullptr);
241
242 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
243 appRunningManager_->appRunningRecordMap_.clear();
244 record->SetProcessCaching(true);
245 record->SetProcessCacheBlocked(true);
246 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
247 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
248 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
249 EXPECT_EQ(ret, nullptr);
250
251 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
252 appRunningManager_->appRunningRecordMap_.clear();
253 record->SetProcessCaching(true);
254 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
255 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
256 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
257 EXPECT_EQ(ret, nullptr);
258
259 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
260 appRunningManager_->appRunningRecordMap_.clear();
261 record->SetProcessCacheBlocked(true);
262 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
263 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
264 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
265 EXPECT_EQ(ret, nullptr);
266
267 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
268 appRunningManager_->appRunningRecordMap_.clear();
269 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
270 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME_EMPTY, PROCESS_NAME,
271 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
272 EXPECT_EQ(ret, nullptr);
273 }
274
275 /**
276 * @tc.name: AppRunningManager_CheckAppRunningRecordIsExist_0400
277 * @tc.desc: NA
278 * @tc.type: FUNC
279 */
280 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_CheckAppRunningRecordIsExist_0400, TestSize.Level1)
281 {
282 int uid = TEST_UID;
283 BundleInfo bundleInfo;
284 std::string specifiedProcessFlag;
285 bool *isProCache = nullptr;
286 std::string instanceKey;
287 std::string customProcessFlag;
288
289 appInfo_->name = APP_NAME;
290 std::shared_ptr<AppRunningRecord> record =
291 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
292 appRunningManager_->appRunningRecordMap_.clear();
293 record->appInfos_.insert(std::make_pair("test", appInfo_));
294 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
295 auto ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME, PROCESS_NAME,
296 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
297 EXPECT_NE(ret, nullptr);
298
299 bool value = false;
300 isProCache = &value;
301 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
302 appRunningManager_->appRunningRecordMap_.clear();
303 record->appInfos_.insert(std::make_pair("test", appInfo_));
304 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
305 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME, PROCESS_NAME,
306 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
307 EXPECT_NE(ret, nullptr);
308 }
309
310 /**
311 * @tc.name: AppRunningManager_CheckAppRunningRecordIsExist_0401
312 * @tc.desc: NA
313 * @tc.type: FUNC
314 */
315 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_CheckAppRunningRecordIsExist_0401, TestSize.Level1)
316 {
317 int uid = TEST_UID;
318 BundleInfo bundleInfo;
319 std::string specifiedProcessFlag;
320 bool *isProCache = nullptr;
321 std::string instanceKey;
322 std::string customProcessFlag;
323
324 appInfo_->name = APP_NAME;
325 std::shared_ptr<AppRunningRecord> record =
326 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
327 appRunningManager_->appRunningRecordMap_.clear();
328 record->appInfos_.insert(std::make_pair("test", appInfo_));
329 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
330 auto ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME, PROCESS_NAME,
331 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag);
332 EXPECT_NE(ret, nullptr);
333
334 bool value = false;
335 isProCache = &value;
336 record = appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
337 appRunningManager_->appRunningRecordMap_.clear();
338 record->appInfos_.insert(std::make_pair("test", appInfo_));
339 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
340
341 bool notReuseCachedPorcess = true;
342 ret = appRunningManager_->CheckAppRunningRecordIsExist(APP_NAME, PROCESS_NAME,
343 uid, bundleInfo, specifiedProcessFlag, isProCache, instanceKey, customProcessFlag, notReuseCachedPorcess);
344 EXPECT_NE(ret, nullptr);
345 }
346
347 /**
348 * @tc.name: AppRunningManager_GetProcessInfosByUserId_0100
349 * @tc.desc: NA
350 * @tc.type: FUNC
351 */
352 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_GetProcessInfosByUserId_0100, TestSize.Level1)
353 {
354 int32_t userId = ONE;
355 std::list<SimpleProcessInfo> processInfos;
356 ApplicationInfo appInfo;
357 BundleInfo bundleInfo;
358 std::shared_ptr<AppRunningRecord> record =
359 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
360 appRunningManager_->appRunningRecordMap_.clear();
361 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, nullptr));
362 auto ret = appRunningManager_->GetProcessInfosByUserId(userId, processInfos);
363 EXPECT_FALSE(ret);
364
365 appRunningManager_->appRunningRecordMap_.clear();
366 record->SetUid(TEST_BASE_USER_RANGE);
367 record->appInfos_.insert(std::make_pair("test", appInfo_));
368 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
369 ret = appRunningManager_->GetProcessInfosByUserId(userId, processInfos);
370 EXPECT_FALSE(ret);
371
372 appRunningManager_->appRunningRecordMap_.clear();
373 record->SetUid(TEST_BASE_USER_RANGE);
374 record->priorityObject_->SetPid(TEST_PID);
375 record->appInfos_.insert(std::make_pair("test", appInfo_));
376 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
377 ret = appRunningManager_->GetProcessInfosByUserId(userId, processInfos);
378 EXPECT_TRUE(ret);
379 }
380
381 /**
382 * @tc.name: AppRunningManager_IsAppRunningByBundleNameAndUserId_0100
383 * @tc.desc: NA
384 * @tc.type: FUNC
385 */
386 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_IsAppRunningByBundleNameAndUserId_0100, TestSize.Level1)
387 {
388 std::string bundleName;
389 int32_t userId = ONE;
390 bool isRunning = false;
391 BundleInfo bundleInfo;
392 std::shared_ptr<AppRunningRecord> record =
393 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
394 appRunningManager_->appRunningRecordMap_.clear();
395 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, nullptr));
396 auto ret = appRunningManager_->IsAppRunningByBundleNameAndUserId(bundleName, userId, isRunning);
397 EXPECT_FALSE(isRunning);
398
399 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
400 ret = appRunningManager_->IsAppRunningByBundleNameAndUserId(BUNDLE_NAME, userId, isRunning);
401 EXPECT_FALSE(isRunning);
402
403 appRunningManager_->appRunningRecordMap_.clear();
404 record->SetRestartAppFlag(true);
405 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
406 ret = appRunningManager_->IsAppRunningByBundleNameAndUserId(BUNDLE_NAME, userId, isRunning);
407 EXPECT_FALSE(isRunning);
408
409 appRunningManager_->appRunningRecordMap_.clear();
410 record->SetRestartAppFlag(false);
411 record->SetUid(0);
412 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
413 ret = appRunningManager_->IsAppRunningByBundleNameAndUserId(BUNDLE_NAME, userId, isRunning);
414 EXPECT_FALSE(isRunning);
415
416 appRunningManager_->appRunningRecordMap_.clear();
417 record->SetUid(TEST_BASE_USER_RANGE);
418 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
419 ret = appRunningManager_->IsAppRunningByBundleNameAndUserId(BUNDLE_NAME, userId, isRunning);
420 EXPECT_TRUE(isRunning);
421 }
422
423 /**
424 * @tc.name: AppRunningManager_ProcessUpdateApplicationInfoInstalled_0100
425 * @tc.desc: NA
426 * @tc.type: FUNC
427 */
428 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_ProcessUpdateApplicationInfoInstalled_0100, TestSize.Level1)
429 {
430 int32_t userId = ONE;
431 ApplicationInfo appInfo;
432 BundleInfo bundleInfo;
433 std::shared_ptr<AppRunningRecord> record =
434 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
435 appRunningManager_->appRunningRecordMap_.clear();
436 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, nullptr));
437 auto ret = appRunningManager_->ProcessUpdateApplicationInfoInstalled(appInfo, MODULE_NAME);
438 EXPECT_EQ(ret, ERR_OK);
439
440 appRunningManager_->appRunningRecordMap_.clear();
441 record->appInfos_.insert(std::make_pair("test", appInfo_));
442 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
443 ret = appRunningManager_->ProcessUpdateApplicationInfoInstalled(appInfo, MODULE_NAME);
444 EXPECT_EQ(ret, ERR_OK);
445
446 appRunningManager_->appRunningRecordMap_.clear();
447 record->appInfos_.insert(std::make_pair("test", appInfo_));
448 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
449 appInfo.bundleName = BUNDLE_NAME;
450 ret = appRunningManager_->ProcessUpdateApplicationInfoInstalled(appInfo, MODULE_NAME);
451 EXPECT_EQ(ret, ERR_OK);
452
453 appRunningManager_->appRunningRecordMap_.clear();
454 record->appInfos_.insert(std::make_pair("test", appInfo_));
455 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
456 appInfo.bundleName = "";
457 appInfo.uid = TEST_UID;
458 ret = appRunningManager_->ProcessUpdateApplicationInfoInstalled(appInfo, MODULE_NAME);
459 EXPECT_EQ(ret, ERR_OK);
460
461 appRunningManager_->appRunningRecordMap_.clear();
462 record->appInfos_.insert(std::make_pair("test", appInfo_));
463 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
464 appInfo.bundleName = BUNDLE_NAME;
465 appInfo.uid = TEST_UID;
466 ret = appRunningManager_->ProcessUpdateApplicationInfoInstalled(appInfo, MODULE_NAME);
467 EXPECT_EQ(ret, ERR_OK);
468 }
469
470 /**
471 * @tc.name: AppRunningManager_HandleUserRequestClean_0100
472 * @tc.desc: Test HandleUserRequestClean
473 * @tc.type: FUNC
474 */
475 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_HandleUserRequestClean_0100, TestSize.Level1)
476 {
477 /**
478 * @tc.steps: step1. Initialize AppRunningManager instance
479 * @tc.expected: expect step1 succeed
480 */
481 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_HandleUserRequestClean_0100 start");
482 BundleInfo bundleInfo;
483
484 /**
485 * @tc.steps: step2. Initialize AppRunningManager instance
486 * @tc.expected: expect step2 focused false
487 */
488 sptr<Token> token = nullptr;
489 pid_t targetPid = 0;
490 int32_t targetUid = 0;
491 auto ret = appRunningManager_->HandleUserRequestClean(token, targetPid, targetUid);
492 EXPECT_EQ(ret, false);
493
494 token = GetTestAbilityToken();
495 ret = appRunningManager_->HandleUserRequestClean(token, targetPid, targetUid);
496 EXPECT_EQ(ret, false);
497
498 std::shared_ptr<AppRunningRecord> appRunningRecord =
499 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
500 std::vector<std::shared_ptr<ModuleRunningRecord>> moduleRunningRecords;
501 auto moduleRecord = std::make_shared<ModuleRunningRecord>(appInfo_, nullptr);
502 auto abilityRuningRecord = GetTestAbilityRuningRecord();
503 moduleRecord->abilities_.emplace(token, abilityRuningRecord);
504 moduleRunningRecords.push_back(moduleRecord);
505 appRunningRecord->hapModules_.emplace(BUNDLE_NAME, moduleRunningRecords);
506 auto recordId = AppRecordId::Create();
507 appRunningManager_->appRunningRecordMap_.emplace(recordId, appRunningRecord);
508 ret = appRunningManager_->HandleUserRequestClean(token, targetPid, targetUid);
509 EXPECT_EQ(ret, true);
510
511 appRunningRecord->procCacheSupportState_ = SupportProcessCacheState::SUPPORT;
512 ret = appRunningManager_->HandleUserRequestClean(token, targetPid, targetUid);
513 EXPECT_EQ(ret, false);
514
515 appRunningRecord->procCacheSupportState_ = SupportProcessCacheState::UNSPECIFIED;
516
517 appRunningRecord->isMainProcess_= true;
518 appRunningRecord->isKeepAliveBundle_= true;
519 appRunningRecord->isKeepAliveRdb_= true;
520 appRunningRecord->mainUid_ = TEST_BASE_USER_RANGE;
521 ret = appRunningManager_->HandleUserRequestClean(token, targetPid, targetUid);
522 EXPECT_EQ(ret, false);
523
524 auto priorityObject = std::make_shared<PriorityObject>();
525 appRunningRecord->isUserRequestCleaning_= true;
526 appRunningRecord->isMainProcess_= false;
527 appRunningRecord->priorityObject_ = nullptr;
528 ret = appRunningManager_->HandleUserRequestClean(token, targetPid, targetUid);
529 EXPECT_EQ(ret, true);
530 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_HandleUserRequestClean_0100 end");
531 }
532
533 /**
534 * @tc.name: AppRunningManager_CheckIsKiaProcess_0100
535 * @tc.desc: Test CheckIsKiaProcess
536 * @tc.type: FUNC
537 */
538 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_CheckIsKiaProcess_0100, TestSize.Level1)
539 {
540 /**
541 * @tc.steps: step1. Initialize AppRunningManager instance
542 * @tc.expected: expect step1 succeed
543 */
544 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_CheckIsKiaProcess_0100 start");
545 BundleInfo bundleInfo;
546
547 /**
548 * @tc.steps: step2. Initialize AppRunningManager instance
549 * @tc.expected: expect step2 focused false
550 */
551 pid_t pid = 0;
552 bool isKia = false;
553 auto ret = appRunningManager_->CheckIsKiaProcess(pid, isKia);
554 EXPECT_EQ(ret, ERR_INVALID_VALUE);
555
556 pid = ONE;
557 std::shared_ptr<AppRunningRecord> appRunningRecord =
558 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
559 appRunningRecord->priorityObject_ = std::make_shared<PriorityObject>();
560 appRunningRecord->priorityObject_->SetPid(pid);
561 auto recordId = AppRecordId::Create();
562 appRunningManager_->appRunningRecordMap_.emplace(recordId, appRunningRecord);
563 ret = appRunningManager_->CheckIsKiaProcess(pid, isKia);
564 EXPECT_EQ(ret, ERR_OK);
565
566 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_CheckIsKiaProcess_0100 end");
567 }
568
569 /**
570 * @tc.name: AppRunningManager_CheckAppRunningRecordIsLast_0100
571 * @tc.desc: Test CheckAppRunningRecordIsLast
572 * @tc.type: FUNC
573 */
574 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_CheckAppRunningRecordIsLast_0100, TestSize.Level1)
575 {
576 /**
577 * @tc.steps: step1. Initialize AppRunningManager instance
578 * @tc.expected: expect step1 succeed
579 */
580 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_CheckAppRunningRecordIsLast_0100 start");
581
582 /**
583 * @tc.steps: step2. Initialize AppRunningManager instance
584 * @tc.expected: expect step2 focused false
585 */
586 std::shared_ptr<AppRunningRecord> appRunningRecord = nullptr;
587 auto ret = appRunningManager_->CheckAppRunningRecordIsLast(appRunningRecord);
588 EXPECT_EQ(ret, false);
589
590 appRunningRecord = std::make_shared<AppRunningRecord>(appInfo_, ONE, PROCESS_NAME);
591 ret = appRunningManager_->CheckAppRunningRecordIsLast(appRunningRecord);
592 EXPECT_EQ(ret, true);
593
594 appRunningManager_->appRunningRecordMap_.emplace(TWO, nullptr);
595 ret = appRunningManager_->CheckAppRunningRecordIsLast(appRunningRecord);
596 EXPECT_EQ(ret, true);
597
598 appRunningRecord->SetUid(TWO);
599 appRunningManager_->appRunningRecordMap_.emplace(ONE, appRunningRecord);
600 ret = appRunningManager_->CheckAppRunningRecordIsLast(appRunningRecord);
601 EXPECT_EQ(ret, true);
602
603 auto appRunningRecord2 = std::make_shared<AppRunningRecord>(appInfo_, TWO, PROCESS_NAME);
604 appRunningRecord2->SetUid(ONE);
605 ret = appRunningManager_->CheckAppRunningRecordIsLast(appRunningRecord2);
606 EXPECT_EQ(ret, true);
607
608 appRunningRecord2->SetUid(TWO);
609 ret = appRunningManager_->CheckAppRunningRecordIsLast(appRunningRecord2);
610 EXPECT_EQ(ret, false);
611
612 appRunningRecord2->SetRestartAppFlag(!appRunningRecord2->GetRestartAppFlag());
613 ret = appRunningManager_->CheckAppRunningRecordIsLast(appRunningRecord2);
614 EXPECT_EQ(ret, true);
615
616 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_CheckAppRunningRecordIsLast_0100 end");
617 }
618
619 /**
620 * @tc.name: ProcessExitByBundleNameAndAppIndex_0100
621 * @tc.desc: test ProcessExitByBundleNameAndAppIndex
622 * @tc.type: FUNC
623 */
624 HWTEST_F(AppRunningManagerFourthTest, ProcessExitByBundleNameAndAppIndex_0100, TestSize.Level1)
625 {
626 static std::shared_ptr<AppRunningManager> appRunningManager = std::make_shared<AppRunningManager>();
627 ASSERT_NE(appRunningManager, nullptr);
628 std::shared_ptr<AppRunningRecord> appRunningRecord = nullptr;
629 int32_t num = 100;
630 appRunningManager->appRunningRecordMap_.insert(std::make_pair(num, appRunningRecord));
631
632 std::string bundleName = "bundleName";
633 int32_t appIndex = 8;
634 std::list<pid_t> pids;
635 bool clearPageStack = true;
636 auto ret = appRunningManager->ProcessExitByBundleNameAndAppIndex(bundleName, appIndex, pids, clearPageStack);
637 EXPECT_EQ(ret, false);
638 }
639
640 /**
641 * @tc.name: ProcessExitByBundleNameAndAppIndex_0200
642 * @tc.desc: test ProcessExitByBundleNameAndAppIndex
643 * @tc.type: FUNC
644 */
645 HWTEST_F(AppRunningManagerFourthTest, ProcessExitByBundleNameAndAppIndex_0200, TestSize.Level1)
646 {
647 static std::shared_ptr<AppRunningManager> appRunningManager = std::make_shared<AppRunningManager>();
648 ASSERT_NE(appRunningManager, nullptr);
649
650 std::shared_ptr<ApplicationInfo> info = nullptr;
651 int32_t recordId = 100;
652 std::string processName = "processName";
653 auto appRunningRecord = std::make_shared<AppRunningRecord>(info, recordId, processName);
654 ASSERT_NE(appRunningRecord, nullptr);
655
656 int32_t priorityUid = 2000000;
657 appRunningRecord->SetUid(priorityUid);
658 appRunningRecord->isKeepAliveBundle_ = true;
659 appRunningRecord->isKeepAliveRdb_ = true;
660 int32_t num = 100;
661 appRunningManager->appRunningRecordMap_.insert(std::make_pair(num, appRunningRecord));
662 std::string bundleName = "bundleName";
663 int32_t appIndex = 8;
664 std::list<pid_t> pids;
665 bool clearPageStack = true;
666 auto ret = appRunningManager->ProcessExitByBundleNameAndAppIndex(bundleName, appIndex, pids, clearPageStack);
667 EXPECT_EQ(ret, false);
668 }
669
670 /**
671 * @tc.name: ProcessExitByBundleNameAndAppIndex_0300
672 * @tc.desc: test ProcessExitByBundleNameAndAppIndex
673 * @tc.type: FUNC
674 */
675 HWTEST_F(AppRunningManagerFourthTest, ProcessExitByBundleNameAndAppIndex_0300, TestSize.Level1)
676 {
677 static std::shared_ptr<AppRunningManager> appRunningManager = std::make_shared<AppRunningManager>();
678 ASSERT_NE(appRunningManager, nullptr);
679
680 std::shared_ptr<ApplicationInfo> info = nullptr;
681 int32_t recordId = 100;
682 std::string processName = "processName";
683 auto appRunningRecord = std::make_shared<AppRunningRecord>(info, recordId, processName);
684 ASSERT_NE(appRunningRecord, nullptr);
685
686 int32_t priorityUid = 2000000;
687 appRunningRecord->SetUid(priorityUid);
688 int32_t num = 100;
689 appRunningManager->appRunningRecordMap_.insert(std::make_pair(num, appRunningRecord));
690 std::string bundleName = "bundleName";
691 int32_t appIndex = 8;
692 std::list<pid_t> pids;
693 bool clearPageStack = true;
694 auto ret = appRunningManager->ProcessExitByBundleNameAndAppIndex(bundleName, appIndex, pids, clearPageStack);
695 EXPECT_EQ(ret, false);
696 }
697
698 /**
699 * @tc.name: ProcessExitByBundleNameAndAppIndex_0400
700 * @tc.desc: test ProcessExitByBundleNameAndAppIndex
701 * @tc.type: FUNC
702 */
703 HWTEST_F(AppRunningManagerFourthTest, ProcessExitByBundleNameAndAppIndex_0400, TestSize.Level1)
704 {
705 static std::shared_ptr<AppRunningManager> appRunningManager = std::make_shared<AppRunningManager>();
706 ASSERT_NE(appRunningManager, nullptr);
707
708 std::shared_ptr<ApplicationInfo> info = std::make_shared<ApplicationInfo>();
709 info->bundleName = "bundleName";
710 int32_t recordId = 100;
711 std::string processName = "processName";
712 auto appRunningRecord = std::make_shared<AppRunningRecord>(info, recordId, processName);
713 ASSERT_NE(appRunningRecord, nullptr);
714
715 int32_t priorityUid = 2000000;
716 appRunningRecord->SetUid(priorityUid);
717 appRunningRecord->priorityObject_ = nullptr;
718 int32_t num = 100;
719 appRunningManager->appRunningRecordMap_.insert(std::make_pair(num, appRunningRecord));
720 std::string bundleName = "bundleName";
721 int32_t appIndex = 8;
722 std::list<pid_t> pids;
723 bool clearPageStack = true;
724 auto ret = appRunningManager->ProcessExitByBundleNameAndAppIndex(bundleName, appIndex, pids, clearPageStack);
725 EXPECT_EQ(ret, false);
726 }
727
728 /**
729 * @tc.name: ProcessExitByBundleNameAndAppIndex_0500
730 * @tc.desc: test ProcessExitByBundleNameAndAppIndex
731 * @tc.type: FUNC
732 */
733 HWTEST_F(AppRunningManagerFourthTest, ProcessExitByBundleNameAndAppIndex_0500, TestSize.Level1)
734 {
735 static std::shared_ptr<AppRunningManager> appRunningManager = std::make_shared<AppRunningManager>();
736 ASSERT_NE(appRunningManager, nullptr);
737
738 std::shared_ptr<ApplicationInfo> info = std::make_shared<ApplicationInfo>();
739 info->bundleName = "bundleName";
740 int32_t recordId = 100;
741 std::string processName = "processName";
742 auto appRunningRecord = std::make_shared<AppRunningRecord>(info, recordId, processName);
743 ASSERT_NE(appRunningRecord, nullptr);
744
745 appRunningRecord->priorityObject_ = std::make_shared<PriorityObject>();
746 int32_t priorityPid = -1;
747 appRunningRecord->priorityObject_->SetPid(priorityPid);
748 int32_t priorityUid = 2000000;
749 appRunningRecord->SetUid(priorityUid);
750 int32_t num = 100;
751 appRunningManager->appRunningRecordMap_.insert(std::make_pair(num, appRunningRecord));
752 int32_t appIndex = 8;
753 appRunningRecord->SetAppIndex(appIndex);
754 std::string bundleName = "bundleName";
755 std::list<pid_t> pids;
756 bool clearPageStack = true;
757 auto ret = appRunningManager->ProcessExitByBundleNameAndAppIndex(bundleName, appIndex, pids, clearPageStack);
758 EXPECT_EQ(ret, false);
759 }
760
761 /**
762 * @tc.name: ProcessExitByBundleNameAndAppIndex_0600
763 * @tc.desc: test ProcessExitByBundleNameAndAppIndex
764 * @tc.type: FUNC
765 */
766 HWTEST_F(AppRunningManagerFourthTest, ProcessExitByBundleNameAndAppIndex_0600, TestSize.Level1)
767 {
768 static std::shared_ptr<AppRunningManager> appRunningManager = std::make_shared<AppRunningManager>();
769 ASSERT_NE(appRunningManager, nullptr);
770
771 std::shared_ptr<ApplicationInfo> info = std::make_shared<ApplicationInfo>();
772 info->bundleName = "bundleName";
773 int32_t recordId = 100;
774 std::string processName = "processName";
775 auto appRunningRecord = std::make_shared<AppRunningRecord>(info, recordId, processName);
776 ASSERT_NE(appRunningRecord, nullptr);
777
778 appRunningRecord->priorityObject_ = std::make_shared<PriorityObject>();
779 int32_t priorityPid = 66;
780 appRunningRecord->priorityObject_->SetPid(priorityPid);
781 int32_t priorityUid = 2000000;
782 appRunningRecord->SetUid(priorityUid);
783 int32_t num = 100;
784 appRunningManager->appRunningRecordMap_.insert(std::make_pair(num, appRunningRecord));
785 int32_t appIndex = 8;
786 appRunningRecord->SetAppIndex(appIndex);
787 std::string bundleName = "bundleName";
788 std::list<pid_t> pids;
789 bool clearPageStack = true;
790 auto ret = appRunningManager->ProcessExitByBundleNameAndAppIndex(bundleName, appIndex, pids, clearPageStack);
791 EXPECT_EQ(ret, true);
792 }
793
794 /**
795 * @tc.name: AppRunningManager_DumpIpcStop_0100
796 * @tc.desc: Test the state of DumpIpcStop
797 * @tc.type: FUNC
798 */
799 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_DumpIpcStop_0100, TestSize.Level1)
800 {
801 auto appRunningManager = std::make_shared<AppRunningManager>();
802 EXPECT_NE(appRunningManager, nullptr);
803 std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
804 std::string result = "";
805 int32_t recordId = 0;
806 auto ret = appRunningManager->DumpIpcStop(recordId, result);
807 EXPECT_EQ(ret, DumpErrorCode::ERR_INVALID_PID_ERROR);
808
809 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo, RECORD_ID, PROCESS_NAME);
810 appRunningManager->appRunningRecordMap_.insert(make_pair(recordId, appRunningRecord));
811 ret = appRunningManager->DumpIpcStop(recordId, result);
812 EXPECT_NE(ret, DumpErrorCode::ERR_INVALID_PID_ERROR);
813 }
814
815 /**
816 * @tc.name: AppRunningManager_DumpIpcStat_0100
817 * @tc.desc: Test the state of DumpIpcStat
818 * @tc.type: FUNC
819 */
820 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_DumpIpcStat_0100, TestSize.Level1)
821 {
822 auto appRunningManager = std::make_shared<AppRunningManager>();
823 EXPECT_NE(appRunningManager, nullptr);
824
825 std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
826 std::string result = "";
827 int32_t recordId = 0;
828 auto ret = appRunningManager->DumpIpcStat(recordId, result);
829 EXPECT_EQ(ret, DumpErrorCode::ERR_INVALID_PID_ERROR);
830
831 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo, RECORD_ID, PROCESS_NAME);
832 appRunningManager->appRunningRecordMap_.insert(make_pair(recordId, appRunningRecord));
833 ret = appRunningManager->DumpIpcStat(recordId, result);
834 EXPECT_NE(ret, DumpErrorCode::ERR_INVALID_PID_ERROR);
835 }
836
837 /**
838 * @tc.name: AppRunningManager_DumpFfrt_0100
839 * @tc.desc: Test the state of DumpFfrt
840 * @tc.type: FUNC
841 */
842 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_DumpFfrt_0100, TestSize.Level1)
843 {
844 auto appRunningManager = std::make_shared<AppRunningManager>();
845 EXPECT_NE(appRunningManager, nullptr);
846
847 std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
848 std::string result = "";
849 std::vector<int32_t> pids = {1, 5, 4, 6};
850 int32_t recordId = 0;
851 auto ret = appRunningManager->DumpFfrt(pids, result);
852 EXPECT_EQ(ret, DumpErrorCode::ERR_INVALID_PID_ERROR);
853
854 pids = {1, 0, 4, 6};
855 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo, RECORD_ID, PROCESS_NAME);
856 appRunningManager->appRunningRecordMap_.clear();
857 appRunningRecord->appLifeCycleDeal_ = std::make_shared<AppLifeCycleDeal>();
858 appRunningManager->appRunningRecordMap_.insert(make_pair(recordId, appRunningRecord));
859 ret = appRunningManager->DumpFfrt(pids, result);
860 EXPECT_EQ(ret, DumpErrorCode::ERR_INTERNAL_ERROR);
861
862 result = "test";
863 ret = appRunningManager->DumpFfrt(pids, result);
864 EXPECT_EQ(ret, DumpErrorCode::ERR_OK);
865 }
866
867 /**
868 * @tc.name: AppRunningManager_OnRemoteRenderDied_0100
869 * @tc.desc: Test the state of OnRemoteRenderDied
870 * @tc.type: FUNC
871 */
872 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_OnRemoteRenderDied_0100, TestSize.Level1)
873 {
874 auto appRunningManager = std::make_shared<AppRunningManager>();
875 EXPECT_NE(appRunningManager, nullptr);
876
877 auto ret = appRunningManager->OnRemoteRenderDied(nullptr);
878 EXPECT_EQ(ret, nullptr);
879
880 OHOS::sptr<IRemoteObject> remote = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
881 appRunningManager->appRunningRecordMap_.clear();
882 int32_t recordId = 0;
883 ret = appRunningManager->OnRemoteRenderDied(remote);
884 EXPECT_EQ(ret, nullptr);
885
886 std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
887 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo, RECORD_ID, PROCESS_NAME);
888 appRunningRecord->appLifeCycleDeal_ = std::make_shared<AppLifeCycleDeal>();
889 appRunningManager->appRunningRecordMap_.insert(make_pair(recordId, appRunningRecord));
890 ret = appRunningManager->OnRemoteRenderDied(remote);
891 EXPECT_EQ(ret, nullptr);
892 }
893
894 /**
895 * @tc.name: UpdateConfigurationForBackgroundApp_0100
896 * @tc.desc: UpdateConfigurationForBackgroundApp.
897 * @tc.type: FUNC
898 */
899 HWTEST_F(AppRunningManagerFourthTest, UpdateConfigurationForBackgroundApp_0100, TestSize.Level1)
900 {
901 auto appRunningManager = std::make_shared<AppRunningManager>();
902 EXPECT_NE(appRunningManager, nullptr);
903
904 std::vector<BackgroundAppInfo> appInfos;
905 AppExecFwk::ConfigurationPolicy policy;
906 int32_t userId = -1;
907 policy.maxCountPerBatch = -1;
908 auto ret = appRunningManager->UpdateConfigurationForBackgroundApp(appInfos, policy, userId);
909 EXPECT_EQ(ret, ERR_INVALID_VALUE);
910
911 policy.maxCountPerBatch = 1;
912 policy.intervalTime = -1;
913 ret = appRunningManager->UpdateConfigurationForBackgroundApp(appInfos, policy, userId);
914 EXPECT_EQ(ret, ERR_INVALID_VALUE);
915
916 policy.maxCountPerBatch = 1;
917 policy.intervalTime = 1;
918 BackgroundAppInfo info;
919 info.bandleName = "com.example.mytest";
920 info.appIndex = 0;
921 appInfos.push_back(info);
922 ret = appRunningManager->UpdateConfigurationForBackgroundApp(appInfos, policy, userId);
923 EXPECT_EQ(ret, 0);
924 }
925
926 /**
927 * @tc.name: UpdateConfiguration_0100
928 * @tc.desc: UpdateConfiguration.
929 * @tc.type: FUNC
930 */
931 HWTEST_F(AppRunningManagerFourthTest, UpdateConfiguration_0100, TestSize.Level1)
932 {
933 auto appRunningManager = std::make_shared<AppRunningManager>();
934 EXPECT_NE(appRunningManager, nullptr);
935
936 ApplicationInfo appInfo;
937 appInfo.name = "KeepAliveApp";
938 appInfo.bundleName = "KeepAliveApplication";
939 appInfo.uid = 2100;
940 auto app = std::make_shared<ApplicationInfo>(appInfo);
941
942 std::shared_ptr<AppRunningRecord> appRecord = std::make_shared<AppRunningRecord>(app, 111, "KeepAliveApplication");
943 auto ret = appRunningManager->UpdateConfiguration(appRecord, Rosen::ConfigMode::FONT_SCALE);
944 EXPECT_FALSE(ret);
945
946 appRecord->delayConfiguration_ = nullptr;
947 ret = appRunningManager->UpdateConfiguration(appRecord, Rosen::ConfigMode::COLOR_MODE);
948 EXPECT_FALSE(ret);
949
950 appRecord->delayConfiguration_ = std::make_shared<Configuration>();
951 appRecord->delayConfiguration_->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
952 ConfigurationInner::EMPTY_STRING);
953 ret = appRunningManager->UpdateConfiguration(appRecord, Rosen::ConfigMode::COLOR_MODE);
954 EXPECT_FALSE(ret);
955
956 appRecord->delayConfiguration_->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
957 ConfigurationInner::COLOR_MODE_DARK);
958 ret = appRunningManager->UpdateConfiguration(appRecord, Rosen::ConfigMode::COLOR_MODE);
959 EXPECT_TRUE(ret);
960
961 appRecord = nullptr;
962 ret = appRunningManager->UpdateConfiguration(appRecord, Rosen::ConfigMode::COLOR_MODE);
963 EXPECT_FALSE(ret);
964 }
965
966 /**
967 * @tc.name: ExecuteConfigurationTask_0100
968 * @tc.desc: ExecuteConfigurationTask.
969 * @tc.type: FUNC
970 */
971 HWTEST_F(AppRunningManagerFourthTest, ExecuteConfigurationTask_0100, TestSize.Level1)
972 {
973 auto appRunningManager = std::make_shared<AppRunningManager>();
974 EXPECT_NE(appRunningManager, nullptr);
975
976 BackgroundAppInfo info;
977 int32_t userId = 0;
978 ApplicationInfo appInfo;
979 appInfo.name = "KeepAliveApp";
980 appInfo.bundleName = "KeepAliveApplication";
981 appInfo.uid = 2100;
982 auto app = std::make_shared<ApplicationInfo>(appInfo);
983 std::shared_ptr<AppRunningRecord> appRecord = std::make_shared<AppRunningRecord>(app, 111, "KeepAliveApplication");
984
985 appRunningManager->updateConfigurationDelayedMap_.emplace(0, true);
986 appRunningManager->updateConfigurationDelayedMap_.emplace(1, true);
987 appRecord->appRecordId_ = 0;
988 appRecord->appIndex_ = 0;
989 appRecord->curState_ = ApplicationState::APP_STATE_BACKGROUND;
990 appRunningManager->appRunningRecordMap_.emplace(0, appRecord);
991 appRunningManager->appRunningRecordMap_.emplace(1, nullptr);
992 info.bandleName = "KeepAliveApplication";
993 info.appIndex = 0;
994 userId = 1;
995 appRunningManager->ExecuteConfigurationTask(info, userId);
996
997 userId = -1;
998 appRecord->delayConfiguration_ = nullptr;
999 appRunningManager->ExecuteConfigurationTask(info, userId);
1000
1001 appRecord->delayConfiguration_ = std::make_shared<Configuration>();
1002 appRecord->delayConfiguration_->AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE,
1003 ConfigurationInner::COLOR_MODE_DARK);
1004 appRunningManager->ExecuteConfigurationTask(info, userId);
1005 std::string value = appRecord->delayConfiguration_->GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_COLORMODE);
1006 EXPECT_TRUE(value == ConfigurationInner::EMPTY_STRING);
1007 }
1008
1009 /**
1010 * @tc.name: AppRunningManager_IsSameAbilityType_0100
1011 * @tc.desc: NA
1012 * @tc.type: FUNC
1013 */
1014 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_IsSameAbilityType_0100, TestSize.Level1)
1015 {
1016 int uid = 0;
1017 BundleInfo bundleInfo;
1018
1019 std::shared_ptr<AppRunningRecord> record =
1020 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1021 ASSERT_NE(record, nullptr);
1022 AppExecFwk::AbilityInfo abilityInfo;
1023
1024 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1025 auto ret = appRunningManager_->IsSameAbilityType(nullptr, abilityInfo);
1026 EXPECT_EQ(ret, false);
1027
1028 record->processType_ = ProcessType::NORMAL;
1029 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1030 ret = appRunningManager_->IsSameAbilityType(record, abilityInfo);
1031 EXPECT_EQ(ret, true);
1032
1033 record->processType_ = ProcessType::NORMAL;
1034 abilityInfo.type = AppExecFwk::AbilityType::FORM;
1035 ret = appRunningManager_->IsSameAbilityType(record, abilityInfo);
1036 EXPECT_EQ(ret, false);
1037
1038 record->extensionType_ = AppExecFwk::ExtensionAbilityType::SERVICE;
1039 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1040 ret = appRunningManager_->IsSameAbilityType(record, abilityInfo);
1041 EXPECT_EQ(ret, true);
1042
1043 record->extensionType_ = AppExecFwk::ExtensionAbilityType::DATASHARE;
1044 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1045 ret = appRunningManager_->IsSameAbilityType(record, abilityInfo);
1046 EXPECT_EQ(ret, true);
1047
1048 record->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1049 abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1050 ret = appRunningManager_->IsSameAbilityType(record, abilityInfo);
1051 EXPECT_EQ(ret, true);
1052 }
1053
1054 /**
1055 * @tc.name: AppRunningManager_CheckMasterProcessAppRunningRecordIsExist_0100
1056 * @tc.desc: NA
1057 * @tc.type: FUNC
1058 */
1059 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_CheckMasterProcessAppRunningRecordIsExist_0100, TestSize.Level1)
1060 {
1061 int uid = 0;
1062 BundleInfo bundleInfo;
1063 std::string processName;
1064 std::shared_ptr<AppRunningRecord> record =
1065 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1066 ASSERT_NE(record, nullptr);
1067 AppExecFwk::AbilityInfo abilityInfo;
1068
1069 record->processType_ = ProcessType::NORMAL;
1070 record->SetMasterProcess(true);
1071 record->SetUid(uid);
1072 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1073 appRunningManager_->appRunningRecordMap_.clear();
1074 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
1075 auto ret = appRunningManager_->CheckMasterProcessAppRunningRecordIsExist(APP_NAME_EMPTY, abilityInfo, uid);
1076 EXPECT_EQ(ret, true);
1077
1078 record->processType_ = ProcessType::EXTENSION;
1079 record->SetMasterProcess(true);
1080 record->SetUid(uid);
1081 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1082 appRunningManager_->appRunningRecordMap_.clear();
1083 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
1084 ret = appRunningManager_->CheckMasterProcessAppRunningRecordIsExist(APP_NAME_EMPTY, abilityInfo, uid);
1085 EXPECT_EQ(ret, false);
1086
1087 record->processType_ = ProcessType::NORMAL;
1088 record->SetMasterProcess(false);
1089 record->SetUid(uid);
1090 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1091 appRunningManager_->appRunningRecordMap_.clear();
1092 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, record));
1093 ret = appRunningManager_->CheckMasterProcessAppRunningRecordIsExist(APP_NAME_EMPTY, abilityInfo, uid);
1094 EXPECT_EQ(ret, false);
1095 }
1096
1097 /**
1098 * @tc.name: AppRunningManager_FindMasterProcessAppRunningRecord_0100
1099 * @tc.desc: NA
1100 * @tc.type: FUNC
1101 */
1102 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_FindMasterProcessAppRunningRecord_0100, TestSize.Level1)
1103 {
1104 int uid = 0;
1105 BundleInfo bundleInfo;
1106 std::shared_ptr<AppRunningRecord> recordOne =
1107 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1108 ASSERT_NE(recordOne, nullptr);
1109 std::shared_ptr<AppRunningRecord> recordTwo =
1110 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1111 ASSERT_NE(recordTwo, nullptr);
1112 std::shared_ptr<AppRunningRecord> recordThree =
1113 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1114 ASSERT_NE(recordThree, nullptr);
1115 AppExecFwk::AbilityInfo abilityInfo;
1116
1117 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1118 recordOne->processType_ = ProcessType::NORMAL;
1119 recordOne->SetMasterProcess(true);
1120 recordOne->SetUid(uid);
1121 recordTwo->processType_ = ProcessType::NORMAL;
1122 recordTwo->SetMasterProcess(false);
1123 recordTwo->SetUid(uid);
1124 recordThree->processType_ = ProcessType::EXTENSION;
1125 recordThree->SetMasterProcess(true);
1126 recordThree->SetUid(uid);
1127 appRunningManager_->appRunningRecordMap_.clear();
1128 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, recordOne));
1129 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(TWO, recordTwo));
1130 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(THREE, recordThree));
1131 auto ret = appRunningManager_->FindMasterProcessAppRunningRecord(APP_NAME_EMPTY, abilityInfo, uid);
1132 EXPECT_EQ(ret, recordOne);
1133 }
1134
1135 /**
1136 * @tc.name: AppRunningManager_FindMasterProcessAppRunningRecord_0200
1137 * @tc.desc: NA
1138 * @tc.type: FUNC
1139 */
1140 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_FindMasterProcessAppRunningRecord_0200, TestSize.Level1)
1141 {
1142 int uid = 0;
1143 BundleInfo bundleInfo;
1144 std::shared_ptr<AppRunningRecord> recordOne =
1145 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1146 ASSERT_NE(recordOne, nullptr);
1147 std::shared_ptr<AppRunningRecord> recordTwo =
1148 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1149 ASSERT_NE(recordTwo, nullptr);
1150 std::shared_ptr<AppRunningRecord> recordThree =
1151 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1152 ASSERT_NE(recordThree, nullptr);
1153 AppExecFwk::AbilityInfo abilityInfo;
1154
1155 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1156 recordOne->processType_ = ProcessType::NORMAL;
1157 recordOne->SetMasterProcess(false);
1158 recordOne->SetUid(uid);
1159 recordTwo->processType_ = ProcessType::NORMAL;
1160 recordTwo->SetMasterProcess(false);
1161 recordTwo->SetTimeStamp(1);
1162 recordTwo->SetUid(uid);
1163 recordThree->processType_ = ProcessType::NORMAL;
1164 recordThree->SetTimeStamp(-1);
1165 recordThree->SetMasterProcess(false);
1166 recordThree->SetUid(uid);
1167 appRunningManager_->appRunningRecordMap_.clear();
1168 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, recordOne));
1169 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(TWO, recordTwo));
1170 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(THREE, recordThree));
1171 auto ret = appRunningManager_->FindMasterProcessAppRunningRecord(APP_NAME_EMPTY, abilityInfo, uid);
1172 EXPECT_EQ(ret, recordTwo);
1173 }
1174
1175 /**
1176 * @tc.name: AppRunningManager_FindMasterProcessAppRunningRecord_0300
1177 * @tc.desc: NA
1178 * @tc.type: FUNC
1179 */
1180 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_FindMasterProcessAppRunningRecord_0300, TestSize.Level1)
1181 {
1182 int uid = 0;
1183 BundleInfo bundleInfo;
1184 std::shared_ptr<AppRunningRecord> recordOne =
1185 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1186 ASSERT_NE(recordOne, nullptr);
1187 std::shared_ptr<AppRunningRecord> recordTwo =
1188 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1189 ASSERT_NE(recordTwo, nullptr);
1190 std::shared_ptr<AppRunningRecord> recordThree =
1191 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1192 ASSERT_NE(recordThree, nullptr);
1193 AppExecFwk::AbilityInfo abilityInfo;
1194
1195 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1196 recordOne->processType_ = ProcessType::NORMAL;
1197 recordOne->SetMasterProcess(true);
1198 recordOne->SetUid(uid);
1199 recordTwo->processType_ = ProcessType::NORMAL;
1200 recordTwo->SetMasterProcess(false);
1201 recordTwo->SetTimeStamp(1);
1202 recordTwo->SetUid(uid);
1203 recordThree->processType_ = ProcessType::NORMAL;
1204 recordThree->SetTimeStamp(-1);
1205 recordThree->SetMasterProcess(false);
1206 recordThree->SetUid(uid);
1207 appRunningManager_->appRunningRecordMap_.clear();
1208 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, recordOne));
1209 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(TWO, recordTwo));
1210 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(THREE, recordThree));
1211 auto ret = appRunningManager_->FindMasterProcessAppRunningRecord(APP_NAME_EMPTY, abilityInfo, uid);
1212 EXPECT_EQ(ret, recordOne);
1213 }
1214
1215 /**
1216 * @tc.name: AppRunningManager_FindMasterProcessAppRunningRecord_0400
1217 * @tc.desc: NA
1218 * @tc.type: FUNC
1219 */
1220 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_FindMasterProcessAppRunningRecord_0400, TestSize.Level1)
1221 {
1222 int uid = 0;
1223 BundleInfo bundleInfo;
1224 std::shared_ptr<AppRunningRecord> recordOne =
1225 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1226 ASSERT_NE(recordOne, nullptr);
1227 std::shared_ptr<AppRunningRecord> recordTwo =
1228 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1229 ASSERT_NE(recordTwo, nullptr);
1230 std::shared_ptr<AppRunningRecord> recordThree =
1231 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1232 ASSERT_NE(recordThree, nullptr);
1233 AppExecFwk::AbilityInfo abilityInfo;
1234
1235 abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1236 recordOne->processType_ = ProcessType::NORMAL;
1237 recordOne->SetMasterProcess(true);
1238 recordOne->SetUid(uid);
1239 recordTwo->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1240 recordTwo->SetMasterProcess(true);
1241 recordTwo->SetTimeStamp(0);
1242 recordTwo->SetUid(uid);
1243 recordThree->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1244 recordThree->SetTimeStamp(-1);
1245 recordThree->SetMasterProcess(false);
1246 recordThree->SetUid(uid);
1247 appRunningManager_->appRunningRecordMap_.clear();
1248 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, recordOne));
1249 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(TWO, recordTwo));
1250 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(THREE, recordThree));
1251 auto ret = appRunningManager_->FindMasterProcessAppRunningRecord(APP_NAME_EMPTY, abilityInfo, uid);
1252 EXPECT_EQ(ret, recordTwo);
1253 }
1254
1255 /**
1256 * @tc.name: AppRunningManager_FindMasterProcessAppRunningRecord_0500
1257 * @tc.desc: NA
1258 * @tc.type: FUNC
1259 */
1260 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_FindMasterProcessAppRunningRecord_0500, TestSize.Level1)
1261 {
1262 int uid = 0;
1263 BundleInfo bundleInfo;
1264 std::shared_ptr<AppRunningRecord> recordOne =
1265 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1266 ASSERT_NE(recordOne, nullptr);
1267 std::shared_ptr<AppRunningRecord> recordTwo =
1268 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1269 ASSERT_NE(recordTwo, nullptr);
1270 std::shared_ptr<AppRunningRecord> recordThree =
1271 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1272 ASSERT_NE(recordThree, nullptr);
1273 AppExecFwk::AbilityInfo abilityInfo;
1274
1275 abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1276 recordOne->processType_ = ProcessType::NORMAL;
1277 recordOne->SetMasterProcess(true);
1278 recordOne->SetUid(uid);
1279 recordTwo->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1280 recordTwo->SetMasterProcess(false);
1281 recordTwo->SetTimeStamp(-2);
1282 recordTwo->SetUid(uid);
1283 recordThree->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1284 recordThree->SetTimeStamp(-1);
1285 recordThree->SetMasterProcess(false);
1286 recordThree->SetUid(uid);
1287 appRunningManager_->appRunningRecordMap_.clear();
1288 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, recordOne));
1289 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(TWO, recordTwo));
1290 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(THREE, recordThree));
1291 auto ret = appRunningManager_->FindMasterProcessAppRunningRecord(APP_NAME_EMPTY, abilityInfo, uid);
1292 EXPECT_EQ(ret, recordThree);
1293 }
1294
1295 /**
1296 * @tc.name: AppRunningManager_FindMasterProcessAppRunningRecord_0600
1297 * @tc.desc: NA
1298 * @tc.type: FUNC
1299 */
1300 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_FindMasterProcessAppRunningRecord_0600, TestSize.Level1)
1301 {
1302 int uid = 0;
1303 BundleInfo bundleInfo;
1304 std::shared_ptr<AppRunningRecord> recordOne =
1305 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1306 ASSERT_NE(recordOne, nullptr);
1307 std::shared_ptr<AppRunningRecord> recordTwo =
1308 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1309 ASSERT_NE(recordTwo, nullptr);
1310 std::shared_ptr<AppRunningRecord> recordThree =
1311 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1312 ASSERT_NE(recordThree, nullptr);
1313 AppExecFwk::AbilityInfo abilityInfo;
1314
1315 abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1316 recordOne->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1317 recordOne->SetMasterProcess(true);
1318 recordOne->SetUid(uid);
1319 recordTwo->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1320 recordTwo->SetMasterProcess(false);
1321 recordTwo->SetTimeStamp(-2);
1322 recordTwo->SetUid(uid);
1323 recordThree->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1324 recordThree->SetTimeStamp(-1);
1325 recordThree->SetMasterProcess(false);
1326 recordThree->SetUid(uid);
1327 appRunningManager_->appRunningRecordMap_.clear();
1328 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, recordOne));
1329 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(TWO, recordTwo));
1330 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(THREE, recordThree));
1331 auto ret = appRunningManager_->FindMasterProcessAppRunningRecord(APP_NAME_EMPTY, abilityInfo, uid);
1332 EXPECT_EQ(ret, recordOne);
1333 }
1334
1335 /**
1336 * @tc.name: AppRunningManager_FindMasterProcessAppRunningRecord_0700
1337 * @tc.desc: NA
1338 * @tc.type: FUNC
1339 */
1340 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_FindMasterProcessAppRunningRecord_0700, TestSize.Level1)
1341 {
1342 int uid = 0;
1343 BundleInfo bundleInfo;
1344 std::shared_ptr<AppRunningRecord> recordOne =
1345 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1346 ASSERT_NE(recordOne, nullptr);
1347 std::shared_ptr<AppRunningRecord> recordTwo =
1348 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1349 ASSERT_NE(recordTwo, nullptr);
1350 std::shared_ptr<AppRunningRecord> recordThree =
1351 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1352 ASSERT_NE(recordThree, nullptr);
1353 AppExecFwk::AbilityInfo abilityInfo;
1354
1355 abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1356 recordOne->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1357 recordOne->SetMasterProcess(false);
1358 recordOne->SetUid(uid);
1359 recordOne->appRecordId_ = 0;
1360 recordTwo->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1361 recordTwo->SetMasterProcess(false);
1362 recordTwo->SetTimeStamp(0);
1363 recordTwo->SetUid(uid);
1364 recordTwo->appRecordId_ = 1;
1365 recordThree->extensionType_ = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1366 recordThree->SetTimeStamp(0);
1367 recordThree->SetMasterProcess(false);
1368 recordThree->SetUid(uid);
1369 recordThree->appRecordId_ = 2;
1370 appRunningManager_->appRunningRecordMap_.clear();
1371 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, recordOne));
1372 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(TWO, recordTwo));
1373 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(THREE, recordThree));
1374 auto ret = appRunningManager_->FindMasterProcessAppRunningRecord(APP_NAME_EMPTY, abilityInfo, uid);
1375 EXPECT_EQ(ret, recordOne);
1376 }
1377
1378 /**
1379 * @tc.name: AppRunningManager_FindMasterProcessAppRunningRecord_0800
1380 * @tc.desc: NA
1381 * @tc.type: FUNC
1382 */
1383 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_FindMasterProcessAppRunningRecord_0800, TestSize.Level1)
1384 {
1385 int uid = 0;
1386 BundleInfo bundleInfo;
1387 AppExecFwk::AbilityInfo abilityInfo;
1388 abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SYS_COMMON_UI;
1389 auto ret = appRunningManager_->FindMasterProcessAppRunningRecord(APP_NAME_EMPTY, abilityInfo, uid);
1390 EXPECT_EQ(ret, nullptr);
1391 }
1392
1393 /**
1394 * @tc.name: AppRunningManager_FindMasterProcessAppRunningRecord_0900
1395 * @tc.desc: NA
1396 * @tc.type: FUNC
1397 */
1398 HWTEST_F(AppRunningManagerFourthTest, AppRunningManager_FindMasterProcessAppRunningRecord_0900, TestSize.Level1)
1399 {
1400 int uid = 0;
1401 BundleInfo bundleInfo;
1402 std::shared_ptr<AppRunningRecord> recordOne =
1403 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1404 ASSERT_NE(recordOne, nullptr);
1405 std::shared_ptr<AppRunningRecord> recordTwo =
1406 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1407 ASSERT_NE(recordTwo, nullptr);
1408 std::shared_ptr<AppRunningRecord> recordThree =
1409 appRunningManager_->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
1410 ASSERT_NE(recordThree, nullptr);
1411 AppExecFwk::AbilityInfo abilityInfo;
1412
1413 abilityInfo.type = AppExecFwk::AbilityType::PAGE;
1414 recordOne->processType_ = ProcessType::NORMAL;
1415 recordOne->SetMasterProcess(false);
1416 recordOne->SetUid(uid);
1417 recordTwo->processType_ = ProcessType::NORMAL;
1418 recordTwo->SetMasterProcess(false);
1419 recordTwo->SetUid(uid);
1420 recordThree->processType_ = ProcessType::EXTENSION;
1421 recordThree->SetMasterProcess(false);
1422 recordThree->SetUid(uid);
1423 appRunningManager_->appRunningRecordMap_.clear();
1424 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(ONE, recordOne));
1425 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(TWO, recordTwo));
1426 appRunningManager_->appRunningRecordMap_.insert(std::make_pair(THREE, recordThree));
1427 auto ret = appRunningManager_->FindMasterProcessAppRunningRecord(APP_NAME_EMPTY, abilityInfo, uid);
1428 EXPECT_EQ(ret, nullptr);
1429 }
1430
1431
1432 /**
1433 * @tc.name: CheckAppRunningRecordForSpecifiedProcess_0100
1434 * @tc.desc: CheckAppRunningRecordForSpecifiedProcess.
1435 * @tc.type: FUNC
1436 */
1437 HWTEST_F(AppRunningManagerFourthTest, CheckAppRunningRecordForSpecifiedProcess_0100, TestSize.Level1)
1438 {
1439 auto appRunningManager = std::make_shared<AppRunningManager>();
1440 EXPECT_NE(appRunningManager, nullptr);
1441
1442 int32_t uid = 12345;
1443 std::string instanceKey = "instanceKey";
1444 std::string customProcessFlag = "customProcessFlag";
1445 ApplicationInfo appInfo;
1446 appInfo.name = "KeepAliveApp";
1447 appInfo.bundleName = "KeepAliveApplication";
1448 appInfo.uid = uid;
1449 auto app = std::make_shared<ApplicationInfo>(appInfo);
1450 std::shared_ptr<AppRunningRecord> appRecord = std::make_shared<AppRunningRecord>(app, 111, "KeepAliveApplication");
1451 appRecord->SetInstanceKey(instanceKey);
1452 appRecord->SetUid(uid);
1453 appRecord->SetCustomProcessFlag(customProcessFlag);
1454
1455 appRunningManager->appRunningRecordMap_.emplace(111, appRecord);
1456 auto result = appRunningManager->CheckAppRunningRecordForSpecifiedProcess(uid, instanceKey, customProcessFlag);
1457 EXPECT_NE(result, nullptr);
1458 }
1459
1460 /**
1461 * @tc.name: CheckAppRunningRecordForSpecifiedProcess_0200
1462 * @tc.desc: CheckAppRunningRecordForSpecifiedProcess.
1463 * @tc.type: FUNC
1464 */
1465 HWTEST_F(AppRunningManagerFourthTest, CheckAppRunningRecordForSpecifiedProcess_0200, TestSize.Level1)
1466 {
1467 auto appRunningManager = std::make_shared<AppRunningManager>();
1468 EXPECT_NE(appRunningManager, nullptr);
1469
1470 int32_t uid = 12345;
1471 std::string instanceKey = "instanceKey";
1472 std::string customProcessFlag = "customProcessFlag";
1473 auto result = appRunningManager->CheckAppRunningRecordForSpecifiedProcess(uid, instanceKey, customProcessFlag);
1474 EXPECT_EQ(result, nullptr);
1475 }
1476 } // namespace AppExecFwk
1477 } // namespace OHOS