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