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