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