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 "app_mgr_service_inner.h"
18 #undef private
19 #include <unistd.h>
20 #include <gtest/gtest.h>
21 #include "iremote_object.h"
22 #include "refbase.h"
23 #include "app_launch_data.h"
24 #include "hilog_wrapper.h"
25 #include "mock_ability_token.h"
26 #include "mock_app_scheduler.h"
27 #include "mock_app_spawn_client.h"
28
29 using namespace testing::ext;
30 using testing::_;
31 using testing::Return;
32 using testing::SetArgReferee;
33 namespace OHOS {
34 namespace AppExecFwk {
35 struct TestApplicationPreRecord {
TestApplicationPreRecordOHOS::AppExecFwk::TestApplicationPreRecord36 TestApplicationPreRecord(
37 const std::shared_ptr<AppRunningRecord>& appRecord, const sptr<MockAppScheduler>& mockAppScheduler)
38 : appRecord_(appRecord), mockAppScheduler_(mockAppScheduler)
39 {}
40
GetAbilityOHOS::AppExecFwk::TestApplicationPreRecord41 std::shared_ptr<AbilityRunningRecord> GetAbility(const sptr<IRemoteObject>& token) const
42 {
43 return appRecord_->GetAbilityRunningRecordByToken(token);
44 }
45
~TestApplicationPreRecordOHOS::AppExecFwk::TestApplicationPreRecord46 virtual ~TestApplicationPreRecord()
47 {}
48
49 std::shared_ptr<AppRunningRecord> appRecord_;
50 sptr<MockAppScheduler> mockAppScheduler_;
51 };
52
53 pid_t g_mockPid = 0;
54 class AmsWorkFlowTest : public testing::Test {
55 public:
56 static void SetUpTestCase();
57 static void TearDownTestCase();
58 void SetUp();
59 void TearDown();
60
61 protected:
62 std::shared_ptr<AbilityInfo> CreateAbilityInfo(const std::string& ability, const std::string& app) const;
63 std::shared_ptr<ApplicationInfo> CreateApplication(const std::string& app) const;
64 sptr<MockAppScheduler> AddApplicationClient(const std::shared_ptr<AppRunningRecord>& appRecord) const;
65 TestApplicationPreRecord CreateTestApplicationRecord(const std::string& ability, const sptr<IRemoteObject>& token,
66 const std::string& app, const AbilityState abilityState, const ApplicationState appState) const;
67
68 protected:
69 std::shared_ptr<AppMgrServiceInner> serviceInner_;
70 std::shared_ptr<AMSEventHandler> handler_ = nullptr;
71 };
72
SetUpTestCase()73 void AmsWorkFlowTest::SetUpTestCase()
74 {}
75
TearDownTestCase()76 void AmsWorkFlowTest::TearDownTestCase()
77 {}
78
SetUp()79 void AmsWorkFlowTest::SetUp()
80 {
81 serviceInner_ = std::make_unique<AppMgrServiceInner>();
82 serviceInner_->Init();
83 auto taskhandler = AAFwk::TaskHandlerWrap::CreateQueueHandler("AmsWorkFlowTest");
84 handler_ = std::make_shared<AMSEventHandler>(taskhandler, serviceInner_);
85 serviceInner_->SetTaskHandler(taskhandler);
86 serviceInner_->SetEventHandler(handler_);
87 }
88
TearDown()89 void AmsWorkFlowTest::TearDown()
90 {
91 g_mockPid = 0;
92 }
93
CreateAbilityInfo(const std::string & ability,const std::string & app) const94 std::shared_ptr<AbilityInfo> AmsWorkFlowTest::CreateAbilityInfo(
95 const std::string& ability, const std::string& app) const
96 {
97 auto abilityInfo = std::make_shared<AbilityInfo>();
98 abilityInfo->visible = true;
99 abilityInfo->name = "test_ability" + ability;
100 abilityInfo->applicationName = "test_app" + app;
101 abilityInfo->applicationInfo.bundleName = "test_app" + app;
102
103 return abilityInfo;
104 }
105
CreateApplication(const std::string & app) const106 std::shared_ptr<ApplicationInfo> AmsWorkFlowTest::CreateApplication(const std::string& app) const
107 {
108 auto appInfo = std::make_shared<ApplicationInfo>();
109 appInfo->name = "test_app" + app;
110 appInfo->bundleName = "test_app" + app;
111
112 return appInfo;
113 }
114
AddApplicationClient(const std::shared_ptr<AppRunningRecord> & appRecord) const115 sptr<MockAppScheduler> AmsWorkFlowTest::AddApplicationClient(const std::shared_ptr<AppRunningRecord>& appRecord) const
116 {
117 if (appRecord->GetApplicationClient()) {
118 return nullptr;
119 }
120 sptr<MockAppScheduler> mockAppScheduler = new (std::nothrow) MockAppScheduler();
121 sptr<IAppScheduler> client = iface_cast<IAppScheduler>(mockAppScheduler.GetRefPtr());
122 appRecord->SetApplicationClient(client);
123 return mockAppScheduler;
124 }
125
126 // create one application that include one ability, and set state
CreateTestApplicationRecord(const std::string & ability,const sptr<IRemoteObject> & token,const std::string & app,const AbilityState abilityState,const ApplicationState appState) const127 TestApplicationPreRecord AmsWorkFlowTest::CreateTestApplicationRecord(const std::string& ability,
128 const sptr<IRemoteObject>& token, const std::string& app, const AbilityState abilityState,
129 const ApplicationState appState) const
130 {
131 auto abilityInfo = CreateAbilityInfo(ability, app);
132 auto appInfo = CreateApplication(app);
133 abilityInfo->applicationInfo.uid = 0;
134 appInfo->uid = 0;
135
136 BundleInfo bundleInfo;
137 bundleInfo.appId = "com.ohos.test.helloworld_code123";
138 HapModuleInfo hapModuleInfo;
139 hapModuleInfo.moduleName = "module789";
140
141 auto appRecord = serviceInner_->appRunningManager_->CheckAppRunningRecordIsExist(
142 appInfo->name, appInfo->name, appInfo->uid, bundleInfo);
143 if (!appRecord) {
144 appRecord = serviceInner_->CreateAppRunningRecord(
145 token, nullptr, appInfo, abilityInfo, appInfo->name, bundleInfo, hapModuleInfo, nullptr);
146 serviceInner_->StartProcess(abilityInfo->applicationName,
147 appInfo->name,
148 false, appRecord,
149 abilityInfo->applicationInfo.uid,
150 abilityInfo->applicationInfo.bundleName, 0);
151 } else {
152 appRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo, nullptr);
153 }
154
155 EXPECT_NE(appRecord, nullptr);
156 appRecord->SetEventHandler(handler_);
157 auto abilityRecord = appRecord->GetAbilityRunningRecordByToken(token);
158 EXPECT_NE(abilityRecord, nullptr);
159 abilityRecord->SetState(abilityState);
160 appRecord->SetState(appState);
161 sptr<MockAppScheduler> mockAppScheduler = AddApplicationClient(appRecord);
162
163 TestApplicationPreRecord testAppPreRecord(appRecord, mockAppScheduler);
164 return testAppPreRecord;
165 }
166
167 /*
168 * Feature: AMS
169 * Function: AppLifeCycle
170 * SubFunction: WorkFlow
171 * FunctionPoints: BackKey
172 * CaseDescription: when only one ability on foreground, previous is another app, simulate press back key
173 */
174 HWTEST_F(AmsWorkFlowTest, BackKey_001, TestSize.Level1)
175 {
176 HILOG_INFO("AmsWorkFlowTest BackKey_001 start");
177 sptr<IRemoteObject> tokenA = new MockAbilityToken();
178 TestApplicationPreRecord appA = CreateTestApplicationRecord(
179 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
180 sptr<IRemoteObject> tokenB = new MockAbilityToken();
181 TestApplicationPreRecord appB = CreateTestApplicationRecord(
182 "B", tokenB, "B", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
183 EXPECT_CALL(*(appB.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
184 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
185
186 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
187 appB.appRecord_->SetUpdateStateFromService(true);
188 serviceInner_->ApplicationForegrounded(appB.appRecord_->GetRecordId());
189 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
190 appA.appRecord_->SetUpdateStateFromService(true);
191 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
192
193 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appB.GetAbility(tokenB)->GetState());
194 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appB.appRecord_->GetState());
195 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
196 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
197 HILOG_INFO("AmsWorkFlowTest BackKey_001 end");
198 }
199
200 /*
201 * Feature: AMS
202 * Function: AppLifeCycle
203 * SubFunction: WorkFlow
204 * FunctionPoints: BackKey
205 * CaseDescription: when only one ability on foreground, previous ability in same app, simulate press back key
206 */
207 HWTEST_F(AmsWorkFlowTest, BackKey_002, TestSize.Level1)
208 {
209 HILOG_INFO("AmsWorkFlowTest BackKey_002 start");
210 sptr<IRemoteObject> tokenA = new MockAbilityToken();
211 TestApplicationPreRecord appA = CreateTestApplicationRecord(
212 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
213 sptr<IRemoteObject> tokenB = new MockAbilityToken();
214 CreateTestApplicationRecord(
215 "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_FOREGROUND);
216 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
217
218 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
219 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
220
221 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
222 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenB)->GetState());
223 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
224 HILOG_INFO("AmsWorkFlowTest BackKey_002 end");
225 }
226
227 /*
228 * Feature: AMS
229 * Function: AppLifeCycle
230 * SubFunction: WorkFlow
231 * FunctionPoints: BackKey
232 * CaseDescription: when two ability on foreground, previous ability in another app, simulate press back key
233 */
234 HWTEST_F(AmsWorkFlowTest, BackKey_003, TestSize.Level1)
235 {
236 HILOG_INFO("AmsWorkFlowTest BackKey_003 start");
237 sptr<IRemoteObject> tokenA = new MockAbilityToken();
238 TestApplicationPreRecord appA = CreateTestApplicationRecord(
239 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
240 sptr<IRemoteObject> tokenB = new MockAbilityToken();
241 CreateTestApplicationRecord(
242 "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
243 sptr<IRemoteObject> tokenC = new MockAbilityToken();
244 TestApplicationPreRecord appC = CreateTestApplicationRecord(
245 "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
246 EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
247 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
248
249 serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
250 appC.appRecord_->SetUpdateStateFromService(true);
251 serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
252 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
253 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
254 appA.appRecord_->SetUpdateStateFromService(true);
255 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
256
257 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
258 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
259 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
260 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
261 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
262 HILOG_INFO("AmsWorkFlowTest BackKey_003 end");
263 }
264
265 /*
266 * Feature: AMS
267 * Function: AppLifeCycle
268 * SubFunction: WorkFlow
269 * FunctionPoints: BackKey
270 * CaseDescription: when two ability on foreground, previous is 2 ability in another app, simulate press back key
271 */
272 HWTEST_F(AmsWorkFlowTest, BackKey_004, TestSize.Level1)
273 {
274 HILOG_INFO("AmsWorkFlowTest BackKey_004 start");
275 sptr<IRemoteObject> tokenA = new MockAbilityToken();
276 TestApplicationPreRecord appA = CreateTestApplicationRecord(
277 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
278 sptr<IRemoteObject> tokenB = new MockAbilityToken();
279 CreateTestApplicationRecord(
280 "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
281 sptr<IRemoteObject> tokenC = new MockAbilityToken();
282 TestApplicationPreRecord appC = CreateTestApplicationRecord(
283 "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
284 sptr<IRemoteObject> tokenD = new MockAbilityToken();
285 CreateTestApplicationRecord(
286 "D", tokenD, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
287 EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
288 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
289
290 serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
291 appC.appRecord_->SetUpdateStateFromService(true);
292 serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
293 serviceInner_->UpdateAbilityState(tokenD, AbilityState::ABILITY_STATE_FOREGROUND);
294 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
295 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
296 appA.appRecord_->SetUpdateStateFromService(true);
297 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
298
299 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
300 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenD)->GetState());
301 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
302 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
303 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
304 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
305 HILOG_INFO("AmsWorkFlowTest BackKey_004 end");
306 }
307
308 /*
309 * Feature: AMS
310 * Function: AppLifeCycle
311 * SubFunction: WorkFlow
312 * FunctionPoints: BackKey
313 * CaseDescription: when only one ability on foreground, previous is another app, simulate press back key and exit
314 app
315 */
316 HWTEST_F(AmsWorkFlowTest, BackKey_005, TestSize.Level1)
317 {
318 HILOG_INFO("AmsWorkFlowTest BackKey_005 start");
319 sptr<IRemoteObject> tokenA = new MockAbilityToken();
320 TestApplicationPreRecord appA = CreateTestApplicationRecord(
321 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
322 appA.appRecord_->LaunchPendingAbilities();
323 sptr<IRemoteObject> tokenB = new MockAbilityToken();
324 TestApplicationPreRecord appB = CreateTestApplicationRecord(
325 "B", tokenB, "B", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
326 appB.appRecord_->LaunchPendingAbilities();
327 EXPECT_CALL(*(appB.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
328 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
329 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_)).Times(1);
330 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication()).Times(1);
331
332 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
333 appB.appRecord_->SetUpdateStateFromService(true);
334 serviceInner_->ApplicationForegrounded(appB.appRecord_->GetRecordId());
335 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
336 appA.appRecord_->SetUpdateStateFromService(true);
337 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
338 serviceInner_->TerminateAbility(tokenA, false);
339 serviceInner_->AbilityTerminated(tokenA);
340 serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
341
342 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appB.GetAbility(tokenB)->GetState());
343 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appB.appRecord_->GetState());
344 EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
345 EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
346 HILOG_INFO("AmsWorkFlowTest BackKey_005 end");
347 }
348
349 /*
350 * Feature: AMS
351 * Function: AppLifeCycle
352 * SubFunction: WorkFlow
353 * FunctionPoints: BackKey
354 * CaseDescription: when two ability on foreground, previous is another app, simulate press back key and exit
355 */
356 HWTEST_F(AmsWorkFlowTest, BackKey_006, TestSize.Level1)
357 {
358 HILOG_INFO("AmsWorkFlowTest BackKey_006 start");
359 sptr<IRemoteObject> tokenA = new MockAbilityToken();
360 TestApplicationPreRecord appA = CreateTestApplicationRecord(
361 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
362 appA.appRecord_->LaunchPendingAbilities();
363 sptr<IRemoteObject> tokenB = new MockAbilityToken();
364 CreateTestApplicationRecord(
365 "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
366 sptr<IRemoteObject> tokenC = new MockAbilityToken();
367 TestApplicationPreRecord appC = CreateTestApplicationRecord(
368 "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
369 appC.appRecord_->LaunchPendingAbilities();
370 EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
371 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
372 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_)).Times(2);
373 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication()).Times(1);
374
375 serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
376 appC.appRecord_->SetUpdateStateFromService(true);
377 serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
378 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
379 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
380 appA.appRecord_->SetUpdateStateFromService(true);
381 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
382 serviceInner_->TerminateAbility(tokenA, false);
383 serviceInner_->AbilityTerminated(tokenA);
384 serviceInner_->TerminateAbility(tokenB, false);
385 serviceInner_->AbilityTerminated(tokenB);
386 serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
387
388 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
389 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
390 EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
391 EXPECT_EQ(appA.GetAbility(tokenB), nullptr);
392 EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
393 HILOG_INFO("AmsWorkFlowTest BackKey_006 end");
394 }
395
396 /*
397 * Feature: AMS
398 * Function: AppLifeCycle
399 * SubFunction: WorkFlow
400 * FunctionPoints: BackKey
401 * CaseDescription: when two ability on foreground, previous is 2 abiltiy in another app,
402 * simulate press back key and exit
403 */
404 HWTEST_F(AmsWorkFlowTest, BackKey_007, TestSize.Level1)
405 {
406 HILOG_INFO("AmsWorkFlowTest BackKey_007 start");
407 sptr<IRemoteObject> tokenA = new MockAbilityToken();
408 TestApplicationPreRecord appA = CreateTestApplicationRecord(
409 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
410 appA.appRecord_->LaunchPendingAbilities();
411 sptr<IRemoteObject> tokenB = new MockAbilityToken();
412 CreateTestApplicationRecord(
413 "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
414 sptr<IRemoteObject> tokenC = new MockAbilityToken();
415 TestApplicationPreRecord appC = CreateTestApplicationRecord(
416 "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
417 appC.appRecord_->LaunchPendingAbilities();
418 sptr<IRemoteObject> tokenD = new MockAbilityToken();
419 CreateTestApplicationRecord(
420 "D", tokenD, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
421 EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
422 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
423 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_)).Times(2);
424 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication()).Times(1);
425
426 serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
427 appC.appRecord_->SetUpdateStateFromService(true);
428 serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
429 serviceInner_->UpdateAbilityState(tokenD, AbilityState::ABILITY_STATE_FOREGROUND);
430 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
431 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
432 appA.appRecord_->SetUpdateStateFromService(true);
433 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
434 serviceInner_->TerminateAbility(tokenA, false);
435 serviceInner_->AbilityTerminated(tokenA);
436 serviceInner_->TerminateAbility(tokenB, false);
437 serviceInner_->AbilityTerminated(tokenB);
438 serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
439
440 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
441 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenD)->GetState());
442 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
443 EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
444 EXPECT_EQ(appA.GetAbility(tokenB), nullptr);
445 EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
446 HILOG_INFO("AmsWorkFlowTest BackKey_007 end");
447 }
448
449 /*
450 * Feature: AMS
451 * Function: AppLifeCycle
452 * SubFunction: WorkFlow
453 * FunctionPoints: ScreenOff
454 * CaseDescription: when only one ability on foreground, simulate screenoff
455 */
456 HWTEST_F(AmsWorkFlowTest, ScreenOff_001, TestSize.Level1)
457 {
458 HILOG_INFO("AmsWorkFlowTest ScreenOff_001 start");
459 sptr<IRemoteObject> tokenA = new MockAbilityToken();
460 TestApplicationPreRecord appA = CreateTestApplicationRecord(
461 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
462 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
463
464 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
465 appA.appRecord_->SetUpdateStateFromService(true);
466 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
467
468 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
469 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
470 HILOG_INFO("AmsWorkFlowTest ScreenOff_001 end");
471 }
472
473 /*
474 * Feature: AMS
475 * Function: AppLifeCycle
476 * SubFunction: WorkFlow
477 * FunctionPoints: ScreenOff
478 * CaseDescription: when multiple ability on foreground, simulate screenoff
479 */
480 HWTEST_F(AmsWorkFlowTest, ScreenOff_002, TestSize.Level1)
481 {
482 HILOG_INFO("AmsWorkFlowTest ScreenOff_002 start");
483 sptr<IRemoteObject> tokenA = new MockAbilityToken();
484 TestApplicationPreRecord appA = CreateTestApplicationRecord(
485 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
486 sptr<IRemoteObject> tokenB = new MockAbilityToken();
487 CreateTestApplicationRecord(
488 "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
489 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
490
491 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
492 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
493 appA.appRecord_->SetUpdateStateFromService(true);
494 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
495
496 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
497 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
498 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
499 HILOG_INFO("AmsWorkFlowTest ScreenOff_002 end");
500 }
501
502 /*
503 * Feature: AMS
504 * Function: AppLifeCycle
505 * SubFunction: WorkFlow
506 * FunctionPoints: ScreenOff
507 * CaseDescription: when one ability on foreground, another ability in same app is background, simulate screenoff
508 */
509 HWTEST_F(AmsWorkFlowTest, ScreenOff_003, TestSize.Level1)
510 {
511 HILOG_INFO("AmsWorkFlowTest ScreenOff_003 start");
512 sptr<IRemoteObject> tokenA = new MockAbilityToken();
513 TestApplicationPreRecord appA = CreateTestApplicationRecord(
514 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
515 sptr<IRemoteObject> tokenB = new MockAbilityToken();
516 CreateTestApplicationRecord(
517 "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_FOREGROUND);
518 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
519
520 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
521 appA.appRecord_->SetUpdateStateFromService(true);
522 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
523
524 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
525 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
526 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
527 HILOG_INFO("AmsWorkFlowTest ScreenOff_003 end");
528 }
529
530 /*
531 * Feature: AMS
532 * Function: AppLifeCycle
533 * SubFunction: WorkFlow
534 * FunctionPoints: ScreenOff
535 * CaseDescription: when only one ability on foreground, simulate screenoff and exit
536 */
537 HWTEST_F(AmsWorkFlowTest, ScreenOff_004, TestSize.Level1)
538 {
539 HILOG_INFO("AmsWorkFlowTest ScreenOff_004 start");
540 sptr<IRemoteObject> tokenA = new MockAbilityToken();
541 TestApplicationPreRecord appA = CreateTestApplicationRecord(
542 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
543 appA.appRecord_->LaunchPendingAbilities();
544 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
545 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_)).Times(1);
546 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication()).Times(1);
547
548 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
549 appA.appRecord_->SetUpdateStateFromService(true);
550 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
551 serviceInner_->TerminateAbility(tokenA, false);
552 serviceInner_->AbilityTerminated(tokenA);
553 serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
554
555 EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
556 EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
557 HILOG_INFO("AmsWorkFlowTest ScreenOff_004 end");
558 }
559
560 /*
561 * Feature: AMS
562 * Function: AppLifeCycle
563 * SubFunction: WorkFlow
564 * FunctionPoints: ScreenOff
565 * CaseDescription: when multiple ability on foreground, simulate screenoff and exit
566 */
567 HWTEST_F(AmsWorkFlowTest, ScreenOff_005, TestSize.Level1)
568 {
569 HILOG_INFO("AmsWorkFlowTest ScreenOff_005 start");
570 sptr<IRemoteObject> tokenA = new MockAbilityToken();
571 TestApplicationPreRecord appA = CreateTestApplicationRecord(
572 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
573 appA.appRecord_->LaunchPendingAbilities();
574 sptr<IRemoteObject> tokenB = new MockAbilityToken();
575 CreateTestApplicationRecord(
576 "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
577 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
578 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_)).Times(2);
579 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication()).Times(1);
580
581 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
582 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
583 appA.appRecord_->SetUpdateStateFromService(true);
584 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
585 serviceInner_->TerminateAbility(tokenA, false);
586 serviceInner_->AbilityTerminated(tokenA);
587 serviceInner_->TerminateAbility(tokenB, false);
588 serviceInner_->AbilityTerminated(tokenB);
589 serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
590
591 EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
592 EXPECT_EQ(appA.GetAbility(tokenB), nullptr);
593 EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
594 HILOG_INFO("AmsWorkFlowTest ScreenOff_005 end");
595 }
596
597 /*
598 * Feature: AMS
599 * Function: AppLifeCycle
600 * SubFunction: WorkFlow
601 * FunctionPoints: ScreenOff
602 * CaseDescription: when one ability on foreground, another ability in same app is background,
603 * simulate screenoff and exit
604 */
605 HWTEST_F(AmsWorkFlowTest, ScreenOff_006, TestSize.Level1)
606 {
607 HILOG_INFO("AmsWorkFlowTest ScreenOff_006 start");
608 sptr<IRemoteObject> tokenA = new MockAbilityToken();
609 TestApplicationPreRecord appA = CreateTestApplicationRecord(
610 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
611 appA.appRecord_->LaunchPendingAbilities();
612 sptr<IRemoteObject> tokenB = new MockAbilityToken();
613 CreateTestApplicationRecord(
614 "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_FOREGROUND);
615 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
616 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_)).Times(2);
617 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication()).Times(1);
618
619 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
620 appA.appRecord_->SetUpdateStateFromService(true);
621 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
622 serviceInner_->TerminateAbility(tokenA, false);
623 serviceInner_->AbilityTerminated(tokenA);
624 serviceInner_->TerminateAbility(tokenB, false);
625 serviceInner_->AbilityTerminated(tokenB);
626 serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
627
628 EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
629 EXPECT_EQ(appA.GetAbility(tokenB), nullptr);
630 EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
631 HILOG_INFO("AmsWorkFlowTest ScreenOff_006 end");
632 }
633
634 /*
635 * Feature: AMS
636 * Function: AppLifeCycle
637 * SubFunction: WorkFlow
638 * FunctionPoints: ScreenOn
639 * CaseDescription: when only one ability on background, simulate screen on
640 */
641 HWTEST_F(AmsWorkFlowTest, ScreenOn_001, TestSize.Level1)
642 {
643 HILOG_INFO("AmsWorkFlowTest ScreenOn_001 start");
644 sptr<IRemoteObject> tokenA = new MockAbilityToken();
645 TestApplicationPreRecord appA = CreateTestApplicationRecord(
646 "A", tokenA, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
647 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
648
649 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_FOREGROUND);
650 appA.appRecord_->SetUpdateStateFromService(true);
651 serviceInner_->ApplicationForegrounded(appA.appRecord_->GetRecordId());
652
653 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenA)->GetState());
654 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
655 HILOG_INFO("AmsWorkFlowTest ScreenOn_001 end");
656 }
657
658 /*
659 * Feature: AMS
660 * Function: AppLifeCycle
661 * SubFunction: WorkFlow
662 * FunctionPoints: ScreenOn
663 * CaseDescription: when multiple abilities on background, previous is one ability, simulate screen on
664 */
665 HWTEST_F(AmsWorkFlowTest, ScreenOn_002, TestSize.Level1)
666 {
667 HILOG_INFO("AmsWorkFlowTest ScreenOn_002 start");
668 sptr<IRemoteObject> tokenA = new MockAbilityToken();
669 TestApplicationPreRecord appA = CreateTestApplicationRecord(
670 "A", tokenA, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
671 sptr<IRemoteObject> tokenB = new MockAbilityToken();
672 CreateTestApplicationRecord(
673 "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
674 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
675
676 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_FOREGROUND);
677 appA.appRecord_->SetUpdateStateFromService(true);
678 serviceInner_->ApplicationForegrounded(appA.appRecord_->GetRecordId());
679
680 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenA)->GetState());
681 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
682 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
683 HILOG_INFO("AmsWorkFlowTest ScreenOn_002 end");
684 }
685
686 /*
687 * Feature: AMS
688 * Function: AppLifeCycle
689 * SubFunction: WorkFlow
690 * FunctionPoints: ScreenOn
691 * CaseDescription: when multiple abilities on background, all abilities are previous, simulate screen on
692 */
693 HWTEST_F(AmsWorkFlowTest, ScreenOn_003, TestSize.Level1)
694 {
695 HILOG_INFO("AmsWorkFlowTest ScreenOn_003 start");
696 sptr<IRemoteObject> tokenA = new MockAbilityToken();
697 TestApplicationPreRecord appA = CreateTestApplicationRecord(
698 "A", tokenA, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
699 sptr<IRemoteObject> tokenB = new MockAbilityToken();
700 CreateTestApplicationRecord(
701 "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
702 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
703
704 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_FOREGROUND);
705 appA.appRecord_->SetUpdateStateFromService(true);
706 serviceInner_->ApplicationForegrounded(appA.appRecord_->GetRecordId());
707 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
708
709 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenA)->GetState());
710 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenB)->GetState());
711 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
712 HILOG_INFO("AmsWorkFlowTest ScreenOn_003 end");
713 }
714
715 /*
716 * Feature: AMS
717 * Function: AppLifeCycle
718 * SubFunction: WorkFlow
719 * FunctionPoints: ChangeAbility
720 * CaseDescription: when one ability on foreground, request to load another ability of the same Application
721 */
722 HWTEST_F(AmsWorkFlowTest, ChangeAbility_001, TestSize.Level1)
723 {
724 HILOG_DEBUG("AmsWorkFlowTest ChangeAbility_001 start");
725 sptr<IRemoteObject> tokenA = new MockAbilityToken();
726 TestApplicationPreRecord appA = CreateTestApplicationRecord(
727 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
728 sptr<IRemoteObject> tokenB = new MockAbilityToken();
729 CreateTestApplicationRecord(
730 "B", tokenB, "A", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_FOREGROUND);
731
732 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
733 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
734
735 std::shared_ptr<AbilityRunningRecord> abilityA = appA.GetAbility(tokenA);
736 std::shared_ptr<AbilityRunningRecord> abilityB = appA.GetAbility(tokenB);
737 EXPECT_EQ(abilityA->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
738
739 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenB)->GetState());
740 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
741 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
742
743 auto abilities = appA.appRecord_->GetAbilities();
744 EXPECT_NE(nullptr, abilities[tokenA]);
745 EXPECT_NE(nullptr, abilities[tokenB]);
746 }
747
748 /*
749 * Feature: AMS
750 * Function: AppLifeCycle
751 * SubFunction: WorkFlow
752 * FunctionPoints: ChangeAbility
753 * CaseDescription: when two ability on foreground, request to load another ability of the same Application
754 */
755 HWTEST_F(AmsWorkFlowTest, ChangeAbility_002, TestSize.Level1)
756 {
757 HILOG_DEBUG("AmsWorkFlowTest ChangeAbility_001 start");
758 sptr<IRemoteObject> tokenA = new MockAbilityToken();
759 TestApplicationPreRecord appA = CreateTestApplicationRecord(
760 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
761 sptr<IRemoteObject> tokenB = new MockAbilityToken();
762 CreateTestApplicationRecord(
763 "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
764 sptr<IRemoteObject> tokenC = new MockAbilityToken();
765 CreateTestApplicationRecord(
766 "C", tokenC, "A", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_FOREGROUND);
767
768 serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
769 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
770 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
771
772 std::shared_ptr<AbilityRunningRecord> abilityA = appA.GetAbility(tokenA);
773 std::shared_ptr<AbilityRunningRecord> abilityB = appA.GetAbility(tokenB);
774 std::shared_ptr<AbilityRunningRecord> abilityC = appA.GetAbility(tokenC);
775 EXPECT_EQ(abilityA->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
776 EXPECT_EQ(abilityC->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
777
778 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenC)->GetState());
779 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
780 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
781 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
782
783 auto abilities = appA.appRecord_->GetAbilities();
784 EXPECT_NE(nullptr, abilities[tokenA]);
785 EXPECT_NE(nullptr, abilities[tokenB]);
786 EXPECT_NE(nullptr, abilities[tokenC]);
787 }
788
789 /*
790 * Feature: AMS
791 * Function: AppLifeCycle
792 * SubFunction: WorkFlow
793 * FunctionPoints: ChangeAbility
794 * CaseDescription: when one ability on foreground, request to load another ability of the another Application
795 */
796 HWTEST_F(AmsWorkFlowTest, ChangeAbility_003, TestSize.Level1)
797 {
798 HILOG_DEBUG("AmsWorkFlowTest ChangeAbility_001 start");
799 sptr<IRemoteObject> tokenA = new MockAbilityToken();
800 TestApplicationPreRecord appA = CreateTestApplicationRecord(
801 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
802 appA.appRecord_->LaunchPendingAbilities();
803 sptr<IRemoteObject> tokenB = new MockAbilityToken();
804 TestApplicationPreRecord appB = CreateTestApplicationRecord(
805 "B", tokenB, "B", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
806 appB.appRecord_->LaunchPendingAbilities();
807 EXPECT_CALL(*(appB.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
808 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
809
810 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
811 appB.appRecord_->SetUpdateStateFromService(true);
812 serviceInner_->ApplicationForegrounded(appB.appRecord_->GetRecordId());
813 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
814 appA.appRecord_->SetUpdateStateFromService(true);
815 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
816
817 std::shared_ptr<AbilityRunningRecord> abilityA = appA.GetAbility(tokenA);
818 std::shared_ptr<AbilityRunningRecord> abilityB = appB.GetAbility(tokenB);
819 EXPECT_NE(abilityA->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
820
821 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appB.GetAbility(tokenB)->GetState());
822 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appB.appRecord_->GetState());
823
824 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
825 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
826
827 auto abilitiesA = appA.appRecord_->GetAbilities();
828 auto abilitiesB = appB.appRecord_->GetAbilities();
829 EXPECT_NE(nullptr, abilitiesA[tokenA]);
830 EXPECT_NE(nullptr, abilitiesB[tokenB]);
831 }
832
833 /*
834 * Feature: AMS
835 * Function: AppLifeCycle
836 * SubFunction: WorkFlow
837 * FunctionPoints: ChangeAbility
838 * CaseDescription: when two ability on foreground, request to load another ability of the another Application
839 */
840 HWTEST_F(AmsWorkFlowTest, ChangeAbility_004, TestSize.Level1)
841 {
842 HILOG_DEBUG("AmsWorkFlowTest ChangeAbility_004 start");
843 sptr<IRemoteObject> tokenA = new MockAbilityToken();
844 TestApplicationPreRecord appA = CreateTestApplicationRecord(
845 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
846 appA.appRecord_->LaunchPendingAbilities();
847 sptr<IRemoteObject> tokenB = new MockAbilityToken();
848 CreateTestApplicationRecord(
849 "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
850 sptr<IRemoteObject> tokenC = new MockAbilityToken();
851 TestApplicationPreRecord appC = CreateTestApplicationRecord(
852 "C", tokenC, "C", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
853 appC.appRecord_->LaunchPendingAbilities();
854 EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
855 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
856
857 serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
858 appC.appRecord_->SetUpdateStateFromService(true);
859 serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
860
861 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
862 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
863 appA.appRecord_->SetUpdateStateFromService(true);
864 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
865
866 std::shared_ptr<AbilityRunningRecord> abilityA = appA.GetAbility(tokenA);
867 std::shared_ptr<AbilityRunningRecord> abilityB = appA.GetAbility(tokenB);
868 std::shared_ptr<AbilityRunningRecord> abilityC = appC.GetAbility(tokenC);
869 EXPECT_EQ(abilityA->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
870 EXPECT_NE(abilityC->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
871
872 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
873 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
874
875 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
876 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
877 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
878
879 auto abilitiesA = appA.appRecord_->GetAbilities();
880 auto abilitiesC = appC.appRecord_->GetAbilities();
881 EXPECT_NE(nullptr, abilitiesA[tokenA]);
882 EXPECT_NE(nullptr, abilitiesA[tokenB]);
883 EXPECT_NE(nullptr, abilitiesC[tokenC]);
884 }
885
886 /*
887 * Feature: AMS
888 * Function: AppLifeCycle
889 * SubFunction: WorkFlow
890 * FunctionPoints: ChangeAbility
891 * CaseDescription: when a application on background, request to load another ability of the same Application
892 */
893 HWTEST_F(AmsWorkFlowTest, ChangeAbility_005, TestSize.Level1)
894 {
895 HILOG_DEBUG("AmsWorkFlowTest ChangeAbility_004 start");
896 sptr<IRemoteObject> tokenA = new MockAbilityToken();
897 TestApplicationPreRecord appA = CreateTestApplicationRecord(
898 "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
899 sptr<IRemoteObject> tokenB = new MockAbilityToken();
900 TestApplicationPreRecord appB = CreateTestApplicationRecord(
901 "B", tokenB, "B", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
902 sptr<IRemoteObject> tokenC = new MockAbilityToken();
903 CreateTestApplicationRecord("C", tokenC, "B", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
904
905 EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
906 EXPECT_CALL(*(appB.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
907
908 serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
909 serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
910 appB.appRecord_->SetUpdateStateFromService(true);
911 serviceInner_->ApplicationForegrounded(appB.appRecord_->GetRecordId());
912
913 serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
914 appA.appRecord_->SetUpdateStateFromService(true);
915 serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
916
917 std::shared_ptr<AbilityRunningRecord> abilityB = appB.GetAbility(tokenB);
918 std::shared_ptr<AbilityRunningRecord> abilityC = appB.GetAbility(tokenC);
919 EXPECT_EQ(abilityC->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
920
921 EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appB.GetAbility(tokenC)->GetState());
922 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appB.GetAbility(tokenB)->GetState());
923 EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appB.appRecord_->GetState());
924
925 EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
926 EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
927
928 auto abilitiesA = appA.appRecord_->GetAbilities();
929 auto abilitiesB = appB.appRecord_->GetAbilities();
930 EXPECT_NE(nullptr, abilitiesA[tokenA]);
931 EXPECT_NE(nullptr, abilitiesB[tokenB]);
932 EXPECT_NE(nullptr, abilitiesB[tokenC]);
933 }
934 } // namespace AppExecFwk
935 } // namespace OHOS
936