1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define private public
17 #include "remote_client_manager.h"
18 #include "app_mgr_service_inner.h"
19 #undef private
20
21 #include <vector>
22 #include <gtest/gtest.h>
23 #include "app_launch_data.h"
24 #include "app_mgr_interface.h"
25 #include "iremote_object.h"
26 #include "app_state_callback_proxy.h"
27 #include "refbase.h"
28 #include "mock_bundle_manager.h"
29 #include "mock_ability_token.h"
30 #include "mock_app_scheduler.h"
31 #include "mock_app_spawn_client.h"
32 #include "mock_iapp_state_callback.h"
33 #include "mock_native_token.h"
34 #include "param.h"
35 #include "system_ability_definition.h"
36 #include "sys_mgr_client.h"
37
38 using namespace testing::ext;
39 using testing::_;
40 using testing::Return;
41 using testing::SetArgReferee;
42 using ::testing::DoAll;
43
44 namespace {
45 const int32_t ABILITY_NUM = 100;
46 const int32_t APPLICATION_NUM = 100;
47 const int32_t INDEX_NUM_100 = 100;
48 const int32_t INDEX_NUM_MAX = 100;
49 const std::string TEST_APP_NAME = "com.ohos.test.helloworld";
50 const std::string TEST_ABILITY_NAME = "test_ability_";
51 #define CHECK_POINTER_IS_NULLPTR(object) \
52 do { \
53 if (object == nullptr) { \
54 return; \
55 } \
56 } while (0)
57 } // namespace
58
59 namespace OHOS {
60 namespace AppExecFwk {
61 struct TestProcessInfo {
62 pid_t pid = 0;
63 bool isStart = false;
64 };
65 // specify process condition
66 class AmsAppLifeCycleModuleTest : public testing::Test {
67 public:
68 static void SetUpTestCase();
69 static void TearDownTestCase();
70 void SetUp();
71 void TearDown();
72 std::shared_ptr<ApplicationInfo> GetApplicationInfo(const std::string& appName) const;
73 std::shared_ptr<AbilityInfo> GetAbilityInfo(const std::string& abilityIndex, const std::string& name,
74 const std::string& process, const std::string& applicationName) const;
75 void StartAppProcess(const pid_t& pid) const;
76 std::shared_ptr<AppRunningRecord> StartProcessAndLoadAbility(const sptr<MockAppScheduler>& mockAppScheduler,
77 const sptr<IRemoteObject>& token, const std::shared_ptr<AbilityInfo>& abilityInfo,
78 const std::shared_ptr<ApplicationInfo>& appInfo, const TestProcessInfo& testProcessInfo) const;
79 void ChangeAbilityStateAfterAppStart(const sptr<MockAppScheduler>& mockAppScheduler, const pid_t& pid) const;
80 void ChangeAbilityStateToForegroud(const sptr<MockAppScheduler>& mockAppScheduler,
81 const std::shared_ptr<AppRunningRecord>& appRunningRecord, const sptr<IRemoteObject>& token,
82 const bool isChange = false) const;
83 void ChangeAbilityStateToBackGroud(const sptr<MockAppScheduler>& mockAppScheduler,
84 const std::shared_ptr<AppRunningRecord>& appRunningRecord, const sptr<IRemoteObject>& token,
85 const bool isChange = false) const;
86 void ChangeAbilityStateToTerminate(
87 const sptr<MockAppScheduler>& mockAppScheduler, const sptr<IRemoteObject>& token) const;
88 void ChangeAppToTerminate(const sptr<MockAppScheduler>& mockAppScheduler,
89 const std::shared_ptr<AppRunningRecord>& appRunningRecord, const sptr<IRemoteObject>& token,
90 const bool isStop = false) const;
91 void CheckState(const std::shared_ptr<AppRunningRecord>& appRunningRecord, const sptr<IRemoteObject>& token,
92 const AbilityState abilityState, const ApplicationState appState) const;
93 void CheckStateAfterClearAbility(const std::shared_ptr<AppRunningRecord>& appRunningRecord,
94 const std::vector<sptr<IRemoteObject>>& tokens, const int32_t& recordId,
95 const sptr<MockAppScheduler>& mockAppScheduler) const;
96 void CheckStateAfterChangeAbility(const std::shared_ptr<AppRunningRecord>& appRunningRecord,
97 const std::vector<sptr<IRemoteObject>>& tokens, const sptr<MockAppScheduler>& mockAppScheduler);
98 void CreateAppRecentList(const int32_t appNum);
99
100 sptr<MockAbilityToken> GetAbilityToken();
101
102 protected:
103 std::shared_ptr<AppMgrServiceInner> serviceInner_ = nullptr;
104 sptr<MockAbilityToken> mockToken_ = nullptr;
105 sptr<MockAppStateCallback> mockAppStateCallbackStub_ = nullptr;
106 std::shared_ptr<AppMgrServiceInner> inner_ = nullptr;
107 sptr<BundleMgrService> mockBundleMgr;
108 std::shared_ptr<AMSEventHandler> handler_ = nullptr;
109 };
110
SetUpTestCase()111 void AmsAppLifeCycleModuleTest::SetUpTestCase()
112 {
113 MockNativeToken::SetNativeToken();
114 }
115
TearDownTestCase()116 void AmsAppLifeCycleModuleTest::TearDownTestCase()
117 {}
118
SetUp()119 void AmsAppLifeCycleModuleTest::SetUp()
120 {
121 serviceInner_.reset(new (std::nothrow) AppMgrServiceInner());
122 serviceInner_->Init();
123 mockAppStateCallbackStub_ = new (std::nothrow) MockAppStateCallback();
124
125 inner_ = std::make_shared<AppMgrServiceInner>();
126
127 if (serviceInner_ && mockAppStateCallbackStub_) {
128 auto mockAppStateCallbackProxy = iface_cast<IAppStateCallback>(mockAppStateCallbackStub_);
129 if (mockAppStateCallbackProxy) {
130 serviceInner_->RegisterAppStateCallback(mockAppStateCallbackProxy);
131 inner_->RegisterAppStateCallback(mockAppStateCallbackProxy);
132 }
133 }
134
135 mockBundleMgr = new (std::nothrow) BundleMgrService();
136 serviceInner_->SetBundleManager(mockBundleMgr);
137
138 auto taskHandler = AAFwk::TaskHandlerWrap::CreateQueueHandler("AmsAppLifeCycleModuleTest");
139 handler_ = std::make_shared<AMSEventHandler>(taskHandler, serviceInner_);
140 serviceInner_->SetTaskHandler(taskHandler);
141 serviceInner_->SetEventHandler(handler_);
142 }
143
TearDown()144 void AmsAppLifeCycleModuleTest::TearDown()
145 {
146 serviceInner_.reset();
147 mockAppStateCallbackStub_.clear();
148 }
149
GetApplicationInfo(const std::string & appName) const150 std::shared_ptr<ApplicationInfo> AmsAppLifeCycleModuleTest::GetApplicationInfo(const std::string& appName) const
151 {
152 auto appInfo = std::make_shared<ApplicationInfo>();
153 appInfo->name = appName;
154 appInfo->bundleName = appName;
155 return appInfo;
156 }
157
GetAbilityInfo(const std::string & abilityIndex,const std::string & name,const std::string & process,const std::string & applicationName) const158 std::shared_ptr<AbilityInfo> AmsAppLifeCycleModuleTest::GetAbilityInfo(const std::string& abilityIndex,
159 const std::string& name, const std::string& process, const std::string& applicationName) const
160 {
161 auto abilityInfo = std::make_shared<AbilityInfo>();
162 abilityInfo->name = name + abilityIndex;
163 if (!process.empty()) {
164 abilityInfo->process = process;
165 }
166 abilityInfo->applicationName = applicationName;
167 abilityInfo->applicationInfo.bundleName = applicationName;
168 return abilityInfo;
169 }
170
StartProcessAndLoadAbility(const sptr<MockAppScheduler> & mockAppScheduler,const sptr<IRemoteObject> & token,const std::shared_ptr<AbilityInfo> & abilityInfo,const std::shared_ptr<ApplicationInfo> & appInfo,const TestProcessInfo & testProcessInfo) const171 std::shared_ptr<AppRunningRecord> AmsAppLifeCycleModuleTest::StartProcessAndLoadAbility(
172 const sptr<MockAppScheduler>& mockAppScheduler, const sptr<IRemoteObject>& token,
173 const std::shared_ptr<AbilityInfo>& abilityInfo, const std::shared_ptr<ApplicationInfo>& appInfo,
174 const TestProcessInfo& testProcessInfo) const
175 {
176 if (!testProcessInfo.isStart) {
177 StartAppProcess(testProcessInfo.pid);
178 } else {
179 EXPECT_CALL(*mockAppScheduler, ScheduleLaunchAbility(_, _, _, _)).Times(1);
180 }
181 AbilityRuntime::LoadParam loadParam;
182 loadParam.token = token;
183 auto loadParamPtr = std::make_shared<AbilityRuntime::LoadParam>(loadParam);
184 serviceInner_->LoadAbility(abilityInfo, appInfo, nullptr, loadParamPtr);
185 BundleInfo bundleInfo;
186 HapModuleInfo hapModuleInfo;
187 EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
188
189 std::shared_ptr<AppRunningRecord> record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(
190 appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo);
191 if (record == nullptr) {
192 EXPECT_TRUE(false);
193 } else {
194 pid_t newPid = record->GetPriorityObject()->GetPid();
195 EXPECT_EQ(newPid, testProcessInfo.pid);
196 }
197 return record;
198 }
199
StartAppProcess(const pid_t & pid) const200 void AmsAppLifeCycleModuleTest::StartAppProcess(const pid_t& pid) const
201 {
202 MockAppSpawnClient* mockClientPtr = new (std::nothrow) MockAppSpawnClient();
203 EXPECT_TRUE(mockClientPtr);
204
205 EXPECT_CALL(*mockClientPtr, StartProcess(_, _)).WillOnce(DoAll(SetArgReferee<1>(pid), Return(ERR_OK)));
206 EXPECT_CALL(*mockAppStateCallbackStub_, OnAppStateChanged(_));
207
208 serviceInner_->SetAppSpawnClient(std::unique_ptr<MockAppSpawnClient>(mockClientPtr));
209 }
210
ChangeAbilityStateAfterAppStart(const sptr<MockAppScheduler> & mockAppScheduler,const pid_t & pid) const211 void AmsAppLifeCycleModuleTest::ChangeAbilityStateAfterAppStart(
212 const sptr<MockAppScheduler>& mockAppScheduler, const pid_t& pid) const
213 {
214 EXPECT_CALL(*mockAppScheduler, ScheduleLaunchApplication(_, _)).Times(1);
215 EXPECT_CALL(*mockAppScheduler, ScheduleLaunchAbility(_, _, _, _)).Times(1);
216
217 sptr<IAppScheduler> client = iface_cast<IAppScheduler>(mockAppScheduler.GetRefPtr());
218 serviceInner_->AttachApplication(pid, client);
219 }
220
ChangeAbilityStateToForegroud(const sptr<MockAppScheduler> & mockAppScheduler,const std::shared_ptr<AppRunningRecord> & appRunningRecord,const sptr<IRemoteObject> & token,const bool isChange) const221 void AmsAppLifeCycleModuleTest::ChangeAbilityStateToForegroud(const sptr<MockAppScheduler>& mockAppScheduler,
222 const std::shared_ptr<AppRunningRecord>& appRunningRecord, const sptr<IRemoteObject>& token,
223 const bool isChange) const
224 {
225 if (!isChange) {
226 EXPECT_CALL(*mockAppScheduler, ScheduleForegroundApplication()).Times(1);
227 EXPECT_CALL(*mockAppStateCallbackStub_, OnAppStateChanged(_)).Times(testing::AtLeast(1));
228 EXPECT_CALL(*mockAppStateCallbackStub_, OnAbilityRequestDone(_, _)).Times(testing::AtLeast(1));
229 }
230
231 serviceInner_->UpdateAbilityState(token, AbilityState::ABILITY_STATE_FOREGROUND);
232
233 if (!isChange) {
234 EXPECT_NE(appRunningRecord, nullptr);
235 CHECK_POINTER_IS_NULLPTR(appRunningRecord);
236 int32_t recordId = appRunningRecord->GetRecordId();
237 serviceInner_->ApplicationForegrounded(recordId);
238 }
239 }
240
ChangeAbilityStateToBackGroud(const sptr<MockAppScheduler> & mockAppScheduler,const std::shared_ptr<AppRunningRecord> & appRunningRecord,const sptr<IRemoteObject> & token,const bool isChange) const241 void AmsAppLifeCycleModuleTest::ChangeAbilityStateToBackGroud(const sptr<MockAppScheduler>& mockAppScheduler,
242 const std::shared_ptr<AppRunningRecord>& appRunningRecord, const sptr<IRemoteObject>& token,
243 const bool isChange) const
244 {
245 if (!isChange) {
246 EXPECT_CALL(*mockAppScheduler, ScheduleBackgroundApplication()).Times(1);
247 EXPECT_CALL(*mockAppStateCallbackStub_, OnAppStateChanged(_)).Times(testing::AtLeast(1));
248 EXPECT_CALL(*mockAppStateCallbackStub_, OnAbilityRequestDone(_, _)).Times(testing::AtLeast(1));
249 }
250
251 serviceInner_->UpdateAbilityState(token, AbilityState::ABILITY_STATE_BACKGROUND);
252
253 if (!isChange) {
254 EXPECT_NE(appRunningRecord, nullptr);
255 CHECK_POINTER_IS_NULLPTR(appRunningRecord);
256 int32_t recordId = appRunningRecord->GetRecordId();
257 serviceInner_->ApplicationBackgrounded(recordId);
258 }
259 }
260
ChangeAppToTerminate(const sptr<MockAppScheduler> & mockAppScheduler,const std::shared_ptr<AppRunningRecord> & appRunningRecord,const sptr<IRemoteObject> & token,const bool isStop) const261 void AmsAppLifeCycleModuleTest::ChangeAppToTerminate(const sptr<MockAppScheduler>& mockAppScheduler,
262 const std::shared_ptr<AppRunningRecord>& appRunningRecord, const sptr<IRemoteObject>& token,
263 const bool isStop) const
264 {
265 ChangeAbilityStateToTerminate(mockAppScheduler, token);
266
267 if (isStop) {
268 EXPECT_CALL(*mockAppScheduler, ScheduleTerminateApplication(_)).Times(1);
269 EXPECT_CALL(*mockAppStateCallbackStub_, OnAppStateChanged(_)).Times(testing::AtLeast(1));
270 serviceInner_->AbilityTerminated(token);
271 EXPECT_NE(appRunningRecord, nullptr);
272 CHECK_POINTER_IS_NULLPTR(appRunningRecord);
273 int32_t recordId = appRunningRecord->GetRecordId();
274 serviceInner_->ApplicationTerminated(recordId);
275 } else {
276 serviceInner_->AbilityTerminated(token);
277 }
278 }
279
ChangeAbilityStateToTerminate(const sptr<MockAppScheduler> & mockAppScheduler,const sptr<IRemoteObject> & token) const280 void AmsAppLifeCycleModuleTest::ChangeAbilityStateToTerminate(
281 const sptr<MockAppScheduler>& mockAppScheduler, const sptr<IRemoteObject>& token) const
282 {
283 EXPECT_CALL(*mockAppScheduler, ScheduleCleanAbility(_, _)).Times(1);
284 serviceInner_->TerminateAbility(token, false);
285 }
286
CheckState(const std::shared_ptr<AppRunningRecord> & appRunningRecord,const sptr<IRemoteObject> & token,const AbilityState abilityState,const ApplicationState appState) const287 void AmsAppLifeCycleModuleTest::CheckState(const std::shared_ptr<AppRunningRecord>& appRunningRecord,
288 const sptr<IRemoteObject>& token, const AbilityState abilityState, const ApplicationState appState) const
289 {
290 EXPECT_NE(appRunningRecord, nullptr);
291 CHECK_POINTER_IS_NULLPTR(appRunningRecord);
292 auto abilityRunningRecord = appRunningRecord->GetAbilityRunningRecordByToken(token);
293 ApplicationState getAppState = appRunningRecord->GetState();
294 EXPECT_EQ(appState, getAppState);
295 EXPECT_NE(abilityRunningRecord, nullptr);
296 CHECK_POINTER_IS_NULLPTR(abilityRunningRecord);
297 AbilityState getAbilityState = abilityRunningRecord->GetState();
298 EXPECT_EQ(abilityState, getAbilityState);
299 }
300
CheckStateAfterClearAbility(const std::shared_ptr<AppRunningRecord> & appRunningRecord,const std::vector<sptr<IRemoteObject>> & tokens,const int32_t & recordId,const sptr<MockAppScheduler> & mockAppScheduler) const301 void AmsAppLifeCycleModuleTest::CheckStateAfterClearAbility(const std::shared_ptr<AppRunningRecord>& appRunningRecord,
302 const std::vector<sptr<IRemoteObject>>& tokens, const int32_t& recordId,
303 const sptr<MockAppScheduler>& mockAppScheduler) const
304 {
305 unsigned long size = tokens.size();
306 for (unsigned long i = 0; i < size; i++) {
307 if (i != size - 1) {
308 ChangeAppToTerminate(mockAppScheduler, appRunningRecord, tokens[i], false);
309 ApplicationState getAppState = appRunningRecord->GetState();
310 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, getAppState);
311 } else {
312 ChangeAppToTerminate(mockAppScheduler, appRunningRecord, tokens[i], true);
313 auto record = serviceInner_->GetAppRunningRecordByAppRecordId(recordId);
314 EXPECT_EQ(nullptr, record);
315 }
316 }
317 }
318
CheckStateAfterChangeAbility(const std::shared_ptr<AppRunningRecord> & appRunningRecord,const std::vector<sptr<IRemoteObject>> & tokens,const sptr<MockAppScheduler> & mockAppScheduler)319 void AmsAppLifeCycleModuleTest::CheckStateAfterChangeAbility(const std::shared_ptr<AppRunningRecord>& appRunningRecord,
320 const std::vector<sptr<IRemoteObject>>& tokens, const sptr<MockAppScheduler>& mockAppScheduler)
321 {
322 unsigned long size = tokens.size();
323 for (unsigned long i = 0; i < size; i++) {
324 if (i != size - 1) {
325 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, tokens[i], true);
326 CheckState(appRunningRecord,
327 tokens[i],
328 AbilityState::ABILITY_STATE_BACKGROUND,
329 ApplicationState::APP_STATE_FOREGROUND);
330 } else {
331 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, tokens[i], false);
332 CheckState(appRunningRecord,
333 tokens[i],
334 AbilityState::ABILITY_STATE_BACKGROUND,
335 ApplicationState::APP_STATE_BACKGROUND);
336 }
337 }
338 }
339
CreateAppRecentList(const int32_t appNum)340 void AmsAppLifeCycleModuleTest::CreateAppRecentList(const int32_t appNum)
341 {
342 for (int32_t i = INDEX_NUM_MAX - appNum + 1; i <= INDEX_NUM_MAX; i++) {
343 std::shared_ptr<ApplicationInfo> appInfo = std::make_shared<ApplicationInfo>();
344 std::shared_ptr<AbilityInfo> abilityInfo = std::make_shared<AbilityInfo>();
345 appInfo->name = TEST_APP_NAME + std::to_string(i);
346 appInfo->bundleName = appInfo->name;
347 abilityInfo->name = TEST_ABILITY_NAME + std::to_string(i);
348 abilityInfo->applicationName = TEST_APP_NAME + std::to_string(i);
349 abilityInfo->applicationInfo.bundleName = appInfo->name;
350 pid_t pid = i;
351 sptr<IRemoteObject> token = new (std::nothrow) MockAbilityToken();
352 MockAppSpawnClient* mockedSpawnClient = new (std::nothrow) MockAppSpawnClient();
353 EXPECT_TRUE(mockedSpawnClient);
354 EXPECT_CALL(*mockedSpawnClient, StartProcess(_, _))
355 .Times(1)
356 .WillOnce(DoAll(SetArgReferee<1>(pid), Return(ERR_OK)));
357 EXPECT_CALL(*mockAppStateCallbackStub_, OnAppStateChanged(_)).Times(1);
358
359 serviceInner_->SetAppSpawnClient(std::unique_ptr<MockAppSpawnClient>(mockedSpawnClient));
360 AbilityRuntime::LoadParam loadParam;
361 loadParam.token = token;
362 auto loadParamPtr = std::make_shared<AbilityRuntime::LoadParam>(loadParam);
363 serviceInner_->LoadAbility(abilityInfo, appInfo, nullptr, loadParamPtr);
364 }
365 return;
366 }
367
GetAbilityToken()368 sptr<MockAbilityToken> AmsAppLifeCycleModuleTest::GetAbilityToken()
369 {
370 if (mockToken_ != nullptr) {
371 return mockToken_;
372 }
373 mockToken_ = new (std::nothrow) MockAbilityToken();
374 return mockToken_;
375 }
376
377 /*
378 * Feature: Ams
379 * Function: AppLifeCycle
380 * SubFunction: NA
381 * FunctionPoints: test app life cycle change with the start of ability
382 * EnvConditions: system running normally
383 * CaseDescription: 1.call loadAbility API to start app
384 * 2.switch ability to foreground and call ScheduleForegroundApplication API to enable Application
385 * foreground
386 * 3.switch ability to background and call ScheduleBackgroundApplication API to enable Application
387 * background
388 * 4.terminate ability
389 * 5.call ScheduleTerminateApplication API to make app terminated
390 */
391 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_001, TestSize.Level2)
392 {
393 EXPECT_NE(serviceInner_, nullptr);
394 CHECK_POINTER_IS_NULLPTR(serviceInner_);
395 pid_t pid = 1024;
396 sptr<IRemoteObject> token = GetAbilityToken();
397 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld");
398 auto appInfo = GetApplicationInfo("com.ohos.test.helloworld");
399 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
400 EXPECT_TRUE(mockAppScheduler);
401
402 TestProcessInfo testProcessInfo;
403 testProcessInfo.pid = pid;
404 testProcessInfo.isStart = false;
405 auto appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token, abilityInfo, appInfo, testProcessInfo);
406 int32_t recordId = appRunningRecord->GetRecordId();
407
408 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid);
409 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
410
411 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token);
412 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
413
414 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, token);
415 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
416
417 ChangeAppToTerminate(mockAppScheduler, appRunningRecord, token, true);
418 auto record = serviceInner_->GetAppRunningRecordByAppRecordId(recordId);
419 EXPECT_EQ(nullptr, record);
420 }
421
422 /*
423 * Feature: Ams
424 * Function: AppLifeCycle
425 * SubFunction: NA
426 * FunctionPoints: test app life cycle change with the start of abilities
427 * EnvConditions: system running normally
428 * CaseDescription: 1.call loadAbility API to start app
429 * 2.switch ability to foreground and call ScheduleForegroundApplication API to enable Application
430 * foreground
431 * 3.load other ability, and switch last ability to background and call ScheduleBackgroundApplication
432 * API to enable Application background
433 * 4.terminate every ability
434 * 5.call ScheduleTerminateApplication API to make app terminated
435 */
436 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_002, TestSize.Level3)
437 {
438 pid_t pid = 1023;
439 EXPECT_NE(serviceInner_, nullptr);
440 CHECK_POINTER_IS_NULLPTR(serviceInner_);
441 std::shared_ptr<AppRunningRecord> appRunningRecord = nullptr;
442 std::vector<sptr<IRemoteObject>> tokens;
443 auto abilityInfo = std::make_shared<AbilityInfo>();
444 auto appInfo = std::make_shared<ApplicationInfo>();
445 sptr<IRemoteObject> token;
446 int32_t recordId;
447 bool flag = false;
448 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
449
450 TestProcessInfo testProcessInfo;
451 testProcessInfo.pid = pid;
452
453 for (int i = 0; i < ABILITY_NUM; i++) {
454 abilityInfo = GetAbilityInfo(std::to_string(i), "MainAbility", "p1", "com.ohos.test.helloworld");
455 appInfo = GetApplicationInfo("com.ohos.test.helloworld");
456 token = new (std::nothrow) MockAbilityToken();
457 tokens.push_back(token);
458 testProcessInfo.isStart = flag;
459 appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token, abilityInfo, appInfo, testProcessInfo);
460 if (!flag) {
461 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid);
462 recordId = appRunningRecord->GetRecordId();
463 flag = true;
464 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
465 } else {
466 CheckState(
467 appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_BACKGROUND);
468 }
469 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token);
470 CheckState(
471 appRunningRecord, token, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
472 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, token);
473 CheckState(
474 appRunningRecord, token, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
475 }
476 auto abilities = appRunningRecord->GetAbilities();
477 int size = abilities.size();
478 EXPECT_EQ(size, ABILITY_NUM);
479 CheckStateAfterClearAbility(appRunningRecord, tokens, recordId, mockAppScheduler);
480 }
481
482 /*
483 * Feature: Ams
484 * Function: AppLifeCycle
485 * SubFunction: NA
486 * FunctionPoints: test app life cycle change with the start of abilities at the same time
487 * EnvConditions: system running normally
488 * CaseDescription: 1.call loadAbility API to start 1000 abilities
489 * 2.switch every ability to foreground
490 * 3.switch every ability to background
491 * 4.terminate every ability
492 * 5.call ScheduleTerminateApplication API to make app terminated
493 */
494 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_003, TestSize.Level3)
495 {
496 pid_t pid = 1025;
497 EXPECT_TRUE(serviceInner_);
498 std::shared_ptr<AppRunningRecord> appRunningRecord = nullptr;
499 std::vector<sptr<IRemoteObject>> tokens;
500 auto abilityInfo = std::make_shared<AbilityInfo>();
501 auto appInfo = std::make_shared<ApplicationInfo>();
502 sptr<IRemoteObject> token;
503 int32_t recordId;
504 bool flag = false;
505 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
506
507 TestProcessInfo testProcessInfo;
508 testProcessInfo.pid = pid;
509
510 for (int i = 0; i < ABILITY_NUM; i++) {
511 abilityInfo = GetAbilityInfo(std::to_string(i), "MainAbility", "p1", "com.ohos.test.helloworld1");
512 appInfo = GetApplicationInfo("com.ohos.test.helloworld1");
513 token = new (std::nothrow) MockAbilityToken();
514 tokens.push_back(token);
515
516 testProcessInfo.isStart = flag;
517 appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token, abilityInfo, appInfo, testProcessInfo);
518 if (!flag) {
519 ChangeAbilityStateAfterAppStart(mockAppScheduler, testProcessInfo.pid);
520 recordId = appRunningRecord->GetRecordId();
521 flag = true;
522 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
523 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token);
524 } else {
525 CheckState(
526 appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_FOREGROUND);
527 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token, true);
528 }
529 }
530 CheckStateAfterChangeAbility(appRunningRecord, tokens, mockAppScheduler);
531 CheckStateAfterClearAbility(appRunningRecord, tokens, recordId, mockAppScheduler);
532 }
533
534 /*
535 * Feature: Ams
536 * Function: AppLifeCycle
537 * SubFunction: NA
538 * FunctionPoints: test app life cycle change with the start of abilities
539 * EnvConditions: system running normally
540 * CaseDescription: 1.call loadAbility API to start app
541 * 2.switch ability to foreground and call ScheduleForegroundApplication API to enable Application
542 * foreground
543 * 3.switch ability to background and call ScheduleBackgroundApplication API to enable Application
544 * background
545 * 4.repeat step 2~3 1000 times
546 */
547 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_004, TestSize.Level3)
548 {
549 EXPECT_NE(serviceInner_, nullptr);
550 CHECK_POINTER_IS_NULLPTR(serviceInner_);
551 pid_t pid = 1024;
552 sptr<IRemoteObject> token = GetAbilityToken();
553 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "p3", "com.ohos.test.helloworld");
554 auto appInfo = GetApplicationInfo("com.ohos.test.helloworld");
555
556 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
557
558 TestProcessInfo testProcessInfo;
559 testProcessInfo.pid = pid;
560 testProcessInfo.isStart = false;
561
562 auto appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token, abilityInfo, appInfo, testProcessInfo);
563
564 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid);
565 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
566
567 int count = 1000;
568 while (count > 0) {
569 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token);
570 CheckState(
571 appRunningRecord, token, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
572
573 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, token);
574 CheckState(
575 appRunningRecord, token, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
576 count--;
577 }
578 }
579
580 /*
581 * Feature: Ams
582 * Function: AppLifeCycle
583 * SubFunction: NA
584 * FunctionPoints: test app life cycle change with the start of ability
585 * EnvConditions: system running normally
586 * CaseDescription: 1.call loadAbility API to start app
587 * 2.switch ability to foreground and call ScheduleForegroundApplication API to enable Application
588 * foreground
589 * 3.switch ability to background
590 * 4.start new ability to foreground
591 * 5.switch ability to background and call ScheduleBackgroundApplication API to enable Application
592 * background
593 * 6.call ScheduleTerminateApplication API to make app terminated
594 */
595 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_005, TestSize.Level2)
596 {
597 EXPECT_NE(serviceInner_, nullptr);
598 CHECK_POINTER_IS_NULLPTR(serviceInner_);
599 pid_t pid = 1024;
600
601 sptr<IRemoteObject> token0 = new (std::nothrow) MockAbilityToken();
602 auto abilityInfo0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld");
603 auto appInfo = GetApplicationInfo("com.ohos.test.helloworld");
604
605 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
606
607 TestProcessInfo testProcessInfo;
608 testProcessInfo.pid = pid;
609 testProcessInfo.isStart = false;
610
611 auto appRunningRecord =
612 StartProcessAndLoadAbility(mockAppScheduler, token0, abilityInfo0, appInfo, testProcessInfo);
613
614 int32_t recordId = appRunningRecord->GetRecordId();
615
616 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid);
617 CheckState(appRunningRecord, token0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
618
619 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token0);
620 CheckState(
621 appRunningRecord, token0, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
622
623 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, token0);
624 CheckState(
625 appRunningRecord, token0, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
626
627 sptr<IRemoteObject> token1 = new (std::nothrow) MockAbilityToken();
628 auto abilityInfo1 = GetAbilityInfo("1", "SubAbility", "p1", "com.ohos.test.helloworld");
629 testProcessInfo.isStart = true;
630 appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token1, abilityInfo1, appInfo, testProcessInfo);
631
632 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token1);
633 CheckState(
634 appRunningRecord, token1, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
635
636 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, token1);
637 CheckState(
638 appRunningRecord, token1, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
639
640 ChangeAppToTerminate(mockAppScheduler, appRunningRecord, token0);
641 ChangeAppToTerminate(mockAppScheduler, appRunningRecord, token1, true);
642 auto record = serviceInner_->GetAppRunningRecordByAppRecordId(recordId);
643 EXPECT_EQ(nullptr, record);
644 }
645
646 /*
647 * Feature: Ams
648 * Function: AppLifeCycle
649 * SubFunction: NA
650 * FunctionPoints: test app life cycle change with the start of ability
651 * EnvConditions: system running normally
652 * CaseDescription: 1.call loadAbility API to start app
653 * 2.switch ability to foreground and call ScheduleForegroundApplication API to enable Application
654 * foreground
655 * 3.switch ability to background and call ScheduleBackgroundApplication API to enable Application
656 * background
657 * 4.through appName kill application
658 */
659 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_006, TestSize.Level2)
660 {
661 EXPECT_NE(serviceInner_, nullptr);
662 CHECK_POINTER_IS_NULLPTR(serviceInner_);
663
664 pid_t pid = fork();
665 if (pid == 0) {
666 pause();
667 exit(0);
668 }
669
670 EXPECT_TRUE(pid > 0);
671 usleep(50000);
672
673 sptr<IRemoteObject> token = GetAbilityToken();
674 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld");
675 auto appInfo = GetApplicationInfo("com.ohos.test.helloworld");
676 appInfo->bundleName = "com.ohos.test.helloworld";
677 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
678
679 TestProcessInfo testProcessInfo;
680 testProcessInfo.pid = pid;
681 testProcessInfo.isStart = false;
682
683 auto appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token, abilityInfo, appInfo, testProcessInfo);
684 int32_t recordId = appRunningRecord->GetRecordId();
685
686 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid);
687 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
688
689 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token);
690 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
691
692 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, token);
693 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
694
695 EXPECT_CALL(*mockAppScheduler, ScheduleProcessSecurityExit()).Times(1);
696
697 int32_t ret = serviceInner_->KillApplication(appInfo->bundleName);
698 EXPECT_EQ(ret, 0);
699 serviceInner_->OnRemoteDied(mockAppScheduler); // A faked death recipient.
700 auto record = serviceInner_->GetAppRunningRecordByAppRecordId(recordId);
701 EXPECT_EQ(nullptr, record);
702 }
703
704 /*
705 * Feature: Ams
706 * Function: AppLifeCycle
707 * SubFunction: NA
708 * FunctionPoints: test app life cycle change with the start of ability
709 * EnvConditions: system running normally
710 * CaseDescription: 1.call loadAbility API to start app
711 * 2.switch ability to foreground and call ScheduleForegroundApplication API to enable Application
712 * foreground
713 * 3.switch ability to background and call ScheduleBackgroundApplication API to enable Application
714 * background
715 * 4.terminate ability
716 * 5.call ScheduleTerminateApplication API to make app terminated
717 */
718 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_007, TestSize.Level2)
719 {
720 EXPECT_NE(serviceInner_, nullptr);
721 CHECK_POINTER_IS_NULLPTR(serviceInner_);
722 pid_t pid = 1024;
723 sptr<IRemoteObject> token = GetAbilityToken();
724 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld");
725 auto appInfo = GetApplicationInfo("com.ohos.test.helloworld");
726 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
727
728 TestProcessInfo testProcessInfo;
729 testProcessInfo.pid = pid;
730 testProcessInfo.isStart = false;
731
732 auto appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token, abilityInfo, appInfo, testProcessInfo);
733 int32_t recordId = appRunningRecord->GetRecordId();
734
735 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid);
736 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
737
738 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token);
739 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
740
741 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, token);
742 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
743
744 ChangeAppToTerminate(mockAppScheduler, appRunningRecord, token, true);
745 auto record = serviceInner_->GetAppRunningRecordByAppRecordId(recordId);
746 EXPECT_EQ(nullptr, record);
747 }
748
749 /*
750 * Feature: Ams
751 * Function: AppLifeCycle
752 * SubFunction: NA
753 * FunctionPoints: test app life cycle change with the start of ability
754 * EnvConditions: system running normally
755 * CaseDescription: 1.call loadAbility API to start app
756 * 2.switch ability to foreground and call ScheduleForegroundApplication API to enable Application
757 * foreground
758 * 3.switch ability to background and call ScheduleBackgroundApplication API to enable Application
759 * background
760 * 4.call loadAbility API to start new app
761 * 5.switch ability to foreground and call ScheduleForegroundApplication API to enable new Application
762 * foreground
763 * 6.switch ability to background and call ScheduleBackgroundApplication API to enable new Application
764 * background
765 * 7.terminate ability
766 * 8.call ScheduleTerminateApplication API to make app terminated
767 */
768 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_008, TestSize.Level2)
769 {
770 EXPECT_NE(serviceInner_, nullptr);
771 CHECK_POINTER_IS_NULLPTR(serviceInner_);
772 pid_t pid_0 = 1024;
773 pid_t pid_1 = 2048;
774 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
775 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
776 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0");
777 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0");
778 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld1");
779 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld1");
780 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
781 TestProcessInfo testProcessInfo;
782
783 testProcessInfo.pid = pid_0;
784 testProcessInfo.isStart = false;
785 auto appRunningRecord_0 =
786 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
787
788 testProcessInfo.pid = pid_1;
789 testProcessInfo.isStart = false;
790 auto appRunningRecord_1 =
791 StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
792 int32_t recordId_0 = appRunningRecord_0->GetRecordId();
793 int32_t recordId_1 = appRunningRecord_1->GetRecordId();
794
795 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0);
796 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
797
798 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord_0, token_0);
799 CheckState(
800 appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
801
802 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord_0, token_0);
803 CheckState(
804 appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
805
806 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_1);
807 CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
808
809 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord_1, token_1);
810 CheckState(
811 appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
812
813 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord_1, token_1);
814 CheckState(
815 appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
816
817 ChangeAppToTerminate(mockAppScheduler, appRunningRecord_0, token_0, true);
818 auto record = serviceInner_->GetAppRunningRecordByAppRecordId(recordId_0);
819 EXPECT_EQ(nullptr, record);
820
821 ChangeAppToTerminate(mockAppScheduler, appRunningRecord_1, token_1, true);
822 record = serviceInner_->GetAppRunningRecordByAppRecordId(recordId_1);
823 EXPECT_EQ(nullptr, record);
824 }
825
826 /*
827 * Feature: Ams
828 * Function: AppLifeCycle
829 * SubFunction: NA
830 * FunctionPoints: test app life cycle change with the start of abilities at the same time
831 * EnvConditions: system running normally
832 * CaseDescription: 1.call loadAbility API to start 100 app
833 * 2.switch every ability to foreground
834 * 3.switch every ability to background
835 * 4.terminate every ability
836 * 5.call ScheduleTerminateApplication API to make app terminated
837 */
838 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_009, TestSize.Level3)
839 {
840 pid_t pid = 1025;
841 EXPECT_NE(serviceInner_, nullptr);
842 CHECK_POINTER_IS_NULLPTR(serviceInner_);
843 std::shared_ptr<AppRunningRecord> appRunningRecord = nullptr;
844 auto abilityInfo = std::make_shared<AbilityInfo>();
845 auto appInfo = std::make_shared<ApplicationInfo>();
846 sptr<IRemoteObject> token;
847 int32_t recordId;
848 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
849
850 TestProcessInfo testProcessInfo;
851
852 for (int i = 0; i < APPLICATION_NUM; i++) {
853 abilityInfo = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld1");
854 appInfo = GetApplicationInfo("com.ohos.test.helloworld1");
855 token = new (std::nothrow) MockAbilityToken();
856 pid += i;
857
858 testProcessInfo.pid = pid;
859 testProcessInfo.isStart = false;
860 appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token, abilityInfo, appInfo, testProcessInfo);
861 ChangeAbilityStateAfterAppStart(mockAppScheduler, testProcessInfo.pid);
862 recordId = appRunningRecord->GetRecordId();
863 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
864 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token);
865
866 ChangeAbilityStateToBackGroud(mockAppScheduler, appRunningRecord, token);
867 CheckState(
868 appRunningRecord, token, AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
869
870 ChangeAppToTerminate(mockAppScheduler, appRunningRecord, token, true);
871 auto record = serviceInner_->GetAppRunningRecordByAppRecordId(recordId);
872 EXPECT_EQ(nullptr, record);
873 }
874 }
875
876 /*
877 * Feature: Ams
878 * Function: AppLifeCycle
879 * SubFunction: NA
880 * FunctionPoints: test get and stop all process.
881 * EnvConditions: system running normally
882 * CaseDescription: OnStop
883 */
884 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_013, TestSize.Level3)
885 {
886 EXPECT_TRUE(serviceInner_);
887 EXPECT_TRUE(serviceInner_->remoteClientManager_);
888 EXPECT_TRUE(serviceInner_->remoteClientManager_->GetSpawnClient());
889
890 EXPECT_EQ(serviceInner_->QueryAppSpawnConnectionState(), SpawnConnectionState::STATE_NOT_CONNECT);
891
892 int ret = serviceInner_->OpenAppSpawnConnection();
893 EXPECT_EQ(ret, 0);
894 EXPECT_EQ(serviceInner_->QueryAppSpawnConnectionState(), SpawnConnectionState::STATE_CONNECTED);
895
896 serviceInner_->OnStop();
897 usleep(50000);
898 EXPECT_EQ(serviceInner_->QueryAppSpawnConnectionState(), SpawnConnectionState::STATE_NOT_CONNECT);
899 }
900
901 /*
902 * Feature: Ams
903 * Function: AppLifeCycle
904 * SubFunction: NA
905 * FunctionPoints: test get app Running Record,When the app is added for the first time
906 * EnvConditions: system running normally
907 * CaseDescription: GetOrCreateAppRunningRecord
908 */
909 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_014, TestSize.Level1)
910 {
911 pid_t pid = 1000;
912 sptr<IRemoteObject> token = GetAbilityToken();
913 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.special");
914 auto appInfo = GetApplicationInfo("com.ohos.test.special");
915 sptr<MockAppScheduler> mockAppScheduler = new MockAppScheduler();
916 TestProcessInfo testProcessInfo;
917 testProcessInfo.pid = pid;
918 testProcessInfo.isStart = false;
919 auto appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token, abilityInfo, appInfo, testProcessInfo);
920
921 // Because GetOrCreateAppRunningRecord was called in LoadAbility.
922 // When the app is added for the first time
923 EXPECT_EQ(appRunningRecord->GetName(), "com.ohos.test.special");
924 EXPECT_EQ(appRunningRecord->GetProcessName(), "p1");
925 }
926
927 /*
928 * Feature: Ams
929 * Function: AppLifeCycle
930 * SubFunction: NA
931 * FunctionPoints: Ability Status change received
932 * EnvConditions: system running normally
933 * CaseDescription: OnAbilityRequestDone
934 */
935 HWTEST_F(AmsAppLifeCycleModuleTest, StateChange_015, TestSize.Level1)
936 {
937 pid_t pid = 1000;
938 sptr<IRemoteObject> token = GetAbilityToken();
939 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.special");
940 auto appInfo = GetApplicationInfo("com.ohos.test.special");
941 sptr<MockAppScheduler> mockAppScheduler = new MockAppScheduler();
942 TestProcessInfo testProcessInfo;
943 testProcessInfo.pid = pid;
944 testProcessInfo.isStart = false;
945
946 auto appRunningRecord = StartProcessAndLoadAbility(mockAppScheduler, token, abilityInfo, appInfo, testProcessInfo);
947
948 EXPECT_CALL(*mockAppScheduler, ScheduleBackgroundApplication()).Times(1);
949 ChangeAbilityStateAfterAppStart(mockAppScheduler, testProcessInfo.pid);
950 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
951
952 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord, token);
953 CheckState(appRunningRecord, token, AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
954
955 std::weak_ptr<AppMgrServiceInner> inner = inner_;
956 appRunningRecord->SetAppMgrServiceInner(inner);
957
958 appRunningRecord->UpdateAbilityState(token, AbilityState::ABILITY_STATE_BACKGROUND);
959 }
960
961 /*
962 * Feature: Ams
963 * Function: AbilityBehaviorAnalysis
964 * SubFunction: NA
965 * FunctionPoints: Ability Status change received
966 * EnvConditions: system running normally
967 * CaseDescription: Ability record update(specify process mode)
968 */
969 HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_01, TestSize.Level1)
970 {
971 const int32_t formateVaule = 0;
972 const int32_t visibility = 1;
973 const int32_t perceptibility = 1;
974 const int32_t connectionState = 1;
975
976 pid_t pid = 123;
977 sptr<IRemoteObject> token = GetAbilityToken();
978 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "pNew", "com.ohos.test.special");
979 auto appInfo = GetApplicationInfo("com.ohos.test.special");
980 sptr<MockAppScheduler> mockAppScheduler = new MockAppScheduler();
981
982 sptr<BundleMgrService> bundleMgr = new BundleMgrService();
983 serviceInner_->SetBundleManager(bundleMgr.GetRefPtr());
984
985 StartAppProcess(pid);
986 AbilityRuntime::LoadParam loadParam;
987 loadParam.token = token;
988 auto loadParamPtr = std::make_shared<AbilityRuntime::LoadParam>(loadParam);
989 serviceInner_->LoadAbility(abilityInfo, appInfo, nullptr, loadParamPtr);
990 BundleInfo bundleInfo;
991 HapModuleInfo hapModuleInfo;
992 EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
993 std::shared_ptr<AppRunningRecord> record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(
994 appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo);
995 if (record == nullptr) {
996 EXPECT_TRUE(false);
997 } else {
998 pid_t newPid = record->GetPriorityObject()->GetPid();
999 EXPECT_EQ(newPid, pid);
1000 }
1001
1002 auto abilityRecord = record->GetAbilityRunningRecordByToken(token);
1003
1004 EXPECT_EQ(abilityRecord->GetVisibility(), formateVaule);
1005 EXPECT_EQ(abilityRecord->GetPerceptibility(), formateVaule);
1006 EXPECT_EQ(abilityRecord->GetConnectionState(), formateVaule);
1007
1008 serviceInner_->AbilityBehaviorAnalysis(token, nullptr, visibility, perceptibility, connectionState);
1009
1010 auto appRecord = serviceInner_->GetAppRunningRecordByAbilityToken(token);
1011 auto abilityRecord_1 = appRecord->GetAbilityRunningRecordByToken(token);
1012
1013 EXPECT_EQ(abilityRecord_1->GetToken(), token);
1014 EXPECT_EQ(abilityRecord_1->GetPreToken(), nullptr);
1015 EXPECT_EQ(abilityRecord_1->GetVisibility(), visibility);
1016 EXPECT_EQ(abilityRecord_1->GetPerceptibility(), perceptibility);
1017 EXPECT_EQ(abilityRecord_1->GetConnectionState(), connectionState);
1018 }
1019
1020 /*
1021 * Feature: Ams
1022 * Function: AbilityBehaviorAnalysis
1023 * SubFunction: NA
1024 * FunctionPoints: Ability Status change received
1025 * EnvConditions: system running normally
1026 * CaseDescription: Ability record update(specify process mode and assign visibility)
1027 */
1028 HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_02, TestSize.Level1)
1029 {
1030 const int32_t formateVaule = 0;
1031 const int32_t visibility = 1;
1032 const int32_t perceptibility = 0;
1033 const int32_t connectionState = 0;
1034
1035 pid_t pid = 123;
1036 sptr<IRemoteObject> token = GetAbilityToken();
1037 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "pNew", "com.ohos.test.special");
1038 auto appInfo = GetApplicationInfo("com.ohos.test.special");
1039 sptr<MockAppScheduler> mockAppScheduler = new MockAppScheduler();
1040
1041 sptr<BundleMgrService> bundleMgr = new BundleMgrService();
1042 serviceInner_->SetBundleManager(bundleMgr.GetRefPtr());
1043
1044 StartAppProcess(pid);
1045 AbilityRuntime::LoadParam loadParam;
1046 loadParam.token = token;
1047 auto loadParamPtr = std::make_shared<AbilityRuntime::LoadParam>(loadParam);
1048 serviceInner_->LoadAbility(abilityInfo, appInfo, nullptr, loadParamPtr);
1049 BundleInfo bundleInfo;
1050 HapModuleInfo hapModuleInfo;
1051 EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
1052 std::shared_ptr<AppRunningRecord> record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(
1053 appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo);
1054 if (record == nullptr) {
1055 EXPECT_TRUE(false);
1056 } else {
1057 pid_t newPid = record->GetPriorityObject()->GetPid();
1058 EXPECT_EQ(newPid, pid);
1059 }
1060
1061 auto abilityRecord = record->GetAbilityRunningRecordByToken(token);
1062
1063 EXPECT_EQ(abilityRecord->GetVisibility(), formateVaule);
1064 EXPECT_EQ(abilityRecord->GetPerceptibility(), formateVaule);
1065 EXPECT_EQ(abilityRecord->GetConnectionState(), formateVaule);
1066
1067 serviceInner_->AbilityBehaviorAnalysis(token, nullptr, visibility, perceptibility, connectionState);
1068
1069 auto appRecord = serviceInner_->GetAppRunningRecordByAbilityToken(token);
1070 auto abilityRecord_1 = appRecord->GetAbilityRunningRecordByToken(token);
1071
1072 EXPECT_EQ(abilityRecord_1->GetToken(), token);
1073 EXPECT_EQ(abilityRecord_1->GetPreToken(), nullptr);
1074 EXPECT_EQ(abilityRecord_1->GetVisibility(), visibility);
1075 EXPECT_EQ(abilityRecord_1->GetPerceptibility(), perceptibility);
1076 EXPECT_EQ(abilityRecord_1->GetConnectionState(), connectionState);
1077 }
1078
1079 /*
1080 * Feature: Ams
1081 * Function: AbilityBehaviorAnalysis
1082 * SubFunction: NA
1083 * FunctionPoints: Ability Status change received
1084 * EnvConditions: system running normally
1085 * CaseDescription: Ability record update(specify process mode and assign perceptibility)
1086 */
1087 HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_03, TestSize.Level1)
1088 {
1089 const int32_t formateVaule = 0;
1090 const int32_t visibility = 0;
1091 const int32_t perceptibility = 1;
1092 const int32_t connectionState = 0;
1093
1094 pid_t pid = 123;
1095 sptr<IRemoteObject> token = GetAbilityToken();
1096 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "pNew", "com.ohos.test.special");
1097 auto appInfo = GetApplicationInfo("com.ohos.test.special");
1098 sptr<MockAppScheduler> mockAppScheduler = new MockAppScheduler();
1099
1100 sptr<BundleMgrService> bundleMgr = new BundleMgrService();
1101 serviceInner_->SetBundleManager(bundleMgr.GetRefPtr());
1102
1103 StartAppProcess(pid);
1104 AbilityRuntime::LoadParam loadParam;
1105 loadParam.token = token;
1106 auto loadParamPtr = std::make_shared<AbilityRuntime::LoadParam>(loadParam);
1107 serviceInner_->LoadAbility(abilityInfo, appInfo, nullptr, loadParamPtr);
1108 BundleInfo bundleInfo;
1109 HapModuleInfo hapModuleInfo;
1110 EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
1111 std::shared_ptr<AppRunningRecord> record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(
1112 appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo);
1113 if (record == nullptr) {
1114 EXPECT_TRUE(false);
1115 } else {
1116 pid_t newPid = record->GetPriorityObject()->GetPid();
1117 EXPECT_EQ(newPid, pid);
1118 }
1119
1120 auto abilityRecord = record->GetAbilityRunningRecordByToken(token);
1121
1122 EXPECT_EQ(abilityRecord->GetVisibility(), formateVaule);
1123 EXPECT_EQ(abilityRecord->GetPerceptibility(), formateVaule);
1124 EXPECT_EQ(abilityRecord->GetConnectionState(), formateVaule);
1125
1126 serviceInner_->AbilityBehaviorAnalysis(token, nullptr, visibility, perceptibility, connectionState);
1127
1128 auto appRecord = serviceInner_->GetAppRunningRecordByAbilityToken(token);
1129 auto abilityRecord_1 = appRecord->GetAbilityRunningRecordByToken(token);
1130
1131 EXPECT_EQ(abilityRecord_1->GetToken(), token);
1132 EXPECT_EQ(abilityRecord_1->GetPreToken(), nullptr);
1133 EXPECT_EQ(abilityRecord_1->GetVisibility(), visibility);
1134 EXPECT_EQ(abilityRecord_1->GetPerceptibility(), perceptibility);
1135 EXPECT_EQ(abilityRecord_1->GetConnectionState(), connectionState);
1136 }
1137
1138 /*
1139 * Feature: Ams
1140 * Function: AbilityBehaviorAnalysis
1141 * SubFunction: NA
1142 * FunctionPoints: Ability Status change received
1143 * EnvConditions: system running normally
1144 * CaseDescription: Ability record update(specify process mode and assign connectionState)
1145 */
1146 HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_04, TestSize.Level1)
1147 {
1148 const int32_t formateVaule = 0;
1149 const int32_t visibility = 0;
1150 const int32_t perceptibility = 0;
1151 const int32_t connectionState = 1;
1152
1153 pid_t pid = 123;
1154 sptr<IRemoteObject> token = GetAbilityToken();
1155 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "pNew", "com.ohos.test.special");
1156 auto appInfo = GetApplicationInfo("com.ohos.test.special");
1157 sptr<MockAppScheduler> mockAppScheduler = new MockAppScheduler();
1158
1159 sptr<BundleMgrService> bundleMgr = new BundleMgrService();
1160 serviceInner_->SetBundleManager(bundleMgr.GetRefPtr());
1161
1162 StartAppProcess(pid);
1163 AbilityRuntime::LoadParam loadParam;
1164 loadParam.token = token;
1165 auto loadParamPtr = std::make_shared<AbilityRuntime::LoadParam>(loadParam);
1166 serviceInner_->LoadAbility(abilityInfo, appInfo, nullptr, loadParamPtr);
1167 BundleInfo bundleInfo;
1168 HapModuleInfo hapModuleInfo;
1169 EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
1170 std::shared_ptr<AppRunningRecord> record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(
1171 appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo);
1172 if (record == nullptr) {
1173 EXPECT_TRUE(false);
1174 } else {
1175 pid_t newPid = record->GetPriorityObject()->GetPid();
1176 EXPECT_EQ(newPid, pid);
1177 }
1178
1179 auto abilityRecord = record->GetAbilityRunningRecordByToken(token);
1180
1181 EXPECT_EQ(abilityRecord->GetVisibility(), formateVaule);
1182 EXPECT_EQ(abilityRecord->GetPerceptibility(), formateVaule);
1183 EXPECT_EQ(abilityRecord->GetConnectionState(), formateVaule);
1184
1185 serviceInner_->AbilityBehaviorAnalysis(token, nullptr, visibility, perceptibility, connectionState);
1186
1187 auto appRecord = serviceInner_->GetAppRunningRecordByAbilityToken(token);
1188 auto abilityRecord_1 = appRecord->GetAbilityRunningRecordByToken(token);
1189
1190 EXPECT_EQ(abilityRecord_1->GetToken(), token);
1191 EXPECT_EQ(abilityRecord_1->GetPreToken(), nullptr);
1192 EXPECT_EQ(abilityRecord_1->GetVisibility(), visibility);
1193 EXPECT_EQ(abilityRecord_1->GetPerceptibility(), perceptibility);
1194 EXPECT_EQ(abilityRecord_1->GetConnectionState(), connectionState);
1195 }
1196
1197 /*
1198 * Feature: Ams
1199 * Function: AbilityBehaviorAnalysis
1200 * SubFunction: NA
1201 * FunctionPoints: Ability Status change received
1202 * EnvConditions: system running normally
1203 * CaseDescription: Ability record update(specify process mode and assign proken)
1204 */
1205 HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_05, TestSize.Level1)
1206 {
1207 const int32_t formateVaule = 0;
1208 const int32_t visibility = 0;
1209 const int32_t perceptibility = 0;
1210 const int32_t connectionState = 0;
1211
1212 pid_t pid = 123;
1213 sptr<IRemoteObject> token = new (std::nothrow) MockAbilityToken();
1214 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "pNew", "com.ohos.test.special");
1215 auto appInfo = GetApplicationInfo("com.ohos.test.special");
1216 sptr<MockAppScheduler> mockAppScheduler = new MockAppScheduler();
1217
1218 sptr<BundleMgrService> bundleMgr = new BundleMgrService();
1219 serviceInner_->SetBundleManager(bundleMgr.GetRefPtr());
1220
1221 StartAppProcess(pid);
1222 AbilityRuntime::LoadParam loadParam;
1223 loadParam.token = token;
1224 auto loadParamPtr = std::make_shared<AbilityRuntime::LoadParam>(loadParam);
1225 serviceInner_->LoadAbility(abilityInfo, appInfo, nullptr, loadParamPtr);
1226 BundleInfo bundleInfo;
1227 HapModuleInfo hapModuleInfo;
1228 EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
1229 std::shared_ptr<AppRunningRecord> record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(
1230 appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo);
1231 if (record == nullptr) {
1232 EXPECT_TRUE(false);
1233 } else {
1234 pid_t newPid = record->GetPriorityObject()->GetPid();
1235 EXPECT_EQ(newPid, pid);
1236 }
1237
1238 auto abilityRecord = record->GetAbilityRunningRecordByToken(token);
1239
1240 EXPECT_EQ(abilityRecord->GetVisibility(), formateVaule);
1241 EXPECT_EQ(abilityRecord->GetPerceptibility(), formateVaule);
1242 EXPECT_EQ(abilityRecord->GetConnectionState(), formateVaule);
1243
1244 sptr<IRemoteObject> preToken = new (std::nothrow) MockAbilityToken();
1245 serviceInner_->AbilityBehaviorAnalysis(token, preToken, visibility, perceptibility, connectionState);
1246
1247 auto appRecord = serviceInner_->GetAppRunningRecordByAbilityToken(token);
1248 auto abilityRecord_1 = appRecord->GetAbilityRunningRecordByToken(token);
1249
1250 EXPECT_EQ(abilityRecord_1->GetToken(), token);
1251 EXPECT_EQ(abilityRecord_1->GetPreToken(), preToken);
1252 EXPECT_EQ(abilityRecord_1->GetVisibility(), visibility);
1253 EXPECT_EQ(abilityRecord_1->GetPerceptibility(), perceptibility);
1254 EXPECT_EQ(abilityRecord_1->GetConnectionState(), connectionState);
1255 }
1256
1257 /*
1258 * Feature: Ams
1259 * Function: AbilityBehaviorAnalysis
1260 * SubFunction: NA
1261 * FunctionPoints: Ability Status change received
1262 * EnvConditions: system running normally
1263 * CaseDescription: Ability record update(specify process mode and assign bundleName)
1264 */
1265 HWTEST_F(AmsAppLifeCycleModuleTest, AbilityBehaviorAnalysis_06, TestSize.Level1)
1266 {
1267 const int32_t formateVaule = 0;
1268 const int32_t visibility = 0;
1269 const int32_t perceptibility = 0;
1270 const int32_t connectionState = 0;
1271
1272 pid_t pid = 123;
1273 sptr<IRemoteObject> token = new (std::nothrow) MockAbilityToken();
1274 auto abilityInfo = GetAbilityInfo("0", "MainAbility", "pNew", "com.ohos.test.special");
1275 auto appInfo = GetApplicationInfo("com.ohos.test.special");
1276 appInfo->bundleName = appInfo->name;
1277 sptr<MockAppScheduler> mockAppScheduler = new MockAppScheduler();
1278
1279 sptr<BundleMgrService> bundleMgr = new BundleMgrService();
1280 serviceInner_->SetBundleManager(bundleMgr.GetRefPtr());
1281
1282 StartAppProcess(pid);
1283 AbilityRuntime::LoadParam loadParam;
1284 loadParam.token = token;
1285 auto loadParamPtr = std::make_shared<AbilityRuntime::LoadParam>(loadParam);
1286 serviceInner_->LoadAbility(abilityInfo, appInfo, nullptr, loadParamPtr);
1287 BundleInfo bundleInfo;
1288 HapModuleInfo hapModuleInfo;
1289 EXPECT_TRUE(serviceInner_->GetBundleAndHapInfo(*abilityInfo, appInfo, bundleInfo, hapModuleInfo));
1290 std::shared_ptr<AppRunningRecord> record = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(
1291 appInfo->name, abilityInfo->process, abilityInfo->applicationInfo.uid, bundleInfo);
1292 if (record == nullptr) {
1293 EXPECT_TRUE(false);
1294 } else {
1295 pid_t newPid = record->GetPriorityObject()->GetPid();
1296 EXPECT_EQ(newPid, pid);
1297 }
1298
1299 auto abilityRecord = record->GetAbilityRunningRecordByToken(token);
1300
1301 EXPECT_EQ(abilityRecord->GetVisibility(), formateVaule);
1302 EXPECT_EQ(abilityRecord->GetPerceptibility(), formateVaule);
1303 EXPECT_EQ(abilityRecord->GetConnectionState(), formateVaule);
1304
1305 sptr<IRemoteObject> preToken = new (std::nothrow) MockAbilityToken();
1306 serviceInner_->AbilityBehaviorAnalysis(token, preToken, visibility, perceptibility, connectionState);
1307
1308 auto appRecord = serviceInner_->GetAppRunningRecordByAbilityToken(token);
1309 auto abilityRecord_1 = appRecord->GetAbilityRunningRecordByToken(token);
1310
1311 EXPECT_EQ(abilityRecord_1->GetToken(), token);
1312 EXPECT_EQ(abilityRecord_1->GetPreToken(), preToken);
1313 EXPECT_EQ(abilityRecord_1->GetVisibility(), visibility);
1314 EXPECT_EQ(abilityRecord_1->GetPerceptibility(), perceptibility);
1315 EXPECT_EQ(abilityRecord_1->GetConnectionState(), connectionState);
1316 }
1317
1318 /*
1319 * Feature: AbilityMgr
1320 * Function: LoadAbility
1321 * SubFunction: NA
1322 * FunctionPoints: NA
1323 * EnvConditions: NA
1324 * CaseDescription: NA
1325 */
1326 HWTEST_F(AmsAppLifeCycleModuleTest, LoadAbility_001, TestSize.Level1)
1327 {
1328 EXPECT_NE(serviceInner_, nullptr);
1329 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1330 pid_t pid_0 = 1024;
1331 pid_t pid_1 = 2048;
1332 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1333 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1334 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0");
1335 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0");
1336 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0");
1337 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0");
1338 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1339 TestProcessInfo testProcessInfo;
1340
1341 testProcessInfo.pid = pid_0;
1342 testProcessInfo.isStart = false;
1343 auto appRunningRecord_0 =
1344 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1345
1346 testProcessInfo.pid = pid_1;
1347 testProcessInfo.isStart = false;
1348 auto appRunningRecord_1 =
1349 StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1350 int32_t recordId_0 = appRunningRecord_0->GetRecordId();
1351 int32_t recordId_1 = appRunningRecord_1->GetRecordId();
1352 EXPECT_NE(recordId_0, recordId_1);
1353 EXPECT_NE(appRunningRecord_0, appRunningRecord_1);
1354 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1355 EXPECT_EQ(2, static_cast<int>(appMap.size()));
1356 }
1357
1358 /*
1359 * Feature: AbilityMgr
1360 * Function: LoadAbility
1361 * SubFunction: NA
1362 * FunctionPoints: NA
1363 * EnvConditions: NA
1364 * CaseDescription: NA
1365 */
1366 HWTEST_F(AmsAppLifeCycleModuleTest, LoadAbility_002, TestSize.Level1)
1367 {
1368 EXPECT_NE(serviceInner_, nullptr);
1369 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1370 pid_t pid_0 = 1024;
1371 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1372 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1373 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0");
1374 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0");
1375 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld0");
1376 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0");
1377 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1378 TestProcessInfo testProcessInfo;
1379
1380 testProcessInfo.pid = pid_0;
1381 testProcessInfo.isStart = false;
1382 auto appRunningRecord_0 =
1383 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1384
1385 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0);
1386 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1387
1388 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord_0, token_0);
1389 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_FOREGROUND,
1390 ApplicationState::APP_STATE_FOREGROUND);
1391
1392 testProcessInfo.pid = pid_0;
1393 testProcessInfo.isStart = true;
1394 auto appRunningRecord_1 =
1395 StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1396 int32_t recordId_0 = appRunningRecord_0->GetRecordId();
1397 int32_t recordId_1 = appRunningRecord_1->GetRecordId();
1398 EXPECT_EQ(recordId_0, recordId_1);
1399 EXPECT_EQ(appRunningRecord_0, appRunningRecord_1);
1400 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1401 EXPECT_EQ(1, static_cast<int>(appMap.size()));
1402 }
1403
1404 /*
1405 * Feature: AbilityMgr
1406 * Function: LoadAbility
1407 * SubFunction: NA
1408 * FunctionPoints: NA
1409 * EnvConditions: NA
1410 * CaseDescription: NA
1411 */
1412 HWTEST_F(AmsAppLifeCycleModuleTest, LoadAbility_003, TestSize.Level1)
1413 {
1414 EXPECT_NE(serviceInner_, nullptr);
1415 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1416 pid_t pid_0 = 1024;
1417 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1418 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1419 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld101");
1420 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld101");
1421 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld102");
1422 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld102");
1423 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1424 TestProcessInfo testProcessInfo;
1425
1426 testProcessInfo.pid = pid_0;
1427 testProcessInfo.isStart = false;
1428 auto appRunningRecord_0 =
1429 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1430 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0);
1431 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1432
1433 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord_0, token_0);
1434 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_FOREGROUND,
1435 ApplicationState::APP_STATE_FOREGROUND);
1436
1437 testProcessInfo.pid = pid_0;
1438 testProcessInfo.isStart = true;
1439 auto appRunningRecord_1 =
1440 StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1441 int32_t recordId_0 = appRunningRecord_0->GetRecordId();
1442 int32_t recordId_1 = appRunningRecord_1->GetRecordId();
1443 EXPECT_EQ(recordId_0, recordId_1);
1444 EXPECT_EQ(appRunningRecord_0, appRunningRecord_1);
1445 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1446 EXPECT_EQ(1, static_cast<int>(appMap.size()));
1447 }
1448
1449 /*
1450 * Feature: AbilityMgr
1451 * Function: LoadAbility
1452 * SubFunction: NA
1453 * FunctionPoints: NA
1454 * EnvConditions: NA
1455 * CaseDescription: NA
1456 */
1457 HWTEST_F(AmsAppLifeCycleModuleTest, LoadAbility_004, TestSize.Level1)
1458 {
1459 EXPECT_NE(serviceInner_, nullptr);
1460 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1461 pid_t pid_0 = 1024;
1462 pid_t pid_1 = 2048;
1463 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1464 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1465 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld103");
1466 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld103");
1467 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld104");
1468 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld104");
1469 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1470 TestProcessInfo testProcessInfo;
1471
1472 testProcessInfo.pid = pid_0;
1473 testProcessInfo.isStart = false;
1474 auto appRunningRecord_0 =
1475 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1476
1477 testProcessInfo.pid = pid_1;
1478 testProcessInfo.isStart = false;
1479 auto appRunningRecord_1 =
1480 StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1481 int32_t recordId_0 = appRunningRecord_0->GetRecordId();
1482 int32_t recordId_1 = appRunningRecord_1->GetRecordId();
1483 EXPECT_NE(recordId_0, recordId_1);
1484 EXPECT_NE(appRunningRecord_0, appRunningRecord_1);
1485 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1486 EXPECT_EQ(2, static_cast<int>(appMap.size()));
1487 }
1488
1489 /*
1490 * Feature: AbilityMgr
1491 * Function: KillApplication
1492 * SubFunction: NA
1493 * FunctionPoints: NA
1494 * EnvConditions: NA
1495 * CaseDescription: NA
1496 */
1497 HWTEST_F(AmsAppLifeCycleModuleTest, KillApplication_001, TestSize.Level1)
1498 {
1499 EXPECT_NE(serviceInner_, nullptr);
1500 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1501 pid_t pid_0 = 1024;
1502 pid_t pid_1 = 2048;
1503 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1504 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1505 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0");
1506 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0");
1507 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0");
1508 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0");
1509 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1510 sptr<MockAppScheduler> mockAppScheduler1 = new (std::nothrow) MockAppScheduler();
1511 TestProcessInfo testProcessInfo;
1512
1513 testProcessInfo.pid = pid_0;
1514 testProcessInfo.isStart = false;
1515 auto appRunningRecord_0 =
1516 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1517
1518 testProcessInfo.pid = pid_1;
1519 testProcessInfo.isStart = false;
1520 auto appRunningRecord_1 =
1521 StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1522 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0);
1523 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1524 ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1);
1525 CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1526
1527 int32_t recordId_0 = appRunningRecord_0->GetRecordId();
1528 int32_t recordId_1 = appRunningRecord_1->GetRecordId();
1529 EXPECT_NE(recordId_0, recordId_1);
1530 EXPECT_NE(appRunningRecord_0, appRunningRecord_1);
1531 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1532 EXPECT_EQ(2, static_cast<int>(appMap.size()));
1533 EXPECT_CALL(*mockAppScheduler, ScheduleProcessSecurityExit()).Times(1);
1534 EXPECT_CALL(*mockAppScheduler1, ScheduleProcessSecurityExit()).Times(1);
1535
1536 int32_t ret = serviceInner_->KillApplication("com.ohos.test.helloworld0");
1537 EXPECT_EQ(ret, 0);
1538 serviceInner_->OnRemoteDied(mockAppScheduler); // A faked death recipient.
1539 auto appMap1 = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1540 EXPECT_EQ(1, static_cast<int>(appMap1.size()));
1541 serviceInner_->OnRemoteDied(mockAppScheduler1);
1542 auto appMap2 = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1543 EXPECT_EQ(0, static_cast<int>(appMap2.size()));
1544 }
1545
1546 /*
1547 * Feature: AbilityMgr
1548 * Function: KillApplication
1549 * SubFunction: NA
1550 * FunctionPoints: NA
1551 * EnvConditions: NA
1552 * CaseDescription: NA
1553 */
1554 HWTEST_F(AmsAppLifeCycleModuleTest, KillApplication_002, TestSize.Level1)
1555 {
1556 EXPECT_NE(serviceInner_, nullptr);
1557 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1558 pid_t pid_0 = 1024;
1559 pid_t pid_1 = 2048;
1560 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1561 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1562 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld103");
1563 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld103");
1564 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld104");
1565 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld104");
1566 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1567 sptr<MockAppScheduler> mockAppScheduler1 = new (std::nothrow) MockAppScheduler();
1568 TestProcessInfo testProcessInfo;
1569
1570 testProcessInfo.pid = pid_0;
1571 testProcessInfo.isStart = false;
1572 auto appRunningRecord_0 =
1573 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1574
1575 testProcessInfo.pid = pid_1;
1576 testProcessInfo.isStart = false;
1577 auto appRunningRecord_1 =
1578 StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1579 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0);
1580 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1581 ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1);
1582 CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1583 int32_t recordId_0 = appRunningRecord_0->GetRecordId();
1584 int32_t recordId_1 = appRunningRecord_1->GetRecordId();
1585 EXPECT_NE(recordId_0, recordId_1);
1586 EXPECT_NE(appRunningRecord_0, appRunningRecord_1);
1587 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1588 EXPECT_EQ(2, static_cast<int>(appMap.size()));
1589 EXPECT_CALL(*mockAppScheduler, ScheduleProcessSecurityExit()).Times(1);
1590
1591 int32_t ret = serviceInner_->KillApplication("com.ohos.test.helloworld103");
1592 EXPECT_EQ(ret, 0);
1593 serviceInner_->OnRemoteDied(mockAppScheduler); // A faked death recipient.
1594 auto appMap1 = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1595 EXPECT_EQ(1, static_cast<int>(appMap1.size()));
1596 }
1597
1598 /*
1599 * Feature: AbilityMgr
1600 * Function: KillApplication
1601 * SubFunction: NA
1602 * FunctionPoints: NA
1603 * EnvConditions: NA
1604 * CaseDescription: NA
1605 */
1606 HWTEST_F(AmsAppLifeCycleModuleTest, KillApplication_003, TestSize.Level1)
1607 {
1608 EXPECT_NE(serviceInner_, nullptr);
1609 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1610 pid_t pid_0 = 1024;
1611 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1612 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1613 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld101");
1614 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld101");
1615 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p1", "com.ohos.test.helloworld102");
1616 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld102");
1617 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1618 TestProcessInfo testProcessInfo;
1619
1620 testProcessInfo.pid = pid_0;
1621 testProcessInfo.isStart = false;
1622 auto appRunningRecord_0 =
1623 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1624 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0);
1625 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1626
1627 ChangeAbilityStateToForegroud(mockAppScheduler, appRunningRecord_0, token_0);
1628 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_FOREGROUND,
1629 ApplicationState::APP_STATE_FOREGROUND);
1630
1631 testProcessInfo.pid = pid_0;
1632 testProcessInfo.isStart = true;
1633 auto appRunningRecord_1 =
1634 StartProcessAndLoadAbility(mockAppScheduler, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1635 int32_t recordId_0 = appRunningRecord_0->GetRecordId();
1636 int32_t recordId_1 = appRunningRecord_1->GetRecordId();
1637 EXPECT_EQ(recordId_0, recordId_1);
1638 EXPECT_EQ(appRunningRecord_0, appRunningRecord_1);
1639 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1640 EXPECT_EQ(1, static_cast<int>(appMap.size()));
1641 EXPECT_CALL(*mockAppScheduler, ScheduleProcessSecurityExit()).Times(1);
1642
1643 int32_t ret = serviceInner_->KillApplication("com.ohos.test.helloworld101");
1644 EXPECT_EQ(ret, 0);
1645 serviceInner_->OnRemoteDied(mockAppScheduler); // A faked death recipient.
1646 auto appMap1 = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1647 EXPECT_EQ(0, static_cast<int>(appMap1.size()));
1648 }
1649
1650 /*
1651 * Feature: AbilityMgr
1652 * Function: UpdateConfiguration
1653 * SubFunction: NA
1654 * FunctionPoints: Environmental Change Notification
1655 * EnvConditions: NA
1656 * CaseDescription: Start two apps and then make environment change notifications
1657 */
1658 HWTEST_F(AmsAppLifeCycleModuleTest, UpdateConfiguration_001, TestSize.Level1)
1659 {
1660 EXPECT_NE(serviceInner_, nullptr);
1661 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1662 pid_t pid_0 = 1024;
1663 pid_t pid_1 = 2048;
1664 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1665 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1666 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0");
1667 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0");
1668 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0");
1669 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0");
1670 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1671 sptr<MockAppScheduler> mockAppScheduler1 = new (std::nothrow) MockAppScheduler();
1672 TestProcessInfo testProcessInfo;
1673
1674 testProcessInfo.pid = pid_0;
1675 testProcessInfo.isStart = false;
1676 auto appRunningRecord_0 =
1677 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1678
1679 testProcessInfo.pid = pid_1;
1680 testProcessInfo.isStart = false;
1681 auto appRunningRecord_1 =
1682 StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1683 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0);
1684 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1685 ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1);
1686 CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1687
1688 auto testLanguge = std::string("ch-zh");
__anon0dd2dd510202(const Configuration& config) 1689 auto configUpdate = [testLanguge](const Configuration& config) {
1690 auto l = config.GetItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
1691 EXPECT_TRUE(testLanguge == l);
1692 };
1693
1694 Configuration config;
1695 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge);
1696
1697 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1698 EXPECT_EQ(2, static_cast<int>(appMap.size()));
1699
1700 EXPECT_CALL(*mockAppScheduler, ScheduleConfigurationUpdated(_))
1701 .Times(1)
1702 .WillOnce(testing::Invoke(configUpdate));
1703 EXPECT_CALL(*mockAppScheduler1, ScheduleConfigurationUpdated(_))
1704 .Times(1)
1705 .WillOnce(testing::Invoke(configUpdate));
1706
1707 serviceInner_->UpdateConfiguration(config);
1708 }
1709
1710 /*
1711 * Feature: AbilityMgr
1712 * Function: UpdateConfiguration
1713 * SubFunction: NA
1714 * FunctionPoints: Environmental Change Notification
1715 * EnvConditions: NA
1716 * CaseDescription: Verify duplicate notification conditions
1717 */
1718 HWTEST_F(AmsAppLifeCycleModuleTest, UpdateConfiguration_002, TestSize.Level1)
1719 {
1720 EXPECT_NE(serviceInner_, nullptr);
1721 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1722 pid_t pid_0 = 1024;
1723 pid_t pid_1 = 2048;
1724 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1725 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1726 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0");
1727 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0");
1728 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0");
1729 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0");
1730 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1731 sptr<MockAppScheduler> mockAppScheduler1 = new (std::nothrow) MockAppScheduler();
1732 TestProcessInfo testProcessInfo;
1733
1734 testProcessInfo.pid = pid_0;
1735 testProcessInfo.isStart = false;
1736 auto appRunningRecord_0 =
1737 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1738
1739 testProcessInfo.pid = pid_1;
1740 testProcessInfo.isStart = false;
1741 auto appRunningRecord_1 =
1742 StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1743 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0);
1744 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1745 ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1);
1746 CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1747
1748 auto testLanguge = std::string("ch-zh");
1749 auto again = std::string("Russian");
1750 auto displayId = 10;
__anon0dd2dd510302(const Configuration& config) 1751 auto configUpdate = [testLanguge, displayId](const Configuration& config) {
1752 auto l = config.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
1753 EXPECT_TRUE(testLanguge == l);
1754 };
1755
__anon0dd2dd510402(const Configuration& config) 1756 auto configUpdateAgain = [again, displayId](const Configuration& config) {
1757 auto l = config.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
1758 EXPECT_TRUE(again == l);
1759 };
1760
1761 Configuration config;
1762 config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge);
1763
1764 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1765 EXPECT_EQ(2, static_cast<int>(appMap.size()));
1766
1767 EXPECT_CALL(*mockAppScheduler, ScheduleConfigurationUpdated(_))
1768 .Times(2)
1769 .WillOnce(testing::Invoke(configUpdate))
1770 .WillOnce(testing::Invoke(configUpdateAgain));
1771
1772 EXPECT_CALL(*mockAppScheduler1, ScheduleConfigurationUpdated(_))
1773 .Times(2)
1774 .WillOnce(testing::Invoke(configUpdate))
1775 .WillOnce(testing::Invoke(configUpdateAgain));
1776
1777 serviceInner_->UpdateConfiguration(config);
1778
1779 config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, again);
1780
1781 serviceInner_->UpdateConfiguration(config);
1782 }
1783
1784 /*
1785 * Feature: AbilityMgr
1786 * Function: UpdateConfiguration
1787 * SubFunction: NA
1788 * FunctionPoints: Environmental Change Notification
1789 * EnvConditions: NA
1790 * CaseDescription: Two types of notifications
1791 */
1792 HWTEST_F(AmsAppLifeCycleModuleTest, UpdateConfiguration_003, TestSize.Level1)
1793 {
1794 EXPECT_NE(serviceInner_, nullptr);
1795 CHECK_POINTER_IS_NULLPTR(serviceInner_);
1796 pid_t pid_0 = 1024;
1797 pid_t pid_1 = 2048;
1798 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
1799 sptr<IRemoteObject> token_1 = new (std::nothrow) MockAbilityToken();
1800 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld0");
1801 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld0");
1802 auto abilityInfo_1 = GetAbilityInfo("0", "MainAbility1", "p2", "com.ohos.test.helloworld0");
1803 auto appInfo_1 = GetApplicationInfo("com.ohos.test.helloworld0");
1804 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1805 sptr<MockAppScheduler> mockAppScheduler1 = new (std::nothrow) MockAppScheduler();
1806 TestProcessInfo testProcessInfo;
1807
1808 testProcessInfo.pid = pid_0;
1809 testProcessInfo.isStart = false;
1810 auto appRunningRecord_0 =
1811 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
1812
1813 testProcessInfo.pid = pid_1;
1814 testProcessInfo.isStart = false;
1815 auto appRunningRecord_1 =
1816 StartProcessAndLoadAbility(mockAppScheduler1, token_1, abilityInfo_1, appInfo_1, testProcessInfo);
1817 ChangeAbilityStateAfterAppStart(mockAppScheduler, pid_0);
1818 CheckState(appRunningRecord_0, token_0, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1819 ChangeAbilityStateAfterAppStart(mockAppScheduler1, pid_1);
1820 CheckState(appRunningRecord_1, token_1, AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
1821
1822 auto testLanguge = std::string("ch-zh");
1823 auto displayId = 10;
__anon0dd2dd510502(const Configuration& config) 1824 auto configUpdate = [testLanguge, displayId](const Configuration& config) {
1825 auto ld = config.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
1826 auto l = config.GetItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE);
1827 EXPECT_TRUE(testLanguge == ld);
1828 EXPECT_TRUE(testLanguge == l);
1829 };
1830
1831 Configuration config;
1832 config.AddItem(displayId, AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge);
1833 config.AddItem(AAFwk::GlobalConfigurationKey::SYSTEM_LANGUAGE, testLanguge);
1834
1835 auto appMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1836 EXPECT_EQ(2, static_cast<int>(appMap.size()));
1837
1838 EXPECT_CALL(*mockAppScheduler, ScheduleConfigurationUpdated(_))
1839 .Times(1)
1840 .WillOnce(testing::Invoke(configUpdate));
1841
1842 EXPECT_CALL(*mockAppScheduler1, ScheduleConfigurationUpdated(_))
1843 .Times(1)
1844 .WillOnce(testing::Invoke(configUpdate));
1845
1846 serviceInner_->UpdateConfiguration(config);
1847 }
1848
1849 /*
1850 * Feature: AbilityMgr
1851 * Function: LoadResidentProcess
1852 * SubFunction: NA
1853 * FunctionPoints: start resident process
1854 * EnvConditions: NA
1855 * CaseDescription: Start a resident process normally
1856 */
1857 HWTEST_F(AmsAppLifeCycleModuleTest, LoadResidentProcess_001, TestSize.Level1)
1858 {
1859 std::string appName = "KeepAliveApp";
1860 std::string proc = "KeepAliveApplication";
1861 int uid = 2100;
1862 BundleInfo info;
1863 info.name = proc;
1864 info.uid = uid;
1865
1866 ApplicationInfo appInfo;
1867 appInfo.name = "KeepAliveApp";
1868 appInfo.bundleName = "KeepAliveApplication";
1869 appInfo.uid = 2100;
1870
1871 info.applicationInfo = appInfo;
1872 HapModuleInfo hapModuleInfo;
1873 hapModuleInfo.name = "Module";
1874 HapModuleInfo hapModuleInfo1;
1875 hapModuleInfo1.name = "Module1";
1876 info.hapModuleInfos.push_back(hapModuleInfo);
1877 info.hapModuleInfos.push_back(hapModuleInfo1);
1878
1879 auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info);
1880 EXPECT_FALSE(appRecord);
1881 }
1882
1883 /*
1884 * Feature: AbilityMgr
1885 * Function: LoadResidentProcess
1886 * SubFunction: NA
1887 * FunctionPoints: start resident process
1888 * EnvConditions: NA
1889 * CaseDescription: Start multiple resident processes
1890 */
1891 HWTEST_F(AmsAppLifeCycleModuleTest, LoadResidentProcess_002, TestSize.Level1)
1892 {
1893 std::vector<BundleInfo> infos;
1894 std::string appName = "KeepAliveApp";
1895 std::string proc = "KeepAliveApplication";
1896 int uid = 2100;
1897
1898 HapModuleInfo hapModuleInfo;
1899 hapModuleInfo.moduleName = "KeepAliveApplication";
1900 BundleInfo info;
1901 info.name = proc;
1902 info.uid = uid;
1903 info.isKeepAlive = true;
1904 info.appId = "com.ohos.test.helloworld_code123";
1905 info.hapModuleInfos.push_back(hapModuleInfo);
1906
1907 ApplicationInfo appInfo;
1908 appInfo.name = appName;
1909 appInfo.bundleName = proc;
1910 appInfo.uid = 2100;
1911 info.applicationInfo = appInfo;
1912
1913 int appUid1 = 2101;
1914 std::string appName1 = "KeepAliveApp1";
1915 std::string proc1 = "KeepAliveApplication1";
1916
1917 HapModuleInfo hapModuleInfo1;
1918 hapModuleInfo1.moduleName = proc1;
1919
1920 ApplicationInfo appInfo1;
1921 appInfo1.name = appName1;
1922 appInfo1.bundleName = proc1;
1923 appInfo1.uid = appUid1;
1924
1925 BundleInfo info1;
1926 info1.name = proc1;
1927 info1.uid = appUid1;
1928 info1.isKeepAlive = true;
1929 info1.appId = "com.ohos.test.helloworld_code123";
1930 info1.hapModuleInfos.push_back(hapModuleInfo1);
1931 info1.applicationInfo = appInfo1;
1932
1933 infos.push_back(info);
1934 infos.push_back(info1);
1935
1936 MockAppSpawnClient* mockClientPtr = new (std::nothrow) MockAppSpawnClient();
1937 EXPECT_TRUE(mockClientPtr);
1938 if (mockClientPtr) {
1939 serviceInner_->SetAppSpawnClient(std::unique_ptr<MockAppSpawnClient>(mockClientPtr));
1940
1941 // start process
1942 serviceInner_->StartResidentProcess(infos, -1, true);
1943 serviceInner_->appRunningManager_->GetAppRunningRecordMap();
1944 }
1945 }
1946
1947 /*
1948 * Feature: AbilityMgr
1949 * Function: RestartResidentProcess
1950 * SubFunction: NA
1951 * FunctionPoints: Resident process exception recovery
1952 * EnvConditions: NA
1953 * CaseDescription: Start the resident process and let it die abnormally, then resume
1954 */
1955 HWTEST_F(AmsAppLifeCycleModuleTest, RestartResidentProcess_001, TestSize.Level1)
1956 {
1957 pid_t pid = 123;
1958 std::string appName = "KeepAliveApp";
1959 std::string proc = "KeepAliveApplication";
1960 int uid = 2100;
1961
1962 HapModuleInfo hapModuleInfo;
1963 hapModuleInfo.moduleName = "KeepAliveApplication";
1964 std::vector<BundleInfo> infos;
1965 BundleInfo info;
1966 info.name = proc;
1967 info.uid = uid;
1968 info.appId = "com.ohos.test.helloworld_code123";
1969 info.hapModuleInfos.push_back(hapModuleInfo);
1970
1971 ApplicationInfo appInfo;
1972 appInfo.name = "KeepAliveApp";
1973 appInfo.bundleName = "KeepAliveApplication";
1974 appInfo.uid = 2100;
1975 info.applicationInfo = appInfo;
1976 infos.push_back(info);
1977
1978 MockAppSpawnClient* mockClientPtr = new (std::nothrow) MockAppSpawnClient();
1979 EXPECT_TRUE(mockClientPtr);
1980 serviceInner_->SetAppSpawnClient(std::unique_ptr<MockAppSpawnClient>(mockClientPtr));
1981 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
1982 sptr<IAppScheduler> client = iface_cast<IAppScheduler>(mockAppScheduler.GetRefPtr());
1983
1984 // start process
1985 serviceInner_->StartResidentProcess(infos, -1, true);
1986 auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info);
1987 if (appRecord == nullptr) {
1988 EXPECT_FALSE(appRecord);
1989 } else {
1990 EXPECT_TRUE(appRecord->GetUid() == uid);
1991 EXPECT_TRUE(appRecord->GetProcessName() == proc);
1992 EXPECT_TRUE(appRecord->IsKeepAliveApp());
1993
1994 serviceInner_->AttachApplication(pid, client);
1995
1996 serviceInner_->OnRemoteDied(mockAppScheduler, false);
1997 appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info);
1998 EXPECT_FALSE(appRecord);
1999
2000 sleep(1);
2001 appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info);
2002 EXPECT_TRUE(appRecord);
2003 }
2004 }
2005
2006 /*
2007 * Feature: AbilityMgr
2008 * Function: RestartResidentProcess
2009 * SubFunction: NA
2010 * FunctionPoints: Resident process exception recovery
2011 * EnvConditions: NA
2012 * CaseDescription: Start an ordinary process, it should not be pulled up after abnormal death
2013 */
2014 HWTEST_F(AmsAppLifeCycleModuleTest, RestartResidentProcess_002, TestSize.Level1)
2015 {
2016 pid_t pid_0 = 1024;
2017
2018 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
2019 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld103");
2020 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld103");
2021
2022 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
2023 TestProcessInfo testProcessInfo;
2024
2025 testProcessInfo.pid = pid_0;
2026 testProcessInfo.isStart = false;
2027 auto appRunningRecord_0 =
2028 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
2029 EXPECT_TRUE(appRunningRecord_0);
2030
2031 sptr<IAppScheduler> client = iface_cast<IAppScheduler>(mockAppScheduler.GetRefPtr());
2032 serviceInner_->AttachApplication(pid_0, client);
2033 serviceInner_->OnRemoteDied(mockAppScheduler, false);
2034
2035 sleep(1);
2036 auto recordMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
2037 EXPECT_TRUE(recordMap.empty());
2038 }
2039
2040 /*
2041 * Feature: AbilityMgr
2042 * Function: RestartResidentProcess
2043 * SubFunction: NA
2044 * FunctionPoints: Resident process exception recovery
2045 * EnvConditions: NA
2046 * CaseDescription: 1.start a normal process
2047 * 2.start a resident process
2048 * 3.make both processes die
2049 */
2050 HWTEST_F(AmsAppLifeCycleModuleTest, RestartResidentProcess_003, TestSize.Level1)
2051 {
2052 pid_t pid_0 = 1024;
2053
2054 sptr<IRemoteObject> token_0 = new (std::nothrow) MockAbilityToken();
2055 auto abilityInfo_0 = GetAbilityInfo("0", "MainAbility", "p1", "com.ohos.test.helloworld103");
2056 auto appInfo_0 = GetApplicationInfo("com.ohos.test.helloworld103");
2057
2058 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
2059 TestProcessInfo testProcessInfo;
2060
2061 testProcessInfo.pid = pid_0;
2062 testProcessInfo.isStart = false;
2063 auto appRunningRecord_0 =
2064 StartProcessAndLoadAbility(mockAppScheduler, token_0, abilityInfo_0, appInfo_0, testProcessInfo);
2065 EXPECT_TRUE(appRunningRecord_0);
2066
2067 pid_t pid = 123;
2068 std::string appName = "KeepAliveApp";
2069 std::string proc = "KeepAliveApplication";
2070 int uid = 2100;
2071
2072 HapModuleInfo hapModuleInfo;
2073 hapModuleInfo.moduleName = "KeepAliveApplication";
2074 std::vector<BundleInfo> infos;
2075 BundleInfo info;
2076 info.name = proc;
2077 info.uid = uid;
2078 info.isKeepAlive = true;
2079 info.appId = "com.ohos.test.helloworld_code123";
2080 info.hapModuleInfos.push_back(hapModuleInfo);
2081
2082 ApplicationInfo appInfo;
2083 appInfo.name = "KeepAliveApp";
2084 appInfo.bundleName = "KeepAliveApplication";
2085 appInfo.uid = 2100;
2086 info.applicationInfo = appInfo;
2087 infos.push_back(info);
2088
2089 MockAppSpawnClient* mockClientPtr = new (std::nothrow) MockAppSpawnClient();
2090 EXPECT_TRUE(mockClientPtr);
2091
2092 serviceInner_->SetAppSpawnClient(std::unique_ptr<MockAppSpawnClient>(mockClientPtr));
2093
2094 // start process
2095 serviceInner_->StartResidentProcess(infos, -1, true);
2096 auto residentRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info);
2097 if (residentRecord == nullptr) {
2098 EXPECT_FALSE(residentRecord);
2099 return;
2100 }
2101 EXPECT_TRUE(residentRecord);
2102 sptr<IAppScheduler> client = iface_cast<IAppScheduler>(mockAppScheduler.GetRefPtr());
2103 serviceInner_->AttachApplication(pid_0, client);
2104
2105 sptr<MockAppScheduler> mockAppSchedulerResident = new (std::nothrow) MockAppScheduler();
2106 EXPECT_CALL(*mockAppSchedulerResident, ScheduleLaunchApplication(_, _));
2107 sptr<IAppScheduler> residentClient = iface_cast<IAppScheduler>(mockAppSchedulerResident.GetRefPtr());
2108 serviceInner_->AttachApplication(pid, residentClient);
2109
2110 serviceInner_->OnRemoteDied(mockAppScheduler, false);
2111 serviceInner_->OnRemoteDied(mockAppSchedulerResident, false);
2112
2113 auto recordMap = serviceInner_->appRunningManager_->GetAppRunningRecordMap();
2114 EXPECT_TRUE(recordMap.empty());
2115
2116 sleep(1);
2117 auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(appName, proc, uid, info);
2118 if (appRecord == nullptr) {
2119 EXPECT_FALSE(appRecord);
2120 } else {
2121 EXPECT_TRUE(appRecord);
2122 }
2123 }
2124
2125 /*
2126 * Feature: AbilityMgr
2127 * Function: KillProcessWithAccount
2128 * SubFunction: NA
2129 * FunctionPoints: Test KillProcessWithAccount
2130 * EnvConditions: NA
2131 * CaseDescription: Specify user to kill process
2132 */
2133 HWTEST_F(AmsAppLifeCycleModuleTest, KillProcessWithAccount_001, TestSize.Level1)
2134 {
2135 const std::string STRING_BUNDLE_NAME = "com.ix.hiworld";
2136 constexpr int ACCOUNT_ID = 100;
2137 auto instance = DelayedSingleton<SysMrgClient>::GetInstance();
2138 EXPECT_NE(instance, nullptr);
2139
2140 auto object = instance->GetSystemAbility(APP_MGR_SERVICE_ID);
2141 EXPECT_NE(object, nullptr);
2142
2143 auto proxy = iface_cast<IAppMgr>(object);
2144 EXPECT_NE(proxy, nullptr);
2145
2146 ErrCode result = proxy->GetAmsMgr()->KillProcessWithAccount(STRING_BUNDLE_NAME, ACCOUNT_ID);
2147 EXPECT_EQ(result, ERR_OK);
2148 }
2149 } // namespace AppExecFwk
2150 } // namespace OHOS
2151