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