1 /*
2  * Copyright (c) 2021-2023 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_tag_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, 0);
146         serviceInner_->StartProcess(abilityInfo->applicationName,
147             appInfo->name,
148             false, appRecord,
149             abilityInfo->applicationInfo.uid,
150             bundleInfo, abilityInfo->applicationInfo.bundleName, 0);
151     } else {
152         appRecord->AddModule(appInfo, abilityInfo, token, hapModuleInfo, nullptr, 0);
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     TAG_LOGI(AAFwkTag::TEST, "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     serviceInner_->ApplicationForegrounded(appB.appRecord_->GetRecordId());
188     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
189     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
190 
191     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appB.GetAbility(tokenB)->GetState());
192     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appB.appRecord_->GetState());
193     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
194     EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
195     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_001 end");
196 }
197 
198 /*
199  * Feature: AMS
200  * Function: AppLifeCycle
201  * SubFunction: WorkFlow
202  * FunctionPoints: BackKey
203  * CaseDescription: when only one ability on foreground, previous ability in same app, simulate press back key
204  */
205 HWTEST_F(AmsWorkFlowTest, BackKey_002, TestSize.Level1)
206 {
207     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_002 start");
208     sptr<IRemoteObject> tokenA = new MockAbilityToken();
209     TestApplicationPreRecord appA = CreateTestApplicationRecord(
210         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
211     sptr<IRemoteObject> tokenB = new MockAbilityToken();
212     CreateTestApplicationRecord(
213         "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_FOREGROUND);
214     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
215 
216     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
217     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
218 
219     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
220     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenB)->GetState());
221     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
222     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_002 end");
223 }
224 
225 /*
226  * Feature: AMS
227  * Function: AppLifeCycle
228  * SubFunction: WorkFlow
229  * FunctionPoints: BackKey
230  * CaseDescription: when two ability on foreground, previous ability in another app, simulate press back key
231  */
232 HWTEST_F(AmsWorkFlowTest, BackKey_003, TestSize.Level1)
233 {
234     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_003 start");
235     sptr<IRemoteObject> tokenA = new MockAbilityToken();
236     TestApplicationPreRecord appA = CreateTestApplicationRecord(
237         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
238     sptr<IRemoteObject> tokenB = new MockAbilityToken();
239     CreateTestApplicationRecord(
240         "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
241     sptr<IRemoteObject> tokenC = new MockAbilityToken();
242     TestApplicationPreRecord appC = CreateTestApplicationRecord(
243         "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
244     EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
245     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
246 
247     serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
248     serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
249     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
250     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
251     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
252 
253     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
254     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
255     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
256     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
257     EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
258     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_003 end");
259 }
260 
261 /*
262  * Feature: AMS
263  * Function: AppLifeCycle
264  * SubFunction: WorkFlow
265  * FunctionPoints: BackKey
266  * CaseDescription: when two ability on foreground, previous is 2 ability in another app, simulate press back key
267  */
268 HWTEST_F(AmsWorkFlowTest, BackKey_004, TestSize.Level1)
269 {
270     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_004 start");
271     sptr<IRemoteObject> tokenA = new MockAbilityToken();
272     TestApplicationPreRecord appA = CreateTestApplicationRecord(
273         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
274     sptr<IRemoteObject> tokenB = new MockAbilityToken();
275     CreateTestApplicationRecord(
276         "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
277     sptr<IRemoteObject> tokenC = new MockAbilityToken();
278     TestApplicationPreRecord appC = CreateTestApplicationRecord(
279         "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
280     sptr<IRemoteObject> tokenD = new MockAbilityToken();
281     CreateTestApplicationRecord(
282         "D", tokenD, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
283     EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
284     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
285 
286     serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
287     serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
288     serviceInner_->UpdateAbilityState(tokenD, AbilityState::ABILITY_STATE_FOREGROUND);
289     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
290     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
291     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
292 
293     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
294     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenD)->GetState());
295     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
296     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
297     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
298     EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
299     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_004 end");
300 }
301 
302 /*
303  * Feature: AMS
304  * Function: AppLifeCycle
305  * SubFunction: WorkFlow
306  * FunctionPoints: BackKey
307  * CaseDescription: when only one ability on foreground, previous is another app, simulate press back key and exit
308  app
309  */
310 HWTEST_F(AmsWorkFlowTest, BackKey_005, TestSize.Level1)
311 {
312     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_005 start");
313     sptr<IRemoteObject> tokenA = new MockAbilityToken();
314     TestApplicationPreRecord appA = CreateTestApplicationRecord(
315         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
316     appA.appRecord_->LaunchPendingAbilities();
317     sptr<IRemoteObject> tokenB = new MockAbilityToken();
318     TestApplicationPreRecord appB = CreateTestApplicationRecord(
319         "B", tokenB, "B", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
320     appB.appRecord_->LaunchPendingAbilities();
321     EXPECT_CALL(*(appB.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
322     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
323     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_, _)).Times(1);
324     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication(_)).Times(1);
325 
326     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
327     serviceInner_->ApplicationForegrounded(appB.appRecord_->GetRecordId());
328     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
329     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
330     serviceInner_->TerminateAbility(tokenA, false);
331     serviceInner_->AbilityTerminated(tokenA);
332     serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
333 
334     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appB.GetAbility(tokenB)->GetState());
335     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appB.appRecord_->GetState());
336     EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
337     EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
338     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_005 end");
339 }
340 
341 /*
342  * Feature: AMS
343  * Function: AppLifeCycle
344  * SubFunction: WorkFlow
345  * FunctionPoints: BackKey
346  * CaseDescription: when two ability on foreground, previous is another app, simulate press back key and exit
347  */
348 HWTEST_F(AmsWorkFlowTest, BackKey_006, TestSize.Level1)
349 {
350     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_006 start");
351     sptr<IRemoteObject> tokenA = new MockAbilityToken();
352     TestApplicationPreRecord appA = CreateTestApplicationRecord(
353         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
354     appA.appRecord_->LaunchPendingAbilities();
355     sptr<IRemoteObject> tokenB = new MockAbilityToken();
356     CreateTestApplicationRecord(
357         "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
358     sptr<IRemoteObject> tokenC = new MockAbilityToken();
359     TestApplicationPreRecord appC = CreateTestApplicationRecord(
360         "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
361     appC.appRecord_->LaunchPendingAbilities();
362     EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
363     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
364     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_, _)).Times(2);
365     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication(_)).Times(1);
366 
367     serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
368     serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
369     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
370     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
371     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
372     serviceInner_->TerminateAbility(tokenA, false);
373     serviceInner_->AbilityTerminated(tokenA);
374     serviceInner_->TerminateAbility(tokenB, false);
375     serviceInner_->AbilityTerminated(tokenB);
376     serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
377 
378     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
379     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
380     EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
381     EXPECT_EQ(appA.GetAbility(tokenB), nullptr);
382     EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
383     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_006 end");
384 }
385 
386 /*
387  * Feature: AMS
388  * Function: AppLifeCycle
389  * SubFunction: WorkFlow
390  * FunctionPoints: BackKey
391  * CaseDescription: when two ability on foreground, previous is 2 abiltiy in another app,
392  *                  simulate press back key and exit
393  */
394 HWTEST_F(AmsWorkFlowTest, BackKey_007, TestSize.Level1)
395 {
396     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_007 start");
397     sptr<IRemoteObject> tokenA = new MockAbilityToken();
398     TestApplicationPreRecord appA = CreateTestApplicationRecord(
399         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
400     appA.appRecord_->LaunchPendingAbilities();
401     sptr<IRemoteObject> tokenB = new MockAbilityToken();
402     CreateTestApplicationRecord(
403         "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
404     sptr<IRemoteObject> tokenC = new MockAbilityToken();
405     TestApplicationPreRecord appC = CreateTestApplicationRecord(
406         "C", tokenC, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
407     appC.appRecord_->LaunchPendingAbilities();
408     sptr<IRemoteObject> tokenD = new MockAbilityToken();
409     CreateTestApplicationRecord(
410         "D", tokenD, "C", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
411     EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
412     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
413     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_, _)).Times(2);
414     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication(_)).Times(1);
415 
416     serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
417     serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
418     serviceInner_->UpdateAbilityState(tokenD, AbilityState::ABILITY_STATE_FOREGROUND);
419     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
420     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
421     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
422     serviceInner_->TerminateAbility(tokenA, false);
423     serviceInner_->AbilityTerminated(tokenA);
424     serviceInner_->TerminateAbility(tokenB, false);
425     serviceInner_->AbilityTerminated(tokenB);
426     serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
427 
428     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
429     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenD)->GetState());
430     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
431     EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
432     EXPECT_EQ(appA.GetAbility(tokenB), nullptr);
433     EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
434     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest BackKey_007 end");
435 }
436 
437 /*
438  * Feature: AMS
439  * Function: AppLifeCycle
440  * SubFunction: WorkFlow
441  * FunctionPoints: ScreenOff
442  * CaseDescription: when only one ability on foreground, simulate screenoff
443  */
444 HWTEST_F(AmsWorkFlowTest, ScreenOff_001, TestSize.Level1)
445 {
446     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_001 start");
447     sptr<IRemoteObject> tokenA = new MockAbilityToken();
448     TestApplicationPreRecord appA = CreateTestApplicationRecord(
449         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
450     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
451 
452     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
453     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
454 
455     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
456     EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
457     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_001 end");
458 }
459 
460 /*
461  * Feature: AMS
462  * Function: AppLifeCycle
463  * SubFunction: WorkFlow
464  * FunctionPoints: ScreenOff
465  * CaseDescription: when multiple ability on foreground, simulate screenoff
466  */
467 HWTEST_F(AmsWorkFlowTest, ScreenOff_002, TestSize.Level1)
468 {
469     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_002 start");
470     sptr<IRemoteObject> tokenA = new MockAbilityToken();
471     TestApplicationPreRecord appA = CreateTestApplicationRecord(
472         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
473     sptr<IRemoteObject> tokenB = new MockAbilityToken();
474     CreateTestApplicationRecord(
475         "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
476     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
477 
478     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
479     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
480     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
481 
482     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
483     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
484     EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
485     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_002 end");
486 }
487 
488 /*
489  * Feature: AMS
490  * Function: AppLifeCycle
491  * SubFunction: WorkFlow
492  * FunctionPoints: ScreenOff
493  * CaseDescription: when one ability on foreground, another ability in same app is background, simulate screenoff
494  */
495 HWTEST_F(AmsWorkFlowTest, ScreenOff_003, TestSize.Level1)
496 {
497     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_003 start");
498     sptr<IRemoteObject> tokenA = new MockAbilityToken();
499     TestApplicationPreRecord appA = CreateTestApplicationRecord(
500         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
501     sptr<IRemoteObject> tokenB = new MockAbilityToken();
502     CreateTestApplicationRecord(
503         "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_FOREGROUND);
504     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
505 
506     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
507     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
508 
509     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
510     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
511     EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
512     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_003 end");
513 }
514 
515 /*
516  * Feature: AMS
517  * Function: AppLifeCycle
518  * SubFunction: WorkFlow
519  * FunctionPoints: ScreenOff
520  * CaseDescription: when only one ability on foreground, simulate screenoff and exit
521  */
522 HWTEST_F(AmsWorkFlowTest, ScreenOff_004, TestSize.Level1)
523 {
524     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_004 start");
525     sptr<IRemoteObject> tokenA = new MockAbilityToken();
526     TestApplicationPreRecord appA = CreateTestApplicationRecord(
527         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
528     appA.appRecord_->LaunchPendingAbilities();
529     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
530     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_, _)).Times(1);
531     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication(_)).Times(1);
532 
533     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
534     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
535     serviceInner_->TerminateAbility(tokenA, false);
536     serviceInner_->AbilityTerminated(tokenA);
537     serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
538 
539     EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
540     EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
541     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_004 end");
542 }
543 
544 /*
545  * Feature: AMS
546  * Function: AppLifeCycle
547  * SubFunction: WorkFlow
548  * FunctionPoints: ScreenOff
549  * CaseDescription: when multiple ability on foreground, simulate screenoff and exit
550  */
551 HWTEST_F(AmsWorkFlowTest, ScreenOff_005, TestSize.Level1)
552 {
553     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_005 start");
554     sptr<IRemoteObject> tokenA = new MockAbilityToken();
555     TestApplicationPreRecord appA = CreateTestApplicationRecord(
556         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
557     appA.appRecord_->LaunchPendingAbilities();
558     sptr<IRemoteObject> tokenB = new MockAbilityToken();
559     CreateTestApplicationRecord(
560         "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
561     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
562     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_, _)).Times(2);
563     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication(_)).Times(1);
564 
565     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
566     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
567     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
568     serviceInner_->TerminateAbility(tokenA, false);
569     serviceInner_->AbilityTerminated(tokenA);
570     serviceInner_->TerminateAbility(tokenB, false);
571     serviceInner_->AbilityTerminated(tokenB);
572     serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
573 
574     EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
575     EXPECT_EQ(appA.GetAbility(tokenB), nullptr);
576     EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
577     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_005 end");
578 }
579 
580 /*
581  * Feature: AMS
582  * Function: AppLifeCycle
583  * SubFunction: WorkFlow
584  * FunctionPoints: ScreenOff
585  * CaseDescription: when one ability on foreground, another ability in same app is background,
586  *                  simulate screenoff and exit
587  */
588 HWTEST_F(AmsWorkFlowTest, ScreenOff_006, TestSize.Level1)
589 {
590     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_006 start");
591     sptr<IRemoteObject> tokenA = new MockAbilityToken();
592     TestApplicationPreRecord appA = CreateTestApplicationRecord(
593         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
594     appA.appRecord_->LaunchPendingAbilities();
595     sptr<IRemoteObject> tokenB = new MockAbilityToken();
596     CreateTestApplicationRecord(
597         "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_FOREGROUND);
598     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
599     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleCleanAbility(_, _)).Times(2);
600     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleTerminateApplication(_)).Times(1);
601 
602     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
603     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
604     serviceInner_->TerminateAbility(tokenA, false);
605     serviceInner_->AbilityTerminated(tokenA);
606     serviceInner_->TerminateAbility(tokenB, false);
607     serviceInner_->AbilityTerminated(tokenB);
608     serviceInner_->ApplicationTerminated(appA.appRecord_->GetRecordId());
609 
610     EXPECT_EQ(appA.GetAbility(tokenA), nullptr);
611     EXPECT_EQ(appA.GetAbility(tokenB), nullptr);
612     EXPECT_EQ(ApplicationState::APP_STATE_TERMINATED, appA.appRecord_->GetState());
613     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOff_006 end");
614 }
615 
616 /*
617  * Feature: AMS
618  * Function: AppLifeCycle
619  * SubFunction: WorkFlow
620  * FunctionPoints: ScreenOn
621  * CaseDescription: when only one ability on background, simulate screen on
622  */
623 HWTEST_F(AmsWorkFlowTest, ScreenOn_001, TestSize.Level1)
624 {
625     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOn_001 start");
626     sptr<IRemoteObject> tokenA = new MockAbilityToken();
627     TestApplicationPreRecord appA = CreateTestApplicationRecord(
628         "A", tokenA, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
629     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
630 
631     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_FOREGROUND);
632     serviceInner_->ApplicationForegrounded(appA.appRecord_->GetRecordId());
633 
634     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenA)->GetState());
635     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
636     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOn_001 end");
637 }
638 
639 /*
640  * Feature: AMS
641  * Function: AppLifeCycle
642  * SubFunction: WorkFlow
643  * FunctionPoints: ScreenOn
644  * CaseDescription: when multiple abilities on background, previous is one ability, simulate screen on
645  */
646 HWTEST_F(AmsWorkFlowTest, ScreenOn_002, TestSize.Level1)
647 {
648     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOn_002 start");
649     sptr<IRemoteObject> tokenA = new MockAbilityToken();
650     TestApplicationPreRecord appA = CreateTestApplicationRecord(
651         "A", tokenA, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
652     sptr<IRemoteObject> tokenB = new MockAbilityToken();
653     CreateTestApplicationRecord(
654         "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
655     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
656 
657     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_FOREGROUND);
658     serviceInner_->ApplicationForegrounded(appA.appRecord_->GetRecordId());
659 
660     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenA)->GetState());
661     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
662     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
663     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOn_002 end");
664 }
665 
666 /*
667  * Feature: AMS
668  * Function: AppLifeCycle
669  * SubFunction: WorkFlow
670  * FunctionPoints: ScreenOn
671  * CaseDescription: when multiple abilities on background, all abilities are previous, simulate screen on
672  */
673 HWTEST_F(AmsWorkFlowTest, ScreenOn_003, TestSize.Level1)
674 {
675     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOn_003 start");
676     sptr<IRemoteObject> tokenA = new MockAbilityToken();
677     TestApplicationPreRecord appA = CreateTestApplicationRecord(
678         "A", tokenA, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
679     sptr<IRemoteObject> tokenB = new MockAbilityToken();
680     CreateTestApplicationRecord(
681         "B", tokenB, "A", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
682     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
683 
684     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_FOREGROUND);
685     serviceInner_->ApplicationForegrounded(appA.appRecord_->GetRecordId());
686     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
687 
688     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenA)->GetState());
689     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenB)->GetState());
690     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
691     TAG_LOGI(AAFwkTag::TEST, "AmsWorkFlowTest ScreenOn_003 end");
692 }
693 
694 /*
695  * Feature: AMS
696  * Function: AppLifeCycle
697  * SubFunction: WorkFlow
698  * FunctionPoints: ChangeAbility
699  * CaseDescription: when one ability on foreground, request to load another ability of the same Application
700  */
701 HWTEST_F(AmsWorkFlowTest, ChangeAbility_001, TestSize.Level1)
702 {
703     TAG_LOGD(AAFwkTag::TEST, "AmsWorkFlowTest ChangeAbility_001 start");
704     sptr<IRemoteObject> tokenA = new MockAbilityToken();
705     TestApplicationPreRecord appA = CreateTestApplicationRecord(
706         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
707     sptr<IRemoteObject> tokenB = new MockAbilityToken();
708     CreateTestApplicationRecord(
709         "B", tokenB, "A", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_FOREGROUND);
710 
711     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
712     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
713 
714     std::shared_ptr<AbilityRunningRecord> abilityA = appA.GetAbility(tokenA);
715     std::shared_ptr<AbilityRunningRecord> abilityB = appA.GetAbility(tokenB);
716     EXPECT_EQ(abilityA->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
717 
718     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenB)->GetState());
719     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
720     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
721 
722     auto abilities = appA.appRecord_->GetAbilities();
723     EXPECT_NE(nullptr, abilities[tokenA]);
724     EXPECT_NE(nullptr, abilities[tokenB]);
725 }
726 
727 /*
728  * Feature: AMS
729  * Function: AppLifeCycle
730  * SubFunction: WorkFlow
731  * FunctionPoints: ChangeAbility
732  * CaseDescription: when two ability on foreground, request to load another ability of the same Application
733  */
734 HWTEST_F(AmsWorkFlowTest, ChangeAbility_002, TestSize.Level1)
735 {
736     TAG_LOGD(AAFwkTag::TEST, "AmsWorkFlowTest ChangeAbility_001 start");
737     sptr<IRemoteObject> tokenA = new MockAbilityToken();
738     TestApplicationPreRecord appA = CreateTestApplicationRecord(
739         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
740     sptr<IRemoteObject> tokenB = new MockAbilityToken();
741     CreateTestApplicationRecord(
742         "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
743     sptr<IRemoteObject> tokenC = new MockAbilityToken();
744     CreateTestApplicationRecord(
745         "C", tokenC, "A", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_FOREGROUND);
746 
747     serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
748     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
749     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
750 
751     std::shared_ptr<AbilityRunningRecord> abilityA = appA.GetAbility(tokenA);
752     std::shared_ptr<AbilityRunningRecord> abilityB = appA.GetAbility(tokenB);
753     std::shared_ptr<AbilityRunningRecord> abilityC = appA.GetAbility(tokenC);
754     EXPECT_EQ(abilityA->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
755     EXPECT_EQ(abilityC->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
756 
757     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appA.GetAbility(tokenC)->GetState());
758     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
759     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
760     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appA.appRecord_->GetState());
761 
762     auto abilities = appA.appRecord_->GetAbilities();
763     EXPECT_NE(nullptr, abilities[tokenA]);
764     EXPECT_NE(nullptr, abilities[tokenB]);
765     EXPECT_NE(nullptr, abilities[tokenC]);
766 }
767 
768 /*
769  * Feature: AMS
770  * Function: AppLifeCycle
771  * SubFunction: WorkFlow
772  * FunctionPoints: ChangeAbility
773  * CaseDescription: when one ability on foreground, request to load another ability of the another Application
774  */
775 HWTEST_F(AmsWorkFlowTest, ChangeAbility_003, TestSize.Level1)
776 {
777     TAG_LOGD(AAFwkTag::TEST, "AmsWorkFlowTest ChangeAbility_001 start");
778     sptr<IRemoteObject> tokenA = new MockAbilityToken();
779     TestApplicationPreRecord appA = CreateTestApplicationRecord(
780         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
781     appA.appRecord_->LaunchPendingAbilities();
782     sptr<IRemoteObject> tokenB = new MockAbilityToken();
783     TestApplicationPreRecord appB = CreateTestApplicationRecord(
784         "B", tokenB, "B", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
785     appB.appRecord_->LaunchPendingAbilities();
786     EXPECT_CALL(*(appB.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
787     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
788 
789     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_FOREGROUND);
790     serviceInner_->ApplicationForegrounded(appB.appRecord_->GetRecordId());
791     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
792     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
793 
794     std::shared_ptr<AbilityRunningRecord> abilityA = appA.GetAbility(tokenA);
795     std::shared_ptr<AbilityRunningRecord> abilityB = appB.GetAbility(tokenB);
796     EXPECT_NE(abilityA->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
797 
798     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appB.GetAbility(tokenB)->GetState());
799     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appB.appRecord_->GetState());
800 
801     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
802     EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
803 
804     auto abilitiesA = appA.appRecord_->GetAbilities();
805     auto abilitiesB = appB.appRecord_->GetAbilities();
806     EXPECT_NE(nullptr, abilitiesA[tokenA]);
807     EXPECT_NE(nullptr, abilitiesB[tokenB]);
808 }
809 
810 /*
811  * Feature: AMS
812  * Function: AppLifeCycle
813  * SubFunction: WorkFlow
814  * FunctionPoints: ChangeAbility
815  * CaseDescription: when two ability on foreground, request to load another ability of the another Application
816  */
817 HWTEST_F(AmsWorkFlowTest, ChangeAbility_004, TestSize.Level1)
818 {
819     TAG_LOGD(AAFwkTag::TEST, "AmsWorkFlowTest ChangeAbility_004 start");
820     sptr<IRemoteObject> tokenA = new MockAbilityToken();
821     TestApplicationPreRecord appA = CreateTestApplicationRecord(
822         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
823     appA.appRecord_->LaunchPendingAbilities();
824     sptr<IRemoteObject> tokenB = new MockAbilityToken();
825     CreateTestApplicationRecord(
826         "B", tokenB, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
827     sptr<IRemoteObject> tokenC = new MockAbilityToken();
828     TestApplicationPreRecord appC = CreateTestApplicationRecord(
829         "C", tokenC, "C", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
830     appC.appRecord_->LaunchPendingAbilities();
831     EXPECT_CALL(*(appC.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
832     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(2);
833 
834     serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
835     serviceInner_->ApplicationForegrounded(appC.appRecord_->GetRecordId());
836 
837     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
838     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
839     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
840 
841     std::shared_ptr<AbilityRunningRecord> abilityA = appA.GetAbility(tokenA);
842     std::shared_ptr<AbilityRunningRecord> abilityB = appA.GetAbility(tokenB);
843     std::shared_ptr<AbilityRunningRecord> abilityC = appC.GetAbility(tokenC);
844     EXPECT_EQ(abilityA->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
845     EXPECT_NE(abilityC->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
846 
847     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appC.GetAbility(tokenC)->GetState());
848     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appC.appRecord_->GetState());
849 
850     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
851     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenB)->GetState());
852     EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
853 
854     auto abilitiesA = appA.appRecord_->GetAbilities();
855     auto abilitiesC = appC.appRecord_->GetAbilities();
856     EXPECT_NE(nullptr, abilitiesA[tokenA]);
857     EXPECT_NE(nullptr, abilitiesA[tokenB]);
858     EXPECT_NE(nullptr, abilitiesC[tokenC]);
859 }
860 
861 /*
862  * Feature: AMS
863  * Function: AppLifeCycle
864  * SubFunction: WorkFlow
865  * FunctionPoints: ChangeAbility
866  * CaseDescription: when a application on background, request to load another ability of the same Application
867  */
868 HWTEST_F(AmsWorkFlowTest, ChangeAbility_005, TestSize.Level1)
869 {
870     TAG_LOGD(AAFwkTag::TEST, "AmsWorkFlowTest ChangeAbility_004 start");
871     sptr<IRemoteObject> tokenA = new MockAbilityToken();
872     TestApplicationPreRecord appA = CreateTestApplicationRecord(
873         "A", tokenA, "A", AbilityState::ABILITY_STATE_FOREGROUND, ApplicationState::APP_STATE_FOREGROUND);
874     sptr<IRemoteObject> tokenB = new MockAbilityToken();
875     TestApplicationPreRecord appB = CreateTestApplicationRecord(
876         "B", tokenB, "B", AbilityState::ABILITY_STATE_BACKGROUND, ApplicationState::APP_STATE_BACKGROUND);
877     sptr<IRemoteObject> tokenC = new MockAbilityToken();
878     CreateTestApplicationRecord("C", tokenC, "B", AbilityState::ABILITY_STATE_READY, ApplicationState::APP_STATE_READY);
879 
880     EXPECT_CALL(*(appA.mockAppScheduler_), ScheduleBackgroundApplication()).Times(1);
881     EXPECT_CALL(*(appB.mockAppScheduler_), ScheduleForegroundApplication()).Times(1);
882 
883     serviceInner_->UpdateAbilityState(tokenC, AbilityState::ABILITY_STATE_FOREGROUND);
884     serviceInner_->UpdateAbilityState(tokenB, AbilityState::ABILITY_STATE_BACKGROUND);
885     serviceInner_->ApplicationForegrounded(appB.appRecord_->GetRecordId());
886 
887     serviceInner_->UpdateAbilityState(tokenA, AbilityState::ABILITY_STATE_BACKGROUND);
888     serviceInner_->ApplicationBackgrounded(appA.appRecord_->GetRecordId());
889 
890     std::shared_ptr<AbilityRunningRecord> abilityB = appB.GetAbility(tokenB);
891     std::shared_ptr<AbilityRunningRecord> abilityC = appB.GetAbility(tokenC);
892     EXPECT_EQ(abilityC->GetAbilityInfo()->applicationName, abilityB->GetAbilityInfo()->applicationName);
893 
894     EXPECT_EQ(AbilityState::ABILITY_STATE_FOREGROUND, appB.GetAbility(tokenC)->GetState());
895     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appB.GetAbility(tokenB)->GetState());
896     EXPECT_EQ(ApplicationState::APP_STATE_FOREGROUND, appB.appRecord_->GetState());
897 
898     EXPECT_EQ(AbilityState::ABILITY_STATE_BACKGROUND, appA.GetAbility(tokenA)->GetState());
899     EXPECT_EQ(ApplicationState::APP_STATE_BACKGROUND, appA.appRecord_->GetState());
900 
901     auto abilitiesA = appA.appRecord_->GetAbilities();
902     auto abilitiesB = appB.appRecord_->GetAbilities();
903     EXPECT_NE(nullptr, abilitiesA[tokenA]);
904     EXPECT_NE(nullptr, abilitiesB[tokenB]);
905     EXPECT_NE(nullptr, abilitiesB[tokenC]);
906 }
907 }  // namespace AppExecFwk
908 }  // namespace OHOS
909