1 /*
2 * Copyright (c) 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 #include <gtest/gtest.h>
17 #define private public
18 #define protected public
19 #include "ability_manager_service.h"
20 #include "ability_event_handler.h"
21 #undef private
22 #undef protected
23
24 #include "app_process_data.h"
25 #include "system_ability_definition.h"
26 #include "ability_manager_errors.h"
27 #include "ability_scheduler.h"
28 #include "bundlemgr/mock_bundle_manager.h"
29 #include "sa_mgr_client.h"
30 #include "mock_ability_connect_callback.h"
31 #include "mock_ability_token.h"
32 #include "if_system_ability_manager.h"
33 #include "iservice_registry.h"
34
35 using namespace testing;
36 using namespace testing::ext;
37 using namespace OHOS::AppExecFwk;
38
39 namespace OHOS {
40 namespace AAFwk {
41 namespace {
42 const int32_t MOCK_MAIN_USER_ID = 100;
43 const int32_t MOCK_MISSION_ID = 10000;
44 const int32_t MOCK_U0_USER_ID = 0;
45 } // namespace
46
WaitUntilTaskFinished()47 static void WaitUntilTaskFinished()
48 {
49 const uint32_t maxRetryCount = 1000;
50 const uint32_t sleepTime = 1000;
51 uint32_t count = 0;
52 auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetEventHandler();
53 std::atomic<bool> taskCalled(false);
54 auto f = [&taskCalled]() { taskCalled.store(true); };
55 if (handler->PostTask(f)) {
56 while (!taskCalled.load()) {
57 ++count;
58 if (count >= maxRetryCount) {
59 break;
60 }
61 usleep(sleepTime);
62 }
63 }
64 }
65
WaitUntilTaskFinishedByTimer()66 static void WaitUntilTaskFinishedByTimer()
67 {
68 const uint32_t maxRetryCount = 1000;
69 const uint32_t sleepTime = 1000;
70 uint32_t count = 0;
71 auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetEventHandler();
72 std::atomic<bool> taskCalled(false);
73 auto f = [&taskCalled]() { taskCalled.store(true); };
74 int sleepingTime = 5000;
75 if (handler->PostTask(f, "AbilityManagerServiceTest", sleepingTime)) {
76 while (!taskCalled.load()) {
77 ++count;
78 if (count >= maxRetryCount) {
79 break;
80 }
81 usleep(sleepTime);
82 }
83 }
84 }
85
86 class AbilityTimeoutTest : public testing::Test {
87 public:
88 static void SetUpTestCase();
89 static void TearDownTestCase();
90 void SetUp();
91 void TearDown();
92 void MockOnStart();
93 static void MockOnStop();
94 static constexpr int TEST_WAIT_TIME = 100000;
95
96 public:
97 std::shared_ptr<AbilityManagerService> abilityMs_ = DelayedSingleton<AbilityManagerService>::GetInstance();
98 };
99
SetUpTestCase()100 void AbilityTimeoutTest::SetUpTestCase()
101 {
102 GTEST_LOG_(INFO) << "SetUpTestCase.";
103 }
104
TearDownTestCase()105 void AbilityTimeoutTest::TearDownTestCase()
106 {
107 MockOnStop();
108 GTEST_LOG_(INFO) << "TearDownTestCase.";
109 }
110
SetUp()111 void AbilityTimeoutTest::SetUp()
112 {
113 MockOnStart();
114 }
115
TearDown()116 void AbilityTimeoutTest::TearDown()
117 {
118 WaitUntilTaskFinishedByTimer();
119 abilityMs_->handler_->RemoveAllEvents();
120 abilityMs_->currentMissionListManager_->terminateAbilityList_.clear();
121 abilityMs_->currentMissionListManager_->launcherList_->missions_.clear();
122 abilityMs_->currentMissionListManager_->defaultStandardList_->missions_.clear();
123 abilityMs_->currentMissionListManager_->defaultSingleList_->missions_.clear();
124 abilityMs_->currentMissionListManager_->currentMissionLists_.clear();
125 abilityMs_->currentMissionListManager_->currentMissionLists_.push_front(
126 abilityMs_->currentMissionListManager_->launcherList_);
127 }
128
MockOnStart()129 void AbilityTimeoutTest::MockOnStart()
130 {
131 if (!abilityMs_) {
132 GTEST_LOG_(ERROR) << "Mock OnStart failed.";
133 return;
134 }
135 if (abilityMs_->state_ == ServiceRunningState::STATE_RUNNING) {
136 return;
137 }
138 abilityMs_->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE);
139 abilityMs_->handler_ = std::make_shared<AbilityEventHandler>(abilityMs_->eventLoop_, abilityMs_);
140 EXPECT_TRUE(abilityMs_->handler_);
141 EXPECT_TRUE(abilityMs_->eventLoop_);
142
143 // init user controller.
144 abilityMs_->userController_ = std::make_shared<UserController>();
145 EXPECT_TRUE(abilityMs_->userController_);
146 abilityMs_->userController_->Init();
147 int userId = MOCK_MAIN_USER_ID;
148
149 abilityMs_->InitConnectManager(userId, true);
150 abilityMs_->InitDataAbilityManager(userId, true);
151 abilityMs_->InitPendWantManager(userId, true);
152 abilityMs_->systemDataAbilityManager_ = std::make_shared<DataAbilityManager>();
153 EXPECT_TRUE(abilityMs_->systemDataAbilityManager_);
154
155 abilityMs_->amsConfigResolver_ = std::make_shared<AmsConfigurationParameter>();
156 EXPECT_TRUE(abilityMs_->amsConfigResolver_);
157 abilityMs_->amsConfigResolver_->Parse();
158
159 abilityMs_->InitMissionListManager(userId, true);
160 abilityMs_->SwitchManagers(MOCK_U0_USER_ID, false);
161
162 abilityMs_->state_ = ServiceRunningState::STATE_RUNNING;
163 abilityMs_->iBundleManager_ = new BundleMgrService();
164 abilityMs_->eventLoop_->Run();
165
166 WaitUntilTaskFinished();
167 }
168
MockOnStop()169 void AbilityTimeoutTest::MockOnStop()
170 {
171 WaitUntilTaskFinishedByTimer();
172 auto abilityMs_ = DelayedSingleton<AbilityManagerService>::GetInstance();
173 if (!abilityMs_) {
174 GTEST_LOG_(ERROR) << "Mock OnStart failed.";
175 return;
176 }
177
178 abilityMs_->handler_->RemoveAllEvents();
179 abilityMs_->connectManagers_.clear();
180 abilityMs_->connectManager_.reset();
181 abilityMs_->iBundleManager_.clear();
182 abilityMs_->dataAbilityManagers_.clear();
183 abilityMs_->dataAbilityManager_.reset();
184 abilityMs_->systemDataAbilityManager_.reset();
185 abilityMs_->pendingWantManagers_.clear();
186 abilityMs_->pendingWantManager_.reset();
187 abilityMs_->amsConfigResolver_.reset();
188 abilityMs_->missionListManagers_.clear();
189 abilityMs_->currentMissionListManager_.reset();
190 abilityMs_->userController_.reset();
191 abilityMs_->abilityController_.clear();
192 abilityMs_->OnStop();
193 }
194 /*
195 * Feature: AbilityManagerService
196 * Function: GetMaxRestartNum
197 * SubFunction: NA
198 * FunctionPoints: NA
199 * EnvConditions: NA
200 * CaseDescription: Verify AbilityManagerService GetMaxRestartNum success
201 */
202 HWTEST_F(AbilityTimeoutTest, GetMaxRestartNum_001, TestSize.Level1)
203 {
204 EXPECT_TRUE(abilityMs_ != nullptr);
205 EXPECT_TRUE(abilityMs_->amsConfigResolver_ != nullptr);
206
207 int maxRestart = -1;
208 abilityMs_->GetMaxRestartNum(maxRestart, true);
209
210 EXPECT_TRUE(maxRestart > -1);
211 }
212
213 /*
214 * Feature: AbilityManagerService
215 * Function: OnAbilityDied
216 * SubFunction: NA
217 * FunctionPoints: NA
218 * EnvConditions: NA
219 * CaseDescription: Verify AbilityManagerService OnAbilityDied success
220 */
221 HWTEST_F(AbilityTimeoutTest, OnAbilityDied_001, TestSize.Level1)
222 {
223 EXPECT_TRUE(abilityMs_ != nullptr);
224 EXPECT_TRUE(abilityMs_->currentMissionListManager_ != nullptr);
225 auto defList = abilityMs_->currentMissionListManager_->defaultStandardList_;
226 EXPECT_TRUE(defList != nullptr);
227
228 AbilityRequest abilityRequest;
229 abilityRequest.abilityInfo.type = AbilityType::PAGE;
230 abilityRequest.abilityInfo.name = "com.test.DiedAbility001";
231 abilityRequest.abilityInfo.bundleName = "com.test";
232 abilityRequest.appInfo.name = "com.test";
233 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
234 auto mission = std::make_shared<Mission>(MOCK_MISSION_ID, abilityRecord, abilityRequest.abilityInfo.bundleName);
235 abilityRecord->SetMission(mission);
236 abilityRecord->SetMissionList(defList);
237 abilityRecord->SetOwnerMissionUserId(MOCK_MAIN_USER_ID);
238 defList->AddMissionToTop(mission);
239 EXPECT_TRUE(defList->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
240
241 abilityMs_->OnAbilityDied(abilityRecord);
242
243 EXPECT_TRUE(defList->GetAbilityRecordByToken(abilityRecord->GetToken()) == nullptr);
244 }
245
246 /*
247 * Feature: AbilityManagerService
248 * Function: OnAbilityDied
249 * SubFunction: NA
250 * FunctionPoints: NA
251 * EnvConditions: NA
252 * CaseDescription: Verify AbilityManagerService OnAbilityDied success
253 */
254 HWTEST_F(AbilityTimeoutTest, OnAbilityDied_002, TestSize.Level1)
255 {
256 EXPECT_TRUE(abilityMs_ != nullptr);
257 EXPECT_TRUE(abilityMs_->currentMissionListManager_ != nullptr);
258 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
259 EXPECT_TRUE(lauList != nullptr);
260 EXPECT_EQ((int)(abilityMs_->currentMissionListManager_->currentMissionLists_.size()), 1);
261
262 AbilityRequest abilityRequest;
263 abilityRequest.abilityInfo.type = AbilityType::PAGE;
264 abilityRequest.abilityInfo.name = "com.test.DiedAbility002";
265 abilityRequest.abilityInfo.bundleName = "com.test";
266 abilityRequest.appInfo.isLauncherApp = true;
267 abilityRequest.appInfo.name = "com.test";
268 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
269 auto mission = std::make_shared<Mission>(MOCK_MISSION_ID, abilityRecord, abilityRequest.abilityInfo.bundleName);
270 abilityRecord->SetMission(mission);
271 abilityRecord->SetMissionList(lauList);
272 abilityRecord->SetLauncherRoot();
273 abilityRecord->SetOwnerMissionUserId(MOCK_MAIN_USER_ID);
274 lauList->AddMissionToTop(mission);
275 EXPECT_TRUE(lauList->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
276
277 abilityMs_->OnAbilityDied(abilityRecord);
278
279 EXPECT_TRUE(lauList->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
280 EXPECT_TRUE(abilityRecord->IsRestarting());
281 EXPECT_TRUE(abilityRecord->restartCount_ < abilityRecord->restartMax_);
282 }
283
284 /*
285 * Feature: AbilityManagerService
286 * Function: HandleLoadTimeOut
287 * SubFunction: NA
288 * FunctionPoints: NA
289 * EnvConditions: NA
290 * CaseDescription: Verify AbilityManagerService HandleLoadTimeOut success
291 */
292 HWTEST_F(AbilityTimeoutTest, HandleLoadTimeOut_001, TestSize.Level1)
293 {
294 EXPECT_TRUE(abilityMs_ != nullptr);
295 EXPECT_TRUE(abilityMs_->currentMissionListManager_ != nullptr);
296 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
297 EXPECT_TRUE(lauList != nullptr);
298 EXPECT_EQ((int)(abilityMs_->currentMissionListManager_->currentMissionLists_.size()), 1);
299
300 // root launcher ability load timeout
301 AbilityRequest abilityRequest;
302 abilityRequest.abilityInfo.type = AbilityType::PAGE;
303 abilityRequest.abilityInfo.name = "com.test.Timeout001";
304 abilityRequest.abilityInfo.bundleName = "com.test";
305 abilityRequest.appInfo.isLauncherApp = true;
306 abilityRequest.appInfo.name = "com.test";
307 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
308 auto mission = std::make_shared<Mission>(MOCK_MISSION_ID, abilityRecord, abilityRequest.abilityInfo.bundleName);
309 EXPECT_TRUE(mission != nullptr);
310 EXPECT_TRUE(abilityRecord != nullptr);
311 abilityRecord->SetMission(mission);
312 abilityRecord->SetMissionList(lauList);
313 abilityRecord->SetLauncherRoot();
314 abilityRecord->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
315 lauList->AddMissionToTop(mission);
316 EXPECT_TRUE(lauList->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
317
318 abilityMs_->HandleLoadTimeOut(abilityRecord->eventId_);
319
320 EXPECT_TRUE(lauList->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
321 EXPECT_TRUE(abilityRecord->IsRestarting());
322 EXPECT_TRUE(abilityRecord->restartCount_ < abilityRecord->restartMax_);
323 }
324
325 /*
326 * Feature: AbilityManagerService
327 * Function: HandleLoadTimeOut
328 * SubFunction: NA
329 * FunctionPoints: NA
330 * EnvConditions: NA
331 * CaseDescription: Verify AbilityManagerService HandleLoadTimeOut success
332 */
333 HWTEST_F(AbilityTimeoutTest, HandleLoadTimeOut_002, TestSize.Level1)
334 {
335 EXPECT_TRUE(abilityMs_ != nullptr);
336 auto curListManager = abilityMs_->currentMissionListManager_;
337 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
338 EXPECT_TRUE(curListManager != nullptr);
339 EXPECT_TRUE(lauList != nullptr);
340 EXPECT_EQ((int)(abilityMs_->currentMissionListManager_->currentMissionLists_.size()), 1);
341
342 AbilityRequest abilityRequest;
343 abilityRequest.abilityInfo.type = AbilityType::PAGE;
344 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
345 abilityRequest.abilityInfo.bundleName = "com.test";
346 abilityRequest.appInfo.isLauncherApp = true;
347 abilityRequest.appInfo.name = "com.test";
348 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
349 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
350 EXPECT_TRUE(launcher != nullptr);
351 EXPECT_TRUE(missionLauncher != nullptr);
352 launcher->SetMission(missionLauncher);
353 launcher->SetMissionList(lauList);
354 launcher->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
355 launcher->SetLauncherRoot();
356 lauList->AddMissionToTop(missionLauncher);
357 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
358
359 // common ability load timeout
360 abilityRequest.appInfo.isLauncherApp = false;
361 abilityRequest.abilityInfo.name = "com.test.Timeout002";
362 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
363 auto mission = std::make_shared<Mission>(MOCK_MISSION_ID, abilityRecord, abilityRequest.abilityInfo.bundleName);
364 EXPECT_TRUE(mission != nullptr);
365 EXPECT_TRUE(abilityRecord != nullptr);
366
367 abilityRecord->SetMission(mission);
368 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
369 abilityRecord->SetMissionList(missionList);
370 abilityRecord->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
371 missionList->AddMissionToTop(mission);
372 curListManager->MoveMissionListToTop(missionList);
373 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
374
375 abilityMs_->HandleLoadTimeOut(abilityRecord->eventId_);
376
377 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) == nullptr);
378 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
379 EXPECT_EQ(launcher, topAbility);
380 }
381
382 /*
383 * Feature: AbilityManagerService
384 * Function: HandleLoadTimeOut
385 * SubFunction: NA
386 * FunctionPoints: NA
387 * EnvConditions: NA
388 * CaseDescription: Verify AbilityManagerService HandleLoadTimeOut success
389 */
390 HWTEST_F(AbilityTimeoutTest, HandleLoadTimeOut_003, TestSize.Level1)
391 {
392 EXPECT_TRUE(abilityMs_ != nullptr);
393 auto curListManager = abilityMs_->currentMissionListManager_;
394 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
395 EXPECT_TRUE(curListManager != nullptr);
396 EXPECT_TRUE(lauList != nullptr);
397 EXPECT_EQ((int)(abilityMs_->currentMissionListManager_->currentMissionLists_.size()), 1);
398 AbilityRequest abilityRequest;
399 abilityRequest.abilityInfo.type = AbilityType::PAGE;
400 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
401 abilityRequest.abilityInfo.bundleName = "com.test";
402 abilityRequest.appInfo.isLauncherApp = true;
403 abilityRequest.appInfo.name = "com.test";
404 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
405 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
406 launcher->SetMission(missionLauncher);
407 launcher->SetMissionList(lauList);
408 launcher->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
409 launcher->SetLauncherRoot();
410 lauList->AddMissionToTop(missionLauncher);
411 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
412 // common ability by caller
413 abilityRequest.appInfo.isLauncherApp = false;
414 abilityRequest.abilityInfo.name = "com.test.caller";
415 auto caller = AbilityRecord::CreateAbilityRecord(abilityRequest);
416 auto callerMission = std::make_shared<Mission>(MOCK_MISSION_ID + 1, caller, abilityRequest.abilityInfo.bundleName);
417 EXPECT_TRUE(caller != nullptr);
418 EXPECT_TRUE(callerMission != nullptr);
419 caller->SetMission(callerMission);
420 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
421 caller->SetMissionList(missionList);
422 caller->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
423 missionList->AddMissionToTop(callerMission);
424 curListManager->MoveMissionListToTop(missionList);
425 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(caller->GetToken()) != nullptr);
426 // common ability load timeout
427 abilityRequest.abilityInfo.name = "com.test.Timeout003";
428 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
429 auto mission =
430 std::make_shared<Mission>(MOCK_MISSION_ID + 2, abilityRecord, abilityRequest.abilityInfo.bundleName);
431 EXPECT_TRUE(abilityRecord != nullptr);
432 EXPECT_TRUE(mission != nullptr);
433 abilityRecord->SetMission(mission);
434 abilityRecord->SetMissionList(missionList);
435 abilityRecord->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
436 abilityRecord->AddCallerRecord(caller->GetToken(), -1);
437 missionList->AddMissionToTop(mission);
438 curListManager->MoveMissionListToTop(missionList);
439 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
440 EXPECT_EQ(abilityRecord->GetCallerRecord(), caller);
441 abilityMs_->HandleLoadTimeOut(abilityRecord->eventId_);
442 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) == nullptr);
443 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
444 EXPECT_EQ(caller, topAbility);
445 }
446
447 /*
448 * Feature: AbilityManagerService
449 * Function: HandleLoadTimeOut
450 * SubFunction: NA
451 * FunctionPoints: NA
452 * EnvConditions: NA
453 * CaseDescription: Verify AbilityManagerService HandleLoadTimeOut success
454 */
455 HWTEST_F(AbilityTimeoutTest, HandleLoadTimeOut_004, TestSize.Level1)
456 {
457 EXPECT_TRUE(abilityMs_ != nullptr);
458 auto curListManager = abilityMs_->currentMissionListManager_;
459 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
460
461 EXPECT_TRUE(curListManager != nullptr);
462 EXPECT_TRUE(lauList != nullptr);
463
464 AbilityRequest abilityRequest;
465 abilityRequest.abilityInfo.type = AbilityType::PAGE;
466 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
467 abilityRequest.abilityInfo.bundleName = "com.test";
468 abilityRequest.appInfo.isLauncherApp = true;
469 abilityRequest.appInfo.name = "com.test";
470 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
471 EXPECT_TRUE(launcher != nullptr);
472 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
473 EXPECT_TRUE(missionLauncher != nullptr);
474 launcher->SetMission(missionLauncher);
475 launcher->SetMissionList(lauList);
476 launcher->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
477 launcher->SetLauncherRoot();
478 lauList->AddMissionToTop(missionLauncher);
479 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
480
481 // common ability by caller with service ability type
482 abilityRequest.appInfo.isLauncherApp = false;
483 abilityRequest.abilityInfo.name = "com.test.caller";
484 abilityRequest.abilityInfo.type = AbilityType::SERVICE;
485 auto caller = AbilityRecord::CreateAbilityRecord(abilityRequest);
486 EXPECT_TRUE(caller != nullptr);
487
488 // common ability load timeout
489 abilityRequest.abilityInfo.type = AbilityType::PAGE;
490 abilityRequest.abilityInfo.name = "com.test.Timeout004";
491 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
492 EXPECT_TRUE(launcher != nullptr);
493 auto mission = std::make_shared<Mission>(MOCK_MISSION_ID, abilityRecord, abilityRequest.abilityInfo.bundleName);
494 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
495 EXPECT_TRUE(mission != nullptr);
496 EXPECT_TRUE(missionList != nullptr);
497 abilityRecord->SetMission(mission);
498 abilityRecord->SetMissionList(missionList);
499 abilityRecord->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
500 abilityRecord->AddCallerRecord(caller->GetToken(), -1);
501 missionList->AddMissionToTop(mission);
502 curListManager->MoveMissionListToTop(missionList);
503 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
504 EXPECT_EQ(abilityRecord->GetCallerRecord(), caller);
505
506 abilityMs_->HandleLoadTimeOut(abilityRecord->eventId_);
507 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) == nullptr);
508 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
509 EXPECT_EQ(launcher, topAbility);
510 }
511
512 /*
513 * Feature: AbilityManagerService
514 * Function: HandleLoadTimeOut
515 * SubFunction: NA
516 * FunctionPoints: NA
517 * EnvConditions: NA
518 * CaseDescription: Verify AbilityManagerService HandleLoadTimeOut success
519 */
520 HWTEST_F(AbilityTimeoutTest, HandleLoadTimeOut_005, TestSize.Level1)
521 {
522 EXPECT_TRUE(abilityMs_ != nullptr);
523 auto curListManager = abilityMs_->currentMissionListManager_;
524 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
525
526 EXPECT_TRUE(curListManager != nullptr);
527 EXPECT_TRUE(lauList != nullptr);
528
529 AbilityRequest abilityRequest;
530 abilityRequest.abilityInfo.type = AbilityType::PAGE;
531 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
532 abilityRequest.abilityInfo.bundleName = "com.test";
533 abilityRequest.appInfo.isLauncherApp = true;
534 abilityRequest.appInfo.name = "com.test";
535 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
536 EXPECT_TRUE(launcher != nullptr);
537 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
538 EXPECT_TRUE(missionLauncher != nullptr);
539 launcher->SetMission(missionLauncher);
540 launcher->SetMissionList(lauList);
541 launcher->SetLauncherRoot();
542 lauList->AddMissionToTop(missionLauncher);
543 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
544
545 // common ability by caller with extension ability type
546 abilityRequest.appInfo.isLauncherApp = false;
547 abilityRequest.abilityInfo.type = AbilityType::EXTENSION;
548 abilityRequest.abilityInfo.name = "com.test.caller";
549 auto caller = AbilityRecord::CreateAbilityRecord(abilityRequest);
550 EXPECT_TRUE(caller != nullptr);
551
552 // common ability load timeout
553 abilityRequest.abilityInfo.type = AbilityType::PAGE;
554 abilityRequest.abilityInfo.name = "com.test.Timeout005";
555 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
556 EXPECT_TRUE(launcher != nullptr);
557 auto mission = std::make_shared<Mission>(MOCK_MISSION_ID, abilityRecord, abilityRequest.abilityInfo.bundleName);
558 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
559 EXPECT_TRUE(mission != nullptr);
560 EXPECT_TRUE(missionList != nullptr);
561 abilityRecord->SetMission(mission);
562 abilityRecord->SetMissionList(missionList);
563 abilityRecord->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
564 abilityRecord->AddCallerRecord(caller->GetToken(), -1);
565 missionList->AddMissionToTop(mission);
566 curListManager->MoveMissionListToTop(missionList);
567 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
568 EXPECT_EQ(abilityRecord->GetCallerRecord(), caller);
569
570 abilityMs_->HandleLoadTimeOut(abilityRecord->eventId_);
571 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) == nullptr);
572 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
573 EXPECT_EQ(launcher, topAbility);
574 }
575
576 /*
577 * Feature: AbilityManagerService
578 * Function: HandleLoadTimeOut
579 * SubFunction: NA
580 * FunctionPoints: NA
581 * EnvConditions: NA
582 * CaseDescription: Verify AbilityManagerService HandleLoadTimeOut success
583 */
584 HWTEST_F(AbilityTimeoutTest, HandleLoadTimeOut_006, TestSize.Level1)
585 {
586 EXPECT_TRUE(abilityMs_ != nullptr);
587 auto curListManager = abilityMs_->currentMissionListManager_;
588 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
589
590 EXPECT_TRUE(curListManager != nullptr);
591 EXPECT_TRUE(lauList != nullptr);
592
593 AbilityRequest abilityRequest;
594 abilityRequest.abilityInfo.type = AbilityType::PAGE;
595 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
596 abilityRequest.abilityInfo.bundleName = "com.test";
597 abilityRequest.appInfo.isLauncherApp = true;
598 abilityRequest.appInfo.name = "com.test";
599 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
600 EXPECT_TRUE(launcher != nullptr);
601 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
602 EXPECT_TRUE(missionLauncher != nullptr);
603 launcher->SetMission(missionLauncher);
604 launcher->SetMissionList(lauList);
605 launcher->SetLauncherRoot();
606 lauList->AddMissionToTop(missionLauncher);
607 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
608
609 // common ability by caller as launcher type
610 auto caller = AbilityRecord::CreateAbilityRecord(abilityRequest);
611 EXPECT_TRUE(caller != nullptr);
612
613 // common ability load timeout
614 abilityRequest.abilityInfo.type = AbilityType::PAGE;
615 abilityRequest.appInfo.isLauncherApp = false;
616 abilityRequest.appInfo.name = "com.test.Timeout006";
617 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
618 EXPECT_TRUE(launcher != nullptr);
619 auto mission = std::make_shared<Mission>(MOCK_MISSION_ID, abilityRecord, abilityRequest.abilityInfo.bundleName);
620 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
621 EXPECT_TRUE(mission != nullptr);
622 EXPECT_TRUE(missionList != nullptr);
623 abilityRecord->SetMission(mission);
624 abilityRecord->SetMissionList(missionList);
625 abilityRecord->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
626 abilityRecord->AddCallerRecord(caller->GetToken(), -1);
627 missionList->AddMissionToTop(mission);
628 curListManager->MoveMissionListToTop(missionList);
629 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
630 EXPECT_EQ(abilityRecord->GetCallerRecord(), caller);
631
632 abilityMs_->HandleLoadTimeOut(abilityRecord->eventId_);
633 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) == nullptr);
634 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
635 EXPECT_EQ(launcher, topAbility);
636 }
637
638 /*
639 * Feature: AbilityManagerService
640 * Function: HandleLoadTimeOut
641 * SubFunction: NA
642 * FunctionPoints: NA
643 * EnvConditions: NA
644 * CaseDescription: Verify AbilityManagerService HandleLoadTimeOut success
645 */
646 HWTEST_F(AbilityTimeoutTest, HandleLoadTimeOut_007, TestSize.Level1)
647 {
648 EXPECT_TRUE(abilityMs_ != nullptr);
649 auto curListManager = abilityMs_->currentMissionListManager_;
650 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
651
652 EXPECT_TRUE(curListManager != nullptr);
653 EXPECT_TRUE(lauList != nullptr);
654
655 AbilityRequest abilityRequest;
656 abilityRequest.abilityInfo.type = AbilityType::PAGE;
657 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
658 abilityRequest.abilityInfo.bundleName = "com.test";
659 abilityRequest.appInfo.isLauncherApp = true;
660 abilityRequest.appInfo.name = "com.test";
661 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
662 EXPECT_TRUE(launcher != nullptr);
663 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
664 EXPECT_TRUE(missionLauncher != nullptr);
665 launcher->SetMission(missionLauncher);
666 launcher->SetMissionList(lauList);
667 launcher->SetLauncherRoot();
668 lauList->AddMissionToTop(missionLauncher);
669 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
670
671 // common ability by caller
672 abilityRequest.appInfo.isLauncherApp = false;
673 abilityRequest.abilityInfo.name = "com.test.caller";
674 auto caller = AbilityRecord::CreateAbilityRecord(abilityRequest);
675 EXPECT_TRUE(caller != nullptr);
676
677 // common launcher ability load timeout
678 abilityRequest.abilityInfo.type = AbilityType::PAGE;
679 abilityRequest.appInfo.isLauncherApp = true;
680 abilityRequest.abilityInfo.name = "com.test.Timeout007";
681 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
682 EXPECT_TRUE(launcher != nullptr);
683 auto mission = std::make_shared<Mission>(MOCK_MISSION_ID, abilityRecord, abilityRequest.abilityInfo.bundleName);
684 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
685 EXPECT_TRUE(mission != nullptr);
686 EXPECT_TRUE(missionList != nullptr);
687 abilityRecord->SetMission(mission);
688 abilityRecord->SetMissionList(missionList);
689 abilityRecord->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
690 abilityRecord->AddCallerRecord(caller->GetToken(), -1);
691 missionList->AddMissionToTop(mission);
692 curListManager->MoveMissionListToTop(missionList);
693 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) != nullptr);
694 EXPECT_EQ(abilityRecord->GetCallerRecord(), caller);
695
696 abilityMs_->HandleLoadTimeOut(abilityRecord->eventId_);
697 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(abilityRecord->GetToken()) == nullptr);
698 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
699 EXPECT_EQ(launcher, topAbility);
700 }
701
702 /*
703 * Feature: AbilityManagerService
704 * Function: HandleForgroundNewTimeout
705 * SubFunction: NA
706 * FunctionPoints: NA
707 * EnvConditions: NA
708 * CaseDescription: Verify AbilityManagerService HandleForgroundNewTimeout success
709 */
710 HWTEST_F(AbilityTimeoutTest, HandleForgroundNewTimeout_001, TestSize.Level1)
711 {
712 EXPECT_TRUE(abilityMs_ != nullptr);
713 auto curListManager = abilityMs_->currentMissionListManager_;
714 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
715
716 EXPECT_TRUE(curListManager != nullptr);
717 EXPECT_TRUE(lauList != nullptr);
718
719 AbilityRequest abilityRequest;
720 abilityRequest.abilityInfo.type = AbilityType::PAGE;
721 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
722 abilityRequest.abilityInfo.bundleName = "com.test";
723 abilityRequest.appInfo.isLauncherApp = true;
724 abilityRequest.appInfo.name = "com.test";
725 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
726 EXPECT_TRUE(launcher != nullptr);
727 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
728 EXPECT_TRUE(missionLauncher != nullptr);
729 launcher->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
730 launcher->SetMission(missionLauncher);
731 launcher->SetMissionList(lauList);
732 launcher->SetLauncherRoot();
733 lauList->AddMissionToTop(missionLauncher);
734 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
735
736 // test root launcher foreground timeout.
737 launcher->SetAbilityState(AbilityState::FOREGROUNDING);
738 abilityMs_->HandleForegroundTimeOut(launcher->eventId_);
739 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
740 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
741 EXPECT_EQ(launcher, topAbility);
742 }
743
744 /*
745 * Feature: AbilityManagerService
746 * Function: HandleForgroundNewTimeout
747 * SubFunction: NA
748 * FunctionPoints: NA
749 * EnvConditions: NA
750 * CaseDescription: Verify AbilityManagerService HandleForgroundNewTimeout success
751 */
752 HWTEST_F(AbilityTimeoutTest, HandleForgroundNewTimeout_002, TestSize.Level1)
753 {
754 EXPECT_TRUE(abilityMs_ != nullptr);
755 auto curListManager = abilityMs_->currentMissionListManager_;
756 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
757
758 EXPECT_TRUE(curListManager != nullptr);
759 EXPECT_TRUE(lauList != nullptr);
760
761 AbilityRequest abilityRequest;
762 abilityRequest.abilityInfo.type = AbilityType::PAGE;
763 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
764 abilityRequest.abilityInfo.bundleName = "com.test";
765 abilityRequest.appInfo.isLauncherApp = true;
766 abilityRequest.appInfo.name = "com.test";
767 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
768 EXPECT_TRUE(launcher != nullptr);
769 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
770 EXPECT_TRUE(missionLauncher != nullptr);
771 launcher->SetMission(missionLauncher);
772 launcher->SetMissionList(lauList);
773 launcher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
774 launcher->SetLauncherRoot();
775 lauList->AddMissionToTop(missionLauncher);
776 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
777
778 // common launcher ability timeout
779 abilityRequest.abilityInfo.name = "com.test.TimeoutForeground002";
780 auto commonLauncher = AbilityRecord::CreateAbilityRecord(abilityRequest);
781 EXPECT_TRUE(commonLauncher != nullptr);
782 auto commonMissionLauncher =
783 std::make_shared<Mission>(MOCK_MISSION_ID, commonLauncher, abilityRequest.abilityInfo.bundleName);
784 EXPECT_TRUE(commonMissionLauncher != nullptr);
785 commonLauncher->SetMission(commonMissionLauncher);
786 commonLauncher->SetMissionList(lauList);
787 commonLauncher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
788 lauList->AddMissionToTop(commonMissionLauncher);
789 commonLauncher->SetAbilityState(AbilityState::FOREGROUNDING);
790 EXPECT_TRUE(lauList->GetAbilityRecordByToken(commonLauncher->GetToken()) != nullptr);
791
792 // test common launcher foreground timeout.
793 abilityMs_->HandleForegroundTimeOut(commonLauncher->eventId_);
794
795 EXPECT_TRUE(lauList->GetAbilityRecordByToken(commonLauncher->GetToken()) == nullptr);
796 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
797 EXPECT_EQ(launcher, topAbility);
798 }
799
800 /*
801 * Feature: AbilityManagerService
802 * Function: HandleForgroundNewTimeout
803 * SubFunction: NA
804 * FunctionPoints: NA
805 * EnvConditions: NA
806 * CaseDescription: Verify AbilityManagerService HandleForgroundNewTimeout success
807 */
808 HWTEST_F(AbilityTimeoutTest, HandleForgroundNewTimeout_003, TestSize.Level1)
809 {
810 EXPECT_TRUE(abilityMs_ != nullptr);
811 auto curListManager = abilityMs_->currentMissionListManager_;
812 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
813 EXPECT_TRUE(curListManager != nullptr);
814 EXPECT_TRUE(lauList != nullptr);
815 AbilityRequest abilityRequest;
816 abilityRequest.abilityInfo.type = AbilityType::PAGE;
817 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
818 abilityRequest.abilityInfo.bundleName = "com.test";
819 abilityRequest.appInfo.isLauncherApp = true;
820 abilityRequest.appInfo.name = "com.test";
821 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
822 EXPECT_TRUE(launcher != nullptr);
823 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
824 EXPECT_TRUE(missionLauncher != nullptr);
825 launcher->SetMission(missionLauncher);
826 launcher->SetMissionList(lauList);
827 launcher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
828 launcher->SetLauncherRoot();
829 lauList->AddMissionToTop(missionLauncher);
830 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
831 // common ability by caller
832 abilityRequest.appInfo.isLauncherApp = false;
833 abilityRequest.abilityInfo.name = "com.test.caller";
834 auto caller = AbilityRecord::CreateAbilityRecord(abilityRequest);
835 auto callerMission = std::make_shared<Mission>(MOCK_MISSION_ID + 1, caller, abilityRequest.abilityInfo.bundleName);
836 EXPECT_TRUE(caller != nullptr);
837 EXPECT_TRUE(callerMission != nullptr);
838 caller->SetMission(callerMission);
839 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
840 caller->SetMissionList(missionList);
841 caller->eventId_ = (AbilityRecord::g_abilityRecordEventId_++);
842 missionList->AddMissionToTop(callerMission);
843 curListManager->MoveMissionListToTop(missionList);
844 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(caller->GetToken()) != nullptr);
845 // common ability timeout
846 abilityRequest.abilityInfo.name = "com.test.TimeoutForeground003";
847 auto commonLauncher = AbilityRecord::CreateAbilityRecord(abilityRequest);
848 EXPECT_TRUE(commonLauncher != nullptr);
849 auto commonMissionLauncher =
850 std::make_shared<Mission>(MOCK_MISSION_ID + 2, commonLauncher, abilityRequest.abilityInfo.bundleName);
851 EXPECT_TRUE(commonMissionLauncher != nullptr);
852 commonLauncher->SetMission(commonMissionLauncher);
853 commonLauncher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
854 commonLauncher->AddCallerRecord(caller->GetToken(), -1);
855 missionList->AddMissionToTop(commonMissionLauncher);
856 curListManager->MoveMissionListToTop(missionList);
857 commonLauncher->SetAbilityState(AbilityState::FOREGROUNDING);
858 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonLauncher->GetToken()) != nullptr);
859 // test common launcher foreground timeout.
860 abilityMs_->HandleForegroundTimeOut(commonLauncher->eventId_);
861 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonLauncher->GetToken()) != nullptr);
862 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
863 EXPECT_EQ(caller, topAbility);
864 }
865
866 /*
867 * Feature: AbilityManagerService
868 * Function: HandleForgroundNewTimeout
869 * SubFunction: NA
870 * FunctionPoints: NA
871 * EnvConditions: NA
872 * CaseDescription: Verify AbilityManagerService HandleForgroundNewTimeout success
873 */
874 HWTEST_F(AbilityTimeoutTest, HandleForgroundNewTimeout_004, TestSize.Level1)
875 {
876 EXPECT_TRUE(abilityMs_ != nullptr);
877 auto curListManager = abilityMs_->currentMissionListManager_;
878 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
879
880 EXPECT_TRUE(curListManager != nullptr);
881 EXPECT_TRUE(lauList != nullptr);
882
883 AbilityRequest abilityRequest;
884 abilityRequest.abilityInfo.type = AbilityType::PAGE;
885 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
886 abilityRequest.abilityInfo.bundleName = "com.test";
887 abilityRequest.appInfo.isLauncherApp = true;
888 abilityRequest.appInfo.name = "com.test";
889 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
890 EXPECT_TRUE(launcher != nullptr);
891 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
892 EXPECT_TRUE(missionLauncher != nullptr);
893 launcher->SetMission(missionLauncher);
894 launcher->SetMissionList(lauList);
895 launcher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
896 launcher->SetLauncherRoot();
897 lauList->AddMissionToTop(missionLauncher);
898 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
899
900 // common ability by caller (launcher type)
901 abilityRequest.appInfo.isLauncherApp = true;
902 abilityRequest.abilityInfo.name = "com.test.caller";
903 auto caller = AbilityRecord::CreateAbilityRecord(abilityRequest);
904 EXPECT_TRUE(caller != nullptr);
905
906 // common ability timeout
907 abilityRequest.appInfo.isLauncherApp = false;
908 abilityRequest.abilityInfo.name = "com.test.TimeoutForeground004";
909 auto commonLauncher = AbilityRecord::CreateAbilityRecord(abilityRequest);
910 EXPECT_TRUE(commonLauncher != nullptr);
911 auto commonMissionLauncher =
912 std::make_shared<Mission>(MOCK_MISSION_ID, commonLauncher, abilityRequest.abilityInfo.bundleName);
913 EXPECT_TRUE(commonMissionLauncher != nullptr);
914 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
915 commonLauncher->SetMissionList(missionList);
916 commonLauncher->SetMission(commonMissionLauncher);
917 commonLauncher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
918 commonLauncher->AddCallerRecord(caller->GetToken(), -1);
919 missionList->AddMissionToTop(commonMissionLauncher);
920 curListManager->MoveMissionListToTop(missionList);
921 commonLauncher->SetAbilityState(AbilityState::FOREGROUNDING);
922 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonLauncher->GetToken()) != nullptr);
923
924 // test common launcher foreground timeout.
925 abilityMs_->HandleForegroundTimeOut(commonLauncher->eventId_);
926
927 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonLauncher->GetToken()) != nullptr);
928 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
929 EXPECT_EQ(launcher, topAbility);
930 }
931
932 /*
933 * Feature: AbilityManagerService
934 * Function: HandleForgroundNewTimeout
935 * SubFunction: NA
936 * FunctionPoints: NA
937 * EnvConditions: NA
938 * CaseDescription: Verify AbilityManagerService HandleForgroundNewTimeout success
939 */
940 HWTEST_F(AbilityTimeoutTest, HandleForgroundNewTimeout_005, TestSize.Level1)
941 {
942 EXPECT_TRUE(abilityMs_ != nullptr);
943 auto curListManager = abilityMs_->currentMissionListManager_;
944 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
945
946 EXPECT_TRUE(curListManager != nullptr);
947 EXPECT_TRUE(lauList != nullptr);
948
949 AbilityRequest abilityRequest;
950 abilityRequest.abilityInfo.type = AbilityType::PAGE;
951 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
952 abilityRequest.abilityInfo.bundleName = "com.test";
953 abilityRequest.appInfo.isLauncherApp = true;
954 abilityRequest.appInfo.name = "com.test";
955 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
956 EXPECT_TRUE(launcher != nullptr);
957 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
958 EXPECT_TRUE(missionLauncher != nullptr);
959 launcher->SetMission(missionLauncher);
960 launcher->SetMissionList(lauList);
961 launcher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
962 launcher->SetLauncherRoot();
963 lauList->AddMissionToTop(missionLauncher);
964 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
965
966 // common ability by service ability
967 abilityRequest.appInfo.isLauncherApp = false;
968 abilityRequest.abilityInfo.type = AbilityType::SERVICE;
969 abilityRequest.abilityInfo.name = "com.test.caller";
970 auto caller = AbilityRecord::CreateAbilityRecord(abilityRequest);
971 EXPECT_TRUE(caller != nullptr);
972
973 // common ability timeout
974 abilityRequest.appInfo.isLauncherApp = false;
975 abilityRequest.abilityInfo.name = "com.test.TimeoutForeground005";
976 auto commonLauncher = AbilityRecord::CreateAbilityRecord(abilityRequest);
977 EXPECT_TRUE(commonLauncher != nullptr);
978 auto commonMissionLauncher =
979 std::make_shared<Mission>(MOCK_MISSION_ID, commonLauncher, abilityRequest.abilityInfo.bundleName);
980 EXPECT_TRUE(commonMissionLauncher != nullptr);
981 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
982 commonLauncher->SetMissionList(missionList);
983 commonLauncher->SetMission(commonMissionLauncher);
984 commonLauncher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
985 commonLauncher->AddCallerRecord(caller->GetToken(), -1);
986 missionList->AddMissionToTop(commonMissionLauncher);
987 curListManager->MoveMissionListToTop(missionList);
988 commonLauncher->SetAbilityState(AbilityState::FOREGROUNDING);
989 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonLauncher->GetToken()) != nullptr);
990
991 // test common launcher foreground timeout.
992 abilityMs_->HandleForegroundTimeOut(commonLauncher->eventId_);
993
994 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonLauncher->GetToken()) != nullptr);
995 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
996 EXPECT_EQ(launcher, topAbility);
997 }
998
999 /*
1000 * Feature: AbilityManagerService
1001 * Function: HandleForgroundNewTimeout
1002 * SubFunction: NA
1003 * FunctionPoints: NA
1004 * EnvConditions: NA
1005 * CaseDescription: Verify AbilityManagerService HandleForgroundNewTimeout success
1006 */
1007 HWTEST_F(AbilityTimeoutTest, HandleForgroundNewTimeout_006, TestSize.Level1)
1008 {
1009 EXPECT_TRUE(abilityMs_ != nullptr);
1010 auto curListManager = abilityMs_->currentMissionListManager_;
1011 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
1012
1013 EXPECT_TRUE(curListManager != nullptr);
1014 EXPECT_TRUE(lauList != nullptr);
1015
1016 AbilityRequest abilityRequest;
1017 abilityRequest.abilityInfo.type = AbilityType::PAGE;
1018 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
1019 abilityRequest.abilityInfo.bundleName = "com.test";
1020 abilityRequest.appInfo.isLauncherApp = true;
1021 abilityRequest.appInfo.name = "com.test";
1022 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
1023 EXPECT_TRUE(launcher != nullptr);
1024 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
1025 EXPECT_TRUE(missionLauncher != nullptr);
1026 launcher->SetMission(missionLauncher);
1027 launcher->SetMissionList(lauList);
1028 launcher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
1029 launcher->SetLauncherRoot();
1030 lauList->AddMissionToTop(missionLauncher);
1031 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
1032
1033 // common ability by service ability
1034 abilityRequest.appInfo.isLauncherApp = false;
1035 abilityRequest.abilityInfo.type = AbilityType::EXTENSION;
1036 abilityRequest.abilityInfo.name = "com.test.caller";
1037 auto caller = AbilityRecord::CreateAbilityRecord(abilityRequest);
1038 EXPECT_TRUE(caller != nullptr);
1039
1040 // common ability timeout
1041 abilityRequest.appInfo.isLauncherApp = false;
1042 abilityRequest.abilityInfo.name = "com.test.TimeoutForeground006";
1043 auto commonAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
1044 EXPECT_TRUE(commonAbility != nullptr);
1045 auto commonMissionLauncher =
1046 std::make_shared<Mission>(MOCK_MISSION_ID, commonAbility, abilityRequest.abilityInfo.bundleName);
1047 EXPECT_TRUE(commonMissionLauncher != nullptr);
1048 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
1049 commonAbility->SetMissionList(missionList);
1050 commonAbility->SetMission(commonMissionLauncher);
1051 commonAbility->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
1052 commonAbility->AddCallerRecord(caller->GetToken(), -1);
1053 missionList->AddMissionToTop(commonMissionLauncher);
1054 curListManager->MoveMissionListToTop(missionList);
1055 commonAbility->SetAbilityState(AbilityState::FOREGROUNDING);
1056 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonAbility->GetToken()) != nullptr);
1057
1058 // test common ability foreground timeout.
1059 abilityMs_->HandleForegroundTimeOut(commonAbility->eventId_);
1060
1061 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonAbility->GetToken()) != nullptr);
1062 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
1063 EXPECT_EQ(launcher, topAbility);
1064 }
1065
1066 /*
1067 * Feature: AbilityManagerService
1068 * Function: HandleForgroundNewTimeout
1069 * SubFunction: NA
1070 * FunctionPoints: NA
1071 * EnvConditions: NA
1072 * CaseDescription: Verify AbilityManagerService HandleForgroundNewTimeout success
1073 */
1074 HWTEST_F(AbilityTimeoutTest, HandleForgroundNewTimeout_007, TestSize.Level1)
1075 {
1076 EXPECT_TRUE(abilityMs_ != nullptr);
1077 auto curListManager = abilityMs_->currentMissionListManager_;
1078 auto lauList = abilityMs_->currentMissionListManager_->launcherList_;
1079
1080 EXPECT_TRUE(curListManager != nullptr);
1081 EXPECT_TRUE(lauList != nullptr);
1082
1083 AbilityRequest abilityRequest;
1084 abilityRequest.abilityInfo.type = AbilityType::PAGE;
1085 abilityRequest.abilityInfo.name = "com.test.rootLauncher";
1086 abilityRequest.abilityInfo.bundleName = "com.test";
1087 abilityRequest.appInfo.isLauncherApp = true;
1088 abilityRequest.appInfo.name = "com.test";
1089 auto launcher = AbilityRecord::CreateAbilityRecord(abilityRequest);
1090 EXPECT_TRUE(launcher != nullptr);
1091 auto missionLauncher = std::make_shared<Mission>(MOCK_MISSION_ID, launcher, abilityRequest.abilityInfo.bundleName);
1092 EXPECT_TRUE(missionLauncher != nullptr);
1093 launcher->SetMission(missionLauncher);
1094 launcher->SetMissionList(lauList);
1095 launcher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
1096 launcher->SetLauncherRoot();
1097 lauList->AddMissionToTop(missionLauncher);
1098 EXPECT_TRUE(lauList->GetAbilityRecordByToken(launcher->GetToken()) != nullptr);
1099
1100 // common ability timeout without caller
1101 abilityRequest.abilityInfo.name = "com.test.TimeoutForeground007";
1102 auto commonLauncher = AbilityRecord::CreateAbilityRecord(abilityRequest);
1103 EXPECT_TRUE(commonLauncher != nullptr);
1104 auto commonMissionLauncher =
1105 std::make_shared<Mission>(MOCK_MISSION_ID, commonLauncher, abilityRequest.abilityInfo.bundleName);
1106 EXPECT_TRUE(commonMissionLauncher != nullptr);
1107 auto missionList = std::make_shared<MissionList>(MissionListType::CURRENT);
1108 commonLauncher->SetMissionList(missionList);
1109 commonLauncher->SetMission(commonMissionLauncher);
1110 commonLauncher->eventId_ = AbilityRecord::g_abilityRecordEventId_++;
1111 missionList->AddMissionToTop(commonMissionLauncher);
1112 curListManager->MoveMissionListToTop(missionList);
1113 commonLauncher->SetAbilityState(AbilityState::FOREGROUNDING);
1114 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonLauncher->GetToken()) != nullptr);
1115
1116 // test common launcher foreground timeout.
1117 abilityMs_->HandleForegroundTimeOut(commonLauncher->eventId_);
1118
1119 EXPECT_TRUE(curListManager->GetAbilityRecordByToken(commonLauncher->GetToken()) != nullptr);
1120 auto topAbility = curListManager->GetCurrentTopAbilityLocked();
1121 EXPECT_EQ(launcher, topAbility);
1122 }
1123 } // namespace AAFwk
1124 } // namespace OHOS
1125