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 #include "app_running_manager.h"
19 #include "app_running_record.h"
20 #include "child_process_record.h"
21 #include "app_record_id.h"
22 #include "exit_resident_process_manager.h"
23 #include "hilog_tag_wrapper.h"
24 #include "ability_record.h"
25 #include "app_mgr_service_dump_error_code.h"
26 #include "mock_app_scheduler.h"
27 #include "ability_scheduler_mock.h"
28 #include "child_process_request.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace AppExecFwk {
35 namespace {
36 constexpr int32_t USR_ID_100 = 100;
37 constexpr int32_t USR_ID_101 = 101;
38 const std::string BUNDLE_NAME = "testBundleName";
39 const std::string PROCESS_NAME = "testProcessName";
40 constexpr pid_t PID = 0;
41 }
42
43 class AppRunningManagerThirdTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 void SetUp() override;
48 void TearDown() override;
49 sptr<Token> MockToken();
50
51 protected:
52 static BundleInfo bundleInfo;
53 static std::shared_ptr<ApplicationInfo> appInfo_;
54 };
55
56 BundleInfo AppRunningManagerThirdTest::bundleInfo;
57 std::shared_ptr<ApplicationInfo> AppRunningManagerThirdTest::appInfo_ = nullptr;
58
SetUpTestCase(void)59 void AppRunningManagerThirdTest::SetUpTestCase(void)
60 {
61 appInfo_ = std::make_shared<ApplicationInfo>();
62 appInfo_->bundleName = BUNDLE_NAME;
63 }
64
TearDownTestCase(void)65 void AppRunningManagerThirdTest::TearDownTestCase(void)
66 {}
67
SetUp()68 void AppRunningManagerThirdTest::SetUp()
69 {}
70
TearDown()71 void AppRunningManagerThirdTest::TearDown()
72 {}
73
MockToken()74 sptr<Token> AppRunningManagerThirdTest::MockToken()
75 {
76 sptr<Token> token = nullptr;
77 AbilityRequest abilityRequest;
78 abilityRequest.appInfo.bundleName = "com.test.demo";
79 abilityRequest.abilityInfo.name = "MainAbility";
80 abilityRequest.abilityInfo.type = AbilityType::PAGE;
81 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
82 if (!abilityRecord) {
83 return nullptr;
84 }
85
86 return abilityRecord->GetToken();
87 }
88
89 class MockIChildScheduler : public IChildScheduler {
90 public:
91 MockIChildScheduler() = default;
92 ~MockIChildScheduler() = default;
ScheduleLoadChild()93 bool ScheduleLoadChild() override
94 {
95 return true;
96 }
97
ScheduleExitProcessSafely()98 bool ScheduleExitProcessSafely() override
99 {
100 return true;
101 }
102
ScheduleRunNativeProc(const sptr<IRemoteObject> & mainProcessCb)103 bool ScheduleRunNativeProc(const sptr<IRemoteObject> &mainProcessCb) override
104 {
105 return true;
106 }
107
AsObject()108 sptr<IRemoteObject> AsObject() override
109 {
110 return nullptr;
111 }
112 };
113
114 /**
115 * @tc.name: AppRunningManager_OnChildProcessRemoteDied_0100
116 * @tc.desc: Test OnChildProcessRemoteDied
117 * @tc.type: FUNC
118 */
119 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_OnChildProcessRemoteDied_0100, TestSize.Level1)
120 {
121 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_OnChildProcessRemoteDied_0100 start");
122 auto appRunningManager = std::make_shared<AppRunningManager>();
123 wptr<IRemoteObject> remote = nullptr;
124 EXPECT_EQ(appRunningManager->OnChildProcessRemoteDied(remote), nullptr);
125
126 sptr<IRemoteObject> remoteObject = MockToken();
127 wptr<IRemoteObject> remote1(remoteObject);
128 ChildProcessRequest request;
129 request.srcEntry = "./ets/AProcess.ts";
130 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo_, USR_ID_100, PROCESS_NAME);
131 EXPECT_NE(appRunningRecord, nullptr);
132 auto childRecord = ChildProcessRecord::CreateChildProcessRecord(USR_ID_100, request, appRunningRecord);
133 EXPECT_NE(childRecord, nullptr);
134 childRecord->scheduler_ = new (std::nothrow) MockIChildScheduler();
135 EXPECT_NE(childRecord->scheduler_, nullptr);
136 appRunningRecord->childProcessRecordMap_.emplace(PID, childRecord);
137 appRunningManager->appRunningRecordMap_.emplace(PID, appRunningRecord);
138 EXPECT_EQ(appRunningManager->OnChildProcessRemoteDied(remote1), nullptr);
139
140 appRunningManager->appRunningRecordMap_.clear();
141 appRunningRecord = nullptr;
142 appRunningManager->appRunningRecordMap_.emplace(PID, appRunningRecord);
143 EXPECT_EQ(appRunningManager->OnChildProcessRemoteDied(remote1), nullptr);
144
145 appRunningRecord = std::make_shared<AppRunningRecord>(appInfo_, USR_ID_100, PROCESS_NAME);
146 appRunningManager->appRunningRecordMap_.clear();
147 appRunningManager->appRunningRecordMap_.emplace(PID, appRunningRecord);
148 appRunningRecord->childProcessRecordMap_.clear();
149 EXPECT_EQ(appRunningManager->OnChildProcessRemoteDied(remote1), nullptr);
150
151 childRecord = nullptr;
152 appRunningRecord->childProcessRecordMap_.emplace(PID, childRecord);
153 EXPECT_EQ(appRunningManager->OnChildProcessRemoteDied(remote1), nullptr);
154 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_OnChildProcessRemoteDied_0100 end");
155 }
156
157 /**
158 * @tc.name: AppRunningManager_GetAppRunningUniqueIdByPid_0100
159 * @tc.desc: Test GetAppRunningUniqueIdByPid
160 * @tc.type: FUNC
161 */
162 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_GetAppRunningUniqueIdByPid_0100, TestSize.Level1)
163 {
164 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetAppRunningUniqueIdByPid_0100 start");
165 auto appRunningManager = std::make_shared<AppRunningManager>();
166 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo_, USR_ID_100, PROCESS_NAME);
167 appRunningManager->appRunningRecordMap_.emplace(PID, appRunningRecord);
168 std::string appRunningUniqueId = "test";
169 EXPECT_EQ(appRunningManager->GetAppRunningUniqueIdByPid(PID, appRunningUniqueId), ERR_OK);
170 appRunningManager->appRunningRecordMap_.clear();
171 EXPECT_EQ(appRunningManager->GetAppRunningUniqueIdByPid(PID, appRunningUniqueId), ERR_INVALID_VALUE);
172 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetAppRunningUniqueIdByPid_0100 end");
173 }
174
175 /**
176 * @tc.name: AppRunningManager_DumpIpcAllStart_0100
177 * @tc.desc: Test DumpIpcAllStart
178 * @tc.type: FUNC
179 */
180 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_DumpIpcAllStart_0100, TestSize.Level1)
181 {
182 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpIpcAllStart_0100 start");
183 auto appRunningManager = std::make_shared<AppRunningManager>();
184 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo_, USR_ID_100, PROCESS_NAME);
185 appRunningManager->appRunningRecordMap_.emplace(PID, appRunningRecord);
186 appRunningRecord->appLifeCycleDeal_ = std::make_shared<AppLifeCycleDeal>();
187 appRunningRecord->appLifeCycleDeal_->appThread_ = new (std::nothrow) MockAppScheduler();
188 std::string result;
189 EXPECT_EQ(appRunningManager->DumpIpcAllStart(result), ERR_OK);
190 appRunningRecord->appLifeCycleDeal_->appThread_ = nullptr;
191 EXPECT_EQ(appRunningManager->DumpIpcAllStart(result), DumpErrorCode::ERR_INTERNAL_ERROR);
192 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpIpcAllStart_0100 end");
193 }
194
195 /**
196 * @tc.name: AppRunningManager_DumpIpcAllStop_0100
197 * @tc.desc: Test DumpIpcAllStop
198 * @tc.type: FUNC
199 */
200 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_DumpIpcAllStop_0100, TestSize.Level1)
201 {
202 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpIpcAllStop_0100 start");
203 auto appRunningManager = std::make_shared<AppRunningManager>();
204 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo_, USR_ID_100, PROCESS_NAME);
205 appRunningManager->appRunningRecordMap_.emplace(PID, appRunningRecord);
206 appRunningRecord->appLifeCycleDeal_ = std::make_shared<AppLifeCycleDeal>();
207 appRunningRecord->appLifeCycleDeal_->appThread_ = new (std::nothrow) MockAppScheduler();
208 std::string result;
209 EXPECT_EQ(appRunningManager->DumpIpcAllStop(result), ERR_OK);
210 appRunningRecord->appLifeCycleDeal_->appThread_ = nullptr;
211 EXPECT_EQ(appRunningManager->DumpIpcAllStop(result), DumpErrorCode::ERR_INTERNAL_ERROR);
212 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpIpcAllStop_0100 end");
213 }
214
215 /**
216 * @tc.name: AppRunningManager_DumpIpcAllStat_0100
217 * @tc.desc: Test DumpIpcAllStat
218 * @tc.type: FUNC
219 */
220 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_DumpIpcAllStat_0100, TestSize.Level1)
221 {
222 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpIpcAllStat_0100 start");
223 auto appRunningManager = std::make_shared<AppRunningManager>();
224 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo_, USR_ID_100, PROCESS_NAME);
225 appRunningManager->appRunningRecordMap_.emplace(PID, appRunningRecord);
226 appRunningRecord->appLifeCycleDeal_ = std::make_shared<AppLifeCycleDeal>();
227 appRunningRecord->appLifeCycleDeal_->appThread_ = new (std::nothrow) MockAppScheduler();
228 std::string result;
229 EXPECT_EQ(appRunningManager->DumpIpcAllStat(result), ERR_OK);
230 appRunningRecord->appLifeCycleDeal_->appThread_ = nullptr;
231 EXPECT_EQ(appRunningManager->DumpIpcAllStat(result), DumpErrorCode::ERR_INTERNAL_ERROR);
232 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpIpcAllStat_0100 end");
233 }
234
235 /**
236 * @tc.name: AppRunningManager_DumpIpcStart_0100
237 * @tc.desc: Test DumpIpcStart
238 * @tc.type: FUNC
239 */
240 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_DumpIpcStart_0100, TestSize.Level1)
241 {
242 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpIpcStart_0100 start");
243 auto appRunningManager = std::make_shared<AppRunningManager>();
244 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo_, USR_ID_100, PROCESS_NAME);
245 appRunningManager->appRunningRecordMap_.emplace(PID, appRunningRecord);
246 appRunningRecord->appLifeCycleDeal_ = std::make_shared<AppLifeCycleDeal>();
247 appRunningRecord->appLifeCycleDeal_->appThread_ = new (std::nothrow) MockAppScheduler();
248 std::string result;
249 EXPECT_EQ(appRunningManager->DumpIpcStart(PID, result), ERR_OK);
250 appRunningRecord->appLifeCycleDeal_->appThread_ = nullptr;
251 EXPECT_EQ(appRunningManager->DumpIpcStart(PID, result), DumpErrorCode::ERR_INTERNAL_ERROR);
252 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpIpcStart_0100 end");
253 }
254
255 /**
256 * @tc.name: AppRunningManager_ProcessExitByTokenIdAndInstance_0100
257 * @tc.desc: Test ProcessExitByTokenIdAndInstance
258 * @tc.type: FUNC
259 */
260 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_ProcessExitByTokenIdAndInstance_0100, TestSize.Level1)
261 {
262 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_ProcessExitByTokenIdAndInstance_0100 start");
263 auto appRunningManager = std::make_shared<AppRunningManager>();
264 EXPECT_NE(appRunningManager, nullptr);
265 uint32_t accessTokenId = 0;
266 std::string instanceKey;
267 std::list<pid_t> pids;
268 bool clearPageStack = false;
269 auto recordId = AppRecordId::Create();
270 appRunningManager->appRunningRecordMap_.emplace(recordId, nullptr);
271
272 auto recordIdOne = AppRecordId::Create();
273 std::shared_ptr<AppRunningRecord> record =
274 appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
275 record->appInfo_ = nullptr;
276 appRunningManager->appRunningRecordMap_.emplace(recordIdOne, record);
277
278 auto recordIdTwo = AppRecordId::Create();
279 record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
280 record->appInfo_ = std::make_shared<ApplicationInfo>();
281 record->appInfo_->accessTokenId = 1;
282 appRunningManager->appRunningRecordMap_.emplace(recordIdTwo, record);
283
284 auto recordIdThree = AppRecordId::Create();
285 record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
286 record->appInfo_ = std::make_shared<ApplicationInfo>();
287 record->appInfo_->accessTokenId = accessTokenId;
288 record->appInfo_->multiAppMode.multiAppModeType = MultiAppModeType::UNSPECIFIED;
289 appRunningManager->appRunningRecordMap_.emplace(recordIdThree, record);
290
291 auto recordIdFour = AppRecordId::Create();
292 instanceKey = "123";
293 record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
294 record->appInfo_ = std::make_shared<ApplicationInfo>();
295 record->appInfo_->accessTokenId = accessTokenId;
296 record->appInfo_->multiAppMode.multiAppModeType = MultiAppModeType::MULTI_INSTANCE;
297 record->instanceKey_ = "456";
298 appRunningManager->appRunningRecordMap_.emplace(recordIdFour, record);
299
300 auto ret = appRunningManager->ProcessExitByTokenIdAndInstance(accessTokenId, instanceKey, pids, clearPageStack);
301 EXPECT_EQ(ret, false);
302 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_ProcessExitByTokenIdAndInstance_0100 end");
303 }
304
305 /**
306 * @tc.name: AppRunningManager_ProcessExitByTokenIdAndInstance_0200
307 * @tc.desc: Test ProcessExitByTokenIdAndInstance
308 * @tc.type: FUNC
309 */
310 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_ProcessExitByTokenIdAndInstance_0200, TestSize.Level1)
311 {
312 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_ProcessExitByTokenIdAndInstance_0200 start");
313 auto appRunningManager = std::make_shared<AppRunningManager>();
314 EXPECT_NE(appRunningManager, nullptr);
315 uint32_t accessTokenId = 0;
316 std::string instanceKey;
317 std::list<pid_t> pids;
318 bool clearPageStack = false;
319 auto recordIdFive = AppRecordId::Create();
320 auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
321 record->appInfo_ = std::make_shared<ApplicationInfo>();
322 record->appInfo_->accessTokenId = accessTokenId;
323 record->appInfo_->multiAppMode.multiAppModeType = MultiAppModeType::MULTI_INSTANCE;
324 record->priorityObject_ = nullptr;
325 record->instanceKey_ = instanceKey;
326 appRunningManager->appRunningRecordMap_.emplace(recordIdFive, record);
327
328 auto recordIdSix = AppRecordId::Create();
329 record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
330 record->appInfo_ = std::make_shared<ApplicationInfo>();
331 record->appInfo_->accessTokenId = accessTokenId;
332 record->appInfo_->multiAppMode.multiAppModeType = MultiAppModeType::MULTI_INSTANCE;
333 record->priorityObject_ = std::make_shared<PriorityObject>();
334 record->instanceKey_ = instanceKey;
335 record->priorityObject_->pid_ = 0;
336 appRunningManager->appRunningRecordMap_.emplace(recordIdSix, record);
337
338 auto recordIdSeven = AppRecordId::Create();
339 record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
340 record->appInfo_ = std::make_shared<ApplicationInfo>();
341 record->appInfo_->accessTokenId = accessTokenId;
342 record->appInfo_->multiAppMode.multiAppModeType = MultiAppModeType::MULTI_INSTANCE;
343 record->priorityObject_ = std::make_shared<PriorityObject>();
344 record->instanceKey_ = instanceKey;
345 record->priorityObject_->pid_ = 1;
346 appRunningManager->appRunningRecordMap_.emplace(recordIdSeven, record);
347 auto ret = appRunningManager->ProcessExitByTokenIdAndInstance(accessTokenId, instanceKey, pids, clearPageStack);
348 EXPECT_EQ(ret, true);
349 clearPageStack = true;
350 ret = appRunningManager->ProcessExitByTokenIdAndInstance(accessTokenId, instanceKey, pids, clearPageStack);
351 EXPECT_EQ(ret, true);
352 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_ProcessExitByTokenIdAndInstance_0200 end");
353 }
354
355 /**
356 * @tc.name: AppRunningManager_GetRunningProcessInfoByPid_0100
357 * @tc.desc: Test GetRunningProcessInfoByPid
358 * @tc.type: FUNC
359 */
360 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_GetRunningProcessInfoByPid_0100, TestSize.Level1)
361 {
362 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetRunningProcessInfoByPid_0100 start");
363 auto appRunningManager = std::make_shared<AppRunningManager>();
364 EXPECT_NE(appRunningManager, nullptr);
365 pid_t pid = 0;
366 OHOS::AppExecFwk::RunningProcessInfo info;
367 auto ret = appRunningManager->GetRunningProcessInfoByPid(pid, info);
368 EXPECT_EQ(ret, ERR_INVALID_OPERATION);
369 pid = -1;
370 ret = appRunningManager->GetRunningProcessInfoByPid(pid, info);
371 EXPECT_EQ(ret, ERR_INVALID_OPERATION);
372 pid = 1;
373 ret = appRunningManager->GetRunningProcessInfoByPid(pid, info);
374 EXPECT_EQ(ret, ERR_INVALID_OPERATION);
375 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetRunningProcessInfoByPid_0100 end");
376 }
377
378 /**
379 * @tc.name: AppRunningManager_GetRunningProcessInfoByChildProcessPid_0100
380 * @tc.desc: Test GetRunningProcessInfoByChildProcessPid
381 * @tc.type: FUNC
382 */
383 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_GetRunningProcessInfoByChildProcessPid_0100, TestSize.Level1)
384 {
385 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetRunningProcessInfoByChildProcessPid_0100 start");
386 auto appRunningManager = std::make_shared<AppRunningManager>();
387 EXPECT_NE(appRunningManager, nullptr);
388 pid_t childPid = -1;
389 OHOS::AppExecFwk::RunningProcessInfo info;
390 auto ret = appRunningManager->GetRunningProcessInfoByChildProcessPid(childPid, info);
391 EXPECT_EQ(ret, ERR_INVALID_OPERATION);
392
393 childPid = 0;
394 ret = appRunningManager->GetRunningProcessInfoByChildProcessPid(childPid, info);
395 EXPECT_EQ(ret, ERR_INVALID_OPERATION);
396
397 childPid = 1;
398 ret = appRunningManager->GetRunningProcessInfoByChildProcessPid(childPid, info);
399 EXPECT_EQ(ret, ERR_INVALID_OPERATION);
400
401 auto recordId = AppRecordId::Create();
402 auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
403 record->appInfo_ = std::make_shared<ApplicationInfo>();
404 record->priorityObject_ = std::make_shared<PriorityObject>();
405 record->priorityObject_->pid_ = 1;
406 appRunningManager->appRunningRecordMap_.emplace(recordId, record);
407 ret = appRunningManager->GetRunningProcessInfoByChildProcessPid(childPid, info);
408 EXPECT_EQ(ret, ERR_OK);
409 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetRunningProcessInfoByChildProcessPid_0100 end");
410 }
411
412 /**
413 * @tc.name: AppRunningManager_DumpJsHeapMemory_0100
414 * @tc.desc: Test DumpJsHeapMemory
415 * @tc.type: FUNC
416 */
417 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_DumpJsHeapMemory_0100, TestSize.Level1)
418 {
419 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpJsHeapMemory_0100 start");
420 auto appRunningManager = std::make_shared<AppRunningManager>();
421 EXPECT_NE(appRunningManager, nullptr);
422 OHOS::AppExecFwk::JsHeapDumpInfo info;
423 info.pid = 0;
424 auto ret = appRunningManager->DumpJsHeapMemory(info);
425 EXPECT_EQ(ret, ERR_INVALID_VALUE);
426
427 info.pid = 1;
428 auto recordId = AppRecordId::Create();
429 auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
430 record->appInfo_ = std::make_shared<ApplicationInfo>();
431 record->priorityObject_ = std::make_shared<PriorityObject>();
432 record->priorityObject_->pid_ = 1;
433 appRunningManager->appRunningRecordMap_.emplace(recordId, record);
434 ret = appRunningManager->DumpJsHeapMemory(info);
435 EXPECT_EQ(ret, ERR_OK);
436 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpJsHeapMemory_0100 end");
437 }
438
439 /**
440 * @tc.name: AppRunningManager_DumpCjHeapMemory_0100
441 * @tc.desc: Test DumpCjHeapMemory
442 * @tc.type: FUNC
443 */
444 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_DumpCjHeapMemory_0100, TestSize.Level1)
445 {
446 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpCjHeapMemory_0100 start");
447 auto appRunningManager = std::make_shared<AppRunningManager>();
448 EXPECT_NE(appRunningManager, nullptr);
449 OHOS::AppExecFwk::CjHeapDumpInfo info;
450 info.pid = 0;
451 auto ret = appRunningManager->DumpCjHeapMemory(info);
452 EXPECT_EQ(ret, ERR_INVALID_VALUE);
453
454 info.pid = 1;
455 auto recordId = AppRecordId::Create();
456 auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
457 record->appInfo_ = std::make_shared<ApplicationInfo>();
458 record->priorityObject_ = std::make_shared<PriorityObject>();
459 record->priorityObject_->pid_ = 1;
460 appRunningManager->appRunningRecordMap_.emplace(recordId, record);
461 ret = appRunningManager->DumpCjHeapMemory(info);
462 EXPECT_EQ(ret, ERR_OK);
463 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_DumpCjHeapMemory_0100 end");
464 }
465
466 /**
467 * @tc.name: AppRunningManager_UpdateConfigurationByBundleName_0100
468 * @tc.desc: Test UpdateConfigurationByBundleName
469 * @tc.type: FUNC
470 */
471 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_UpdateConfigurationByBundleName_0100, TestSize.Level1)
472 {
473 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_UpdateConfigurationByBundleName_0100 start");
474 auto appRunningManager = std::make_shared<AppRunningManager>();
475 EXPECT_NE(appRunningManager, nullptr);
476 Configuration config;
477 const std::string name = "";
478 int32_t appIndex = 0;
479 auto recordId = AppRecordId::Create();
480 auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
481 record->SetState(ApplicationState::APP_STATE_CREATE);
482 appRunningManager->appRunningRecordMap_.emplace(recordId, record);
483
484 auto recordIdOne = AppRecordId::Create();
485 appRunningManager->appRunningRecordMap_.emplace(recordIdOne, nullptr);
486
487 auto recordIdTwo = AppRecordId::Create();
488 record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
489 record->SetState(ApplicationState::APP_STATE_READY);
490 appRunningManager->appRunningRecordMap_.emplace(recordIdTwo, record);
491
492 auto ret = appRunningManager->UpdateConfigurationByBundleName(config, name, appIndex);
493 EXPECT_EQ(ret, ERR_OK);
494 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_UpdateConfigurationByBundleName_0100 end");
495 }
496
497 /**
498 * @tc.name: AppRunningManager_UpdateConfigurationByBundleName_0200
499 * @tc.desc: Test UpdateConfigurationByBundleName
500 * @tc.type: FUNC
501 */
502 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_UpdateConfigurationByBundleName_0200, TestSize.Level1)
503 {
504 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_UpdateConfigurationByBundleName_0200 start");
505 auto appRunningManager = std::make_shared<AppRunningManager>();
506 EXPECT_NE(appRunningManager, nullptr);
507 Configuration config;
508 const std::string name = "123";
509 int32_t appIndex = 0;
510 auto recordIdOne = AppRecordId::Create();
511 appRunningManager->appRunningRecordMap_.emplace(recordIdOne, nullptr);
512 auto recordIdTwo = AppRecordId::Create();
513 auto record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
514 record->SetState(ApplicationState::APP_STATE_READY);
515 record->appInfo_ = std::make_shared<ApplicationInfo>();
516 record->appInfo_->name = "123";
517 record->mainBundleName_ = "123";
518 record->appIndex_ = 0;
519 appRunningManager->appRunningRecordMap_.emplace(recordIdTwo, record);
520 auto recordIdThree = AppRecordId::Create();
521 record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
522 record->SetState(ApplicationState::APP_STATE_READY);
523 record->appInfo_ = std::make_shared<ApplicationInfo>();
524 record->appInfo_->name = "1234";
525 record->mainBundleName_ = "123";
526 record->appIndex_ = 0;
527 appRunningManager->appRunningRecordMap_.emplace(recordIdThree, record);
528 auto recordIdFour = AppRecordId::Create();
529 record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
530 record->SetState(ApplicationState::APP_STATE_READY);
531 record->appInfo_ = std::make_shared<ApplicationInfo>();
532 record->appInfo_->name = "123";
533 record->mainBundleName_ = "123";
534 record->appIndex_ = 1;
535 appRunningManager->appRunningRecordMap_.emplace(recordIdFour, record);
536 auto recordIdFive = AppRecordId::Create();
537 record = appRunningManager->CreateAppRunningRecord(appInfo_, PROCESS_NAME, bundleInfo, "");
538 record->SetState(ApplicationState::APP_STATE_READY);
539 record->appInfo_ = std::make_shared<ApplicationInfo>();
540 record->appInfo_->name = "123";
541 record->mainBundleName_ = "1234";
542 record->appIndex_ = 1;
543 appRunningManager->appRunningRecordMap_.emplace(recordIdFive, record);
544 auto ret = appRunningManager->UpdateConfigurationByBundleName(config, name, appIndex);
545 EXPECT_EQ(ret, ERR_INVALID_VALUE);
546 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_UpdateConfigurationByBundleName_0200 end");
547 }
548
549 /**
550 * @tc.name: AppRunningManager_GetAppRunningRecordByChildRecordPid_0100
551 * @tc.desc: Test GetAppRunningRecordByChildRecordPid
552 * @tc.type: FUNC
553 */
554 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_GetAppRunningRecordByChildRecordPid_0100, TestSize.Level1)
555 {
556 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetAppRunningRecordByChildRecordPid_0100 start");
557 auto appRunningManager = std::make_shared<AppRunningManager>();
558 EXPECT_NE(appRunningManager, nullptr);
559 pid_t pid = PID;
560 auto result = appRunningManager->GetAppRunningRecordByChildRecordPid(pid);
561 EXPECT_EQ(result, nullptr);
562 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetAppRunningRecordByChildRecordPid_0100 end");
563 }
564
565 /**
566 * @tc.name: AppRunningManager_GetAppRunningRecordByChildRecordPid_0200
567 * @tc.desc: Test GetAppRunningRecordByChildRecordPid
568 * @tc.type: FUNC
569 */
570 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_GetAppRunningRecordByChildRecordPid_0200, TestSize.Level1)
571 {
572 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetAppRunningRecordByChildRecordPid_0200 start");
573 auto appRunningManager = std::make_shared<AppRunningManager>();
574 EXPECT_NE(appRunningManager, nullptr);
575 auto appRunningRecord = std::make_shared<AppRunningRecord>(appInfo_, USR_ID_100, PROCESS_NAME);
576 auto appRunningRecordChild = std::make_shared<AppRunningRecord>(appInfo_, USR_ID_100, PROCESS_NAME);
577 appRunningRecord->childAppRecordMap_[PID] = appRunningRecordChild;
578 EXPECT_NE(appRunningRecord, nullptr);
579 appRunningManager->appRunningRecordMap_.emplace(PID, appRunningRecord);
580 pid_t pid = PID;
581 auto ret = appRunningManager->GetAppRunningRecordByChildRecordPid(pid);
582 EXPECT_NE(ret, nullptr);
583 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_GetAppRunningRecordByChildRecordPid_0200 end");
584 }
585
586 /**
587 * @tc.name: AppRunningManager_AddUIExtensionBindItem_0100
588 * @tc.desc: Test AddUIExtensionBindItem
589 * @tc.type: FUNC
590 */
591 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_AddUIExtensionBindItem_0100, TestSize.Level1)
592 {
593 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_AddUIExtensionBindItem_0100 start");
594 auto appRunningManager = std::make_shared<AppRunningManager>();
595 EXPECT_NE(appRunningManager, nullptr);
596 int32_t bindId = 0;
597 UIExtensionProcessBindInfo bindInfo;
598 auto ret = appRunningManager->AddUIExtensionBindItem(bindId, bindInfo);
599 EXPECT_EQ(ret, ERR_OK);
600 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_AddUIExtensionBindItem_0100 end");
601 }
602
603 /**
604 * @tc.name: AppRunningManager_RemoveUIExtensionBindItemById_0100
605 * @tc.desc: Test RemoveUIExtensionBindItemById
606 * @tc.type: FUNC
607 */
608 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_RemoveUIExtensionBindItemById_0100, TestSize.Level1)
609 {
610 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_RemoveUIExtensionBindItemById_0100 start");
611 auto appRunningManager = std::make_shared<AppRunningManager>();
612 EXPECT_NE(appRunningManager, nullptr);
613 int32_t bindId = 0;
614 auto ret = appRunningManager->RemoveUIExtensionBindItemById(bindId);
615 EXPECT_EQ(ret, ERR_OK);
616 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_RemoveUIExtensionBindItemById_0100 end");
617 }
618
619 /**
620 * @tc.name: AppRunningManager_QueryUIExtensionBindItemById_0100
621 * @tc.desc: Test QueryUIExtensionBindItemById
622 * @tc.type: FUNC
623 */
624 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_QueryUIExtensionBindItemById_0100, TestSize.Level1)
625 {
626 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_QueryUIExtensionBindItemById_0100 start");
627 auto appRunningManager = std::make_shared<AppRunningManager>();
628 EXPECT_NE(appRunningManager, nullptr);
629 int32_t bindId = 0;
630 UIExtensionProcessBindInfo bindInfo;
631 appRunningManager->AddUIExtensionBindItem(bindId, bindInfo);
632 auto ret = appRunningManager->QueryUIExtensionBindItemById(bindId, bindInfo);
633 EXPECT_EQ(ret, ERR_OK);
634 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_QueryUIExtensionBindItemById_0100 end");
635 }
636
637 /**
638 * @tc.name: AppRunningManager_QueryUIExtensionBindItemById_0200
639 * @tc.desc: Test QueryUIExtensionBindItemById
640 * @tc.type: FUNC
641 */
642 HWTEST_F(AppRunningManagerThirdTest, AppRunningManager_QueryUIExtensionBindItemById_0200, TestSize.Level1)
643 {
644 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_QueryUIExtensionBindItemById_0100 start");
645 auto appRunningManager = std::make_shared<AppRunningManager>();
646 EXPECT_NE(appRunningManager, nullptr);
647 int32_t bindId = 0;
648 UIExtensionProcessBindInfo bindInfo;
649 auto result = appRunningManager->QueryUIExtensionBindItemById(bindId, bindInfo);
650 EXPECT_EQ(result, ERR_INVALID_VALUE);
651 TAG_LOGI(AAFwkTag::TEST, "AppRunningManager_QueryUIExtensionBindItemById_0200 end");
652 }
653 } // namespace AppExecFwk
654 } // namespace OHOS
655