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