1 /*
2 * Copyright (c) 2023 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
18 #include "ability_manager_errors.h"
19 #define private public
20 #define protected public
21 #include "ability_record.h"
22 #include "ability_start_setting.h"
23 #include "app_scheduler.h"
24 #include "app_utils.h"
25 #include "scene_board/ui_ability_lifecycle_manager.h"
26 #undef protected
27 #undef private
28 #include "app_mgr_client.h"
29 #include "mock_ability_info_callback_stub.h"
30 #include "process_options.h"
31 #include "session/host/include/session.h"
32 #include "session_info.h"
33 #include "startup_util.h"
34 #include "ability_manager_service.h"
35 #include "ability_scheduler_mock.h"
36
37 using namespace testing;
38 using namespace testing::ext;
39
40 namespace OHOS {
41 namespace AAFwk {
42 namespace {
43 #ifdef WITH_DLP
44 const std::string DLP_INDEX = "ohos.dlp.params.index";
45 #endif // WITH_DLP
46 constexpr int32_t TEST_UID = 20010001;
47 };
48 class UIAbilityLifecycleManagerTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp() override;
53 void TearDown() override;
54 std::shared_ptr<AbilityRecord> InitAbilityRecord();
55 };
56
SetUpTestCase()57 void UIAbilityLifecycleManagerTest::SetUpTestCase() {}
58
TearDownTestCase()59 void UIAbilityLifecycleManagerTest::TearDownTestCase() {}
60
SetUp()61 void UIAbilityLifecycleManagerTest::SetUp() {}
62
TearDown()63 void UIAbilityLifecycleManagerTest::TearDown() {}
64
65 class UIAbilityLifcecycleManagerTestStub : public IRemoteStub<IAbilityConnection> {
66 public:
UIAbilityLifcecycleManagerTestStub()67 UIAbilityLifcecycleManagerTestStub() {};
~UIAbilityLifcecycleManagerTestStub()68 virtual ~UIAbilityLifcecycleManagerTestStub() {};
69
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)70 virtual int OnRemoteRequest(
71 uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
72 {
73 return 0;
74 };
75
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int resultCode)76 virtual void OnAbilityConnectDone(
77 const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& remoteObject, int resultCode) {};
78
79 /**
80 * OnAbilityDisconnectDone, AbilityMs notify caller ability the result of disconnect.
81 *
82 * @param element, service ability's ElementName.
83 * @param resultCode, ERR_OK on success, others on failure.
84 */
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int resultCode)85 virtual void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode) {};
86 };
87
InitAbilityRecord()88 std::shared_ptr<AbilityRecord> UIAbilityLifecycleManagerTest::InitAbilityRecord()
89 {
90 AbilityRequest abilityRequest;
91 abilityRequest.appInfo.bundleName = "com.example.unittest";
92 abilityRequest.abilityInfo.name = "MainAbility";
93 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
94 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
95 return abilityRecord;
96 }
97
98 /**
99 * @tc.name: UIAbilityLifecycleManager_StartUIAbility_0100
100 * @tc.desc: StartUIAbility
101 * @tc.type: FUNC
102 */
103 HWTEST_F(UIAbilityLifecycleManagerTest, StartUIAbility_001, TestSize.Level1)
104 {
105 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
106 AbilityRequest abilityRequest;
107 bool isColdStart = false;
108 EXPECT_EQ(mgr->StartUIAbility(abilityRequest, nullptr, 0, isColdStart), ERR_INVALID_VALUE);
109 }
110
111 /**
112 * @tc.name: UIAbilityLifecycleManager_StartUIAbility_0200
113 * @tc.desc: StartUIAbility
114 * @tc.type: FUNC
115 */
116 HWTEST_F(UIAbilityLifecycleManagerTest, StartUIAbility_002, TestSize.Level1)
117 {
118 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
119 AbilityRequest abilityRequest;
120 Rosen::SessionInfo info;
121 sptr<SessionInfo> sessionInfo(new SessionInfo());
122 sessionInfo->sessionToken = new Rosen::Session(info);
123 bool isColdStart = false;
124 EXPECT_EQ(mgr->StartUIAbility(abilityRequest, sessionInfo, 0, isColdStart), ERR_OK);
125 }
126
127 /**
128 * @tc.name: UIAbilityLifecycleManager_StartUIAbility_0300
129 * @tc.desc: StartUIAbility
130 * @tc.type: FUNC
131 */
132 HWTEST_F(UIAbilityLifecycleManagerTest, StartUIAbility_003, TestSize.Level1)
133 {
134 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
135 AbilityRequest abilityRequest;
136 Rosen::SessionInfo info;
137 sptr<SessionInfo> sessionInfo(new SessionInfo());
138 sessionInfo->sessionToken = new Rosen::Session(info);
139 sessionInfo->persistentId = 1;
140 abilityRequest.sessionInfo = sessionInfo;
141 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
142 mgr->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
143 bool isColdStart = false;
144 EXPECT_EQ(mgr->StartUIAbility(abilityRequest, sessionInfo, 0, isColdStart), ERR_OK);
145 }
146
147 /**
148 * @tc.name: UIAbilityLifecycleManager_StartUIAbility_0400
149 * @tc.desc: StartUIAbility
150 * @tc.type: FUNC
151 */
152 HWTEST_F(UIAbilityLifecycleManagerTest, StartUIAbility_004, TestSize.Level1)
153 {
154 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
155 AbilityRequest abilityRequest;
156 Rosen::SessionInfo info;
157 sptr<SessionInfo> sessionInfo(new SessionInfo());
158 sessionInfo->sessionToken = new Rosen::Session(info);
159 sessionInfo->startSetting = std::make_shared<AbilityStartSetting>();
160 sessionInfo->persistentId = 1;
161 abilityRequest.sessionInfo = sessionInfo;
162 bool isColdStart = false;
163 EXPECT_EQ(mgr->StartUIAbility(abilityRequest, sessionInfo, 0, isColdStart), ERR_OK);
164 }
165
166 /**
167 * @tc.name: UIAbilityLifecycleManager_StartUIAbility_0500
168 * @tc.desc: StartUIAbility
169 * @tc.type: FUNC
170 */
171 HWTEST_F(UIAbilityLifecycleManagerTest, StartUIAbility_005, TestSize.Level1)
172 {
173 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
174 AbilityRequest abilityRequest;
175 Rosen::SessionInfo info;
176 sptr<SessionInfo> sessionInfo(new SessionInfo());
177 sessionInfo->sessionToken = new Rosen::Session(info);
178 sessionInfo->persistentId = 1;
179 abilityRequest.sessionInfo = sessionInfo;
180 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
181 abilityRecord->SetPendingState(AbilityState::FOREGROUND);
182 mgr->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
183 bool isColdStart = false;
184 EXPECT_EQ(mgr->StartUIAbility(abilityRequest, sessionInfo, 0, isColdStart), ERR_OK);
185 }
186
187 /**
188 * @tc.name: UIAbilityLifecycleManager_StartUIAbility_0600
189 * @tc.desc: StartUIAbility
190 * @tc.type: FUNC
191 */
192 HWTEST_F(UIAbilityLifecycleManagerTest, StartUIAbility_006, TestSize.Level1)
193 {
194 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
195 AbilityRequest abilityRequest;
196 abilityRequest.abilityInfoCallback = new MockAbilityInfoCallbackStub();
197 Rosen::SessionInfo info;
198 sptr<SessionInfo> sessionInfo(new SessionInfo());
199 sessionInfo->sessionToken = new Rosen::Session(info);
200 bool isColdStart = false;
201 EXPECT_EQ(mgr->StartUIAbility(abilityRequest, sessionInfo, 0, isColdStart), ERR_OK);
202 }
203
204 /**
205 * @tc.name: UIAbilityLifecycleManager_StartUIAbility_0700
206 * @tc.desc: StartUIAbility
207 * @tc.type: FUNC
208 */
209 HWTEST_F(UIAbilityLifecycleManagerTest, StartUIAbility_007, TestSize.Level1)
210 {
211 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
212 AbilityRequest abilityRequest;
213 abilityRequest.abilityInfo.visible = true;
214 abilityRequest.abilityInfoCallback = new MockAbilityInfoCallbackStub();
215 Rosen::SessionInfo info;
216 sptr<SessionInfo> sessionInfo(new SessionInfo());
217 sessionInfo->sessionToken = new Rosen::Session(info);
218 bool isColdStart = false;
219 EXPECT_EQ(mgr->StartUIAbility(abilityRequest, sessionInfo, 0, isColdStart), ERR_OK);
220 }
221
222 /**
223 * @tc.name: UIAbilityLifecycleManager_StartUIAbility_0800
224 * @tc.desc: StartUIAbility
225 * @tc.type: FUNC
226 */
227 HWTEST_F(UIAbilityLifecycleManagerTest, StartUIAbility_008, TestSize.Level1)
228 {
229 auto mgr = std::make_shared<UIAbilityLifecycleManager>();
230 AbilityRequest abilityRequest;
231 Rosen::SessionInfo info;
232 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
233 sessionInfo->sessionToken = new (std::nothrow) Rosen::Session(info);
234 sessionInfo->persistentId = 1;
235 abilityRequest.abilityInfo.bundleName = "com.example.test";
236 abilityRequest.abilityInfo.name = "Entry";
237 abilityRequest.abilityInfo.moduleName = "EntryModule";
238 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
239 mgr->sessionAbilityMap_.emplace(2, abilityRecord);
240 bool isColdStart = false;
241 EXPECT_EQ(mgr->StartUIAbility(abilityRequest, sessionInfo, 0, isColdStart), ERR_OK);
242 }
243
244 /**
245 * @tc.name: UIAbilityLifecycleManager_CreateSessionInfo_0100
246 * @tc.desc: CreateSessionInfo
247 * @tc.type: FUNC
248 */
249 HWTEST_F(UIAbilityLifecycleManagerTest, CreateSessionInfo_001, TestSize.Level1)
250 {
251 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
252 EXPECT_NE(mgr, nullptr);
253 AbilityRequest abilityRequest;
254 abilityRequest.startSetting = std::make_shared<AbilityStartSetting>();
255 EXPECT_NE(mgr->CreateSessionInfo(abilityRequest), nullptr);
256 }
257
258 /**
259 * @tc.name: UIAbilityLifecycleManager_AbilityTransactionDone_0100
260 * @tc.desc: AbilityTransactionDone
261 * @tc.type: FUNC
262 */
263 HWTEST_F(UIAbilityLifecycleManagerTest, AbilityTransactionDone_001, TestSize.Level1)
264 {
265 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
266 AbilityRequest abilityRequest;
267 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
268 auto token = abilityRecord->GetToken()->AsObject();
269 int state = 6;
270 PacMap saveData;
271 EXPECT_EQ(mgr->AbilityTransactionDone(token, state, saveData), ERR_INVALID_VALUE);
272 }
273
274 /**
275 * @tc.name: UIAbilityLifecycleManager_AbilityTransactionDone_0200
276 * @tc.desc: AbilityTransactionDone
277 * @tc.type: FUNC
278 */
279 HWTEST_F(UIAbilityLifecycleManagerTest, AbilityTransactionDone_002, TestSize.Level1)
280 {
281 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
282 AbilityRequest abilityRequest;
283 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
284 mgr->terminateAbilityList_.emplace_back(abilityRecord);
285 auto token = abilityRecord->GetToken()->AsObject();
286 int state = 6;
287 PacMap saveData;
288 EXPECT_EQ(mgr->AbilityTransactionDone(token, state, saveData), ERR_INVALID_VALUE);
289 }
290
291 /**
292 * @tc.name: UIAbilityLifecycleManager_AttachAbilityThread_0100
293 * @tc.desc: AttachAbilityThread
294 * @tc.type: FUNC
295 */
296 HWTEST_F(UIAbilityLifecycleManagerTest, AttachAbilityThread_001, TestSize.Level1)
297 {
298 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
299 sptr<IAbilityScheduler> scheduler = nullptr;
300 sptr<IRemoteObject> token = nullptr;
301 EXPECT_EQ(mgr->AttachAbilityThread(scheduler, token), ERR_INVALID_VALUE);
302 }
303
304 /**
305 * @tc.name: UIAbilityLifecycleManager_AttachAbilityThread_0200
306 * @tc.desc: AttachAbilityThread
307 * @tc.type: FUNC
308 */
309 HWTEST_F(UIAbilityLifecycleManagerTest, AttachAbilityThread_002, TestSize.Level1)
310 {
311 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
312 AbilityRequest abilityRequest;
313 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
314 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
315 sptr<IAbilityScheduler> scheduler = nullptr;
316 auto&& token = abilityRecord->GetToken()->AsObject();
317 EXPECT_EQ(mgr->AttachAbilityThread(scheduler, token), ERR_INVALID_VALUE);
318 }
319
320 /**
321 * @tc.name: UIAbilityLifecycleManager_AttachAbilityThread_0300
322 * @tc.desc: AttachAbilityThread
323 * @tc.type: FUNC
324 */
325 HWTEST_F(UIAbilityLifecycleManagerTest, AttachAbilityThread_003, TestSize.Level1)
326 {
327 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
328 AbilityRequest abilityRequest;
329 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
330 abilityRecord->SetStartedByCall(true);
331
332 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
333 sptr<IAbilityScheduler> scheduler = nullptr;
334 auto&& token = abilityRecord->GetToken()->AsObject();
335 EXPECT_EQ(mgr->AttachAbilityThread(scheduler, token), ERR_INVALID_VALUE);
336 }
337
338 /**
339 * @tc.name: UIAbilityLifecycleManager_AttachAbilityThread_0400
340 * @tc.desc: AttachAbilityThread
341 * @tc.type: FUNC
342 */
343 HWTEST_F(UIAbilityLifecycleManagerTest, AttachAbilityThread_004, TestSize.Level1)
344 {
345 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
346 AbilityRequest abilityRequest;
347 Want want;
348 want.SetParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, true);
349 abilityRequest.want = want;
350 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
351 abilityRecord->SetStartedByCall(true);
352
353 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
354 sptr<IAbilityScheduler> scheduler = nullptr;
355 auto&& token = abilityRecord->GetToken()->AsObject();
356 EXPECT_EQ(mgr->AttachAbilityThread(scheduler, token), ERR_INVALID_VALUE);
357 }
358
359 /**
360 * @tc.name: UIAbilityLifecycleManager_OnAbilityRequestDone_0100
361 * @tc.desc: OnAbilityRequestDone
362 * @tc.type: FUNC
363 */
364 HWTEST_F(UIAbilityLifecycleManagerTest, OnAbilityRequestDone_001, TestSize.Level1)
365 {
366 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
367 EXPECT_NE(mgr, nullptr);
368 sptr<IRemoteObject> token = nullptr;
369 mgr->OnAbilityRequestDone(token, 1);
370 EXPECT_NE(mgr, nullptr);
371 }
372
373 /**
374 * @tc.name: UIAbilityLifecycleManager_OnAbilityRequestDone_0200
375 * @tc.desc: OnAbilityRequestDone
376 * @tc.type: FUNC
377 */
378 HWTEST_F(UIAbilityLifecycleManagerTest, OnAbilityRequestDone_002, TestSize.Level1)
379 {
380 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
381 EXPECT_NE(mgr, nullptr);
382 AbilityRequest abilityRequest;
383 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
384 auto&& token = abilityRecord->GetToken()->AsObject();
385 mgr->OnAbilityRequestDone(token, 1);
386 EXPECT_NE(mgr, nullptr);
387 }
388
389 /**
390 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordByToken_0100
391 * @tc.desc: GetAbilityRecordByToken
392 * @tc.type: FUNC
393 */
394 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordByToken_001, TestSize.Level1)
395 {
396 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
397 sptr<IRemoteObject> token = nullptr;
398 EXPECT_EQ(mgr->GetAbilityRecordByToken(token), nullptr);
399 }
400
401 /**
402 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordByToken_0200
403 * @tc.desc: GetAbilityRecordByToken
404 * @tc.type: FUNC
405 */
406 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordByToken_002, TestSize.Level1)
407 {
408 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
409 AbilityRequest abilityRequest;
410 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
411 auto&& token = abilityRecord->GetToken()->AsObject();
412 EXPECT_EQ(mgr->GetAbilityRecordByToken(token), nullptr);
413 }
414
415 /**
416 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordByToken_0300
417 * @tc.desc: GetAbilityRecordByToken
418 * @tc.type: FUNC
419 */
420 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordByToken_003, TestSize.Level1)
421 {
422 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
423 AbilityRequest abilityRequest;
424 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
425 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
426 auto&& token = abilityRecord->GetToken()->AsObject();
427 EXPECT_NE(mgr->GetAbilityRecordByToken(token), nullptr);
428 }
429
430 /**
431 * @tc.name: UIAbilityLifecycleManager_UpdateAbilityRecordLaunchReason_0100
432 * @tc.desc: UpdateAbilityRecordLaunchReason
433 * @tc.type: FUNC
434 */
435 HWTEST_F(UIAbilityLifecycleManagerTest, UpdateAbilityRecordLaunchReason_001, TestSize.Level1)
436 {
437 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
438 EXPECT_NE(mgr, nullptr);
439 AbilityRequest abilityRequest;
440 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
441 mgr->UpdateAbilityRecordLaunchReason(abilityRequest, abilityRecord);
442 EXPECT_NE(mgr, nullptr);
443 }
444
445 /**
446 * @tc.name: UIAbilityLifecycleManager_UpdateAbilityRecordLaunchReason_0200
447 * @tc.desc: UpdateAbilityRecordLaunchReason
448 * @tc.type: FUNC
449 */
450 HWTEST_F(UIAbilityLifecycleManagerTest, UpdateAbilityRecordLaunchReason_002, TestSize.Level1)
451 {
452 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
453 EXPECT_NE(mgr, nullptr);
454 Want want;
455 want.SetFlags(Want::FLAG_ABILITY_CONTINUATION);
456 AbilityRequest abilityRequest;
457 abilityRequest.want = want;
458 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
459 mgr->UpdateAbilityRecordLaunchReason(abilityRequest, abilityRecord);
460 EXPECT_NE(mgr, nullptr);
461 }
462
463 /**
464 * @tc.name: UIAbilityLifecycleManager_UpdateAbilityRecordLaunchReason_0300
465 * @tc.desc: UpdateAbilityRecordLaunchReason
466 * @tc.type: FUNC
467 */
468 HWTEST_F(UIAbilityLifecycleManagerTest, UpdateAbilityRecordLaunchReason_003, TestSize.Level1)
469 {
470 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
471 EXPECT_NE(mgr, nullptr);
472 Want want;
473 want.SetParam(Want::PARAM_ABILITY_RECOVERY_RESTART, true);
474 AbilityRequest abilityRequest;
475 abilityRequest.want = want;
476 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
477 mgr->UpdateAbilityRecordLaunchReason(abilityRequest, abilityRecord);
478 EXPECT_NE(mgr, nullptr);
479 }
480
481 /**
482 * @tc.name: UIAbilityLifecycleManager_UpdateAbilityRecordLaunchReason_0400
483 * @tc.desc: UpdateAbilityRecordLaunchReason
484 * @tc.type: FUNC
485 */
486 HWTEST_F(UIAbilityLifecycleManagerTest, UpdateAbilityRecordLaunchReason_004, TestSize.Level1)
487 {
488 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
489 EXPECT_NE(mgr, nullptr);
490 Want want;
491 want.SetParam(Want::PARAM_ABILITY_RECOVERY_RESTART, true);
492 AbilityRequest abilityRequest;
493 abilityRequest.want = want;
494 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
495 mgr->UpdateAbilityRecordLaunchReason(abilityRequest, abilityRecord);
496 EXPECT_NE(mgr, nullptr);
497 }
498
499 /**
500 * @tc.name: UIAbilityLifecycleManager_EraseAbilityRecord_0100
501 * @tc.desc: EraseAbilityRecord
502 * @tc.type: FUNC
503 */
504 HWTEST_F(UIAbilityLifecycleManagerTest, EraseAbilityRecord_001, TestSize.Level1)
505 {
506 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
507 EXPECT_NE(mgr, nullptr);
508 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
509 mgr->EraseAbilityRecord(abilityRecord);
510 EXPECT_NE(mgr, nullptr);
511 }
512
513 /**
514 * @tc.name: UIAbilityLifecycleManager_EraseAbilityRecord_0200
515 * @tc.desc: EraseAbilityRecord
516 * @tc.type: FUNC
517 */
518 HWTEST_F(UIAbilityLifecycleManagerTest, EraseAbilityRecord_002, TestSize.Level1)
519 {
520 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
521 EXPECT_NE(mgr, nullptr);
522 AbilityRequest abilityRequest;
523 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
524 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
525 mgr->EraseAbilityRecord(abilityRecord);
526 EXPECT_NE(mgr, nullptr);
527 }
528
529 /**
530 * @tc.name: UIAbilityLifecycleManager_DispatchState_0100
531 * @tc.desc: DispatchState
532 * @tc.type: FUNC
533 */
534 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchState_001, TestSize.Level1)
535 {
536 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
537 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
538 EXPECT_EQ(mgr->DispatchState(abilityRecord, AbilityState::INITIAL), ERR_INVALID_VALUE);
539 }
540
541 /**
542 * @tc.name: UIAbilityLifecycleManager_DispatchState_0200
543 * @tc.desc: DispatchState
544 * @tc.type: FUNC
545 */
546 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchState_002, TestSize.Level1)
547 {
548 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
549 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
550 EXPECT_EQ(mgr->DispatchState(abilityRecord, AbilityState::FOREGROUND), ERR_INVALID_VALUE);
551 }
552
553 /**
554 * @tc.name: UIAbilityLifecycleManager_DispatchState_0300
555 * @tc.desc: DispatchState
556 * @tc.type: FUNC
557 */
558 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchState_003, TestSize.Level1)
559 {
560 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
561 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
562 EXPECT_EQ(mgr->DispatchState(abilityRecord, AbilityState::FOREGROUND_FAILED), ERR_INVALID_VALUE);
563 }
564
565 /**
566 * @tc.name: UIAbilityLifecycleManager_DispatchState_0400
567 * @tc.desc: DispatchState
568 * @tc.type: FUNC
569 */
570 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchState_004, TestSize.Level1)
571 {
572 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
573 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
574 int state = 130;
575 EXPECT_EQ(mgr->DispatchState(abilityRecord, state), ERR_INVALID_VALUE);
576 }
577
578 /**
579 * @tc.name: UIAbilityLifecycleManager_DispatchForeground_0100
580 * @tc.desc: DispatchForeground
581 * @tc.type: FUNC
582 */
583 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchForeground_001, TestSize.Level1)
584 {
585 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
586 AbilityRequest abilityRequest;
587 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
588 EXPECT_EQ(mgr->DispatchForeground(abilityRecord, true, AbilityState::FOREGROUND), ERR_INVALID_VALUE);
589 }
590
591 /**
592 * @tc.name: UIAbilityLifecycleManager_CompleteForegroundSuccess_0100
593 * @tc.desc: CompleteForegroundSuccess
594 * @tc.type: FUNC
595 */
596 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteForegroundSuccess_001, TestSize.Level1)
597 {
598 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
599 EXPECT_NE(mgr, nullptr);
600 AbilityRequest abilityRequest;
601 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
602 abilityRecord->SetPendingState(AbilityState::BACKGROUND);
603 mgr->CompleteForegroundSuccess(abilityRecord);
604 EXPECT_NE(mgr, nullptr);
605 }
606
607 /**
608 * @tc.name: UIAbilityLifecycleManager_CompleteForegroundSuccess_0200
609 * @tc.desc: CompleteForegroundSuccess
610 * @tc.type: FUNC
611 */
612 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteForegroundSuccess_002, TestSize.Level1)
613 {
614 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
615 EXPECT_NE(mgr, nullptr);
616 AbilityRequest abilityRequest;
617 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
618 abilityRecord->SetPendingState(AbilityState::FOREGROUND);
619 mgr->CompleteForegroundSuccess(abilityRecord);
620 EXPECT_NE(mgr, nullptr);
621 }
622
623 /**
624 * @tc.name: UIAbilityLifecycleManager_CompleteForegroundSuccess_0300
625 * @tc.desc: CompleteForegroundSuccess
626 * @tc.type: FUNC
627 */
628 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteForegroundSuccess_003, TestSize.Level1)
629 {
630 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
631 EXPECT_NE(mgr, nullptr);
632 AbilityRequest abilityRequest;
633 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
634 abilityRecord->SetStartedByCall(true);
635 abilityRecord->SetStartToForeground(true);
636 abilityRecord->isReady_ = true;
637 mgr->CompleteForegroundSuccess(abilityRecord);
638 EXPECT_NE(mgr, nullptr);
639 }
640
641 /**
642 * @tc.name: UIAbilityLifecycleManager_CompleteForegroundSuccess_0400
643 * @tc.desc: CompleteForegroundSuccess
644 * @tc.type: FUNC
645 */
646 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteForegroundSuccess_004, TestSize.Level1)
647 {
648 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
649 EXPECT_NE(mgr, nullptr);
650 AbilityRequest abilityRequest;
651 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
652 abilityRecord->SetStartedByCall(true);
653 abilityRecord->SetStartToForeground(true);
654 abilityRecord->isReady_ = true;
655 abilityRecord->SetSessionInfo(new SessionInfo());
656 mgr->CompleteForegroundSuccess(abilityRecord);
657 EXPECT_NE(mgr, nullptr);
658 }
659
660 /**
661 * @tc.name: UIAbilityLifecycleManager_HandleForegroundFailed_0100
662 * @tc.desc: HandleForegroundOrFailed
663 * @tc.type: FUNC
664 */
665 HWTEST_F(UIAbilityLifecycleManagerTest, HandleForegroundFailed_001, TestSize.Level1)
666 {
667 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
668 EXPECT_NE(mgr, nullptr);
669 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
670 mgr->HandleForegroundFailed(abilityRecord, AbilityState::FOREGROUND_FAILED);
671 EXPECT_NE(mgr, nullptr);
672 }
673
674 /**
675 * @tc.name: UIAbilityLifecycleManager_HandleForegroundFailed_0200
676 * @tc.desc: HandleForegroundFailed
677 * @tc.type: FUNC
678 */
679 HWTEST_F(UIAbilityLifecycleManagerTest, HandleForegroundFailed_002, TestSize.Level1)
680 {
681 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
682 EXPECT_NE(mgr, nullptr);
683 AbilityRequest abilityRequest;
684 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
685 abilityRecord->currentState_ = AbilityState::FOREGROUNDING;
686 mgr->HandleForegroundFailed(abilityRecord, AbilityState::FOREGROUND_FAILED);
687 EXPECT_NE(mgr, nullptr);
688 }
689
690 /**
691 * @tc.name: UIAbilityLifecycleManager_MinimizeUIAbility_0100
692 * @tc.desc: MinimizeUIAbility
693 * @tc.type: FUNC
694 */
695 HWTEST_F(UIAbilityLifecycleManagerTest, MinimizeUIAbility_001, TestSize.Level1)
696 {
697 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
698 EXPECT_EQ(uiAbilityLifecycleManager->MinimizeUIAbility(nullptr, false, 0), ERR_INVALID_VALUE);
699 uiAbilityLifecycleManager.reset();
700 }
701
702 /**
703 * @tc.name: UIAbilityLifecycleManager_MinimizeUIAbility_0200
704 * @tc.desc: MinimizeUIAbility
705 * @tc.type: FUNC
706 */
707 HWTEST_F(UIAbilityLifecycleManagerTest, MinimizeUIAbility_002, TestSize.Level1)
708 {
709 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
710 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
711 abilityRecord->currentState_ = AbilityState::BACKGROUND;
712 EXPECT_EQ(uiAbilityLifecycleManager->MinimizeUIAbility(abilityRecord, false, 0), ERR_OK);
713 uiAbilityLifecycleManager.reset();
714 }
715
716 /**
717 * @tc.name: UIAbilityLifecycleManager_MinimizeUIAbility_0300
718 * @tc.desc: MinimizeUIAbility
719 * @tc.type: FUNC
720 */
721 HWTEST_F(UIAbilityLifecycleManagerTest, MinimizeUIAbility_003, TestSize.Level1)
722 {
723 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
724 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
725 abilityRecord->currentState_ = AbilityState::FOREGROUND;
726 EXPECT_EQ(uiAbilityLifecycleManager->MinimizeUIAbility(abilityRecord, false, 0), ERR_OK);
727 uiAbilityLifecycleManager.reset();
728 }
729
730 /**
731 * @tc.name: UIAbilityLifecycleManager_MoveToBackground_0100
732 * @tc.desc: MoveToBackground
733 * @tc.type: FUNC
734 */
735 HWTEST_F(UIAbilityLifecycleManagerTest, MoveToBackground_001, TestSize.Level1)
736 {
737 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
738 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
739 uiAbilityLifecycleManager->MoveToBackground(nullptr);
740 uiAbilityLifecycleManager.reset();
741 }
742
743 /**
744 * @tc.name: UIAbilityLifecycleManager_MoveToBackground_0200
745 * @tc.desc: MoveToBackground
746 * @tc.type: FUNC
747 */
748 HWTEST_F(UIAbilityLifecycleManagerTest, MoveToBackground_002, TestSize.Level1)
749 {
750 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
751 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
752 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
753 uiAbilityLifecycleManager->MoveToBackground(abilityRecord);
754 uiAbilityLifecycleManager.reset();
755 }
756
757 /**
758 * @tc.name: UIAbilityLifecycleManager_PrintTimeOutLog_0100
759 * @tc.desc: PrintTimeOutLog
760 * @tc.type: FUNC
761 */
762 HWTEST_F(UIAbilityLifecycleManagerTest, PrintTimeOutLog_001, TestSize.Level1)
763 {
764 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
765 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
766 uint32_t msgId = 0;
767 uiAbilityLifecycleManager->PrintTimeOutLog(nullptr, msgId);
768 uiAbilityLifecycleManager.reset();
769 }
770
771 /**
772 * @tc.name: UIAbilityLifecycleManager_PrintTimeOutLog_0200
773 * @tc.desc: PrintTimeOutLog
774 * @tc.type: FUNC
775 */
776 HWTEST_F(UIAbilityLifecycleManagerTest, PrintTimeOutLog_002, TestSize.Level1)
777 {
778 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
779 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
780 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
781 uint32_t msgId = 0;
782 uiAbilityLifecycleManager->PrintTimeOutLog(abilityRecord, msgId);
783 uiAbilityLifecycleManager.reset();
784 }
785
786 /**
787 * @tc.name: UIAbilityLifecycleManager_PrintTimeOutLog_0300
788 * @tc.desc: PrintTimeOutLog
789 * @tc.type: FUNC
790 */
791 HWTEST_F(UIAbilityLifecycleManagerTest, PrintTimeOutLog_003, TestSize.Level1)
792 {
793 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
794 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
795 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
796 uint32_t msgId = 1;
797 uiAbilityLifecycleManager->PrintTimeOutLog(abilityRecord, msgId);
798 uiAbilityLifecycleManager.reset();
799 }
800
801 /**
802 * @tc.name: UIAbilityLifecycleManager_PrintTimeOutLog_0400
803 * @tc.desc: PrintTimeOutLog
804 * @tc.type: FUNC
805 */
806 HWTEST_F(UIAbilityLifecycleManagerTest, PrintTimeOutLog_004, TestSize.Level1)
807 {
808 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
809 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
810 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
811 uint32_t msgId = 2;
812 uiAbilityLifecycleManager->PrintTimeOutLog(abilityRecord, msgId);
813 uiAbilityLifecycleManager.reset();
814 }
815
816 /**
817 * @tc.name: UIAbilityLifecycleManager_PrintTimeOutLog_0500
818 * @tc.desc: PrintTimeOutLog
819 * @tc.type: FUNC
820 */
821 HWTEST_F(UIAbilityLifecycleManagerTest, PrintTimeOutLog_005, TestSize.Level1)
822 {
823 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
824 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
825 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
826 uint32_t msgId = 3;
827 uiAbilityLifecycleManager->PrintTimeOutLog(abilityRecord, msgId);
828 uiAbilityLifecycleManager.reset();
829 }
830
831 /**
832 * @tc.name: UIAbilityLifecycleManager_PrintTimeOutLog_0600
833 * @tc.desc: PrintTimeOutLog
834 * @tc.type: FUNC
835 */
836 HWTEST_F(UIAbilityLifecycleManagerTest, PrintTimeOutLog_006, TestSize.Level1)
837 {
838 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
839 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
840 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
841 uint32_t msgId = 4;
842 uiAbilityLifecycleManager->PrintTimeOutLog(abilityRecord, msgId);
843 uiAbilityLifecycleManager.reset();
844 }
845
846 /**
847 * @tc.name: UIAbilityLifecycleManager_PrintTimeOutLog_0700
848 * @tc.desc: PrintTimeOutLog
849 * @tc.type: FUNC
850 */
851 HWTEST_F(UIAbilityLifecycleManagerTest, PrintTimeOutLog_007, TestSize.Level1)
852 {
853 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
854 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
855 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
856 uint32_t msgId = 5;
857 uiAbilityLifecycleManager->PrintTimeOutLog(abilityRecord, msgId);
858 uiAbilityLifecycleManager.reset();
859 }
860
861 /**
862 * @tc.name: UIAbilityLifecycleManager_PrintTimeOutLog_0800
863 * @tc.desc: PrintTimeOutLog
864 * @tc.type: FUNC
865 */
866 HWTEST_F(UIAbilityLifecycleManagerTest, PrintTimeOutLog_008, TestSize.Level1)
867 {
868 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
869 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
870 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
871 uint32_t msgId = 6;
872 uiAbilityLifecycleManager->PrintTimeOutLog(abilityRecord, msgId);
873 uiAbilityLifecycleManager.reset();
874 }
875
876 /**
877 * @tc.name: UIAbilityLifecycleManager_CompleteBackground_0100
878 * @tc.desc: CompleteBackground
879 * @tc.type: FUNC
880 */
881 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteBackground_001, TestSize.Level1)
882 {
883 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
884 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
885 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
886 abilityRecord->currentState_ = AbilityState::FOREGROUND;
887 uiAbilityLifecycleManager->CompleteBackground(abilityRecord);
888 uiAbilityLifecycleManager.reset();
889 }
890
891 /**
892 * @tc.name: UIAbilityLifecycleManager_CompleteBackground_0200
893 * @tc.desc: CompleteBackground
894 * @tc.type: FUNC
895 */
896 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteBackground_002, TestSize.Level1)
897 {
898 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
899 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
900 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
901 abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
902 abilityRecord->SetPendingState(AbilityState::FOREGROUND);
903 uiAbilityLifecycleManager->CompleteBackground(abilityRecord);
904 uiAbilityLifecycleManager.reset();
905 }
906
907 /**
908 * @tc.name: UIAbilityLifecycleManager_CompleteBackground_0300
909 * @tc.desc: CompleteBackground
910 * @tc.type: FUNC
911 */
912 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteBackground_003, TestSize.Level1)
913 {
914 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
915 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
916 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
917 abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
918 abilityRecord->SetPendingState(AbilityState::BACKGROUND);
919 uiAbilityLifecycleManager->CompleteBackground(abilityRecord);
920 uiAbilityLifecycleManager.reset();
921 }
922
923 /**
924 * @tc.name: UIAbilityLifecycleManager_CompleteBackground_0400
925 * @tc.desc: CompleteBackground
926 * @tc.type: FUNC
927 */
928 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteBackground_004, TestSize.Level1)
929 {
930 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
931 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
932 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
933 abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
934 abilityRecord->SetPendingState(AbilityState::FOREGROUND);
935 uiAbilityLifecycleManager->CompleteBackground(abilityRecord);
936 uiAbilityLifecycleManager.reset();
937 }
938
939 /**
940 * @tc.name: UIAbilityLifecycleManager_CompleteBackground_0500
941 * @tc.desc: CompleteBackground
942 * @tc.type: FUNC
943 */
944 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteBackground_005, TestSize.Level1)
945 {
946 auto mgr = std::make_shared<UIAbilityLifecycleManager>();
947 EXPECT_NE(mgr, nullptr);
948 AbilityRequest abilityRequest;
949 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
950 abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
951 abilityRecord->SetStartedByCall(true);
952 abilityRecord->SetStartToBackground(true);
953 abilityRecord->isReady_ = true;
954 mgr->CompleteBackground(abilityRecord);
955 EXPECT_NE(mgr, nullptr);
956 }
957
958 /**
959 * @tc.name: UIAbilityLifecycleManager_CompleteBackground_0600
960 * @tc.desc: CompleteBackground
961 * @tc.type: FUNC
962 */
963 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteBackground_006, TestSize.Level1)
964 {
965 auto mgr = std::make_shared<UIAbilityLifecycleManager>();
966 EXPECT_NE(mgr, nullptr);
967 AbilityRequest abilityRequest;
968 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
969 abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
970 mgr->terminateAbilityList_.push_back(abilityRecord);
971 mgr->CompleteBackground(abilityRecord);
972 EXPECT_NE(mgr, nullptr);
973 }
974
975 /**
976 * @tc.name: UIAbilityLifecycleManager_CloseUIAbility_0100
977 * @tc.desc: CloseUIAbility
978 * @tc.type: FUNC
979 */
980 HWTEST_F(UIAbilityLifecycleManagerTest, CloseUIAbility_001, TestSize.Level1)
981 {
982 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
983 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
984 abilityRecord->SetTerminatingState();
985 abilityRecord->currentState_ = AbilityState::BACKGROUND;
986 EXPECT_EQ(uiAbilityLifecycleManager->CloseUIAbility(abilityRecord, -1, nullptr, false), ERR_OK);
987 uiAbilityLifecycleManager.reset();
988 }
989
990 /**
991 * @tc.name: UIAbilityLifecycleManager_CloseUIAbility_0200
992 * @tc.desc: CloseUIAbility
993 * @tc.type: FUNC
994 */
995 HWTEST_F(UIAbilityLifecycleManagerTest, CloseUIAbility_002, TestSize.Level1)
996 {
997 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
998 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
999 EXPECT_EQ(uiAbilityLifecycleManager->CloseUIAbility(abilityRecord, -1, nullptr, false), ERR_INVALID_VALUE);
1000 uiAbilityLifecycleManager.reset();
1001 }
1002
1003 /**
1004 * @tc.name: UIAbilityLifecycleManager_CloseUIAbility_0300
1005 * @tc.desc: CloseUIAbility
1006 * @tc.type: FUNC
1007 */
1008 HWTEST_F(UIAbilityLifecycleManagerTest, CloseUIAbility_003, TestSize.Level1)
1009 {
1010 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1011 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1012 Want want;
1013 EXPECT_EQ(uiAbilityLifecycleManager->CloseUIAbility(abilityRecord, -1, &want, false), ERR_INVALID_VALUE);
1014 uiAbilityLifecycleManager.reset();
1015 }
1016
1017 /**
1018 * @tc.name: UIAbilityLifecycleManager_CloseUIAbility_0400
1019 * @tc.desc: CloseUIAbility
1020 * @tc.type: FUNC
1021 */
1022 HWTEST_F(UIAbilityLifecycleManagerTest, CloseUIAbility_004, TestSize.Level1)
1023 {
1024 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1025 auto abilityRecord = InitAbilityRecord();
1026 abilityRecord->currentState_ = AbilityState::FOREGROUND;
1027 Want want;
1028 EXPECT_EQ(uiAbilityLifecycleManager->CloseUIAbility(abilityRecord, -1, &want, false), ERR_OK);
1029 uiAbilityLifecycleManager.reset();
1030 }
1031
1032 /**
1033 * @tc.name: UIAbilityLifecycleManager_CloseUIAbility_0500
1034 * @tc.desc: CloseUIAbility
1035 * @tc.type: FUNC
1036 */
1037 HWTEST_F(UIAbilityLifecycleManagerTest, CloseUIAbility_005, TestSize.Level1)
1038 {
1039 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1040 auto abilityRecord = InitAbilityRecord();
1041 abilityRecord->currentState_ = AbilityState::FOREGROUNDING;
1042 Want want;
1043 EXPECT_EQ(uiAbilityLifecycleManager->CloseUIAbility(abilityRecord, -1, &want, false), ERR_OK);
1044 uiAbilityLifecycleManager.reset();
1045 }
1046
1047 /**
1048 * @tc.name: UIAbilityLifecycleManager_CloseUIAbility_0600
1049 * @tc.desc: CloseUIAbility
1050 * @tc.type: FUNC
1051 */
1052 HWTEST_F(UIAbilityLifecycleManagerTest, CloseUIAbility_006, TestSize.Level1)
1053 {
1054 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1055 auto abilityRecord = InitAbilityRecord();
1056 abilityRecord->currentState_ = AbilityState::BACKGROUND;
1057 Want want;
1058 EXPECT_EQ(uiAbilityLifecycleManager->CloseUIAbility(abilityRecord, -1, &want, false), ERR_OK);
1059 uiAbilityLifecycleManager.reset();
1060 }
1061
1062 /**
1063 * @tc.name: UIAbilityLifecycleManager_DelayCompleteTerminate_0100
1064 * @tc.desc: DelayCompleteTerminate
1065 * @tc.type: FUNC
1066 */
1067 HWTEST_F(UIAbilityLifecycleManagerTest, DelayCompleteTerminate_001, TestSize.Level1)
1068 {
1069 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1070 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1071 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1072 uiAbilityLifecycleManager->DelayCompleteTerminate(abilityRecord);
1073 uiAbilityLifecycleManager.reset();
1074 }
1075
1076 /**
1077 * @tc.name: UIAbilityLifecycleManager_CompleteTerminate_0100
1078 * @tc.desc: CompleteTerminate
1079 * @tc.type: FUNC
1080 */
1081 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteTerminate_001, TestSize.Level1)
1082 {
1083 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1084 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1085 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1086 abilityRecord->currentState_ = AbilityState::BACKGROUND;
1087 uiAbilityLifecycleManager->CompleteTerminate(abilityRecord);
1088 uiAbilityLifecycleManager.reset();
1089 }
1090
1091 /**
1092 * @tc.name: UIAbilityLifecycleManager_CompleteTerminate_0200
1093 * @tc.desc: CompleteTerminate
1094 * @tc.type: FUNC
1095 */
1096 HWTEST_F(UIAbilityLifecycleManagerTest, CompleteTerminate_002, TestSize.Level1)
1097 {
1098 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1099 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1100 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1101 abilityRecord->currentState_ = AbilityState::TERMINATING;
1102 uiAbilityLifecycleManager->CompleteTerminate(abilityRecord);
1103 uiAbilityLifecycleManager.reset();
1104 }
1105
1106 /**
1107 * @tc.name: UIAbilityLifecycleManager_OnTimeOut_0100
1108 * @tc.desc: OnTimeOut
1109 * @tc.type: FUNC
1110 */
1111 HWTEST_F(UIAbilityLifecycleManagerTest, OnTimeOut_001, TestSize.Level1)
1112 {
1113 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1114 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1115 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1116 uint32_t msgId = 0;
1117 int64_t abilityRecordId = 0;
1118 uiAbilityLifecycleManager->OnTimeOut(msgId, abilityRecordId);
1119 uiAbilityLifecycleManager.reset();
1120 }
1121
1122 /**
1123 * @tc.name: UIAbilityLifecycleManager_OnTimeOut_0200
1124 * @tc.desc: OnTimeOut
1125 * @tc.type: FUNC
1126 */
1127 HWTEST_F(UIAbilityLifecycleManagerTest, OnTimeOut_002, TestSize.Level1)
1128 {
1129 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1130 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1131 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1132 uint32_t msgId = 0;
1133 int64_t abilityRecordId = 0;
1134 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
1135 uiAbilityLifecycleManager->OnTimeOut(msgId, abilityRecordId);
1136 uiAbilityLifecycleManager.reset();
1137 }
1138
1139 /**
1140 * @tc.name: UIAbilityLifecycleManager_OnTimeOut_0300
1141 * @tc.desc: OnTimeOut
1142 * @tc.type: FUNC
1143 */
1144 HWTEST_F(UIAbilityLifecycleManagerTest, OnTimeOut_003, TestSize.Level1)
1145 {
1146 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1147 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1148 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1149 uint32_t msgId = 5;
1150 int64_t abilityRecordId = 0;
1151 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
1152 uiAbilityLifecycleManager->OnTimeOut(msgId, abilityRecordId);
1153 uiAbilityLifecycleManager.reset();
1154 }
1155
1156 /**
1157 * @tc.name: UIAbilityLifecycleManager_OnTimeOut_0400
1158 * @tc.desc: OnTimeOut
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(UIAbilityLifecycleManagerTest, OnTimeOut_004, TestSize.Level1)
1162 {
1163 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1164 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1165 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1166 uint32_t msgId = 6;
1167 int64_t abilityRecordId = 0;
1168 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(msgId, abilityRecord);
1169 uiAbilityLifecycleManager->OnTimeOut(msgId, abilityRecordId);
1170 uiAbilityLifecycleManager.reset();
1171 }
1172
1173 /**
1174 * @tc.name: UIAbilityLifecycleManager_NotifySCBToHandleException_0100
1175 * @tc.desc: NotifySCBToHandleException
1176 * @tc.type: FUNC
1177 */
1178 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToHandleException_001, TestSize.Level1)
1179 {
1180 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1181 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1182 std::shared_ptr<AbilityRecord> record = nullptr;
1183 uiAbilityLifecycleManager->NotifySCBToHandleException(record,
1184 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleLoadTimeout");
1185 uiAbilityLifecycleManager.reset();
1186 }
1187
1188 /**
1189 * @tc.name: UIAbilityLifecycleManager_NotifySCBToHandleException_0200
1190 * @tc.desc: NotifySCBToHandleException
1191 * @tc.type: FUNC
1192 */
1193 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToHandleException_002, TestSize.Level1)
1194 {
1195 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1196 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1197 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1198 uiAbilityLifecycleManager->NotifySCBToHandleException(abilityRecord,
1199 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleLoadTimeout");
1200 uiAbilityLifecycleManager.reset();
1201 }
1202
1203 /**
1204 * @tc.name: UIAbilityLifecycleManager_NotifySCBToHandleException_0300
1205 * @tc.desc: NotifySCBToHandleException
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToHandleException_003, TestSize.Level1)
1209 {
1210 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1211 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1212 AbilityRequest abilityRequest;
1213 sptr<SessionInfo> sessionInfo(new SessionInfo());
1214 abilityRequest.sessionInfo = sessionInfo;
1215 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1216 uiAbilityLifecycleManager->NotifySCBToHandleException(abilityRecord,
1217 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleLoadTimeout");
1218 uiAbilityLifecycleManager.reset();
1219 }
1220
1221 /**
1222 * @tc.name: UIAbilityLifecycleManager_NotifySCBToHandleException_0400
1223 * @tc.desc: NotifySCBToHandleException
1224 * @tc.type: FUNC
1225 */
1226 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToHandleException_004, TestSize.Level1)
1227 {
1228 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1229 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1230 AbilityRequest abilityRequest;
1231 Rosen::SessionInfo info;
1232 sptr<SessionInfo> sessionInfo(new SessionInfo());
1233 sessionInfo->sessionToken = new Rosen::Session(info);
1234 abilityRequest.sessionInfo = sessionInfo;
1235 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1236 uiAbilityLifecycleManager->NotifySCBToHandleException(abilityRecord,
1237 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleLoadTimeout");
1238 uiAbilityLifecycleManager.reset();
1239 }
1240
1241 /**
1242 * @tc.name: UIAbilityLifecycleManager_NotifySCBToHandleException_0500
1243 * @tc.desc: NotifySCBToHandleException
1244 * @tc.type: FUNC
1245 */
1246 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToHandleException_005, TestSize.Level1)
1247 {
1248 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1249 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1250 AbilityRequest abilityRequest;
1251 Rosen::SessionInfo info;
1252 sptr<SessionInfo> sessionInfo(new SessionInfo());
1253 sessionInfo->sessionToken = new Rosen::Session(info);
1254 abilityRequest.sessionInfo = sessionInfo;
1255 sessionInfo->persistentId = 0;
1256 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1257 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1258 uiAbilityLifecycleManager->NotifySCBToHandleException(abilityRecord,
1259 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleLoadTimeout");
1260 uiAbilityLifecycleManager.reset();
1261 }
1262
1263 /**
1264 * @tc.name: UIAbilityLifecycleManager_NotifySCBToHandleException_0600
1265 * @tc.desc: NotifySCBToHandleException
1266 * @tc.type: FUNC
1267 */
1268 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToHandleException_006, TestSize.Level1)
1269 {
1270 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1271 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1272 AbilityRequest abilityRequest;
1273 Rosen::SessionInfo info;
1274 sptr<SessionInfo> sessionInfo(new SessionInfo());
1275 sessionInfo->sessionToken = new Rosen::Session(info);
1276 abilityRequest.sessionInfo = sessionInfo;
1277 sessionInfo->persistentId = 0;
1278 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1279 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1280 uiAbilityLifecycleManager->NotifySCBToHandleException(abilityRecord,
1281 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_FOREGROUND_TIMEOUT), "handleForegroundTimeout");
1282 uiAbilityLifecycleManager.reset();
1283 }
1284
1285 /**
1286 * @tc.name: UIAbilityLifecycleManager_NotifySCBToHandleException_0700
1287 * @tc.desc: NotifySCBToHandleException
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToHandleException_007, TestSize.Level1)
1291 {
1292 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1293 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1294 AbilityRequest abilityRequest;
1295 Rosen::SessionInfo info;
1296 sptr<SessionInfo> sessionInfo(new SessionInfo());
1297 sessionInfo->sessionToken = new Rosen::Session(info);
1298 abilityRequest.sessionInfo = sessionInfo;
1299 sessionInfo->persistentId = 0;
1300 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1301 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1302 uiAbilityLifecycleManager->NotifySCBToHandleException(abilityRecord,
1303 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_DIED), "onAbilityDied");
1304 uiAbilityLifecycleManager.reset();
1305 }
1306
1307 /**
1308 * @tc.name: UIAbilityLifecycleManager_HandleLoadTimeout_0100
1309 * @tc.desc: HandleLoadTimeout
1310 * @tc.type: FUNC
1311 */
1312 HWTEST_F(UIAbilityLifecycleManagerTest, HandleLoadTimeout_001, TestSize.Level1)
1313 {
1314 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1315 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1316 uiAbilityLifecycleManager->HandleLoadTimeout(nullptr);
1317 uiAbilityLifecycleManager.reset();
1318 }
1319
1320 /**
1321 * @tc.name: UIAbilityLifecycleManager_HandleLoadTimeout_0200
1322 * @tc.desc: HandleLoadTimeout
1323 * @tc.type: FUNC
1324 */
1325 HWTEST_F(UIAbilityLifecycleManagerTest, HandleLoadTimeout_002, TestSize.Level1)
1326 {
1327 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1328 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1329 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1330 uiAbilityLifecycleManager->HandleLoadTimeout(abilityRecord);
1331 uiAbilityLifecycleManager.reset();
1332 }
1333
1334 /**
1335 * @tc.name: UIAbilityLifecycleManager_HandleLoadTimeout_0300
1336 * @tc.desc: HandleLoadTimeout
1337 * @tc.type: FUNC
1338 */
1339 HWTEST_F(UIAbilityLifecycleManagerTest, HandleLoadTimeout_003, TestSize.Level1)
1340 {
1341 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1342 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1343 AbilityRequest abilityRequest;
1344 sptr<SessionInfo> sessionInfo(new SessionInfo());
1345 abilityRequest.sessionInfo = sessionInfo;
1346 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1347 uiAbilityLifecycleManager->HandleLoadTimeout(abilityRecord);
1348 uiAbilityLifecycleManager.reset();
1349 }
1350
1351 /**
1352 * @tc.name: UIAbilityLifecycleManager_HandleLoadTimeout_0400
1353 * @tc.desc: HandleLoadTimeout
1354 * @tc.type: FUNC
1355 */
1356 HWTEST_F(UIAbilityLifecycleManagerTest, HandleLoadTimeout_004, TestSize.Level1)
1357 {
1358 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1359 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1360 AbilityRequest abilityRequest;
1361 Rosen::SessionInfo info;
1362 sptr<SessionInfo> sessionInfo(new SessionInfo());
1363 sessionInfo->sessionToken = new Rosen::Session(info);
1364 abilityRequest.sessionInfo = sessionInfo;
1365 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1366 uiAbilityLifecycleManager->HandleLoadTimeout(abilityRecord);
1367 uiAbilityLifecycleManager.reset();
1368 }
1369
1370 /**
1371 * @tc.name: UIAbilityLifecycleManager_HandleLoadTimeout_0500
1372 * @tc.desc: HandleLoadTimeout
1373 * @tc.type: FUNC
1374 */
1375 HWTEST_F(UIAbilityLifecycleManagerTest, HandleLoadTimeout_005, TestSize.Level1)
1376 {
1377 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1378 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1379 AbilityRequest abilityRequest;
1380 Rosen::SessionInfo info;
1381 sptr<SessionInfo> sessionInfo(new SessionInfo());
1382 sessionInfo->sessionToken = new Rosen::Session(info);
1383 abilityRequest.sessionInfo = sessionInfo;
1384 sessionInfo->persistentId = 0;
1385 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1386 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1387 uiAbilityLifecycleManager->HandleLoadTimeout(abilityRecord);
1388 uiAbilityLifecycleManager.reset();
1389 }
1390
1391 /**
1392 * @tc.name: UIAbilityLifecycleManager_HandleForegroundTimeout_0100
1393 * @tc.desc: HandleForegroundTimeout
1394 * @tc.type: FUNC
1395 */
1396 HWTEST_F(UIAbilityLifecycleManagerTest, HandleForegroundTimeout_001, TestSize.Level1)
1397 {
1398 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1399 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1400 uiAbilityLifecycleManager->HandleForegroundTimeout(nullptr);
1401 uiAbilityLifecycleManager.reset();
1402 }
1403
1404 /**
1405 * @tc.name: UIAbilityLifecycleManager_HandleForegroundTimeout_0200
1406 * @tc.desc: HandleForegroundTimeout
1407 * @tc.type: FUNC
1408 */
1409 HWTEST_F(UIAbilityLifecycleManagerTest, HandleForegroundTimeout_002, TestSize.Level1)
1410 {
1411 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1412 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1413 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1414 abilityRecord->currentState_ = AbilityState::TERMINATING;
1415 uiAbilityLifecycleManager->HandleForegroundTimeout(abilityRecord);
1416 uiAbilityLifecycleManager.reset();
1417 }
1418
1419 /**
1420 * @tc.name: UIAbilityLifecycleManager_HandleForegroundTimeout_0300
1421 * @tc.desc: HandleForegroundTimeout
1422 * @tc.type: FUNC
1423 */
1424 HWTEST_F(UIAbilityLifecycleManagerTest, HandleForegroundTimeout_003, TestSize.Level1)
1425 {
1426 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1427 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1428 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1429 abilityRecord->currentState_ = AbilityState::FOREGROUNDING;
1430 uiAbilityLifecycleManager->HandleForegroundTimeout(abilityRecord);
1431 uiAbilityLifecycleManager.reset();
1432 }
1433
1434 /**
1435 * @tc.name: UIAbilityLifecycleManager_HandleForegroundTimeout_0400
1436 * @tc.desc: HandleForegroundTimeout
1437 * @tc.type: FUNC
1438 */
1439 HWTEST_F(UIAbilityLifecycleManagerTest, HandleForegroundTimeout_004, TestSize.Level1)
1440 {
1441 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1442 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1443 AbilityRequest abilityRequest;
1444 sptr<SessionInfo> sessionInfo(new SessionInfo());
1445 abilityRequest.sessionInfo = sessionInfo;
1446 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1447 abilityRecord->currentState_ = AbilityState::FOREGROUNDING;
1448 uiAbilityLifecycleManager->HandleForegroundTimeout(abilityRecord);
1449 uiAbilityLifecycleManager.reset();
1450 }
1451
1452 /**
1453 * @tc.name: UIAbilityLifecycleManager_HandleForegroundTimeout_0500
1454 * @tc.desc: HandleForegroundTimeout
1455 * @tc.type: FUNC
1456 */
1457 HWTEST_F(UIAbilityLifecycleManagerTest, HandleForegroundTimeout_005, TestSize.Level1)
1458 {
1459 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1460 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1461 AbilityRequest abilityRequest;
1462 Rosen::SessionInfo info;
1463 sptr<SessionInfo> sessionInfo(new SessionInfo());
1464 sessionInfo->sessionToken = new Rosen::Session(info);
1465 abilityRequest.sessionInfo = sessionInfo;
1466 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1467 abilityRecord->currentState_ = AbilityState::FOREGROUNDING;
1468 uiAbilityLifecycleManager->HandleForegroundTimeout(abilityRecord);
1469 uiAbilityLifecycleManager.reset();
1470 }
1471
1472 /**
1473 * @tc.name: UIAbilityLifecycleManager_HandleForegroundTimeout_0600
1474 * @tc.desc: HandleForegroundTimeout
1475 * @tc.type: FUNC
1476 */
1477 HWTEST_F(UIAbilityLifecycleManagerTest, HandleForegroundTimeout_006, TestSize.Level1)
1478 {
1479 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1480 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1481 AbilityRequest abilityRequest;
1482 Rosen::SessionInfo info;
1483 sptr<SessionInfo> sessionInfo(new SessionInfo());
1484 sessionInfo->sessionToken = new Rosen::Session(info);
1485 abilityRequest.sessionInfo = sessionInfo;
1486 sessionInfo->persistentId = 0;
1487 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1488 abilityRecord->currentState_ = AbilityState::FOREGROUNDING;
1489 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1490 uiAbilityLifecycleManager->HandleForegroundTimeout(abilityRecord);
1491 uiAbilityLifecycleManager.reset();
1492 }
1493
1494 /**
1495 * @tc.name: UIAbilityLifecycleManager_OnAbilityDied_0100
1496 * @tc.desc: OnAbilityDied
1497 * @tc.type: FUNC
1498 */
1499 HWTEST_F(UIAbilityLifecycleManagerTest, OnAbilityDied_001, TestSize.Level1)
1500 {
1501 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1502 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1503 uiAbilityLifecycleManager->OnAbilityDied(nullptr);
1504 uiAbilityLifecycleManager.reset();
1505 }
1506
1507 /**
1508 * @tc.name: UIAbilityLifecycleManager_OnAbilityDied_0200
1509 * @tc.desc: OnAbilityDied
1510 * @tc.type: FUNC
1511 */
1512 HWTEST_F(UIAbilityLifecycleManagerTest, OnAbilityDied_002, TestSize.Level1)
1513 {
1514 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1515 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1516 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1517 uiAbilityLifecycleManager->OnAbilityDied(abilityRecord);
1518 uiAbilityLifecycleManager.reset();
1519 }
1520
1521 /**
1522 * @tc.name: UIAbilityLifecycleManager_OnAbilityDied_0300
1523 * @tc.desc: OnAbilityDied
1524 * @tc.type: FUNC
1525 */
1526 HWTEST_F(UIAbilityLifecycleManagerTest, OnAbilityDied_003, TestSize.Level1)
1527 {
1528 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1529 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1530 AbilityRequest abilityRequest;
1531 sptr<SessionInfo> sessionInfo(new SessionInfo());
1532 abilityRequest.sessionInfo = sessionInfo;
1533 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1534 uiAbilityLifecycleManager->OnAbilityDied(abilityRecord);
1535 uiAbilityLifecycleManager.reset();
1536 }
1537
1538 /**
1539 * @tc.name: UIAbilityLifecycleManager_OnAbilityDied_0400
1540 * @tc.desc: OnAbilityDied
1541 * @tc.type: FUNC
1542 */
1543 HWTEST_F(UIAbilityLifecycleManagerTest, OnAbilityDied_004, TestSize.Level1)
1544 {
1545 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1546 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1547 AbilityRequest abilityRequest;
1548 Rosen::SessionInfo info;
1549 sptr<SessionInfo> sessionInfo(new SessionInfo());
1550 sessionInfo->sessionToken = new Rosen::Session(info);
1551 abilityRequest.sessionInfo = sessionInfo;
1552 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1553 uiAbilityLifecycleManager->OnAbilityDied(abilityRecord);
1554 uiAbilityLifecycleManager.reset();
1555 }
1556
1557 /**
1558 * @tc.name: UIAbilityLifecycleManager_OnAbilityDied_0500
1559 * @tc.desc: OnAbilityDied
1560 * @tc.type: FUNC
1561 */
1562 HWTEST_F(UIAbilityLifecycleManagerTest, OnAbilityDied_005, TestSize.Level1)
1563 {
1564 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
1565 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
1566 AbilityRequest abilityRequest;
1567 Rosen::SessionInfo info;
1568 sptr<SessionInfo> sessionInfo(new SessionInfo());
1569 sessionInfo->sessionToken = new Rosen::Session(info);
1570 abilityRequest.sessionInfo = sessionInfo;
1571 sessionInfo->persistentId = 0;
1572 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1573 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1574 uiAbilityLifecycleManager->OnAbilityDied(abilityRecord);
1575 uiAbilityLifecycleManager.reset();
1576 }
1577
1578 /**
1579 * @tc.name: UIAbilityLifecycleManager_SetRootSceneSession_0100
1580 * @tc.desc: SetRootSceneSession
1581 * @tc.type: FUNC
1582 */
1583 HWTEST_F(UIAbilityLifecycleManagerTest, SetRootSceneSession_001, TestSize.Level1)
1584 {
1585 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1586 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1587 sptr<IRemoteObject> object = nullptr;
1588 uiAbilityLifecycleManager->SetRootSceneSession(object);
1589 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1590 }
1591
1592 /**
1593 * @tc.name: UIAbilityLifecycleManager_SetRootSceneSession_0200
1594 * @tc.desc: SetRootSceneSession
1595 * @tc.type: FUNC
1596 */
1597 HWTEST_F(UIAbilityLifecycleManagerTest, SetRootSceneSession_002, TestSize.Level1)
1598 {
1599 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1600 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1601 auto abilityRecord = InitAbilityRecord();
1602 EXPECT_NE(abilityRecord, nullptr);
1603 auto token = abilityRecord->GetToken();
1604 EXPECT_NE(token, nullptr);
1605 auto object = token->AsObject();
1606 uiAbilityLifecycleManager->SetRootSceneSession(object);
1607 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1608 }
1609
1610 /**
1611 * @tc.name: UIAbilityLifecycleManager_SetRootSceneSession_0300
1612 * @tc.desc: SetRootSceneSession
1613 * @tc.type: FUNC
1614 */
1615 HWTEST_F(UIAbilityLifecycleManagerTest, SetRootSceneSession_003, TestSize.Level1)
1616 {
1617 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1618 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1619 Rosen::SessionInfo info;
1620 sptr<Rosen::ISession> session = new Rosen::Session(info);
1621 EXPECT_NE(session, nullptr);
1622 sptr<IRemoteObject> rootSceneSession = session->AsObject();
1623 uiAbilityLifecycleManager->SetRootSceneSession(rootSceneSession);
1624 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1625 }
1626
1627 /**
1628 * @tc.name: UIAbilityLifecycleManager_NotifySCBToStartUIAbility_0100
1629 * @tc.desc: NotifySCBToStartUIAbility
1630 * @tc.type: FUNC
1631 */
1632 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToStartUIAbility_001, TestSize.Level1)
1633 {
1634 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1635 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1636 AbilityRequest abilityRequest;
1637 uiAbilityLifecycleManager->NotifySCBToStartUIAbility(abilityRequest);
1638 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1639 }
1640
1641 /**
1642 * @tc.name: UIAbilityLifecycleManager_GetPersistentIdByAbilityRequest_0100
1643 * @tc.desc: GetPersistentIdByAbilityRequest
1644 * @tc.type: FUNC
1645 */
1646 HWTEST_F(UIAbilityLifecycleManagerTest, GetPersistentIdByAbilityRequest_001, TestSize.Level1)
1647 {
1648 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1649 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1650 AbilityRequest abilityRequest;
1651 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
1652 bool reuse = false;
1653 EXPECT_EQ(uiAbilityLifecycleManager->GetPersistentIdByAbilityRequest(abilityRequest, reuse), 0);
1654 }
1655
1656 /**
1657 * @tc.name: UIAbilityLifecycleManager_GetPersistentIdByAbilityRequest_0200
1658 * @tc.desc: GetPersistentIdByAbilityRequest
1659 * @tc.type: FUNC
1660 */
1661 HWTEST_F(UIAbilityLifecycleManagerTest, GetPersistentIdByAbilityRequest_002, TestSize.Level1)
1662 {
1663 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1664 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1665 AbilityRequest abilityRequest;
1666 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::STANDARD;
1667 bool reuse = false;
1668 EXPECT_EQ(uiAbilityLifecycleManager->GetPersistentIdByAbilityRequest(abilityRequest, reuse), 0);
1669 }
1670
1671 /**
1672 * @tc.name: UIAbilityLifecycleManager_GetPersistentIdByAbilityRequest_0300
1673 * @tc.desc: GetPersistentIdByAbilityRequest
1674 * @tc.type: FUNC
1675 */
1676 HWTEST_F(UIAbilityLifecycleManagerTest, GetPersistentIdByAbilityRequest_003, TestSize.Level1)
1677 {
1678 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1679 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1680 AbilityRequest abilityRequest;
1681 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
1682 abilityRequest.abilityInfo.name = "testAbility";
1683 abilityRequest.abilityInfo.moduleName = "testModule";
1684 abilityRequest.abilityInfo.bundleName = "com.test.ut";
1685
1686 Rosen::SessionInfo info;
1687 sptr<SessionInfo> sessionInfo(new SessionInfo());
1688 sessionInfo->sessionToken = new Rosen::Session(info);
1689 sessionInfo->persistentId = 1;
1690 abilityRequest.sessionInfo = sessionInfo;
1691 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1692 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1693 bool reuse = false;
1694 EXPECT_EQ(uiAbilityLifecycleManager->GetPersistentIdByAbilityRequest(abilityRequest, reuse),
1695 sessionInfo->persistentId);
1696 }
1697
1698 /**
1699 * @tc.name: UIAbilityLifecycleManager_GetPersistentIdByAbilityRequest_0400
1700 * @tc.desc: GetPersistentIdByAbilityRequest
1701 * @tc.type: FUNC
1702 */
1703 HWTEST_F(UIAbilityLifecycleManagerTest, GetPersistentIdByAbilityRequest_004, TestSize.Level1)
1704 {
1705 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1706 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1707 AbilityRequest abilityRequest1;
1708 abilityRequest1.abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
1709
1710 Rosen::SessionInfo info;
1711 sptr<SessionInfo> sessionInfo(new SessionInfo());
1712 sessionInfo->sessionToken = new Rosen::Session(info);
1713 sessionInfo->persistentId = 1;
1714 AbilityRequest abilityRequest;
1715 abilityRequest.sessionInfo = sessionInfo;
1716 abilityRequest.abilityInfo.name = "testAbility";
1717 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1718 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1719 bool reuse = false;
1720 EXPECT_EQ(uiAbilityLifecycleManager->GetPersistentIdByAbilityRequest(abilityRequest1, reuse), 0);
1721 }
1722
1723 /**
1724 * @tc.name: UIAbilityLifecycleManager_GetReusedSpecifiedPersistentId_0100
1725 * @tc.desc: GetReusedSpecifiedPersistentId
1726 * @tc.type: FUNC
1727 */
1728 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedSpecifiedPersistentId_001, TestSize.Level1)
1729 {
1730 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1731 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1732 AbilityRequest abilityRequest;
1733 bool reuse = false;
1734 EXPECT_EQ(uiAbilityLifecycleManager->GetReusedSpecifiedPersistentId(abilityRequest, reuse), 0);
1735 }
1736
1737 /**
1738 * @tc.name: UIAbilityLifecycleManager_GetReusedSpecifiedPersistentId_0200
1739 * @tc.desc: GetReusedSpecifiedPersistentId
1740 * @tc.type: FUNC
1741 */
1742 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedSpecifiedPersistentId_002, TestSize.Level1)
1743 {
1744 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1745 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1746 AbilityRequest abilityRequest;
1747 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
1748 abilityRequest.abilityInfo.name = "testAbility";
1749 abilityRequest.abilityInfo.moduleName = "testModule";
1750 abilityRequest.abilityInfo.bundleName = "com.test.ut";
1751 abilityRequest.startRecent = true;
1752 std::string flag = "specified";
1753 abilityRequest.specifiedFlag = flag;
1754
1755 Rosen::SessionInfo info;
1756 sptr<SessionInfo> sessionInfo(new SessionInfo());
1757 sessionInfo->sessionToken = new Rosen::Session(info);
1758 sessionInfo->persistentId = 1;
1759 abilityRequest.sessionInfo = sessionInfo;
1760 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1761 abilityRecord->SetSpecifiedFlag(flag);
1762 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1763 bool reuse = false;
1764 EXPECT_EQ(uiAbilityLifecycleManager->GetReusedSpecifiedPersistentId(abilityRequest, reuse),
1765 sessionInfo->persistentId);
1766 }
1767
1768 /**
1769 * @tc.name: UIAbilityLifecycleManager_GetReusedSpecifiedPersistentId_0300
1770 * @tc.desc: GetReusedSpecifiedPersistentId
1771 * @tc.type: FUNC
1772 */
1773 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedSpecifiedPersistentId_003, TestSize.Level1)
1774 {
1775 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1776 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1777 AbilityRequest abilityRequest;
1778 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
1779 abilityRequest.startRecent = true;
1780 std::string flag = "specified";
1781 abilityRequest.specifiedFlag = flag;
1782
1783 Rosen::SessionInfo info;
1784 sptr<SessionInfo> sessionInfo(new SessionInfo());
1785 sessionInfo->sessionToken = new Rosen::Session(info);
1786 sessionInfo->persistentId = 1;
1787 abilityRequest.sessionInfo = sessionInfo;
1788 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1789 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1790 bool reuse = false;
1791 EXPECT_EQ(uiAbilityLifecycleManager->GetReusedSpecifiedPersistentId(abilityRequest, reuse), 0);
1792 }
1793
1794 /**
1795 * @tc.name: UIAbilityLifecycleManager_GetReusedStandardPersistentId_0100
1796 * @tc.desc: GetReusedStandardPersistentId
1797 * @tc.type: FUNC
1798 */
1799 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedStandardPersistentId_001, TestSize.Level1)
1800 {
1801 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1802 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1803 AbilityRequest abilityRequest;
1804 bool reuse = false;
1805 EXPECT_EQ(uiAbilityLifecycleManager->GetReusedStandardPersistentId(abilityRequest, reuse), 0);
1806 }
1807
1808 /**
1809 * @tc.name: UIAbilityLifecycleManager_GetReusedStandardPersistentId_0200
1810 * @tc.desc: GetReusedStandardPersistentId
1811 * @tc.type: FUNC
1812 */
1813 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedStandardPersistentId_002, TestSize.Level1)
1814 {
1815 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1816 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1817 AbilityRequest abilityRequest;
1818 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::STANDARD;
1819 abilityRequest.abilityInfo.name = "testAbility";
1820 abilityRequest.abilityInfo.moduleName = "testModule";
1821 abilityRequest.abilityInfo.bundleName = "com.test.ut";
1822 abilityRequest.startRecent = true;
1823
1824 Rosen::SessionInfo info;
1825 sptr<SessionInfo> sessionInfo(new SessionInfo());
1826 sessionInfo->sessionToken = new Rosen::Session(info);
1827 sessionInfo->persistentId = 1;
1828 abilityRequest.sessionInfo = sessionInfo;
1829 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1830 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1831 bool reuse = false;
1832 EXPECT_EQ(uiAbilityLifecycleManager->GetReusedStandardPersistentId(abilityRequest, reuse),
1833 sessionInfo->persistentId);
1834 }
1835
1836 /**
1837 * @tc.name: UIAbilityLifecycleManager_NotifySCBPendingActivation_0100
1838 * @tc.desc: NotifySCBPendingActivation
1839 * @tc.type: FUNC
1840 */
1841 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBPendingActivation_001, TestSize.Level1)
1842 {
1843 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1844 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1845 AbilityRequest abilityRequest;
1846 Rosen::SessionInfo info;
1847 sptr<SessionInfo> sessionInfo(new SessionInfo());
1848 sessionInfo->sessionToken = new Rosen::Session(info);
1849 sessionInfo->persistentId = 1;
1850 abilityRequest.sessionInfo = sessionInfo;
1851 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1852 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1853 auto token = abilityRecord->GetToken();
1854 EXPECT_NE(token, nullptr);
1855 abilityRequest.callerToken = token->AsObject();
1856 uiAbilityLifecycleManager->NotifySCBPendingActivation(sessionInfo, abilityRequest);
1857 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1858 }
1859
1860 /**
1861 * @tc.name: UIAbilityLifecycleManager_ResolveLocked_0100
1862 * @tc.desc: ResolveLocked
1863 * @tc.type: FUNC
1864 */
1865 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveLocked_001, TestSize.Level1)
1866 {
1867 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1868 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1869 AbilityRequest abilityRequest;
1870 EXPECT_EQ(uiAbilityLifecycleManager->ResolveLocked(abilityRequest), RESOLVE_CALL_ABILITY_INNER_ERR);
1871 }
1872
1873 /**
1874 * @tc.name: UIAbilityLifecycleManager_ResolveLocked_0200
1875 * @tc.desc: ResolveLocked
1876 * @tc.type: FUNC
1877 */
1878 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveLocked_002, TestSize.Level1)
1879 {
1880 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1881 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1882 AbilityRequest abilityRequest;
1883 abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
1884 EXPECT_EQ(uiAbilityLifecycleManager->ResolveLocked(abilityRequest), RESOLVE_CALL_ABILITY_INNER_ERR);
1885 }
1886
1887 /**
1888 * @tc.name: UIAbilityLifecycleManager_CallAbilityLocked_0100
1889 * @tc.desc: CallAbilityLocked
1890 * @tc.type: FUNC
1891 */
1892 HWTEST_F(UIAbilityLifecycleManagerTest, CallAbilityLocked_001, TestSize.Level1)
1893 {
1894 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1895 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1896
1897 AbilityRequest abilityRequest;
1898 Rosen::SessionInfo info;
1899 sptr<SessionInfo> sessionInfo(new SessionInfo());
1900 sessionInfo->sessionToken = new Rosen::Session(info);
1901 sessionInfo->persistentId = 1;
1902 Want want;
1903 want.SetParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, true);
1904 abilityRequest.sessionInfo = sessionInfo;
1905 abilityRequest.want = want;
1906 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
1907 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1908 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
1909 abilityRecord->isReady_ = true;
1910
1911 uiAbilityLifecycleManager->CallAbilityLocked(abilityRequest);
1912 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1913 }
1914
1915 /**
1916 * @tc.name: UIAbilityLifecycleManager_CallAbilityLocked_0200
1917 * @tc.desc: CallAbilityLocked
1918 * @tc.type: FUNC
1919 */
1920 HWTEST_F(UIAbilityLifecycleManagerTest, CallAbilityLocked_002, TestSize.Level1)
1921 {
1922 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1923 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1924 AbilityRequest abilityRequest;
1925 abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
1926 Want want;
1927 want.SetParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, true);
1928 abilityRequest.want = want;
1929 uiAbilityLifecycleManager->CallAbilityLocked(abilityRequest);
1930 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1931 }
1932
1933 /**
1934 * @tc.name: UIAbilityLifecycleManager_CallUIAbilityBySCB_0100
1935 * @tc.desc: CallUIAbilityBySCB
1936 * @tc.type: FUNC
1937 */
1938 HWTEST_F(UIAbilityLifecycleManagerTest, CallUIAbilityBySCB_001, TestSize.Level1)
1939 {
1940 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1941 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1942 sptr<SessionInfo> sessionInfo;
1943 bool isColdStart = false;
1944 uiAbilityLifecycleManager->CallUIAbilityBySCB(sessionInfo, isColdStart);
1945 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1946 }
1947
1948 /**
1949 * @tc.name: UIAbilityLifecycleManager_CallUIAbilityBySCB_0200
1950 * @tc.desc: CallUIAbilityBySCB
1951 * @tc.type: FUNC
1952 */
1953 HWTEST_F(UIAbilityLifecycleManagerTest, CallUIAbilityBySCB_002, TestSize.Level1)
1954 {
1955 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1956 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1957 sptr<SessionInfo> sessionInfo(new SessionInfo());
1958 sessionInfo->sessionToken = nullptr;
1959 bool isColdStart = false;
1960 uiAbilityLifecycleManager->CallUIAbilityBySCB(sessionInfo, isColdStart);
1961 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1962 }
1963
1964 /**
1965 * @tc.name: UIAbilityLifecycleManager_CallUIAbilityBySCB_0300
1966 * @tc.desc: CallUIAbilityBySCB
1967 * @tc.type: FUNC
1968 */
1969 HWTEST_F(UIAbilityLifecycleManagerTest, CallUIAbilityBySCB_003, TestSize.Level1)
1970 {
1971 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1972 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1973 sptr<SessionInfo> sessionInfo(new SessionInfo());
1974 AbilityRequest abilityRequest;
1975 abilityRequest.sessionInfo = sessionInfo;
1976 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
1977 auto token = abilityRecord->GetToken();
1978 EXPECT_NE(token, nullptr);
1979 sessionInfo->sessionToken = token->AsObject();
1980 bool isColdStart = false;
1981 uiAbilityLifecycleManager->CallUIAbilityBySCB(sessionInfo, isColdStart);
1982 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1983 }
1984
1985 /**
1986 * @tc.name: UIAbilityLifecycleManager_CallUIAbilityBySCB_0400
1987 * @tc.desc: CallUIAbilityBySCB
1988 * @tc.type: FUNC
1989 */
1990 HWTEST_F(UIAbilityLifecycleManagerTest, CallUIAbilityBySCB_004, TestSize.Level1)
1991 {
1992 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
1993 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
1994 Rosen::SessionInfo info;
1995 sptr<SessionInfo> sessionInfo(new SessionInfo());
1996 sessionInfo->sessionToken = new Rosen::Session(info);
1997 bool isColdStart = false;
1998 uiAbilityLifecycleManager->CallUIAbilityBySCB(sessionInfo, isColdStart);
1999 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2000 }
2001
2002 /**
2003 * @tc.name: UIAbilityLifecycleManager_CallUIAbilityBySCB_0500
2004 * @tc.desc: CallUIAbilityBySCB
2005 * @tc.type: FUNC
2006 */
2007 HWTEST_F(UIAbilityLifecycleManagerTest, CallUIAbilityBySCB_005, TestSize.Level1)
2008 {
2009 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2010 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2011 Rosen::SessionInfo info;
2012 sptr<SessionInfo> sessionInfo(new SessionInfo());
2013 sessionInfo->sessionToken = new Rosen::Session(info);
2014 sessionInfo->uiAbilityId = 1;
2015
2016 uiAbilityLifecycleManager->tmpAbilityMap_.emplace(1, nullptr);
2017 bool isColdStart = false;
2018 uiAbilityLifecycleManager->CallUIAbilityBySCB(sessionInfo, isColdStart);
2019 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2020 }
2021
2022 /**
2023 * @tc.name: UIAbilityLifecycleManager_CallUIAbilityBySCB_0600
2024 * @tc.desc: CallUIAbilityBySCB
2025 * @tc.type: FUNC
2026 */
2027 HWTEST_F(UIAbilityLifecycleManagerTest, CallUIAbilityBySCB_006, TestSize.Level1)
2028 {
2029 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2030 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2031 Rosen::SessionInfo info;
2032 sptr<SessionInfo> sessionInfo(new SessionInfo());
2033 sessionInfo->sessionToken = new Rosen::Session(info);
2034 sessionInfo->uiAbilityId = 1;
2035
2036 AbilityRequest abilityRequest;
2037 abilityRequest.sessionInfo = sessionInfo;
2038 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2039 uiAbilityLifecycleManager->tmpAbilityMap_.emplace(1, abilityRecord);
2040 bool isColdStart = false;
2041 uiAbilityLifecycleManager->CallUIAbilityBySCB(sessionInfo, isColdStart);
2042 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2043 }
2044
2045 /**
2046 * @tc.name: UIAbilityLifecycleManager_CallUIAbilityBySCB_0700
2047 * @tc.desc: CallUIAbilityBySCB
2048 * @tc.type: FUNC
2049 */
2050 HWTEST_F(UIAbilityLifecycleManagerTest, CallUIAbilityBySCB_007, TestSize.Level1)
2051 {
2052 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2053 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2054 Rosen::SessionInfo info;
2055 sptr<SessionInfo> sessionInfo(new SessionInfo());
2056 sessionInfo->sessionToken = new Rosen::Session(info);
2057 sessionInfo->uiAbilityId = 1;
2058 sessionInfo->persistentId = 1;
2059
2060 AbilityRequest abilityRequest;
2061 abilityRequest.sessionInfo = sessionInfo;
2062 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
2063 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2064
2065 uiAbilityLifecycleManager->tmpAbilityMap_.emplace(1, abilityRecord);
2066 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
2067 bool isColdStart = false;
2068 uiAbilityLifecycleManager->CallUIAbilityBySCB(sessionInfo, isColdStart);
2069 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2070 }
2071
2072 /**
2073 * @tc.name: UIAbilityLifecycleManager_CallRequestDone_0100
2074 * @tc.desc: CallRequestDone
2075 * @tc.type: FUNC
2076 */
2077 HWTEST_F(UIAbilityLifecycleManagerTest, CallRequestDone_001, TestSize.Level1)
2078 {
2079 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2080 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2081 uiAbilityLifecycleManager->CallRequestDone(nullptr, nullptr);
2082 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2083 }
2084
2085 /**
2086 * @tc.name: UIAbilityLifecycleManager_CallRequestDone_0200
2087 * @tc.desc: CallRequestDone
2088 * @tc.type: FUNC
2089 */
2090 HWTEST_F(UIAbilityLifecycleManagerTest, CallRequestDone_002, TestSize.Level1)
2091 {
2092 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2093 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2094 AbilityRequest abilityRequest;
2095 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2096 uiAbilityLifecycleManager->CallRequestDone(abilityRecord, nullptr);
2097 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2098 }
2099
2100 /**
2101 * @tc.name: UIAbilityLifecycleManager_CallRequestDone_0300
2102 * @tc.desc: CallRequestDone
2103 * @tc.type: FUNC
2104 */
2105 HWTEST_F(UIAbilityLifecycleManagerTest, CallRequestDone_003, TestSize.Level1)
2106 {
2107 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2108 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2109 AbilityRequest abilityRequest;
2110 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2111 auto token = abilityRecord->GetToken();
2112 EXPECT_NE(token, nullptr);
2113 uiAbilityLifecycleManager->CallRequestDone(abilityRecord, token->AsObject());
2114 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2115 }
2116
2117 /**
2118 * @tc.name: UIAbilityLifecycleManager_ReleaseCallLocked_0100
2119 * @tc.desc: ReleaseCallLocked
2120 * @tc.type: FUNC
2121 */
2122 HWTEST_F(UIAbilityLifecycleManagerTest, ReleaseCallLocked_001, TestSize.Level1)
2123 {
2124 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2125 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2126 sptr<IAbilityConnection> connect = new UIAbilityLifcecycleManagerTestStub();
2127 AppExecFwk::ElementName element;
2128 auto ret = uiAbilityLifecycleManager->ReleaseCallLocked(connect, element);
2129 EXPECT_EQ(ret, RELEASE_CALL_ABILITY_INNER_ERR);
2130 }
2131
2132 /**
2133 * @tc.name: UIAbilityLifecycleManager_ReleaseCallLocked_0200
2134 * @tc.desc: ReleaseCallLocked
2135 * @tc.type: FUNC
2136 */
2137 HWTEST_F(UIAbilityLifecycleManagerTest, ReleaseCallLocked_002, TestSize.Level1)
2138 {
2139 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2140 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2141 auto abilityRecord = InitAbilityRecord();
2142 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2143 sptr<IAbilityConnection> connect = new UIAbilityLifcecycleManagerTestStub();
2144 AppExecFwk::ElementName element("", "com.example.unittest", "MainAbility");
2145 auto ret = uiAbilityLifecycleManager->ReleaseCallLocked(connect, element);
2146 EXPECT_EQ(ret, RELEASE_CALL_ABILITY_INNER_ERR);
2147 }
2148
2149 /**
2150 * @tc.name: UIAbilityLifecycleManager_Dump_001
2151 * @tc.desc: Dump
2152 * @tc.type: FUNC
2153 */
2154 HWTEST_F(UIAbilityLifecycleManagerTest, Dump_001, TestSize.Level1)
2155 {
2156 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2157 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2158 AbilityRequest abilityRequest;
2159 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2160 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2161 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, nullptr);
2162 std::vector<std::string> info;
2163 uiAbilityLifecycleManager->Dump(info);
2164 }
2165
2166 /**
2167 * @tc.name: UIAbilityLifecycleManager_DumpMissionList_001
2168 * @tc.desc: DumpMissionList
2169 * @tc.type: FUNC
2170 */
2171 HWTEST_F(UIAbilityLifecycleManagerTest, DumpMissionList_001, TestSize.Level1)
2172 {
2173 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2174 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2175 AbilityRequest abilityRequest;
2176 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2177 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, nullptr);
2178 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2179 std::vector<std::string> info;
2180 bool isClient = false;
2181 std::string args;
2182 uiAbilityLifecycleManager->DumpMissionList(info, isClient, args);
2183 }
2184
2185 /**
2186 * @tc.name: UIAbilityLifecycleManager_DumpMissionList_002
2187 * @tc.desc: DumpMissionList
2188 * @tc.type: FUNC
2189 */
2190 HWTEST_F(UIAbilityLifecycleManagerTest, DumpMissionList_002, TestSize.Level1)
2191 {
2192 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2193 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2194 AbilityRequest abilityRequest;
2195 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2196 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2197 std::vector<std::string> info;
2198 bool isClient = false;
2199 std::string args;
2200 uiAbilityLifecycleManager->DumpMissionList(info, isClient, args);
2201 }
2202
2203 /**
2204 * @tc.name: UIAbilityLifecycleManager_DumpMissionListByRecordId_001
2205 * @tc.desc: DumpMissionListByRecordId
2206 * @tc.type: FUNC
2207 */
2208 HWTEST_F(UIAbilityLifecycleManagerTest, DumpMissionListByRecordId_001, TestSize.Level1)
2209 {
2210 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2211 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2212 AbilityRequest abilityRequest;
2213 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2214 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, nullptr);
2215 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2216 std::vector<std::string> info;
2217 bool isClient = false;
2218 int32_t abilityRecordId = 0;
2219 std::vector<std::string> params;
2220 uiAbilityLifecycleManager->DumpMissionListByRecordId(info, isClient, abilityRecordId, params);
2221 }
2222
2223 /**
2224 * @tc.name: UIAbilityLifecycleManager_DumpMissionListByRecordId_002
2225 * @tc.desc: DumpMissionListByRecordId
2226 * @tc.type: FUNC
2227 */
2228 HWTEST_F(UIAbilityLifecycleManagerTest, DumpMissionListByRecordId_002, TestSize.Level1)
2229 {
2230 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2231 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2232 AbilityRequest abilityRequest;
2233 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2234 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2235 std::vector<std::string> info;
2236 bool isClient = false;
2237 int32_t abilityRecordId = 1;
2238 std::vector<std::string> params;
2239 uiAbilityLifecycleManager->DumpMissionListByRecordId(info, isClient, abilityRecordId, params);
2240 }
2241
2242 /**
2243 * @tc.name: UIAbilityLifecycleManager_OnAcceptWantResponse_0100
2244 * @tc.desc: OnAcceptWantResponse
2245 * @tc.type: FUNC
2246 */
2247 HWTEST_F(UIAbilityLifecycleManagerTest, OnAcceptWantResponse_001, TestSize.Level1)
2248 {
2249 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2250 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2251 Want want;
2252 std::string flag = "flag";
2253 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2254
2255 AbilityRequest abilityRequest;
2256 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2257
2258 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
2259 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2260
2261 uiAbilityLifecycleManager->OnAcceptWantResponse(want, "");
2262 uiAbilityLifecycleManager.reset();
2263 }
2264
2265 #ifdef WITH_DLP
2266 /**
2267 * @tc.name: UIAbilityLifecycleManager_OnAcceptWantResponse_0200
2268 * @tc.desc: OnAcceptWantResponse
2269 * @tc.type: FUNC
2270 */
2271 HWTEST_F(UIAbilityLifecycleManagerTest, OnAcceptWantResponse_002, TestSize.Level1)
2272 {
2273 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2274 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2275 Want want;
2276 std::string flag = "flag";
2277 AbilityRequest abilityRequest;
2278 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
2279 abilityRequest.startRecent = true;
2280 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
2281 abilityRequest.abilityInfo.name = "MainAbility";
2282 abilityRequest.abilityInfo.moduleName = "entry";
2283 abilityRequest.specifiedFlag = flag;
2284 want.SetParam(DLP_INDEX, 1);
2285 abilityRequest.want = want;
2286 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2287 abilityRecord->abilityInfo_.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
2288 abilityRecord->abilityInfo_.moduleName = "entry";
2289 abilityRecord->SetAppIndex(1);
2290 abilityRecord->SetSpecifiedFlag(flag);
2291 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2292 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2293
2294 std::shared_ptr<AbilityRecord> callerAbility = InitAbilityRecord();
2295 abilityRequest.callerToken = callerAbility->GetToken()->AsObject();
2296 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2297 uiAbilityLifecycleManager.reset();
2298 }
2299 #endif // WITH_DLP
2300
2301 /**
2302 * @tc.name: UIAbilityLifecycleManager_StartSpecifiedAbilityBySCB_0100
2303 * @tc.desc: StartSpecifiedAbilityBySCB
2304 * @tc.type: FUNC
2305 */
2306 HWTEST_F(UIAbilityLifecycleManagerTest, StartSpecifiedAbilityBySCB_001, TestSize.Level1)
2307 {
2308 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2309 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2310 Want want;
2311 uiAbilityLifecycleManager->StartSpecifiedAbilityBySCB(want);
2312 uiAbilityLifecycleManager.reset();
2313 }
2314
2315 /**
2316 * @tc.name: UIAbilityLifecycleManager_NotifyRestartSpecifiedAbility_0100
2317 * @tc.desc: NotifyRestartSpecifiedAbility
2318 * @tc.type: FUNC
2319 */
2320 HWTEST_F(UIAbilityLifecycleManagerTest, NotifyRestartSpecifiedAbility_001, TestSize.Level1)
2321 {
2322 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2323 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2324 AbilityRequest request;
2325 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2326 sptr<IRemoteObject> token = abilityRecord->GetToken();
2327 request.abilityInfoCallback = new MockAbilityInfoCallbackStub();
2328 uiAbilityLifecycleManager->NotifyRestartSpecifiedAbility(request, token);
2329 uiAbilityLifecycleManager.reset();
2330 }
2331
2332 /**
2333 * @tc.name: UIAbilityLifecycleManager_NotifyStartSpecifiedAbility_0100
2334 * @tc.desc: NotifyStartSpecifiedAbility
2335 * @tc.type: FUNC
2336 */
2337 HWTEST_F(UIAbilityLifecycleManagerTest, NotifyStartSpecifiedAbility_001, TestSize.Level1)
2338 {
2339 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2340 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2341 AbilityRequest request;
2342 Want want;
2343 request.abilityInfoCallback = new MockAbilityInfoCallbackStub();
2344 uiAbilityLifecycleManager->NotifyStartSpecifiedAbility(request, want);
2345 uiAbilityLifecycleManager.reset();
2346 }
2347
2348 /**
2349 * @tc.name: UIAbilityLifecycleManager_MoveAbilityToFront_0100
2350 * @tc.desc: MoveAbilityToFront
2351 * @tc.type: FUNC
2352 */
2353 HWTEST_F(UIAbilityLifecycleManagerTest, MoveAbilityToFront_001, TestSize.Level1)
2354 {
2355 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2356 AbilityRequest abilityRequest;
2357 int res = uiAbilityLifecycleManager->MoveAbilityToFront(abilityRequest, nullptr, nullptr, nullptr);
2358 EXPECT_EQ(res, ERR_INVALID_VALUE);
2359
2360 abilityRequest.sessionInfo = new SessionInfo();
2361 abilityRequest.appInfo.bundleName = "com.example.unittest";
2362 abilityRequest.abilityInfo.name = "MainAbility";
2363 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
2364 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2365 res = uiAbilityLifecycleManager->MoveAbilityToFront(abilityRequest, abilityRecord, nullptr, nullptr);
2366 EXPECT_EQ(res, ERR_OK);
2367
2368 auto startOptions = std::make_shared<StartOptions>();
2369 res = uiAbilityLifecycleManager->MoveAbilityToFront(abilityRequest, abilityRecord, nullptr, nullptr);
2370 EXPECT_EQ(res, ERR_OK);
2371
2372 uiAbilityLifecycleManager.reset();
2373 }
2374
2375 /**
2376 * @tc.name: UIAbilityLifecycleManager_SendSessionInfoToSCB_0100
2377 * @tc.desc: SendSessionInfoToSCB
2378 * @tc.type: FUNC
2379 */
2380 HWTEST_F(UIAbilityLifecycleManagerTest, SendSessionInfoToSCB_001, TestSize.Level1)
2381 {
2382 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2383 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2384 Rosen::SessionInfo info;
2385 sptr<SessionInfo> sessionInfo(new SessionInfo());
2386 AbilityRequest abilityRequest;
2387 sessionInfo->sessionToken = new Rosen::Session(info);
2388 abilityRequest.sessionInfo = sessionInfo;
2389 abilityRequest.appInfo.bundleName = "com.example.unittest";
2390 abilityRequest.abilityInfo.name = "MainAbility";
2391 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
2392 std::shared_ptr<AbilityRecord> callerAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
2393 int res = uiAbilityLifecycleManager->SendSessionInfoToSCB(callerAbility, sessionInfo);
2394 EXPECT_EQ(res, ERR_OK);
2395
2396 sessionInfo->sessionToken = nullptr;
2397 abilityRequest.sessionInfo = sessionInfo;
2398 callerAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
2399 res = uiAbilityLifecycleManager->SendSessionInfoToSCB(callerAbility, sessionInfo);
2400 EXPECT_EQ(res, ERR_INVALID_VALUE);
2401
2402 abilityRequest.sessionInfo = nullptr;
2403 callerAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
2404 auto token = callerAbility->GetToken();
2405 EXPECT_NE(token, nullptr);
2406 auto object = token->AsObject();
2407 uiAbilityLifecycleManager->SetRootSceneSession(object);
2408 res = uiAbilityLifecycleManager->SendSessionInfoToSCB(callerAbility, sessionInfo);
2409 EXPECT_EQ(res, ERR_INVALID_VALUE);
2410
2411 uiAbilityLifecycleManager->SetRootSceneSession(nullptr);
2412 res = uiAbilityLifecycleManager->SendSessionInfoToSCB(callerAbility, sessionInfo);
2413 EXPECT_EQ(res, ERR_INVALID_VALUE);
2414
2415 uiAbilityLifecycleManager.reset();
2416 }
2417
2418 /**
2419 * @tc.name: UIAbilityLifecycleManager_StartAbilityBySpecifed_0100
2420 * @tc.desc: StartAbilityBySpecifed
2421 * @tc.type: FUNC
2422 */
2423 HWTEST_F(UIAbilityLifecycleManagerTest, StartAbilityBySpecifed_001, TestSize.Level1)
2424 {
2425 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2426 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2427 AbilityRequest request;
2428 std::shared_ptr<AbilityRecord> callerAbility = nullptr;
2429 uiAbilityLifecycleManager->StartAbilityBySpecifed(request, callerAbility, 0, "");
2430 uiAbilityLifecycleManager.reset();
2431 }
2432
2433 /**
2434 * @tc.name: UIAbilityLifecycleManager_GetAbilityStateByPersistentId_0100
2435 * @tc.desc: GetAbilityStateByPersistentId
2436 * @tc.type: FUNC
2437 */
2438 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityStateByPersistentId_001, TestSize.Level1)
2439 {
2440 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2441 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2442 int32_t persistentId = 100;
2443 bool state;
2444 int32_t ret = uiAbilityLifecycleManager->GetAbilityStateByPersistentId(persistentId, state);
2445 EXPECT_EQ(ERR_INVALID_VALUE, ret);
2446 }
2447
2448 /**
2449 * @tc.name: UIAbilityLifecycleManager_GetAbilityStateByPersistentId_0200
2450 * @tc.desc: GetAbilityStateByPersistentId
2451 * @tc.type: FUNC
2452 */
2453 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityStateByPersistentId_002, TestSize.Level1)
2454 {
2455 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2456 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2457 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2458 abilityRecord->SetPendingState(AbilityState::INITIAL);
2459 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(100, abilityRecord);
2460 int32_t persistentId = 100;
2461 bool state;
2462 int32_t ret = uiAbilityLifecycleManager->GetAbilityStateByPersistentId(persistentId, state);
2463 EXPECT_EQ(ERR_OK, ret);
2464 }
2465
2466 /**
2467 * @tc.name: UIAbilityLifecycleManager_UpdateProcessName_0100
2468 * @tc.desc: UpdateProcessName
2469 * @tc.type: FUNC
2470 */
2471 HWTEST_F(UIAbilityLifecycleManagerTest, UpdateProcessName_001, TestSize.Level1)
2472 {
2473 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2474 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2475 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
2476 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
2477 EXPECT_NE(sessionInfo->processOptions, nullptr);
2478 sessionInfo->processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_PARENT;
2479 AbilityRequest abilityRequest;
2480 abilityRequest.sessionInfo = sessionInfo;
2481 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
2482 abilityRequest.abilityInfo.moduleName = "entry";
2483 abilityRequest.abilityInfo.name = "MainAbility";
2484 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2485 uiAbilityLifecycleManager->UpdateProcessName(abilityRequest, abilityRecord);
2486 EXPECT_EQ("com.example.unittest:entry:MainAbility:0", abilityRecord->GetProcessName());
2487 }
2488
2489 /**
2490 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0100
2491 * @tc.desc: ChangeAbilityVisibility
2492 * @tc.type: FUNC
2493 */
2494 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_001, TestSize.Level1)
2495 {
2496 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2497 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2498 int32_t ret = uiAbilityLifecycleManager->ChangeAbilityVisibility(nullptr, true);
2499 EXPECT_EQ(ERR_INVALID_VALUE, ret);
2500 }
2501
2502 /**
2503 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0100
2504 * @tc.desc: ChangeUIAbilityVisibilityBySCB
2505 * @tc.type: FUNC
2506 */
2507 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_001, TestSize.Level1)
2508 {
2509 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2510 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2511 int32_t ret = uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(nullptr, true);
2512 EXPECT_EQ(ERR_INVALID_VALUE, ret);
2513 }
2514
2515 /**
2516 * @tc.name: UIAbilityLifecycleManager_IsContainsAbility_0100
2517 * @tc.desc: IsContainsAbility
2518 * @tc.type: FUNC
2519 */
2520 HWTEST_F(UIAbilityLifecycleManagerTest, IsContainsAbility_001, TestSize.Level1)
2521 {
2522 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2523 EXPECT_NE(mgr, nullptr);
2524 sptr<IRemoteObject> token = nullptr;
2525 bool boolValue = mgr->IsContainsAbility(token);
2526 EXPECT_FALSE(boolValue);
2527 }
2528
2529 /**
2530 * @tc.name: UIAbilityLifecycleManager_IsContainsAbility_0200
2531 * @tc.desc: IsContainsAbility
2532 * @tc.type: FUNC
2533 */
2534 HWTEST_F(UIAbilityLifecycleManagerTest, IsContainsAbility_002, TestSize.Level1)
2535 {
2536 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2537 EXPECT_NE(mgr, nullptr);
2538 AbilityRequest abilityRequest;
2539 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2540 auto&& token = abilityRecord->GetToken()->AsObject();
2541 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
2542 bool boolValue = mgr->IsContainsAbility(token);
2543 EXPECT_TRUE(boolValue);
2544 }
2545
2546 /**
2547 * @tc.name: UIAbilityLifecycleManager_IsContainsAbilityInner_0100
2548 * @tc.desc: IsContainsAbilityInner
2549 * @tc.type: FUNC
2550 */
2551 HWTEST_F(UIAbilityLifecycleManagerTest, IsContainsAbilityInner_001, TestSize.Level1)
2552 {
2553 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2554 EXPECT_NE(mgr, nullptr);
2555 sptr<IRemoteObject> token = nullptr;
2556 bool boolValue = mgr->IsContainsAbilityInner(token);
2557 EXPECT_FALSE(boolValue);
2558 }
2559
2560 /**
2561 * @tc.name: UIAbilityLifecycleManager_IsContainsAbilityInner_0200
2562 * @tc.desc: IsContainsAbilityInner
2563 * @tc.type: FUNC
2564 */
2565 HWTEST_F(UIAbilityLifecycleManagerTest, IsContainsAbilityInner_002, TestSize.Level1)
2566 {
2567 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2568 EXPECT_NE(mgr, nullptr);
2569 AbilityRequest abilityRequest;
2570 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2571 auto&& token = abilityRecord->GetToken()->AsObject();
2572 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
2573 bool boolValue = mgr->IsContainsAbilityInner(token);
2574 EXPECT_TRUE(boolValue);
2575 }
2576
2577 /**
2578 * @tc.name: UIAbilityLifecycleManager_NotifySCBToMinimizeUIAbility_0100
2579 * @tc.desc: NotifySCBToMinimizeUIAbility
2580 * @tc.type: FUNC
2581 */
2582 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToMinimizeUIAbility_001, TestSize.Level1)
2583 {
2584 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2585 sptr<IRemoteObject> token = nullptr;
2586 EXPECT_NE(mgr->NotifySCBToMinimizeUIAbility(token), ERR_OK);
2587 }
2588
2589 /**
2590 * @tc.name: UIAbilityLifecycleManager_GetUIAbilityRecordBySessionInfo_0100
2591 * @tc.desc: GetUIAbilityRecordBySessionInfo
2592 * @tc.type: FUNC
2593 */
2594 HWTEST_F(UIAbilityLifecycleManagerTest, GetUIAbilityRecordBySessionInfo_001, TestSize.Level1)
2595 {
2596 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2597 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2598 sptr<SessionInfo> sessionInfo = nullptr;
2599 EXPECT_EQ(uiAbilityLifecycleManager->GetUIAbilityRecordBySessionInfo(sessionInfo), nullptr);
2600 }
2601
2602 /**
2603 * @tc.name: UIAbilityLifecycleManager_GetUIAbilityRecordBySessionInfo_0200
2604 * @tc.desc: GetUIAbilityRecordBySessionInfo
2605 * @tc.type: FUNC
2606 */
2607 HWTEST_F(UIAbilityLifecycleManagerTest, GetUIAbilityRecordBySessionInfo_002, TestSize.Level1)
2608 {
2609 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2610 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2611 sptr<SessionInfo> sessionInfo(new SessionInfo());
2612 sessionInfo->sessionToken = nullptr;
2613 EXPECT_EQ(uiAbilityLifecycleManager->GetUIAbilityRecordBySessionInfo(sessionInfo), nullptr);
2614 }
2615
2616 /**
2617 * @tc.name: UIAbilityLifecycleManager_GetUIAbilityRecordBySessionInfo_0300
2618 * @tc.desc: GetUIAbilityRecordBySessionInfo
2619 * @tc.type: FUNC
2620 */
2621 HWTEST_F(UIAbilityLifecycleManagerTest, GetUIAbilityRecordBySessionInfo_003, TestSize.Level1)
2622 {
2623 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2624 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2625 Rosen::SessionInfo info;
2626 sptr<SessionInfo> sessionInfo(new SessionInfo());
2627 sessionInfo->sessionToken = new Rosen::Session(info);
2628 EXPECT_EQ(uiAbilityLifecycleManager->GetUIAbilityRecordBySessionInfo(sessionInfo), nullptr);
2629 }
2630
2631 /**
2632 * @tc.name: UIAbilityLifecycleManager_GetUIAbilityRecordBySessionInfo_0400
2633 * @tc.desc: GetUIAbilityRecordBySessionInfo
2634 * @tc.type: FUNC
2635 */
2636 HWTEST_F(UIAbilityLifecycleManagerTest, GetUIAbilityRecordBySessionInfo_004, TestSize.Level1)
2637 {
2638 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2639 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2640 AbilityRequest abilityRequest;
2641 Rosen::SessionInfo info;
2642 sptr<SessionInfo> sessionInfo(new SessionInfo());
2643 sessionInfo->sessionToken = new Rosen::Session(info);
2644 sessionInfo->persistentId = 1;
2645 abilityRequest.sessionInfo = sessionInfo;
2646 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2647 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
2648 EXPECT_NE(uiAbilityLifecycleManager->GetUIAbilityRecordBySessionInfo(sessionInfo), nullptr);
2649 }
2650
2651 /**
2652 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedProcessResponse_0100
2653 * @tc.desc: OnStartSpecifiedProcessResponse
2654 * @tc.type: FUNC
2655 */
2656 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedProcessResponse_001, TestSize.Level1)
2657 {
2658 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2659 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2660 Want want;
2661 std::string flag = "flag";
2662 uiAbilityLifecycleManager->OnStartSpecifiedProcessResponse(want, flag);
2663 uiAbilityLifecycleManager.reset();
2664 }
2665
2666 /**
2667 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedProcessResponse_0200
2668 * @tc.desc: OnStartSpecifiedProcessResponse
2669 * @tc.type: FUNC
2670 */
2671 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedProcessResponse_002, TestSize.Level1)
2672 {
2673 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2674 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2675 Want want;
2676 std::string flag = "flag";
2677 int32_t requestId = 100;
2678 uiAbilityLifecycleManager->OnStartSpecifiedProcessResponse(want, flag, requestId);
2679 uiAbilityLifecycleManager.reset();
2680 }
2681
2682 /**
2683 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedAbilityTimeoutResponse_0100
2684 * @tc.desc: OnStartSpecifiedAbilityTimeoutResponse
2685 * @tc.type: FUNC
2686 */
2687 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedAbilityTimeoutResponse_001, TestSize.Level1)
2688 {
2689 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2690 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2691 Want want;
2692 uiAbilityLifecycleManager->OnStartSpecifiedAbilityTimeoutResponse(want);
2693 uiAbilityLifecycleManager.reset();
2694 }
2695
2696 /**
2697 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedAbilityTimeoutResponse_0200
2698 * @tc.desc: OnStartSpecifiedAbilityTimeoutResponse
2699 * @tc.type: FUNC
2700 */
2701 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedAbilityTimeoutResponse_002, TestSize.Level1)
2702 {
2703 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2704 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2705 Want want;
2706 int32_t requestId = 100;
2707 uiAbilityLifecycleManager->OnStartSpecifiedAbilityTimeoutResponse(want, requestId);
2708 uiAbilityLifecycleManager.reset();
2709 }
2710
2711 /**
2712 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedFailed_0100
2713 * @tc.desc: OnStartSpecifiedFailed
2714 * @tc.type: FUNC
2715 */
2716 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedFailed_001, TestSize.Level1)
2717 {
2718 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2719 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2720 int32_t requestId = 0;
2721 uiAbilityLifecycleManager->OnStartSpecifiedFailed(requestId);
2722
2723 auto &list = uiAbilityLifecycleManager->specifiedRequestList_[std::string()];
2724 list.push_back(std::make_shared<SpecifiedRequest>(requestId, AbilityRequest()));
2725
2726 uiAbilityLifecycleManager->OnStartSpecifiedFailed(requestId);
2727 EXPECT_TRUE(list.empty());
2728 }
2729
2730 /**
2731 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedProcessTimeoutResponse_0100
2732 * @tc.desc: OnStartSpecifiedProcessTimeoutResponse
2733 * @tc.type: FUNC
2734 */
2735 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedProcessTimeoutResponse_001, TestSize.Level1)
2736 {
2737 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2738 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2739 Want want;
2740 uiAbilityLifecycleManager->OnStartSpecifiedProcessTimeoutResponse(want);
2741 uiAbilityLifecycleManager.reset();
2742 }
2743
2744 /**
2745 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedProcessTimeoutResponse_0200
2746 * @tc.desc: OnStartSpecifiedProcessTimeoutResponse
2747 * @tc.type: FUNC
2748 */
2749 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedProcessTimeoutResponse_002, TestSize.Level1)
2750 {
2751 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2752 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2753 Want want;
2754 int32_t requestId = 100;
2755 uiAbilityLifecycleManager->OnStartSpecifiedProcessTimeoutResponse(want, requestId);
2756 uiAbilityLifecycleManager.reset();
2757 }
2758
2759 /**
2760 * @tc.name: UIAbilityLifecycleManager_OnCallConnectDied_0100
2761 * @tc.desc: OnCallConnectDied
2762 * @tc.type: FUNC
2763 */
2764 HWTEST_F(UIAbilityLifecycleManagerTest, OnCallConnectDied_001, TestSize.Level1)
2765 {
2766 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2767 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2768 std::shared_ptr<CallRecord> callRecord = nullptr;
2769 uiAbilityLifecycleManager->OnCallConnectDied(callRecord);
2770 uiAbilityLifecycleManager.reset();
2771 }
2772
2773 /**
2774 * @tc.name: UIAbilityLifecycleManager_GetSessionIdByAbilityToken_0100
2775 * @tc.desc: GetSessionIdByAbilityToken
2776 * @tc.type: FUNC
2777 */
2778 HWTEST_F(UIAbilityLifecycleManagerTest, GetSessionIdByAbilityToken_001, TestSize.Level1)
2779 {
2780 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2781 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2782 sptr<IRemoteObject> token = nullptr;
2783 EXPECT_EQ(uiAbilityLifecycleManager->GetSessionIdByAbilityToken(token), ERR_OK);
2784 }
2785
2786 /**
2787 * @tc.name: UIAbilityLifecycleManager_GetSessionIdByAbilityToken_0200
2788 * @tc.desc: GetSessionIdByAbilityToken
2789 * @tc.type: FUNC
2790 */
2791 HWTEST_F(UIAbilityLifecycleManagerTest, GetSessionIdByAbilityToken_002, TestSize.Level1)
2792 {
2793 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2794 AbilityRequest abilityRequest;
2795 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2796 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
2797 auto&& token = abilityRecord->GetToken()->AsObject();
2798 EXPECT_EQ(mgr->GetSessionIdByAbilityToken(token), 1);
2799 }
2800
2801 /**
2802 * @tc.name: UIAbilityLifecycleManager_GetActiveAbilityList_0100
2803 * @tc.desc: GetActiveAbilityList
2804 * @tc.type: FUNC
2805 */
2806 HWTEST_F(UIAbilityLifecycleManagerTest, GetActiveAbilityList_001, TestSize.Level1)
2807 {
2808 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2809 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2810 AbilityRequest abilityRequest;
2811 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2812 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2813 std::vector<std::string> abilityList;
2814 int32_t pid = 100;
2815 uiAbilityLifecycleManager->GetActiveAbilityList(TEST_UID, abilityList, pid);
2816 uiAbilityLifecycleManager.reset();
2817 }
2818
2819 /**
2820 * @tc.name: UIAbilityLifecycleManager_GetActiveAbilityList_0200
2821 * @tc.desc: GetActiveAbilityList
2822 * @tc.type: FUNC
2823 */
2824 HWTEST_F(UIAbilityLifecycleManagerTest, GetActiveAbilityList_002, TestSize.Level1)
2825 {
2826 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2827 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2828 AbilityRequest abilityRequest;
2829 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::STANDARD;
2830 abilityRequest.abilityInfo.name = "testAbility";
2831 abilityRequest.abilityInfo.moduleName = "testModule";
2832 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
2833 abilityRequest.abilityInfo.applicationInfo.uid = TEST_UID;
2834 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2835 abilityRecord->SetOwnerMissionUserId(DelayedSingleton<AbilityManagerService>::GetInstance()->GetUserId());
2836 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2837 std::vector<std::string> abilityList;
2838 int32_t pid = 100;
2839 uiAbilityLifecycleManager->GetActiveAbilityList(TEST_UID, abilityList, pid);
2840 uiAbilityLifecycleManager.reset();
2841 }
2842
2843 /**
2844 * @tc.name: UIAbilityLifecycleManager_IsAbilityStarted_0100
2845 * @tc.desc: IsAbilityStarted
2846 * @tc.type: FUNC
2847 */
2848 HWTEST_F(UIAbilityLifecycleManagerTest, IsAbilityStarted_001, TestSize.Level1)
2849 {
2850 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2851 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
2852 AbilityRequest abilityRequest;
2853 Rosen::SessionInfo info;
2854 sptr<SessionInfo> sessionInfo(new SessionInfo());
2855 sessionInfo->sessionToken = new Rosen::Session(info);
2856 sessionInfo->persistentId = 0;
2857 abilityRequest.sessionInfo = sessionInfo;
2858 auto targetRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2859 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, targetRecord);
2860 EXPECT_EQ(uiAbilityLifecycleManager->IsAbilityStarted(abilityRequest, targetRecord), false);
2861 }
2862
2863 /**
2864 * @tc.name: UIAbilityLifecycleManager_IsAbilityStarted_0200
2865 * @tc.desc: IsAbilityStarted
2866 * @tc.type: FUNC
2867 */
2868 HWTEST_F(UIAbilityLifecycleManagerTest, IsAbilityStarted_002, TestSize.Level1)
2869 {
2870 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2871 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
2872 AbilityRequest abilityRequest;
2873 Rosen::SessionInfo info;
2874 sptr<SessionInfo> sessionInfo(new SessionInfo());
2875 sessionInfo->sessionToken = new Rosen::Session(info);
2876 sessionInfo->persistentId = 1;
2877 abilityRequest.sessionInfo = sessionInfo;
2878 auto targetRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2879 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, targetRecord);
2880 EXPECT_EQ(uiAbilityLifecycleManager->IsAbilityStarted(abilityRequest, targetRecord), false);
2881 sptr<IAbilityScheduler> scheduler = new AbilitySchedulerMock();
2882 targetRecord->SetScheduler(scheduler);
2883 EXPECT_EQ(uiAbilityLifecycleManager->IsAbilityStarted(abilityRequest, targetRecord), true);
2884 }
2885
2886 /**
2887 * @tc.name: UIAbilityLifecycleManager_TryPrepareTerminateByPids_0100
2888 * @tc.desc: TryPrepareTerminateByPids
2889 * @tc.type: FUNC
2890 */
2891 HWTEST_F(UIAbilityLifecycleManagerTest, TryPrepareTerminateByPids_001, TestSize.Level1)
2892 {
2893 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2894 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
2895 std::vector<int32_t> pids;
2896 EXPECT_EQ(uiAbilityLifecycleManager->TryPrepareTerminateByPids(pids), ERR_OK);
2897 }
2898
2899 /**
2900 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0200
2901 * @tc.desc: ChangeAbilityVisibility
2902 * @tc.type: FUNC
2903 */
2904 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_002, TestSize.Level1)
2905 {
2906 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2907 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2908 sptr<IRemoteObject> token = nullptr;
2909 bool isShow = false;
2910 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_INVALID_VALUE);
2911 }
2912
2913 /**
2914 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0300
2915 * @tc.desc: ChangeAbilityVisibility
2916 * @tc.type: FUNC
2917 */
2918 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_003, TestSize.Level1)
2919 {
2920 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2921 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2922 AbilityRequest abilityRequest;
2923 abilityRequest.appInfo.accessTokenId = 100;
2924 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2925 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
2926 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
2927 bool isShow = true;
2928 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_NATIVE_NOT_SELF_APPLICATION);
2929 }
2930
2931 /**
2932 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0400
2933 * @tc.desc: ChangeAbilityVisibility
2934 * @tc.type: FUNC
2935 */
2936 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_004, TestSize.Level1)
2937 {
2938 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2939 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2940 AbilityRequest abilityRequest;
2941 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
2942 abilityRequest.sessionInfo = nullptr;
2943 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2944 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
2945 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
2946 bool isShow = true;
2947 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_INVALID_VALUE);
2948 }
2949
2950 /**
2951 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0500
2952 * @tc.desc: ChangeAbilityVisibility
2953 * @tc.type: FUNC
2954 */
2955 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_005, TestSize.Level1)
2956 {
2957 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2958 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2959 AbilityRequest abilityRequest;
2960 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
2961 sptr<SessionInfo> sessionInfo(new SessionInfo());
2962 sessionInfo->processOptions = nullptr;
2963 abilityRequest.sessionInfo = sessionInfo;
2964 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2965 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
2966 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
2967 bool isShow = true;
2968 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_START_OPTIONS_CHECK_FAILED);
2969 }
2970
2971 /**
2972 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0600
2973 * @tc.desc: ChangeAbilityVisibility
2974 * @tc.type: FUNC
2975 */
2976 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_006, TestSize.Level1)
2977 {
2978 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2979 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2980 AbilityRequest abilityRequest;
2981 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
2982 sptr<SessionInfo> sessionInfo(new SessionInfo());
2983 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
2984 abilityRequest.sessionInfo = sessionInfo;
2985 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2986 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
2987 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
2988 bool isShow = true;
2989 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_START_OPTIONS_CHECK_FAILED);
2990 }
2991
2992 /**
2993 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0700
2994 * @tc.desc: ChangeAbilityVisibility
2995 * @tc.type: FUNC
2996 */
2997 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_007, TestSize.Level1)
2998 {
2999 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3000 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3001 AbilityRequest abilityRequest;
3002 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3003 sptr<SessionInfo> sessionInfo(new SessionInfo());
3004 sessionInfo->sessionToken = nullptr;
3005 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
3006 sessionInfo->processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM;
3007 abilityRequest.sessionInfo = sessionInfo;
3008 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3009 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3010 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
3011 bool isShow = true;
3012 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_START_OPTIONS_CHECK_FAILED);
3013 }
3014
3015 /**
3016 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0800
3017 * @tc.desc: ChangeAbilityVisibility
3018 * @tc.type: FUNC
3019 */
3020 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_008, TestSize.Level1)
3021 {
3022 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3023 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3024 AbilityRequest abilityRequest;
3025 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3026 Rosen::SessionInfo info;
3027 sptr<SessionInfo> sessionInfo(new SessionInfo());
3028 sessionInfo->sessionToken = new Rosen::Session(info);
3029 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
3030 sessionInfo->processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM;
3031 abilityRequest.sessionInfo = sessionInfo;
3032 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3033 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3034 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
3035 bool isShow = true;
3036 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_START_OPTIONS_CHECK_FAILED);
3037 }
3038
3039 /**
3040 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0900
3041 * @tc.desc: ChangeAbilityVisibility
3042 * @tc.type: FUNC
3043 */
3044 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_009, TestSize.Level1)
3045 {
3046 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3047 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3048 AbilityRequest abilityRequest;
3049 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3050 Rosen::SessionInfo info;
3051 sptr<SessionInfo> sessionInfo(new SessionInfo());
3052 sessionInfo->sessionToken = new Rosen::Session(info);
3053 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
3054 sessionInfo->processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM;
3055 abilityRequest.sessionInfo = sessionInfo;
3056 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3057 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3058 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
3059 bool isShow = false;
3060 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_START_OPTIONS_CHECK_FAILED);
3061 }
3062
3063 /**
3064 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0200
3065 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3066 * @tc.type: FUNC
3067 */
3068 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_002, TestSize.Level1)
3069 {
3070 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3071 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3072 sptr<SessionInfo> sessionInfo = nullptr;
3073 bool isShow = false;
3074 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow), ERR_INVALID_VALUE);
3075 }
3076
3077 /**
3078 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0300
3079 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3080 * @tc.type: FUNC
3081 */
3082 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_003, TestSize.Level1)
3083 {
3084 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3085 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3086 AbilityRequest abilityRequest;
3087 sptr<SessionInfo> sessionInfo(new SessionInfo());
3088 sessionInfo->persistentId = 100;
3089 abilityRequest.sessionInfo = sessionInfo;
3090 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3091 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3092 bool isShow = false;
3093 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow),
3094 ERR_NATIVE_ABILITY_NOT_FOUND);
3095 }
3096
3097 /**
3098 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0400
3099 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3100 * @tc.type: FUNC
3101 */
3102 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_004, TestSize.Level1)
3103 {
3104 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3105 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3106 sptr<SessionInfo> sessionInfo(new SessionInfo());
3107 sessionInfo->persistentId = 100;
3108 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, nullptr);
3109 bool isShow = false;
3110 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow),
3111 ERR_INVALID_VALUE);
3112 }
3113
3114 /**
3115 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0500
3116 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3117 * @tc.type: FUNC
3118 */
3119 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_005, TestSize.Level1)
3120 {
3121 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3122 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3123 AbilityRequest abilityRequest;
3124 sptr<SessionInfo> sessionInfo(new SessionInfo());
3125 sessionInfo->persistentId = 100;
3126 abilityRequest.sessionInfo = sessionInfo;
3127 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3128 abilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::INITIAL);
3129 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3130 bool isShow = false;
3131 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow), ERR_OK);
3132 }
3133
3134 /**
3135 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0600
3136 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3137 * @tc.type: FUNC
3138 */
3139 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_006, TestSize.Level1)
3140 {
3141 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3142 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3143 AbilityRequest abilityRequest;
3144 sptr<SessionInfo> sessionInfo(new SessionInfo());
3145 sessionInfo->persistentId = 100;
3146 abilityRequest.sessionInfo = sessionInfo;
3147 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3148 abilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::UNSPECIFIED);
3149 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3150 bool isShow = false;
3151 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow), ERR_OK);
3152 }
3153
3154 /**
3155 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0700
3156 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3157 * @tc.type: FUNC
3158 */
3159 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_007, TestSize.Level1)
3160 {
3161 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3162 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3163 AbilityRequest abilityRequest;
3164 sptr<SessionInfo> sessionInfo(new SessionInfo());
3165 sessionInfo->persistentId = 100;
3166 abilityRequest.sessionInfo = sessionInfo;
3167 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3168 abilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::FOREGROUND_SHOW);
3169 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3170 bool isShow = true;
3171 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow), ERR_OK);
3172 }
3173
3174 /**
3175 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0800
3176 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3177 * @tc.type: FUNC
3178 */
3179 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_008, TestSize.Level1)
3180 {
3181 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3182 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3183 AbilityRequest abilityRequest;
3184 sptr<SessionInfo> sessionInfo(new SessionInfo());
3185 sessionInfo->persistentId = 100;
3186 abilityRequest.sessionInfo = sessionInfo;
3187 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3188 abilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::FOREGROUND_HIDE);
3189 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3190 bool isShow = false;
3191 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow), ERR_OK);
3192 }
3193
3194 /**
3195 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByName_0100
3196 * @tc.desc: GetAbilityRecordsByName
3197 * @tc.type: FUNC
3198 */
3199 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByName_001, TestSize.Level1)
3200 {
3201 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3202 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3203 AbilityRequest abilityRequest;
3204 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3205 abilityRequest.abilityInfo.name = "MainAbility";
3206 abilityRequest.abilityInfo.deviceId = "100";
3207 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3208 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3209 AppExecFwk::ElementName element;
3210 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByName(element);
3211 EXPECT_EQ(ret.empty(), true);
3212 }
3213
3214 /**
3215 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByName_0200
3216 * @tc.desc: GetAbilityRecordsByName
3217 * @tc.type: FUNC
3218 */
3219 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByName_002, TestSize.Level1)
3220 {
3221 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3222 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3223 AbilityRequest abilityRequest;
3224 abilityRequest.abilityInfo.deviceId = "100";
3225 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3226 abilityRequest.abilityInfo.name = "MainAbility";
3227 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3228 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3229 AppExecFwk::ElementName element("100", "com.example.unittest", "MainAbility");
3230 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByName(element);
3231 EXPECT_EQ(ret.empty(), false);
3232 }
3233
3234 /**
3235 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByName_0300
3236 * @tc.desc: GetAbilityRecordsByName
3237 * @tc.type: FUNC
3238 */
3239 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByName_003, TestSize.Level1)
3240 {
3241 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3242 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3243 AbilityRequest abilityRequest;
3244 abilityRequest.abilityInfo.deviceId = "100";
3245 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3246 abilityRequest.abilityInfo.name = "MainAbility";
3247 abilityRequest.abilityInfo.moduleName = "entry";
3248 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3249 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3250 AppExecFwk::ElementName element("100", "com.example.unittest", "MainAbility", "entry");
3251 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByName(element);
3252 EXPECT_EQ(ret.empty(), false);
3253 }
3254
3255 /**
3256 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByNameInner_0100
3257 * @tc.desc: GetAbilityRecordsByNameInner
3258 * @tc.type: FUNC
3259 */
3260 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByNameInner_001, TestSize.Level1)
3261 {
3262 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3263 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3264 AbilityRequest abilityRequest;
3265 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3266 abilityRequest.abilityInfo.name = "MainAbility";
3267 abilityRequest.abilityInfo.deviceId = "100";
3268 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3269 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3270 AppExecFwk::ElementName element;
3271 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByNameInner(element);
3272 EXPECT_EQ(ret.empty(), true);
3273 }
3274
3275 /**
3276 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByNameInner_0200
3277 * @tc.desc: GetAbilityRecordsByNameInner
3278 * @tc.type: FUNC
3279 */
3280 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByNameInner_002, TestSize.Level1)
3281 {
3282 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3283 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3284 AbilityRequest abilityRequest;
3285 abilityRequest.abilityInfo.deviceId = "100";
3286 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3287 abilityRequest.abilityInfo.name = "MainAbility";
3288 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3289 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3290 AppExecFwk::ElementName element("100", "com.example.unittest", "MainAbility");
3291 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByNameInner(element);
3292 EXPECT_EQ(ret.empty(), false);
3293 }
3294
3295 /**
3296 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByNameInner_0300
3297 * @tc.desc: GetAbilityRecordsByNameInner
3298 * @tc.type: FUNC
3299 */
3300 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByNameInner_003, TestSize.Level1)
3301 {
3302 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3303 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3304 AbilityRequest abilityRequest;
3305 abilityRequest.abilityInfo.deviceId = "100";
3306 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3307 abilityRequest.abilityInfo.name = "MainAbility";
3308 abilityRequest.abilityInfo.moduleName = "entry";
3309 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3310 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3311 AppExecFwk::ElementName element("100", "com.example.unittest", "MainAbility", "entry");
3312 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByNameInner(element);
3313 EXPECT_EQ(ret.empty(), false);
3314 }
3315
3316 /**
3317 * @tc.name: UIAbilityLifecycleManager_PrepareTerminateAbility_0100
3318 * @tc.desc: PrepareTerminateAbility
3319 * @tc.type: FUNC
3320 */
3321 HWTEST_F(UIAbilityLifecycleManagerTest, PrepareTerminateAbility_001, TestSize.Level1)
3322 {
3323 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3324 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3325 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
3326 bool boolValue = uiAbilityLifecycleManager->PrepareTerminateAbility(abilityRecord, false);
3327 EXPECT_FALSE(boolValue);
3328 }
3329
3330 /**
3331 * @tc.name: UIAbilityLifecycleManager_PrepareTerminateAbility_0200
3332 * @tc.desc: PrepareTerminateAbility
3333 * @tc.type: FUNC
3334 */
3335 HWTEST_F(UIAbilityLifecycleManagerTest, PrepareTerminateAbility_002, TestSize.Level1)
3336 {
3337 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3338 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3339 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3340 bool boolValue = uiAbilityLifecycleManager->PrepareTerminateAbility(abilityRecord, false);
3341 EXPECT_FALSE(boolValue);
3342 }
3343
3344 /**
3345 * @tc.name: UIAbilityLifecycleManager_SetSessionHandler_0100
3346 * @tc.desc: SetSessionHandler
3347 * @tc.type: FUNC
3348 */
3349 HWTEST_F(UIAbilityLifecycleManagerTest, SetSessionHandler_001, TestSize.Level1)
3350 {
3351 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3352 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3353 sptr<ISessionHandler> handler;
3354 uiAbilityLifecycleManager->SetSessionHandler(handler);
3355 EXPECT_EQ(uiAbilityLifecycleManager->handler_, handler);
3356 }
3357
3358 /**
3359 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsById_0100
3360 * @tc.desc: GetAbilityRecordsById
3361 * @tc.type: FUNC
3362 */
3363 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsById_001, TestSize.Level1)
3364 {
3365 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3366 int32_t sessionId = 100;
3367 AbilityRequest abilityRequest;
3368 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3369 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionId, abilityRecord);
3370 EXPECT_EQ(uiAbilityLifecycleManager->GetAbilityRecordsById(sessionId + 1), nullptr);
3371 }
3372
3373 /**
3374 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsById_0200
3375 * @tc.desc: GetAbilityRecordsById
3376 * @tc.type: FUNC
3377 */
3378 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsById_002, TestSize.Level1)
3379 {
3380 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3381 int32_t sessionId = 100;
3382 AbilityRequest abilityRequest;
3383 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3384 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionId, abilityRecord);
3385 EXPECT_NE(uiAbilityLifecycleManager->GetAbilityRecordsById(sessionId), nullptr);
3386 }
3387
3388 /**
3389 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0100
3390 * @tc.desc: OnAppStateChanged
3391 * @tc.type: FUNC
3392 */
3393 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_001, TestSize.Level1)
3394 {
3395 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3396 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3397 AbilityRequest abilityRequest;
3398 abilityRequest.appInfo.bundleName = "com.example.unittest";
3399 abilityRequest.abilityInfo.name = "MainAbility";
3400 abilityRequest.abilityInfo.process = "AbilityProcess";
3401 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3402 AppInfo info;
3403 info.processName = "AbilityProcess";
3404 info.state = AppState::TERMINATED;
3405 uiAbilityLifecycleManager->terminateAbilityList_.emplace_back(abilityRecord);
3406 uiAbilityLifecycleManager->OnAppStateChanged(info);
3407 uiAbilityLifecycleManager.reset();
3408 }
3409
3410 /**
3411 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0200
3412 * @tc.desc: OnAppStateChanged
3413 * @tc.type: FUNC
3414 */
3415 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_002, TestSize.Level1)
3416 {
3417 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3418 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3419 AbilityRequest abilityRequest;
3420 abilityRequest.appInfo.bundleName = "com.example.unittest";
3421 abilityRequest.abilityInfo.name = "MainAbility";
3422 abilityRequest.abilityInfo.process = "AbilityProcess";
3423 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3424 AppInfo info;
3425 info.processName = "AbilityProcess";
3426 info.state = AppState::END;
3427 uiAbilityLifecycleManager->terminateAbilityList_.emplace_back(abilityRecord);
3428 uiAbilityLifecycleManager->OnAppStateChanged(info);
3429 uiAbilityLifecycleManager.reset();
3430 }
3431
3432 /**
3433 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0300
3434 * @tc.desc: OnAppStateChanged
3435 * @tc.type: FUNC
3436 */
3437 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_003, TestSize.Level1)
3438 {
3439 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3440 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3441 AbilityRequest abilityRequest;
3442 abilityRequest.appInfo.bundleName = "com.example.unittest";
3443 abilityRequest.abilityInfo.name = "MainAbility";
3444 abilityRequest.abilityInfo.process = "AbilityProcess";
3445 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3446 AppInfo info;
3447 info.processName = "com.example.unittest";
3448 info.state = AppState::TERMINATED;
3449 uiAbilityLifecycleManager->terminateAbilityList_.emplace_back(abilityRecord);
3450 uiAbilityLifecycleManager->OnAppStateChanged(info);
3451 uiAbilityLifecycleManager.reset();
3452 }
3453
3454 /**
3455 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0400
3456 * @tc.desc: OnAppStateChanged
3457 * @tc.type: FUNC
3458 */
3459 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_004, TestSize.Level1)
3460 {
3461 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3462 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3463 AbilityRequest abilityRequest;
3464 abilityRequest.appInfo.bundleName = "com.example.unittest";
3465 abilityRequest.abilityInfo.name = "MainAbility";
3466 abilityRequest.abilityInfo.process = "AbilityProcess";
3467 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3468 AppInfo info;
3469 info.processName = "com.example.unittest";
3470 info.state = AppState::END;
3471 uiAbilityLifecycleManager->terminateAbilityList_.emplace_back(abilityRecord);
3472 uiAbilityLifecycleManager->OnAppStateChanged(info);
3473 uiAbilityLifecycleManager.reset();
3474 }
3475
3476 /**
3477 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0500
3478 * @tc.desc: OnAppStateChanged
3479 * @tc.type: FUNC
3480 */
3481 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_005, TestSize.Level1)
3482 {
3483 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3484 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3485 AbilityRequest abilityRequest;
3486 abilityRequest.appInfo.bundleName = "com.example.unittest";
3487 abilityRequest.abilityInfo.name = "MainAbility";
3488 abilityRequest.abilityInfo.process = "AbilityProcess";
3489 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3490 AppInfo info;
3491 info.processName = "com.example.unittest";
3492 info.state = AppState::COLD_START;
3493 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3494 uiAbilityLifecycleManager->OnAppStateChanged(info);
3495 uiAbilityLifecycleManager.reset();
3496 }
3497
3498 /**
3499 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0600
3500 * @tc.desc: OnAppStateChanged
3501 * @tc.type: FUNC
3502 */
3503 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_006, TestSize.Level1)
3504 {
3505 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3506 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3507 AbilityRequest abilityRequest;
3508 abilityRequest.appInfo.bundleName = "com.example.unittest";
3509 abilityRequest.abilityInfo.name = "MainAbility";
3510 abilityRequest.abilityInfo.process = "AbilityProcess";
3511 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3512 AppInfo info;
3513 info.processName = "AbilityProcess";
3514 info.state = AppState::COLD_START;
3515 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3516 uiAbilityLifecycleManager->OnAppStateChanged(info);
3517 uiAbilityLifecycleManager.reset();
3518 }
3519
3520 /**
3521 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0700
3522 * @tc.desc: OnAppStateChanged
3523 * @tc.type: FUNC
3524 */
3525 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_007, TestSize.Level1)
3526 {
3527 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3528 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3529 AbilityRequest abilityRequest;
3530 abilityRequest.appInfo.bundleName = "com.example.unittest";
3531 abilityRequest.abilityInfo.name = "MainAbility";
3532 abilityRequest.abilityInfo.process = "AbilityProcess";
3533 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3534 AppInfo info;
3535 info.processName = "com.example.unittest";
3536 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3537 uiAbilityLifecycleManager->OnAppStateChanged(info);
3538 uiAbilityLifecycleManager.reset();
3539 }
3540
3541 /**
3542 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0800
3543 * @tc.desc: OnAppStateChanged
3544 * @tc.type: FUNC
3545 */
3546 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_008, TestSize.Level1)
3547 {
3548 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3549 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3550 AbilityRequest abilityRequest;
3551 abilityRequest.appInfo.bundleName = "com.example.unittest";
3552 abilityRequest.abilityInfo.name = "MainAbility";
3553 abilityRequest.abilityInfo.process = "AbilityProcess";
3554 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3555 AppInfo info;
3556 info.processName = "AbilityProcess";
3557 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3558 uiAbilityLifecycleManager->OnAppStateChanged(info);
3559 uiAbilityLifecycleManager.reset();
3560 }
3561
3562 /**
3563 * @tc.name: UIAbilityLifecycleManager_UninstallApp_0100
3564 * @tc.desc: UninstallApp
3565 * @tc.type: FUNC
3566 */
3567 HWTEST_F(UIAbilityLifecycleManagerTest, UninstallApp_001, TestSize.Level1)
3568 {
3569 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3570 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3571 AbilityRequest abilityRequest;
3572 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3573 abilityRequest.abilityInfo.name = "MainAbility";
3574 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3575 AppInfo info;
3576 std::string bundleName = "com.example.unittest";
3577 int32_t uid = 0;
3578 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3579 uiAbilityLifecycleManager->UninstallApp(bundleName, uid);
3580 uiAbilityLifecycleManager.reset();
3581 }
3582
3583 /**
3584 * @tc.name: UIAbilityLifecycleManager_GetAbilityRunningInfos_0100
3585 * @tc.desc: GetAbilityRunningInfos
3586 * @tc.type: FUNC
3587 */
3588 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRunningInfos_001, TestSize.Level1)
3589 {
3590 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3591 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3592 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3593 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3594 std::vector<AbilityRunningInfo> info;
3595 bool isPerm = true;
3596 uiAbilityLifecycleManager->GetAbilityRunningInfos(info, isPerm);
3597 uiAbilityLifecycleManager.reset();
3598 }
3599
3600 /**
3601 * @tc.name: UIAbilityLifecycleManager_GetAbilityRunningInfos_0200
3602 * @tc.desc: GetAbilityRunningInfos
3603 * @tc.type: FUNC
3604 */
3605 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRunningInfos_002, TestSize.Level1)
3606 {
3607 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3608 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3609 AbilityRequest abilityRequest;
3610 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3611 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3612 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3613 std::vector<AbilityRunningInfo> info;
3614 bool isPerm = false;
3615 uiAbilityLifecycleManager->GetAbilityRunningInfos(info, isPerm);
3616 uiAbilityLifecycleManager.reset();
3617 }
3618
3619 /**
3620 * @tc.name: UIAbilityLifecycleManager_MoveMissionToFront_0100
3621 * @tc.desc: MoveMissionToFront
3622 * @tc.type: FUNC
3623 */
3624 HWTEST_F(UIAbilityLifecycleManagerTest, MoveMissionToFront_001, TestSize.Level1)
3625 {
3626 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3627 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3628 uiAbilityLifecycleManager->rootSceneSession_ = nullptr;
3629 int32_t sessionId = 100;
3630 std::shared_ptr<StartOptions> startOptions;
3631 EXPECT_EQ(uiAbilityLifecycleManager->MoveMissionToFront(sessionId, startOptions), ERR_INVALID_VALUE);
3632 }
3633
3634 /**
3635 * @tc.name: UIAbilityLifecycleManager_MoveMissionToFront_0200
3636 * @tc.desc: MoveMissionToFront
3637 * @tc.type: FUNC
3638 */
3639 HWTEST_F(UIAbilityLifecycleManagerTest, MoveMissionToFront_002, TestSize.Level1)
3640 {
3641 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3642 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3643 Rosen::SessionInfo info;
3644 uiAbilityLifecycleManager->rootSceneSession_ = new Rosen::Session(info);
3645 int32_t sessionId = 100;
3646 std::shared_ptr<StartOptions> startOptions;
3647 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3648 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3649 EXPECT_EQ(uiAbilityLifecycleManager->MoveMissionToFront(sessionId, startOptions), ERR_INVALID_VALUE);
3650 }
3651
3652 /**
3653 * @tc.name: UIAbilityLifecycleManager_MoveMissionToFront_0300
3654 * @tc.desc: MoveMissionToFront
3655 * @tc.type: FUNC
3656 */
3657 HWTEST_F(UIAbilityLifecycleManagerTest, MoveMissionToFront_003, TestSize.Level1)
3658 {
3659 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3660 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3661 Rosen::SessionInfo info;
3662 uiAbilityLifecycleManager->rootSceneSession_ = new Rosen::Session(info);
3663 int32_t sessionId = 100;
3664 std::shared_ptr<StartOptions> startOptions;
3665 AbilityRequest abilityRequest;
3666 sptr<SessionInfo> sessionInfo = nullptr;
3667 abilityRequest.sessionInfo = sessionInfo;
3668 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3669 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionId, abilityRecord);
3670 EXPECT_EQ(uiAbilityLifecycleManager->MoveMissionToFront(sessionId, startOptions), ERR_INVALID_VALUE);
3671 }
3672
3673 /**
3674 * @tc.name: UIAbilityLifecycleManager_MoveMissionToFront_0400
3675 * @tc.desc: MoveMissionToFront
3676 * @tc.type: FUNC
3677 */
3678 HWTEST_F(UIAbilityLifecycleManagerTest, MoveMissionToFront_004, TestSize.Level1)
3679 {
3680 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3681 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3682 int32_t sessionId = 100;
3683 std::shared_ptr<StartOptions> startOptions;
3684 Rosen::SessionInfo info;
3685 uiAbilityLifecycleManager->rootSceneSession_ = new Rosen::Session(info);
3686 AbilityRequest abilityRequest;
3687 sptr<SessionInfo> sessionInfo = (new SessionInfo());
3688 abilityRequest.sessionInfo = sessionInfo;
3689 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3690 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionId, abilityRecord);
3691 EXPECT_EQ(uiAbilityLifecycleManager->MoveMissionToFront(sessionId, startOptions), ERR_OK);
3692 }
3693
3694 /**
3695 * @tc.name: UIAbilityLifecycleManager_GetReusedCollaboratorPersistentId_0100
3696 * @tc.desc: GetReusedCollaboratorPersistentId
3697 * @tc.type: FUNC
3698 */
3699 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedCollaboratorPersistentId_001, TestSize.Level1)
3700 {
3701 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3702 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3703 AbilityRequest abilityRequest;
3704 Want want;
3705 want.SetParam("ohos.anco.param.missionAffinity", false);
3706 abilityRequest.want = want;
3707 sptr<SessionInfo> sessionInfo(new SessionInfo());
3708 sessionInfo->persistentId = 100;
3709 abilityRequest.sessionInfo = sessionInfo;
3710 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3711 abilityRecord->collaboratorType_ = CollaboratorType::DEFAULT_TYPE;
3712 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3713 bool reuse = false;
3714 EXPECT_NE(uiAbilityLifecycleManager->GetReusedCollaboratorPersistentId(abilityRequest, reuse),
3715 sessionInfo->persistentId);
3716 }
3717
3718 /**
3719 * @tc.name: UIAbilityLifecycleManager_GetReusedCollaboratorPersistentId_0200
3720 * @tc.desc: GetReusedCollaboratorPersistentId
3721 * @tc.type: FUNC
3722 */
3723 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedCollaboratorPersistentId_002, TestSize.Level1)
3724 {
3725 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3726 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3727 AbilityRequest abilityRequest;
3728 Want want;
3729 want.SetParam("ohos.anco.param.missionAffinity", false);
3730 abilityRequest.want = want;
3731 sptr<SessionInfo> sessionInfo(new SessionInfo());
3732 sessionInfo->persistentId = 100;
3733 abilityRequest.sessionInfo = sessionInfo;
3734 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3735 abilityRecord->collaboratorType_ = CollaboratorType::RESERVE_TYPE;
3736 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3737 bool reuse = false;
3738 EXPECT_EQ(uiAbilityLifecycleManager->GetReusedCollaboratorPersistentId(abilityRequest, reuse),
3739 sessionInfo->persistentId);
3740 }
3741
3742 /**
3743 * @tc.name: UIAbilityLifecycleManager_GetReusedCollaboratorPersistentId_0300
3744 * @tc.desc: GetReusedCollaboratorPersistentId
3745 * @tc.type: FUNC
3746 */
3747 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedCollaboratorPersistentId_003, TestSize.Level1)
3748 {
3749 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3750 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3751 AbilityRequest abilityRequest;
3752 Want want;
3753 want.SetParam("ohos.anco.param.missionAffinity", false);
3754 abilityRequest.want = want;
3755 sptr<SessionInfo> sessionInfo(new SessionInfo());
3756 sessionInfo->persistentId = 100;
3757 abilityRequest.sessionInfo = sessionInfo;
3758 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3759 abilityRecord->collaboratorType_ = CollaboratorType::OTHERS_TYPE;
3760 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3761 bool reuse = false;
3762 EXPECT_EQ(uiAbilityLifecycleManager->GetReusedCollaboratorPersistentId(abilityRequest, reuse),
3763 sessionInfo->persistentId);
3764 }
3765
3766 /**
3767 * @tc.name: UIAbilityLifecycleManager_DispatchTerminate_0100
3768 * @tc.desc: DispatchTerminate
3769 * @tc.type: FUNC
3770 */
3771 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchTerminate_001, TestSize.Level1)
3772 {
3773 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3774 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3775 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
3776 EXPECT_EQ(uiAbilityLifecycleManager->DispatchTerminate(abilityRecord), ERR_INVALID_VALUE);
3777 }
3778
3779 /**
3780 * @tc.name: UIAbilityLifecycleManager_DispatchTerminate_0200
3781 * @tc.desc: DispatchTerminate
3782 * @tc.type: FUNC
3783 */
3784 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchTerminate_002, TestSize.Level1)
3785 {
3786 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3787 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3788 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3789 abilityRecord->currentState_ = AbilityState::INITIAL;
3790 EXPECT_EQ(uiAbilityLifecycleManager->DispatchTerminate(abilityRecord), INNER_ERR);
3791 }
3792
3793 /**
3794 * @tc.name: UIAbilityLifecycleManager_DispatchTerminate_0300
3795 * @tc.desc: DispatchTerminate
3796 * @tc.type: FUNC
3797 */
3798 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchTerminate_003, TestSize.Level1)
3799 {
3800 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3801 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3802 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3803 abilityRecord->currentState_ = AbilityState::TERMINATING;
3804 EXPECT_EQ(uiAbilityLifecycleManager->DispatchTerminate(abilityRecord), ERR_INVALID_VALUE);
3805 }
3806
3807 /**
3808 * @tc.name: UIAbilityLifecycleManager_DispatchBackground_0100
3809 * @tc.desc: DispatchBackground
3810 * @tc.type: FUNC
3811 */
3812 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchBackground_001, TestSize.Level1)
3813 {
3814 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3815 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3816 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3817 EXPECT_EQ(uiAbilityLifecycleManager->DispatchBackground(abilityRecord), ERR_INVALID_VALUE);
3818 }
3819
3820 /**
3821 * @tc.name: UIAbilityLifecycleManager_DispatchBackground_0200
3822 * @tc.desc: DispatchBackground
3823 * @tc.type: FUNC
3824 */
3825 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchBackground_002, TestSize.Level1)
3826 {
3827 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3828 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3829 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
3830 EXPECT_EQ(uiAbilityLifecycleManager->DispatchBackground(abilityRecord), ERR_INVALID_VALUE);
3831 }
3832
3833 #ifdef WITH_DLP
3834 /**
3835 * @tc.name: UIAbilityLifecycleManager_CheckProperties_0100
3836 * @tc.desc: CheckProperties
3837 * @tc.type: FUNC
3838 */
3839 HWTEST_F(UIAbilityLifecycleManagerTest, CheckProperties_001, TestSize.Level1)
3840 {
3841 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3842 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3843 Want want;
3844 AbilityRequest abilityRequest;
3845 want.SetParam(DLP_INDEX, 1);
3846 abilityRequest.want = want;
3847 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3848 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3849 abilityRequest.abilityInfo.name = "MainAbility";
3850 abilityRequest.abilityInfo.moduleName = "entry";
3851 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3852 abilityRecord->SetAppIndex(2);
3853 AppExecFwk::LaunchMode launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3854 auto ret = uiAbilityLifecycleManager->CheckProperties(abilityRecord, abilityRequest, launchMode);
3855 EXPECT_EQ(ret, false);
3856 }
3857
3858 /**
3859 * @tc.name: UIAbilityLifecycleManager_CheckProperties_0200
3860 * @tc.desc: CheckProperties
3861 * @tc.type: FUNC
3862 */
3863 HWTEST_F(UIAbilityLifecycleManagerTest, CheckProperties_002, TestSize.Level1)
3864 {
3865 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3866 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3867 Want want;
3868 AbilityRequest abilityRequest;
3869 want.SetParam(DLP_INDEX, 1);
3870 abilityRequest.want = want;
3871 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3872 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3873 abilityRequest.abilityInfo.name = "MainAbility";
3874 abilityRequest.abilityInfo.moduleName = "entry";
3875 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3876 abilityRecord->SetAppIndex(1);
3877 AppExecFwk::LaunchMode launchMode = AppExecFwk::LaunchMode::STANDARD;
3878 auto ret = uiAbilityLifecycleManager->CheckProperties(abilityRecord, abilityRequest, launchMode);
3879 EXPECT_EQ(ret, false);
3880 }
3881
3882 /**
3883 * @tc.name: UIAbilityLifecycleManager_CheckProperties_0300
3884 * @tc.desc: CheckProperties
3885 * @tc.type: FUNC
3886 */
3887 HWTEST_F(UIAbilityLifecycleManagerTest, CheckProperties_003, TestSize.Level1)
3888 {
3889 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3890 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3891 Want want;
3892 AbilityRequest abilityRequest;
3893 want.SetParam(DLP_INDEX, 1);
3894 abilityRequest.want = want;
3895 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3896 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3897 abilityRequest.abilityInfo.name = "MainAbility";
3898 abilityRequest.abilityInfo.moduleName = "entry";
3899 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3900 abilityRecord->SetAppIndex(1);
3901 AppExecFwk::LaunchMode launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3902 auto ret = uiAbilityLifecycleManager->CheckProperties(abilityRecord, abilityRequest, launchMode);
3903 EXPECT_EQ(ret, true);
3904 }
3905 #endif // WITH_DLP
3906
3907 /**
3908 * @tc.name: UIAbilityLifecycleManager_ResolveAbility_0100
3909 * @tc.desc: ResolveAbility
3910 * @tc.type: FUNC
3911 */
3912 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveAbility_001, TestSize.Level1)
3913 {
3914 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3915 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3916 AbilityRequest abilityRequest;
3917 std::shared_ptr<AbilityRecord> targetAbility = nullptr;
3918 EXPECT_EQ(uiAbilityLifecycleManager->ResolveAbility(targetAbility, abilityRequest),
3919 ResolveResultType::NG_INNER_ERROR);
3920 }
3921
3922 /**
3923 * @tc.name: UIAbilityLifecycleManager_ResolveAbility_0200
3924 * @tc.desc: ResolveAbility
3925 * @tc.type: FUNC
3926 */
3927 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveAbility_002, TestSize.Level1)
3928 {
3929 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3930 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3931 AbilityRequest abilityRequest;
3932 abilityRequest.callType = AbilityCallType::START_OPTIONS_TYPE;
3933 auto targetAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
3934 EXPECT_EQ(uiAbilityLifecycleManager->ResolveAbility(targetAbility, abilityRequest),
3935 ResolveResultType::NG_INNER_ERROR);
3936 }
3937
3938 /**
3939 * @tc.name: UIAbilityLifecycleManager_ResolveAbility_0300
3940 * @tc.desc: ResolveAbility
3941 * @tc.type: FUNC
3942 */
3943 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveAbility_003, TestSize.Level1)
3944 {
3945 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3946 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3947 AbilityRequest abilityRequest;
3948 abilityRequest.connect = new UIAbilityLifcecycleManagerTestStub();
3949 abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
3950 auto targetAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
3951 targetAbility->callContainer_ = std::make_shared<CallContainer>();
3952 EXPECT_EQ(uiAbilityLifecycleManager->ResolveAbility(targetAbility, abilityRequest),
3953 ResolveResultType::OK_NO_REMOTE_OBJ);
3954 }
3955
3956 /**
3957 * @tc.name: UIAbilityLifecycleManager_ResolveAbility_0400
3958 * @tc.desc: ResolveAbility
3959 * @tc.type: FUNC
3960 */
3961 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveAbility_004, TestSize.Level1)
3962 {
3963 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3964 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3965 AbilityRequest abilityRequest;
3966 abilityRequest.connect = new UIAbilityLifcecycleManagerTestStub();
3967 abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
3968 auto targetAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
3969 targetAbility->isReady_ = true;
3970 EXPECT_EQ(uiAbilityLifecycleManager->ResolveAbility(targetAbility, abilityRequest),
3971 ResolveResultType::OK_HAS_REMOTE_OBJ);
3972 }
3973
3974 /**
3975 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0100
3976 * @tc.desc: GetContentAndTypeId
3977 * @tc.type: FUNC
3978 */
3979 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_001, TestSize.Level1)
3980 {
3981 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3982 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3983 uint32_t msgId = AbilityManagerService::LOAD_TIMEOUT_MSG;
3984 std::string msgContent = "content";
3985 int typeId;
3986 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), true);
3987 }
3988
3989 /**
3990 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0200
3991 * @tc.desc: GetContentAndTypeId
3992 * @tc.type: FUNC
3993 */
3994 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_002, TestSize.Level1)
3995 {
3996 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3997 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3998 uint32_t msgId = AbilityManagerService::FOREGROUND_TIMEOUT_MSG;
3999 std::string msgContent = "content";
4000 int typeId;
4001 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), true);
4002 }
4003
4004 /**
4005 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0300
4006 * @tc.desc: GetContentAndTypeId
4007 * @tc.type: FUNC
4008 */
4009 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_003, TestSize.Level1)
4010 {
4011 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4012 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4013 uint32_t msgId = AbilityManagerService::BACKGROUND_TIMEOUT_MSG;
4014 std::string msgContent = "content";
4015 int typeId;
4016 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), true);
4017 }
4018
4019 /**
4020 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0400
4021 * @tc.desc: GetContentAndTypeId
4022 * @tc.type: FUNC
4023 */
4024 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_004, TestSize.Level1)
4025 {
4026 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4027 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4028 uint32_t msgId = AbilityManagerService::TERMINATE_TIMEOUT_MSG;
4029 std::string msgContent = "content";
4030 int typeId;
4031 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), true);
4032 }
4033
4034 /**
4035 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0500
4036 * @tc.desc: GetContentAndTypeId
4037 * @tc.type: FUNC
4038 */
4039 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_005, TestSize.Level1)
4040 {
4041 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4042 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4043 uint32_t msgId = AbilityManagerService::ACTIVE_TIMEOUT_MSG;
4044 std::string msgContent = "content";
4045 int typeId;
4046 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), false);
4047 }
4048
4049 /**
4050 * @tc.name: UIAbilityLifecycleManager_CheckCallerFromBackground_0100
4051 * @tc.desc: CheckCallerFromBackground
4052 * @tc.type: FUNC
4053 */
4054 HWTEST_F(UIAbilityLifecycleManagerTest, CheckCallerFromBackground_0100, TestSize.Level1)
4055 {
4056 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4057 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4058 sptr<SessionInfo> info = nullptr;
4059 uiAbilityLifecycleManager->CheckCallerFromBackground(nullptr, info);
4060 }
4061
4062 /**
4063 * @tc.name: UIAbilityLifecycleManager_CheckCallerFromBackground_0200
4064 * @tc.desc: CheckCallerFromBackground
4065 * @tc.type: FUNC
4066 */
4067 HWTEST_F(UIAbilityLifecycleManagerTest, CheckCallerFromBackground_0200, TestSize.Level1)
4068 {
4069 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4070 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4071 sptr<SessionInfo> info = nullptr;
4072 sptr<SessionInfo> sessionInfo(new SessionInfo());
4073 AbilityRequest abilityRequest;
4074 abilityRequest.sessionInfo = sessionInfo;
4075 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
4076 uiAbilityLifecycleManager->CheckCallerFromBackground(abilityRecord, info);
4077 }
4078
4079 /**
4080 * @tc.name: UIAbilityLifecycleManager_CheckCallerFromBackground_0300
4081 * @tc.desc: CheckCallerFromBackground
4082 * @tc.type: FUNC
4083 */
4084 HWTEST_F(UIAbilityLifecycleManagerTest, CheckCallerFromBackground_0300, TestSize.Level1)
4085 {
4086 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4087 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4088 sptr<SessionInfo> sessionInfo(new SessionInfo());
4089 uiAbilityLifecycleManager->CheckCallerFromBackground(nullptr, sessionInfo);
4090 }
4091
4092 /**
4093 * @tc.name: UIAbilityLifecycleManager_CheckCallerFromBackground_0400
4094 * @tc.desc: CheckCallerFromBackground
4095 * @tc.type: FUNC
4096 */
4097 HWTEST_F(UIAbilityLifecycleManagerTest, CheckCallerFromBackground_0400, TestSize.Level1)
4098 {
4099 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4100 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4101 sptr<SessionInfo> sessionInfo(new SessionInfo());
4102 AbilityRequest abilityRequest;
4103 abilityRequest.sessionInfo = sessionInfo;
4104 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
4105 uiAbilityLifecycleManager->CheckCallerFromBackground(abilityRecord, sessionInfo);
4106 }
4107
4108 /*
4109 * Feature: UIAbilityLifecycleManagerTest
4110 * Function: BackToCallerAbilityWithResult
4111 * SubFunction: NA
4112 * FunctionPoints: UIAbilityLifecycleManagerTest BackToCallerAbilityWithResult
4113 * EnvConditions: NA
4114 * CaseDescription: Verify BackToCallerAbilityWithResult
4115 */
4116 HWTEST_F(UIAbilityLifecycleManagerTest, BackToCallerAbilityWithResult_001, TestSize.Level1)
4117 {
4118 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4119 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4120
4121 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
4122 Want resultWant;
4123 int32_t resultCode = 100;
4124 int64_t callerRequestCode = 0;
4125 auto ret = uiAbilityLifecycleManager->BackToCallerAbilityWithResult(abilityRecord,
4126 resultCode, &resultWant, callerRequestCode);
4127 EXPECT_EQ(ret, ERR_CALLER_NOT_EXISTS);
4128 }
4129
4130 /*
4131 * Feature: UIAbilityLifecycleManagerTest
4132 * Function: BackToCallerAbilityWithResult
4133 * SubFunction: NA
4134 * FunctionPoints: UIAbilityLifecycleManagerTest BackToCallerAbilityWithResult
4135 * EnvConditions: NA
4136 * CaseDescription: Verify BackToCallerAbilityWithResult
4137 */
4138 HWTEST_F(UIAbilityLifecycleManagerTest, BackToCallerAbilityWithResult_002, TestSize.Level1)
4139 {
4140 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4141 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4142
4143 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
4144 Want resultWant;
4145 int32_t resultCode = 100;
4146 int64_t callerRequestCode = 1;
4147 auto ret = uiAbilityLifecycleManager->BackToCallerAbilityWithResult(abilityRecord,
4148 resultCode, &resultWant, callerRequestCode);
4149 EXPECT_EQ(ret, ERR_CALLER_NOT_EXISTS);
4150 }
4151
4152 /*
4153 * Feature: UIAbilityLifecycleManagerTest
4154 * Function: BackToCallerAbilityWithResult
4155 * SubFunction: NA
4156 * FunctionPoints: UIAbilityLifecycleManagerTest BackToCallerAbilityWithResult
4157 * EnvConditions: NA
4158 * CaseDescription: Verify BackToCallerAbilityWithResult
4159 */
4160 HWTEST_F(UIAbilityLifecycleManagerTest, BackToCallerAbilityWithResult_003, TestSize.Level1)
4161 {
4162 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4163 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4164
4165 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
4166 Want resultWant;
4167 int32_t resultCode = 100;
4168 int32_t requestCode = 1;
4169 int32_t pid = 1;
4170 bool backFlag = false;
4171 int64_t callerRequestCode = AbilityRuntime::StartupUtil::GenerateFullRequestCode(pid, backFlag, requestCode);
4172
4173 // not support back to caller
4174 std::shared_ptr<AbilityRecord> callerAbilityRecord = InitAbilityRecord();
4175 callerAbilityRecord->pid_ = pid;
4176 auto newCallerRecord = std::make_shared<CallerRecord>(requestCode, callerAbilityRecord);
4177 newCallerRecord->AddHistoryRequestCode(requestCode);
4178 abilityRecord->callerList_.emplace_back(newCallerRecord);
4179 auto ret = uiAbilityLifecycleManager->BackToCallerAbilityWithResult(abilityRecord,
4180 resultCode, &resultWant, callerRequestCode);
4181 EXPECT_EQ(ret, ERR_NOT_SUPPORT_BACK_TO_CALLER);
4182 }
4183
4184 /*
4185 * Feature: UIAbilityLifecycleManagerTest
4186 * Function: BackToCallerAbilityWithResult
4187 * SubFunction: NA
4188 * FunctionPoints: UIAbilityLifecycleManagerTest BackToCallerAbilityWithResult
4189 * EnvConditions: NA
4190 * CaseDescription: Verify BackToCallerAbilityWithResult
4191 */
4192 HWTEST_F(UIAbilityLifecycleManagerTest, BackToCallerAbilityWithResult_004, TestSize.Level1)
4193 {
4194 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4195 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4196
4197 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
4198 Want resultWant;
4199 int32_t resultCode = 100;
4200 int32_t requestCode = 1;
4201 int32_t pid = 1;
4202 bool backFlag = true;
4203 int64_t callerRequestCode = AbilityRuntime::StartupUtil::GenerateFullRequestCode(pid, backFlag, requestCode);
4204
4205 // caller is self
4206 abilityRecord->pid_ = pid;
4207 auto newCallerRecord = std::make_shared<CallerRecord>(requestCode, abilityRecord);
4208 newCallerRecord->AddHistoryRequestCode(requestCode);
4209 abilityRecord->callerList_.emplace_back(newCallerRecord);
4210 auto ret = uiAbilityLifecycleManager->BackToCallerAbilityWithResult(abilityRecord,
4211 resultCode, &resultWant, callerRequestCode);
4212 EXPECT_EQ(ret, ERR_OK);
4213 }
4214
4215 /*
4216 * Feature: UIAbilityLifecycleManagerTest
4217 * Function: BackToCallerAbilityWithResult
4218 * SubFunction: NA
4219 * FunctionPoints: UIAbilityLifecycleManagerTest BackToCallerAbilityWithResult
4220 * EnvConditions: NA
4221 * CaseDescription: Verify BackToCallerAbilityWithResult
4222 */
4223 HWTEST_F(UIAbilityLifecycleManagerTest, BackToCallerAbilityWithResult_005, TestSize.Level1)
4224 {
4225 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4226 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4227
4228 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
4229 Want resultWant;
4230 int32_t resultCode = 100;
4231 int32_t requestCode = 1;
4232 int32_t pid = 1;
4233 bool backFlag = true;
4234 int64_t callerRequestCode = AbilityRuntime::StartupUtil::GenerateFullRequestCode(pid, backFlag, requestCode);
4235
4236 std::shared_ptr<AbilityRecord> callerAbilityRecord = InitAbilityRecord();
4237 callerAbilityRecord->pid_ = pid;
4238 auto newCallerRecord = std::make_shared<CallerRecord>(requestCode, callerAbilityRecord);
4239 newCallerRecord->AddHistoryRequestCode(requestCode);
4240 abilityRecord->pid_ = pid;
4241 abilityRecord->callerList_.emplace_back(newCallerRecord);
4242
4243 // current ability is backgrounded
4244 abilityRecord->currentState_ = AbilityState::BACKGROUND;
4245 auto ret = uiAbilityLifecycleManager->BackToCallerAbilityWithResult(abilityRecord,
4246 resultCode, &resultWant, callerRequestCode);
4247 EXPECT_EQ(ret, CHECK_PERMISSION_FAILED);
4248 }
4249
4250 /*
4251 * Feature: UIAbilityLifecycleManagerTest
4252 * Function: BackToCallerAbilityWithResult
4253 * SubFunction: NA
4254 * FunctionPoints: UIAbilityLifecycleManagerTest BackToCallerAbilityWithResult
4255 * EnvConditions: NA
4256 * CaseDescription: Verify BackToCallerAbilityWithResult
4257 */
4258 HWTEST_F(UIAbilityLifecycleManagerTest, BackToCallerAbilityWithResult_006, TestSize.Level1)
4259 {
4260 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4261 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4262
4263 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
4264 Want resultWant;
4265 int32_t resultCode = 100;
4266 int32_t requestCode = 1;
4267 int32_t pid = 1;
4268 bool backFlag = true;
4269 int64_t callerRequestCode = AbilityRuntime::StartupUtil::GenerateFullRequestCode(pid, backFlag, requestCode);
4270
4271 std::shared_ptr<AbilityRecord> callerAbilityRecord = InitAbilityRecord();
4272 callerAbilityRecord->pid_ = pid;
4273 auto newCallerRecord = std::make_shared<CallerRecord>(requestCode, callerAbilityRecord);
4274 newCallerRecord->AddHistoryRequestCode(requestCode);
4275 abilityRecord->pid_ = pid;
4276 abilityRecord->callerList_.emplace_back(newCallerRecord);
4277
4278 abilityRecord->currentState_ = AbilityState::FOREGROUND;
4279 auto ret = uiAbilityLifecycleManager->BackToCallerAbilityWithResult(abilityRecord, resultCode,
4280 &resultWant, callerRequestCode);
4281 EXPECT_EQ(ret, ERR_INVALID_VALUE);
4282 }
4283
4284 /**
4285 * @tc.name: UIAbilityLifecycleManager_UpdateSpecifiedFlag_0100
4286 * @tc.desc: UpdateSpecifiedFlag
4287 * @tc.type: FUNC
4288 */
4289 HWTEST_F(UIAbilityLifecycleManagerTest, UpdateSpecifiedFlag_0100, TestSize.Level1)
4290 {
4291 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4292 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4293 AbilityRequest abilityRequest;
4294 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
4295 abilityRequest.startRecent = true;
4296 std::string flag = "specified";
4297 abilityRequest.specifiedFlag = flag;
4298
4299 Rosen::SessionInfo info;
4300 sptr<SessionInfo> sessionInfo(new SessionInfo());
4301 sessionInfo->sessionToken = new Rosen::Session(info);
4302 sessionInfo->persistentId = 1;
4303 abilityRequest.sessionInfo = sessionInfo;
4304 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
4305 EXPECT_NE(abilityRecord, nullptr);
4306 auto ret = uiAbilityLifecycleManager->UpdateSpecifiedFlag(abilityRecord, flag);
4307 EXPECT_EQ(ret, true);
4308 }
4309 } // namespace AAFwk
4310 } // namespace OHOS
4311