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