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_EraseSpecifiedAbilityRecord_0100
2242 * @tc.desc: EraseSpecifiedAbilityRecord
2243 * @tc.type: FUNC
2244 */
2245 HWTEST_F(UIAbilityLifecycleManagerTest, EraseSpecifiedAbilityRecord_001, TestSize.Level1)
2246 {
2247 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2248 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2249 std::shared_ptr<AbilityRecord> abilityRecord1 = InitAbilityRecord();
2250 std::shared_ptr<AbilityRecord> abilityRecord2 = InitAbilityRecord();
2251 UIAbilityLifecycleManager::SpecifiedInfo specifiedInfo1;
2252 UIAbilityLifecycleManager::SpecifiedInfo specifiedInfo2;
2253 UIAbilityLifecycleManager::SpecifiedInfo specifiedInfo3;
2254 UIAbilityLifecycleManager::SpecifiedInfo specifiedInfo4;
2255 specifiedInfo1.abilityName = "MainAbility";
2256 specifiedInfo1.bundleName = "com.example.unittest";
2257 specifiedInfo1.flag = "flag";
2258 specifiedInfo2.abilityName = "MainAbility2";
2259 specifiedInfo2.bundleName = "com.example.unittest";
2260 specifiedInfo2.flag = "flag";
2261 specifiedInfo3.abilityName = "MainAbility";
2262 specifiedInfo3.bundleName = "com.example.unittest2";
2263 specifiedInfo3.flag = "flag";
2264 specifiedInfo4.abilityName = "MainAbility";
2265 specifiedInfo4.bundleName = "com.example.unittest2";
2266 specifiedInfo4.flag = "flag2";
2267 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo1, abilityRecord1);
2268 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo1, nullptr);
2269 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo1, abilityRecord2);
2270 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo2, abilityRecord1);
2271 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo3, abilityRecord1);
2272 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo4, abilityRecord1);
2273 uiAbilityLifecycleManager->EraseSpecifiedAbilityRecord(abilityRecord1);
2274 uiAbilityLifecycleManager.reset();
2275 }
2276
2277 /**
2278 * @tc.name: UIAbilityLifecycleManager_OnAcceptWantResponse_0100
2279 * @tc.desc: OnAcceptWantResponse
2280 * @tc.type: FUNC
2281 */
2282 HWTEST_F(UIAbilityLifecycleManagerTest, OnAcceptWantResponse_001, TestSize.Level1)
2283 {
2284 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2285 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2286 Want want;
2287 std::string flag = "flag";
2288 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2289
2290 AbilityRequest abilityRequest;
2291 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2292
2293 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
2294 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2295
2296 uiAbilityLifecycleManager->OnAcceptWantResponse(want, "");
2297 uiAbilityLifecycleManager.reset();
2298 }
2299
2300 #ifdef WITH_DLP
2301 /**
2302 * @tc.name: UIAbilityLifecycleManager_OnAcceptWantResponse_0200
2303 * @tc.desc: OnAcceptWantResponse
2304 * @tc.type: FUNC
2305 */
2306 HWTEST_F(UIAbilityLifecycleManagerTest, OnAcceptWantResponse_002, TestSize.Level1)
2307 {
2308 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2309 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2310 Want want;
2311 std::string flag = "flag";
2312 AbilityRequest abilityRequest;
2313 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
2314 abilityRequest.startRecent = true;
2315 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
2316 abilityRequest.abilityInfo.name = "MainAbility";
2317 abilityRequest.abilityInfo.moduleName = "entry";
2318 abilityRequest.specifiedFlag = flag;
2319 want.SetParam(DLP_INDEX, 1);
2320 abilityRequest.want = want;
2321 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2322 abilityRecord->abilityInfo_.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
2323 abilityRecord->abilityInfo_.moduleName = "entry";
2324 abilityRecord->SetAppIndex(1);
2325 abilityRecord->SetSpecifiedFlag(flag);
2326 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2327 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2328
2329 UIAbilityLifecycleManager::SpecifiedInfo specifiedInfo;
2330 specifiedInfo.abilityName = "MainAbility";
2331 specifiedInfo.bundleName = "com.example.unittest";
2332 specifiedInfo.flag = "flag";
2333 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo, abilityRecord);
2334 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2335
2336 std::shared_ptr<AbilityRecord> callerAbility = InitAbilityRecord();
2337 abilityRequest.callerToken = callerAbility->GetToken()->AsObject();
2338 uiAbilityLifecycleManager->OnAcceptWantResponse(want, flag);
2339 uiAbilityLifecycleManager.reset();
2340 }
2341 #endif // WITH_DLP
2342
2343 /**
2344 * @tc.name: UIAbilityLifecycleManager_StartSpecifiedAbilityBySCB_0100
2345 * @tc.desc: StartSpecifiedAbilityBySCB
2346 * @tc.type: FUNC
2347 */
2348 HWTEST_F(UIAbilityLifecycleManagerTest, StartSpecifiedAbilityBySCB_001, TestSize.Level1)
2349 {
2350 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2351 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2352 Want want;
2353 uiAbilityLifecycleManager->StartSpecifiedAbilityBySCB(want);
2354 uiAbilityLifecycleManager.reset();
2355 }
2356
2357 /**
2358 * @tc.name: UIAbilityLifecycleManager_GetReusedSpecifiedAbility_0100
2359 * @tc.desc: GetReusedSpecifiedAbility
2360 * @tc.type: FUNC
2361 */
2362 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedSpecifiedAbility_001, TestSize.Level1)
2363 {
2364 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2365 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2366 Want want;
2367 std::string flag = "flag";
2368 UIAbilityLifecycleManager::SpecifiedInfo specifiedInfo;
2369 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2370 specifiedInfo.flag = "flag2";
2371 want.SetElementName(specifiedInfo.abilityName, specifiedInfo.bundleName);
2372 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo, abilityRecord);
2373 specifiedInfo.abilityName = "MainAbility2";
2374 specifiedInfo.flag = "flag";
2375 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo, abilityRecord);
2376 specifiedInfo.abilityName = "MainAbility";
2377 specifiedInfo.bundleName = "com.example.unittest2";
2378 uiAbilityLifecycleManager->specifiedAbilityMap_.emplace(specifiedInfo, abilityRecord);
2379 uiAbilityLifecycleManager->GetReusedSpecifiedAbility(want, flag);
2380 uiAbilityLifecycleManager.reset();
2381 }
2382
2383 /**
2384 * @tc.name: UIAbilityLifecycleManager_NotifyRestartSpecifiedAbility_0100
2385 * @tc.desc: NotifyRestartSpecifiedAbility
2386 * @tc.type: FUNC
2387 */
2388 HWTEST_F(UIAbilityLifecycleManagerTest, NotifyRestartSpecifiedAbility_001, TestSize.Level1)
2389 {
2390 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2391 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2392 AbilityRequest request;
2393 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2394 sptr<IRemoteObject> token = abilityRecord->GetToken();
2395 request.abilityInfoCallback = new MockAbilityInfoCallbackStub();
2396 uiAbilityLifecycleManager->NotifyRestartSpecifiedAbility(request, token);
2397 uiAbilityLifecycleManager.reset();
2398 }
2399
2400 /**
2401 * @tc.name: UIAbilityLifecycleManager_NotifyStartSpecifiedAbility_0100
2402 * @tc.desc: NotifyStartSpecifiedAbility
2403 * @tc.type: FUNC
2404 */
2405 HWTEST_F(UIAbilityLifecycleManagerTest, NotifyStartSpecifiedAbility_001, TestSize.Level1)
2406 {
2407 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2408 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2409 AbilityRequest request;
2410 Want want;
2411 request.abilityInfoCallback = new MockAbilityInfoCallbackStub();
2412 uiAbilityLifecycleManager->NotifyStartSpecifiedAbility(request, want);
2413 uiAbilityLifecycleManager.reset();
2414 }
2415
2416 /**
2417 * @tc.name: UIAbilityLifecycleManager_MoveAbilityToFront_0100
2418 * @tc.desc: MoveAbilityToFront
2419 * @tc.type: FUNC
2420 */
2421 HWTEST_F(UIAbilityLifecycleManagerTest, MoveAbilityToFront_001, TestSize.Level1)
2422 {
2423 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2424 AbilityRequest abilityRequest;
2425 int res = uiAbilityLifecycleManager->MoveAbilityToFront(abilityRequest, nullptr, nullptr, nullptr);
2426 EXPECT_EQ(res, ERR_INVALID_VALUE);
2427
2428 abilityRequest.sessionInfo = new SessionInfo();
2429 abilityRequest.appInfo.bundleName = "com.example.unittest";
2430 abilityRequest.abilityInfo.name = "MainAbility";
2431 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
2432 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2433 res = uiAbilityLifecycleManager->MoveAbilityToFront(abilityRequest, abilityRecord, nullptr, nullptr);
2434 EXPECT_EQ(res, ERR_OK);
2435
2436 auto startOptions = std::make_shared<StartOptions>();
2437 res = uiAbilityLifecycleManager->MoveAbilityToFront(abilityRequest, abilityRecord, nullptr, nullptr);
2438 EXPECT_EQ(res, ERR_OK);
2439
2440 uiAbilityLifecycleManager.reset();
2441 }
2442
2443 /**
2444 * @tc.name: UIAbilityLifecycleManager_SendSessionInfoToSCB_0100
2445 * @tc.desc: SendSessionInfoToSCB
2446 * @tc.type: FUNC
2447 */
2448 HWTEST_F(UIAbilityLifecycleManagerTest, SendSessionInfoToSCB_001, TestSize.Level1)
2449 {
2450 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2451 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2452 Rosen::SessionInfo info;
2453 sptr<SessionInfo> sessionInfo(new SessionInfo());
2454 AbilityRequest abilityRequest;
2455 sessionInfo->sessionToken = new Rosen::Session(info);
2456 abilityRequest.sessionInfo = sessionInfo;
2457 abilityRequest.appInfo.bundleName = "com.example.unittest";
2458 abilityRequest.abilityInfo.name = "MainAbility";
2459 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
2460 std::shared_ptr<AbilityRecord> callerAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
2461 int res = uiAbilityLifecycleManager->SendSessionInfoToSCB(callerAbility, sessionInfo);
2462 EXPECT_EQ(res, ERR_OK);
2463
2464 sessionInfo->sessionToken = nullptr;
2465 abilityRequest.sessionInfo = sessionInfo;
2466 callerAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
2467 res = uiAbilityLifecycleManager->SendSessionInfoToSCB(callerAbility, sessionInfo);
2468 EXPECT_EQ(res, ERR_INVALID_VALUE);
2469
2470 abilityRequest.sessionInfo = nullptr;
2471 callerAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
2472 auto token = callerAbility->GetToken();
2473 EXPECT_NE(token, nullptr);
2474 auto object = token->AsObject();
2475 uiAbilityLifecycleManager->SetRootSceneSession(object);
2476 res = uiAbilityLifecycleManager->SendSessionInfoToSCB(callerAbility, sessionInfo);
2477 EXPECT_EQ(res, ERR_INVALID_VALUE);
2478
2479 uiAbilityLifecycleManager->SetRootSceneSession(nullptr);
2480 res = uiAbilityLifecycleManager->SendSessionInfoToSCB(callerAbility, sessionInfo);
2481 EXPECT_EQ(res, ERR_INVALID_VALUE);
2482
2483 uiAbilityLifecycleManager.reset();
2484 }
2485
2486 /**
2487 * @tc.name: UIAbilityLifecycleManager_StartAbilityBySpecifed_0100
2488 * @tc.desc: StartAbilityBySpecifed
2489 * @tc.type: FUNC
2490 */
2491 HWTEST_F(UIAbilityLifecycleManagerTest, StartAbilityBySpecifed_001, TestSize.Level1)
2492 {
2493 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2494 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2495 AbilityRequest request;
2496 std::shared_ptr<AbilityRecord> callerAbility = nullptr;
2497 uiAbilityLifecycleManager->StartAbilityBySpecifed(request, callerAbility);
2498 uiAbilityLifecycleManager.reset();
2499 }
2500
2501 /**
2502 * @tc.name: UIAbilityLifecycleManager_GetAbilityStateByPersistentId_0100
2503 * @tc.desc: GetAbilityStateByPersistentId
2504 * @tc.type: FUNC
2505 */
2506 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityStateByPersistentId_001, TestSize.Level1)
2507 {
2508 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2509 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2510 int32_t persistentId = 100;
2511 bool state;
2512 int32_t ret = uiAbilityLifecycleManager->GetAbilityStateByPersistentId(persistentId, state);
2513 EXPECT_EQ(ERR_INVALID_VALUE, ret);
2514 }
2515
2516 /**
2517 * @tc.name: UIAbilityLifecycleManager_GetAbilityStateByPersistentId_0200
2518 * @tc.desc: GetAbilityStateByPersistentId
2519 * @tc.type: FUNC
2520 */
2521 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityStateByPersistentId_002, TestSize.Level1)
2522 {
2523 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2524 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2525 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2526 abilityRecord->SetPendingState(AbilityState::INITIAL);
2527 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(100, abilityRecord);
2528 int32_t persistentId = 100;
2529 bool state;
2530 int32_t ret = uiAbilityLifecycleManager->GetAbilityStateByPersistentId(persistentId, state);
2531 EXPECT_EQ(ERR_OK, ret);
2532 }
2533
2534 /**
2535 * @tc.name: UIAbilityLifecycleManager_UpdateProcessName_0100
2536 * @tc.desc: UpdateProcessName
2537 * @tc.type: FUNC
2538 */
2539 HWTEST_F(UIAbilityLifecycleManagerTest, UpdateProcessName_001, TestSize.Level1)
2540 {
2541 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2542 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2543 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
2544 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
2545 EXPECT_NE(sessionInfo->processOptions, nullptr);
2546 sessionInfo->processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_PARENT;
2547 AbilityRequest abilityRequest;
2548 abilityRequest.sessionInfo = sessionInfo;
2549 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
2550 abilityRequest.abilityInfo.moduleName = "entry";
2551 abilityRequest.abilityInfo.name = "MainAbility";
2552 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2553 uiAbilityLifecycleManager->UpdateProcessName(abilityRequest, abilityRecord);
2554 EXPECT_EQ("com.example.unittest:entry:MainAbility:0", abilityRecord->GetProcessName());
2555 }
2556
2557 /**
2558 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0100
2559 * @tc.desc: ChangeAbilityVisibility
2560 * @tc.type: FUNC
2561 */
2562 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_001, TestSize.Level1)
2563 {
2564 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2565 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2566 int32_t ret = uiAbilityLifecycleManager->ChangeAbilityVisibility(nullptr, true);
2567 EXPECT_EQ(ERR_INVALID_VALUE, ret);
2568 }
2569
2570 /**
2571 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0100
2572 * @tc.desc: ChangeUIAbilityVisibilityBySCB
2573 * @tc.type: FUNC
2574 */
2575 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_001, TestSize.Level1)
2576 {
2577 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2578 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2579 int32_t ret = uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(nullptr, true);
2580 EXPECT_EQ(ERR_INVALID_VALUE, ret);
2581 }
2582
2583 /**
2584 * @tc.name: UIAbilityLifecycleManager_IsContainsAbility_0100
2585 * @tc.desc: IsContainsAbility
2586 * @tc.type: FUNC
2587 */
2588 HWTEST_F(UIAbilityLifecycleManagerTest, IsContainsAbility_001, TestSize.Level1)
2589 {
2590 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2591 EXPECT_NE(mgr, nullptr);
2592 sptr<IRemoteObject> token = nullptr;
2593 bool boolValue = mgr->IsContainsAbility(token);
2594 EXPECT_FALSE(boolValue);
2595 }
2596
2597 /**
2598 * @tc.name: UIAbilityLifecycleManager_IsContainsAbility_0200
2599 * @tc.desc: IsContainsAbility
2600 * @tc.type: FUNC
2601 */
2602 HWTEST_F(UIAbilityLifecycleManagerTest, IsContainsAbility_002, TestSize.Level1)
2603 {
2604 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2605 EXPECT_NE(mgr, nullptr);
2606 AbilityRequest abilityRequest;
2607 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2608 auto&& token = abilityRecord->GetToken()->AsObject();
2609 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
2610 bool boolValue = mgr->IsContainsAbility(token);
2611 EXPECT_TRUE(boolValue);
2612 }
2613
2614 /**
2615 * @tc.name: UIAbilityLifecycleManager_IsContainsAbilityInner_0100
2616 * @tc.desc: IsContainsAbilityInner
2617 * @tc.type: FUNC
2618 */
2619 HWTEST_F(UIAbilityLifecycleManagerTest, IsContainsAbilityInner_001, TestSize.Level1)
2620 {
2621 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2622 EXPECT_NE(mgr, nullptr);
2623 sptr<IRemoteObject> token = nullptr;
2624 bool boolValue = mgr->IsContainsAbilityInner(token);
2625 EXPECT_FALSE(boolValue);
2626 }
2627
2628 /**
2629 * @tc.name: UIAbilityLifecycleManager_IsContainsAbilityInner_0200
2630 * @tc.desc: IsContainsAbilityInner
2631 * @tc.type: FUNC
2632 */
2633 HWTEST_F(UIAbilityLifecycleManagerTest, IsContainsAbilityInner_002, TestSize.Level1)
2634 {
2635 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2636 EXPECT_NE(mgr, nullptr);
2637 AbilityRequest abilityRequest;
2638 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2639 auto&& token = abilityRecord->GetToken()->AsObject();
2640 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
2641 bool boolValue = mgr->IsContainsAbilityInner(token);
2642 EXPECT_TRUE(boolValue);
2643 }
2644
2645 /**
2646 * @tc.name: UIAbilityLifecycleManager_NotifySCBToMinimizeUIAbility_0100
2647 * @tc.desc: NotifySCBToMinimizeUIAbility
2648 * @tc.type: FUNC
2649 */
2650 HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBToMinimizeUIAbility_001, TestSize.Level1)
2651 {
2652 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2653 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
2654 sptr<IRemoteObject> token = nullptr;
2655 EXPECT_NE(mgr->NotifySCBToMinimizeUIAbility(abilityRecord, token), ERR_OK);
2656 }
2657
2658 /**
2659 * @tc.name: UIAbilityLifecycleManager_GetUIAbilityRecordBySessionInfo_0100
2660 * @tc.desc: GetUIAbilityRecordBySessionInfo
2661 * @tc.type: FUNC
2662 */
2663 HWTEST_F(UIAbilityLifecycleManagerTest, GetUIAbilityRecordBySessionInfo_001, TestSize.Level1)
2664 {
2665 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2666 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2667 sptr<SessionInfo> sessionInfo = nullptr;
2668 EXPECT_EQ(uiAbilityLifecycleManager->GetUIAbilityRecordBySessionInfo(sessionInfo), nullptr);
2669 }
2670
2671 /**
2672 * @tc.name: UIAbilityLifecycleManager_GetUIAbilityRecordBySessionInfo_0200
2673 * @tc.desc: GetUIAbilityRecordBySessionInfo
2674 * @tc.type: FUNC
2675 */
2676 HWTEST_F(UIAbilityLifecycleManagerTest, GetUIAbilityRecordBySessionInfo_002, TestSize.Level1)
2677 {
2678 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2679 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2680 sptr<SessionInfo> sessionInfo(new SessionInfo());
2681 sessionInfo->sessionToken = nullptr;
2682 EXPECT_EQ(uiAbilityLifecycleManager->GetUIAbilityRecordBySessionInfo(sessionInfo), nullptr);
2683 }
2684
2685 /**
2686 * @tc.name: UIAbilityLifecycleManager_GetUIAbilityRecordBySessionInfo_0300
2687 * @tc.desc: GetUIAbilityRecordBySessionInfo
2688 * @tc.type: FUNC
2689 */
2690 HWTEST_F(UIAbilityLifecycleManagerTest, GetUIAbilityRecordBySessionInfo_003, TestSize.Level1)
2691 {
2692 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2693 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2694 Rosen::SessionInfo info;
2695 sptr<SessionInfo> sessionInfo(new SessionInfo());
2696 sessionInfo->sessionToken = new Rosen::Session(info);
2697 EXPECT_EQ(uiAbilityLifecycleManager->GetUIAbilityRecordBySessionInfo(sessionInfo), nullptr);
2698 }
2699
2700 /**
2701 * @tc.name: UIAbilityLifecycleManager_GetUIAbilityRecordBySessionInfo_0400
2702 * @tc.desc: GetUIAbilityRecordBySessionInfo
2703 * @tc.type: FUNC
2704 */
2705 HWTEST_F(UIAbilityLifecycleManagerTest, GetUIAbilityRecordBySessionInfo_004, TestSize.Level1)
2706 {
2707 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2708 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2709 AbilityRequest abilityRequest;
2710 Rosen::SessionInfo info;
2711 sptr<SessionInfo> sessionInfo(new SessionInfo());
2712 sessionInfo->sessionToken = new Rosen::Session(info);
2713 sessionInfo->persistentId = 1;
2714 abilityRequest.sessionInfo = sessionInfo;
2715 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2716 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
2717 EXPECT_NE(uiAbilityLifecycleManager->GetUIAbilityRecordBySessionInfo(sessionInfo), nullptr);
2718 }
2719
2720 /**
2721 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedProcessResponse_0100
2722 * @tc.desc: OnStartSpecifiedProcessResponse
2723 * @tc.type: FUNC
2724 */
2725 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedProcessResponse_001, TestSize.Level1)
2726 {
2727 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2728 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2729 Want want;
2730 std::string flag = "flag";
2731 uiAbilityLifecycleManager->OnStartSpecifiedProcessResponse(want, flag);
2732 uiAbilityLifecycleManager.reset();
2733 }
2734
2735 /**
2736 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedProcessResponse_0200
2737 * @tc.desc: OnStartSpecifiedProcessResponse
2738 * @tc.type: FUNC
2739 */
2740 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedProcessResponse_002, TestSize.Level1)
2741 {
2742 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2743 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2744 Want want;
2745 std::string flag = "flag";
2746 int32_t requestId = 100;
2747 uiAbilityLifecycleManager->OnStartSpecifiedProcessResponse(want, flag, requestId);
2748 uiAbilityLifecycleManager.reset();
2749 }
2750
2751 /**
2752 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedAbilityTimeoutResponse_0100
2753 * @tc.desc: OnStartSpecifiedAbilityTimeoutResponse
2754 * @tc.type: FUNC
2755 */
2756 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedAbilityTimeoutResponse_001, TestSize.Level1)
2757 {
2758 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2759 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2760 Want want;
2761 uiAbilityLifecycleManager->OnStartSpecifiedAbilityTimeoutResponse(want);
2762 uiAbilityLifecycleManager.reset();
2763 }
2764
2765 /**
2766 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedAbilityTimeoutResponse_0200
2767 * @tc.desc: OnStartSpecifiedAbilityTimeoutResponse
2768 * @tc.type: FUNC
2769 */
2770 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedAbilityTimeoutResponse_002, TestSize.Level1)
2771 {
2772 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2773 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2774 Want want;
2775 int32_t requestId = 100;
2776 uiAbilityLifecycleManager->OnStartSpecifiedAbilityTimeoutResponse(want, requestId);
2777 uiAbilityLifecycleManager.reset();
2778 }
2779
2780 /**
2781 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedProcessTimeoutResponse_0100
2782 * @tc.desc: OnStartSpecifiedProcessTimeoutResponse
2783 * @tc.type: FUNC
2784 */
2785 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedProcessTimeoutResponse_001, TestSize.Level1)
2786 {
2787 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2788 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2789 Want want;
2790 uiAbilityLifecycleManager->OnStartSpecifiedProcessTimeoutResponse(want);
2791 uiAbilityLifecycleManager.reset();
2792 }
2793
2794 /**
2795 * @tc.name: UIAbilityLifecycleManager_OnStartSpecifiedProcessTimeoutResponse_0200
2796 * @tc.desc: OnStartSpecifiedProcessTimeoutResponse
2797 * @tc.type: FUNC
2798 */
2799 HWTEST_F(UIAbilityLifecycleManagerTest, OnStartSpecifiedProcessTimeoutResponse_002, TestSize.Level1)
2800 {
2801 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2802 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2803 Want want;
2804 int32_t requestId = 100;
2805 uiAbilityLifecycleManager->OnStartSpecifiedProcessTimeoutResponse(want, requestId);
2806 uiAbilityLifecycleManager.reset();
2807 }
2808
2809 /**
2810 * @tc.name: UIAbilityLifecycleManager_OnCallConnectDied_0100
2811 * @tc.desc: OnCallConnectDied
2812 * @tc.type: FUNC
2813 */
2814 HWTEST_F(UIAbilityLifecycleManagerTest, OnCallConnectDied_001, TestSize.Level1)
2815 {
2816 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
2817 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2818 std::shared_ptr<CallRecord> callRecord = nullptr;
2819 uiAbilityLifecycleManager->OnCallConnectDied(callRecord);
2820 uiAbilityLifecycleManager.reset();
2821 }
2822
2823 /**
2824 * @tc.name: UIAbilityLifecycleManager_GetSessionIdByAbilityToken_0100
2825 * @tc.desc: GetSessionIdByAbilityToken
2826 * @tc.type: FUNC
2827 */
2828 HWTEST_F(UIAbilityLifecycleManagerTest, GetSessionIdByAbilityToken_001, TestSize.Level1)
2829 {
2830 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2831 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2832 sptr<IRemoteObject> token = nullptr;
2833 EXPECT_EQ(uiAbilityLifecycleManager->GetSessionIdByAbilityToken(token), ERR_OK);
2834 }
2835
2836 /**
2837 * @tc.name: UIAbilityLifecycleManager_GetSessionIdByAbilityToken_0200
2838 * @tc.desc: GetSessionIdByAbilityToken
2839 * @tc.type: FUNC
2840 */
2841 HWTEST_F(UIAbilityLifecycleManagerTest, GetSessionIdByAbilityToken_002, TestSize.Level1)
2842 {
2843 auto mgr = std::make_unique<UIAbilityLifecycleManager>();
2844 AbilityRequest abilityRequest;
2845 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2846 mgr->sessionAbilityMap_.emplace(1, abilityRecord);
2847 auto&& token = abilityRecord->GetToken()->AsObject();
2848 EXPECT_EQ(mgr->GetSessionIdByAbilityToken(token), 1);
2849 }
2850
2851 /**
2852 * @tc.name: UIAbilityLifecycleManager_GetActiveAbilityList_0100
2853 * @tc.desc: GetActiveAbilityList
2854 * @tc.type: FUNC
2855 */
2856 HWTEST_F(UIAbilityLifecycleManagerTest, GetActiveAbilityList_001, TestSize.Level1)
2857 {
2858 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2859 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2860 AbilityRequest abilityRequest;
2861 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2862 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2863 std::vector<std::string> abilityList;
2864 int32_t pid = 100;
2865 uiAbilityLifecycleManager->GetActiveAbilityList(TEST_UID, abilityList, pid);
2866 uiAbilityLifecycleManager.reset();
2867 }
2868
2869 /**
2870 * @tc.name: UIAbilityLifecycleManager_GetActiveAbilityList_0200
2871 * @tc.desc: GetActiveAbilityList
2872 * @tc.type: FUNC
2873 */
2874 HWTEST_F(UIAbilityLifecycleManagerTest, GetActiveAbilityList_002, TestSize.Level1)
2875 {
2876 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2877 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2878 AbilityRequest abilityRequest;
2879 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::STANDARD;
2880 abilityRequest.abilityInfo.name = "testAbility";
2881 abilityRequest.abilityInfo.moduleName = "testModule";
2882 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
2883 abilityRequest.abilityInfo.applicationInfo.uid = TEST_UID;
2884 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2885 abilityRecord->SetOwnerMissionUserId(DelayedSingleton<AbilityManagerService>::GetInstance()->GetUserId());
2886 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
2887 std::vector<std::string> abilityList;
2888 int32_t pid = 100;
2889 uiAbilityLifecycleManager->GetActiveAbilityList(TEST_UID, abilityList, pid);
2890 uiAbilityLifecycleManager.reset();
2891 }
2892
2893 /**
2894 * @tc.name: UIAbilityLifecycleManager_IsAbilityStarted_0100
2895 * @tc.desc: IsAbilityStarted
2896 * @tc.type: FUNC
2897 */
2898 HWTEST_F(UIAbilityLifecycleManagerTest, IsAbilityStarted_001, TestSize.Level1)
2899 {
2900 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2901 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
2902 AbilityRequest abilityRequest;
2903 Rosen::SessionInfo info;
2904 sptr<SessionInfo> sessionInfo(new SessionInfo());
2905 sessionInfo->sessionToken = new Rosen::Session(info);
2906 sessionInfo->persistentId = 0;
2907 abilityRequest.sessionInfo = sessionInfo;
2908 auto targetRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2909 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, targetRecord);
2910 EXPECT_EQ(uiAbilityLifecycleManager->IsAbilityStarted(abilityRequest, targetRecord), false);
2911 }
2912
2913 /**
2914 * @tc.name: UIAbilityLifecycleManager_IsAbilityStarted_0200
2915 * @tc.desc: IsAbilityStarted
2916 * @tc.type: FUNC
2917 */
2918 HWTEST_F(UIAbilityLifecycleManagerTest, IsAbilityStarted_002, TestSize.Level1)
2919 {
2920 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2921 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
2922 AbilityRequest abilityRequest;
2923 Rosen::SessionInfo info;
2924 sptr<SessionInfo> sessionInfo(new SessionInfo());
2925 sessionInfo->sessionToken = new Rosen::Session(info);
2926 sessionInfo->persistentId = 1;
2927 abilityRequest.sessionInfo = sessionInfo;
2928 auto targetRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2929 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, targetRecord);
2930 EXPECT_EQ(uiAbilityLifecycleManager->IsAbilityStarted(abilityRequest, targetRecord), true);
2931 }
2932
2933 /**
2934 * @tc.name: UIAbilityLifecycleManager_TryPrepareTerminateByPids_0100
2935 * @tc.desc: TryPrepareTerminateByPids
2936 * @tc.type: FUNC
2937 */
2938 HWTEST_F(UIAbilityLifecycleManagerTest, TryPrepareTerminateByPids_001, TestSize.Level1)
2939 {
2940 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2941 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
2942 std::vector<int32_t> pids;
2943 EXPECT_EQ(uiAbilityLifecycleManager->TryPrepareTerminateByPids(pids), ERR_OK);
2944 }
2945
2946 /**
2947 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0200
2948 * @tc.desc: ChangeAbilityVisibility
2949 * @tc.type: FUNC
2950 */
2951 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_002, TestSize.Level1)
2952 {
2953 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2954 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2955 sptr<IRemoteObject> token = nullptr;
2956 bool isShow = false;
2957 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_INVALID_VALUE);
2958 }
2959
2960 /**
2961 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0300
2962 * @tc.desc: ChangeAbilityVisibility
2963 * @tc.type: FUNC
2964 */
2965 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_003, TestSize.Level1)
2966 {
2967 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2968 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2969 AbilityRequest abilityRequest;
2970 abilityRequest.appInfo.accessTokenId = 100;
2971 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2972 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
2973 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
2974 bool isShow = true;
2975 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_NATIVE_NOT_SELF_APPLICATION);
2976 }
2977
2978 /**
2979 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0400
2980 * @tc.desc: ChangeAbilityVisibility
2981 * @tc.type: FUNC
2982 */
2983 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_004, TestSize.Level1)
2984 {
2985 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
2986 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
2987 AbilityRequest abilityRequest;
2988 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
2989 abilityRequest.sessionInfo = nullptr;
2990 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
2991 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
2992 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
2993 bool isShow = true;
2994 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_INVALID_VALUE);
2995 }
2996
2997 /**
2998 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0500
2999 * @tc.desc: ChangeAbilityVisibility
3000 * @tc.type: FUNC
3001 */
3002 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_005, TestSize.Level1)
3003 {
3004 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3005 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3006 AbilityRequest abilityRequest;
3007 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3008 sptr<SessionInfo> sessionInfo(new SessionInfo());
3009 sessionInfo->processOptions = nullptr;
3010 abilityRequest.sessionInfo = sessionInfo;
3011 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3012 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3013 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
3014 bool isShow = true;
3015 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_START_OPTIONS_CHECK_FAILED);
3016 }
3017
3018 /**
3019 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0600
3020 * @tc.desc: ChangeAbilityVisibility
3021 * @tc.type: FUNC
3022 */
3023 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_006, TestSize.Level1)
3024 {
3025 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3026 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3027 AbilityRequest abilityRequest;
3028 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3029 sptr<SessionInfo> sessionInfo(new SessionInfo());
3030 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
3031 abilityRequest.sessionInfo = sessionInfo;
3032 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3033 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3034 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
3035 bool isShow = true;
3036 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_START_OPTIONS_CHECK_FAILED);
3037 }
3038
3039 /**
3040 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0700
3041 * @tc.desc: ChangeAbilityVisibility
3042 * @tc.type: FUNC
3043 */
3044 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_007, TestSize.Level1)
3045 {
3046 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3047 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3048 AbilityRequest abilityRequest;
3049 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3050 sptr<SessionInfo> sessionInfo(new SessionInfo());
3051 sessionInfo->sessionToken = nullptr;
3052 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
3053 sessionInfo->processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM;
3054 abilityRequest.sessionInfo = sessionInfo;
3055 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3056 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3057 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
3058 bool isShow = true;
3059 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_INVALID_VALUE);
3060 }
3061
3062 /**
3063 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0800
3064 * @tc.desc: ChangeAbilityVisibility
3065 * @tc.type: FUNC
3066 */
3067 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_008, TestSize.Level1)
3068 {
3069 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3070 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3071 AbilityRequest abilityRequest;
3072 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3073 Rosen::SessionInfo info;
3074 sptr<SessionInfo> sessionInfo(new SessionInfo());
3075 sessionInfo->sessionToken = new Rosen::Session(info);
3076 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
3077 sessionInfo->processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM;
3078 abilityRequest.sessionInfo = sessionInfo;
3079 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3080 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3081 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
3082 bool isShow = true;
3083 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_OK);
3084 }
3085
3086 /**
3087 * @tc.name: UIAbilityLifecycleManager_ChangeAbilityVisibility_0900
3088 * @tc.desc: ChangeAbilityVisibility
3089 * @tc.type: FUNC
3090 */
3091 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeAbilityVisibility_009, TestSize.Level1)
3092 {
3093 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3094 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3095 AbilityRequest abilityRequest;
3096 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3097 Rosen::SessionInfo info;
3098 sptr<SessionInfo> sessionInfo(new SessionInfo());
3099 sessionInfo->sessionToken = new Rosen::Session(info);
3100 sessionInfo->processOptions = std::make_shared<ProcessOptions>();
3101 sessionInfo->processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM;
3102 abilityRequest.sessionInfo = sessionInfo;
3103 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3104 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3105 sptr<IRemoteObject> token = abilityRecord->GetToken()->AsObject();
3106 bool isShow = false;
3107 EXPECT_EQ(uiAbilityLifecycleManager->ChangeAbilityVisibility(token, isShow), ERR_OK);
3108 }
3109
3110 /**
3111 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0200
3112 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3113 * @tc.type: FUNC
3114 */
3115 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_002, TestSize.Level1)
3116 {
3117 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3118 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3119 sptr<SessionInfo> sessionInfo = nullptr;
3120 bool isShow = false;
3121 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow), ERR_INVALID_VALUE);
3122 }
3123
3124 /**
3125 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0300
3126 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3127 * @tc.type: FUNC
3128 */
3129 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_003, TestSize.Level1)
3130 {
3131 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3132 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3133 AbilityRequest abilityRequest;
3134 sptr<SessionInfo> sessionInfo(new SessionInfo());
3135 sessionInfo->persistentId = 100;
3136 abilityRequest.sessionInfo = sessionInfo;
3137 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3138 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3139 bool isShow = false;
3140 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow),
3141 ERR_NATIVE_ABILITY_NOT_FOUND);
3142 }
3143
3144 /**
3145 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0400
3146 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3147 * @tc.type: FUNC
3148 */
3149 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_004, TestSize.Level1)
3150 {
3151 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3152 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3153 sptr<SessionInfo> sessionInfo(new SessionInfo());
3154 sessionInfo->persistentId = 100;
3155 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, nullptr);
3156 bool isShow = false;
3157 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow),
3158 ERR_INVALID_VALUE);
3159 }
3160
3161 /**
3162 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0500
3163 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3164 * @tc.type: FUNC
3165 */
3166 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_005, TestSize.Level1)
3167 {
3168 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3169 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3170 AbilityRequest abilityRequest;
3171 sptr<SessionInfo> sessionInfo(new SessionInfo());
3172 sessionInfo->persistentId = 100;
3173 abilityRequest.sessionInfo = sessionInfo;
3174 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3175 abilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::INITIAL);
3176 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3177 bool isShow = false;
3178 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow),
3179 ERR_NATIVE_ABILITY_STATE_CHECK_FAILED);
3180 }
3181
3182 /**
3183 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0600
3184 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3185 * @tc.type: FUNC
3186 */
3187 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_006, TestSize.Level1)
3188 {
3189 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3190 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3191 AbilityRequest abilityRequest;
3192 sptr<SessionInfo> sessionInfo(new SessionInfo());
3193 sessionInfo->persistentId = 100;
3194 abilityRequest.sessionInfo = sessionInfo;
3195 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3196 abilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::UNSPECIFIED);
3197 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3198 bool isShow = false;
3199 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow),
3200 ERR_NATIVE_ABILITY_STATE_CHECK_FAILED);
3201 }
3202
3203 /**
3204 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0700
3205 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3206 * @tc.type: FUNC
3207 */
3208 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_007, TestSize.Level1)
3209 {
3210 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3211 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3212 AbilityRequest abilityRequest;
3213 sptr<SessionInfo> sessionInfo(new SessionInfo());
3214 sessionInfo->persistentId = 100;
3215 abilityRequest.sessionInfo = sessionInfo;
3216 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3217 abilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::FOREGROUND_SHOW);
3218 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3219 bool isShow = true;
3220 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow), ERR_OK);
3221 }
3222
3223 /**
3224 * @tc.name: UIAbilityLifecycleManager_ChangeUIAbilityVisibilityBySCB_0800
3225 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3226 * @tc.type: FUNC
3227 */
3228 HWTEST_F(UIAbilityLifecycleManagerTest, ChangeUIAbilityVisibilityBySCB_008, TestSize.Level1)
3229 {
3230 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3231 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3232 AbilityRequest abilityRequest;
3233 sptr<SessionInfo> sessionInfo(new SessionInfo());
3234 sessionInfo->persistentId = 100;
3235 abilityRequest.sessionInfo = sessionInfo;
3236 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3237 abilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::FOREGROUND_HIDE);
3238 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3239 bool isShow = false;
3240 EXPECT_EQ(uiAbilityLifecycleManager->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow), ERR_OK);
3241 }
3242
3243 /**
3244 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByName_0100
3245 * @tc.desc: GetAbilityRecordsByName
3246 * @tc.type: FUNC
3247 */
3248 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByName_001, TestSize.Level1)
3249 {
3250 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3251 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3252 AbilityRequest abilityRequest;
3253 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3254 abilityRequest.abilityInfo.name = "MainAbility";
3255 abilityRequest.abilityInfo.deviceId = "100";
3256 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3257 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3258 AppExecFwk::ElementName element;
3259 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByName(element);
3260 EXPECT_EQ(ret.empty(), true);
3261 }
3262
3263 /**
3264 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByName_0200
3265 * @tc.desc: GetAbilityRecordsByName
3266 * @tc.type: FUNC
3267 */
3268 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByName_002, TestSize.Level1)
3269 {
3270 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3271 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3272 AbilityRequest abilityRequest;
3273 abilityRequest.abilityInfo.deviceId = "100";
3274 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3275 abilityRequest.abilityInfo.name = "MainAbility";
3276 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3277 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3278 AppExecFwk::ElementName element("100", "com.example.unittest", "MainAbility");
3279 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByName(element);
3280 EXPECT_EQ(ret.empty(), false);
3281 }
3282
3283 /**
3284 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByName_0300
3285 * @tc.desc: GetAbilityRecordsByName
3286 * @tc.type: FUNC
3287 */
3288 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByName_003, TestSize.Level1)
3289 {
3290 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3291 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3292 AbilityRequest abilityRequest;
3293 abilityRequest.abilityInfo.deviceId = "100";
3294 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3295 abilityRequest.abilityInfo.name = "MainAbility";
3296 abilityRequest.abilityInfo.moduleName = "entry";
3297 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3298 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3299 AppExecFwk::ElementName element("100", "com.example.unittest", "MainAbility", "entry");
3300 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByName(element);
3301 EXPECT_EQ(ret.empty(), false);
3302 }
3303
3304 /**
3305 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByNameInner_0100
3306 * @tc.desc: GetAbilityRecordsByNameInner
3307 * @tc.type: FUNC
3308 */
3309 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByNameInner_001, TestSize.Level1)
3310 {
3311 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3312 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3313 AbilityRequest abilityRequest;
3314 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3315 abilityRequest.abilityInfo.name = "MainAbility";
3316 abilityRequest.abilityInfo.deviceId = "100";
3317 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3318 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3319 AppExecFwk::ElementName element;
3320 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByNameInner(element);
3321 EXPECT_EQ(ret.empty(), true);
3322 }
3323
3324 /**
3325 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByNameInner_0200
3326 * @tc.desc: GetAbilityRecordsByNameInner
3327 * @tc.type: FUNC
3328 */
3329 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByNameInner_002, TestSize.Level1)
3330 {
3331 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3332 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3333 AbilityRequest abilityRequest;
3334 abilityRequest.abilityInfo.deviceId = "100";
3335 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3336 abilityRequest.abilityInfo.name = "MainAbility";
3337 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3338 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3339 AppExecFwk::ElementName element("100", "com.example.unittest", "MainAbility");
3340 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByNameInner(element);
3341 EXPECT_EQ(ret.empty(), false);
3342 }
3343
3344 /**
3345 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsByNameInner_0300
3346 * @tc.desc: GetAbilityRecordsByNameInner
3347 * @tc.type: FUNC
3348 */
3349 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsByNameInner_003, TestSize.Level1)
3350 {
3351 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3352 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3353 AbilityRequest abilityRequest;
3354 abilityRequest.abilityInfo.deviceId = "100";
3355 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3356 abilityRequest.abilityInfo.name = "MainAbility";
3357 abilityRequest.abilityInfo.moduleName = "entry";
3358 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3359 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(1, abilityRecord);
3360 AppExecFwk::ElementName element("100", "com.example.unittest", "MainAbility", "entry");
3361 auto ret = uiAbilityLifecycleManager->GetAbilityRecordsByNameInner(element);
3362 EXPECT_EQ(ret.empty(), false);
3363 }
3364
3365 /**
3366 * @tc.name: UIAbilityLifecycleManager_PrepareTerminateAbility_0100
3367 * @tc.desc: PrepareTerminateAbility
3368 * @tc.type: FUNC
3369 */
3370 HWTEST_F(UIAbilityLifecycleManagerTest, PrepareTerminateAbility_001, TestSize.Level1)
3371 {
3372 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3373 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3374 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
3375 bool boolValue = uiAbilityLifecycleManager->PrepareTerminateAbility(abilityRecord);
3376 EXPECT_FALSE(boolValue);
3377 }
3378
3379 /**
3380 * @tc.name: UIAbilityLifecycleManager_PrepareTerminateAbility_0200
3381 * @tc.desc: PrepareTerminateAbility
3382 * @tc.type: FUNC
3383 */
3384 HWTEST_F(UIAbilityLifecycleManagerTest, PrepareTerminateAbility_002, TestSize.Level1)
3385 {
3386 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3387 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3388 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3389 bool boolValue = uiAbilityLifecycleManager->PrepareTerminateAbility(abilityRecord);
3390 EXPECT_FALSE(boolValue);
3391 }
3392
3393 /**
3394 * @tc.name: UIAbilityLifecycleManager_SetSessionHandler_0100
3395 * @tc.desc: SetSessionHandler
3396 * @tc.type: FUNC
3397 */
3398 HWTEST_F(UIAbilityLifecycleManagerTest, SetSessionHandler_001, TestSize.Level1)
3399 {
3400 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3401 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3402 sptr<ISessionHandler> handler;
3403 uiAbilityLifecycleManager->SetSessionHandler(handler);
3404 EXPECT_EQ(uiAbilityLifecycleManager->handler_, handler);
3405 }
3406
3407 /**
3408 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsById_0100
3409 * @tc.desc: GetAbilityRecordsById
3410 * @tc.type: FUNC
3411 */
3412 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsById_001, TestSize.Level1)
3413 {
3414 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3415 int32_t sessionId = 100;
3416 AbilityRequest abilityRequest;
3417 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3418 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionId, abilityRecord);
3419 EXPECT_EQ(uiAbilityLifecycleManager->GetAbilityRecordsById(sessionId + 1), nullptr);
3420 }
3421
3422 /**
3423 * @tc.name: UIAbilityLifecycleManager_GetAbilityRecordsById_0200
3424 * @tc.desc: GetAbilityRecordsById
3425 * @tc.type: FUNC
3426 */
3427 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRecordsById_002, TestSize.Level1)
3428 {
3429 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3430 int32_t sessionId = 100;
3431 AbilityRequest abilityRequest;
3432 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3433 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionId, abilityRecord);
3434 EXPECT_NE(uiAbilityLifecycleManager->GetAbilityRecordsById(sessionId), nullptr);
3435 }
3436
3437 /**
3438 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0100
3439 * @tc.desc: OnAppStateChanged
3440 * @tc.type: FUNC
3441 */
3442 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_001, TestSize.Level1)
3443 {
3444 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3445 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3446 AbilityRequest abilityRequest;
3447 abilityRequest.appInfo.bundleName = "com.example.unittest";
3448 abilityRequest.abilityInfo.name = "MainAbility";
3449 abilityRequest.abilityInfo.process = "AbilityProcess";
3450 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3451 AppInfo info;
3452 info.processName = "AbilityProcess";
3453 info.state = AppState::TERMINATED;
3454 uiAbilityLifecycleManager->terminateAbilityList_.emplace_back(abilityRecord);
3455 uiAbilityLifecycleManager->OnAppStateChanged(info);
3456 uiAbilityLifecycleManager.reset();
3457 }
3458
3459 /**
3460 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0200
3461 * @tc.desc: OnAppStateChanged
3462 * @tc.type: FUNC
3463 */
3464 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_002, TestSize.Level1)
3465 {
3466 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3467 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3468 AbilityRequest abilityRequest;
3469 abilityRequest.appInfo.bundleName = "com.example.unittest";
3470 abilityRequest.abilityInfo.name = "MainAbility";
3471 abilityRequest.abilityInfo.process = "AbilityProcess";
3472 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3473 AppInfo info;
3474 info.processName = "AbilityProcess";
3475 info.state = AppState::END;
3476 uiAbilityLifecycleManager->terminateAbilityList_.emplace_back(abilityRecord);
3477 uiAbilityLifecycleManager->OnAppStateChanged(info);
3478 uiAbilityLifecycleManager.reset();
3479 }
3480
3481 /**
3482 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0300
3483 * @tc.desc: OnAppStateChanged
3484 * @tc.type: FUNC
3485 */
3486 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_003, TestSize.Level1)
3487 {
3488 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3489 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3490 AbilityRequest abilityRequest;
3491 abilityRequest.appInfo.bundleName = "com.example.unittest";
3492 abilityRequest.abilityInfo.name = "MainAbility";
3493 abilityRequest.abilityInfo.process = "AbilityProcess";
3494 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3495 AppInfo info;
3496 info.processName = "com.example.unittest";
3497 info.state = AppState::TERMINATED;
3498 uiAbilityLifecycleManager->terminateAbilityList_.emplace_back(abilityRecord);
3499 uiAbilityLifecycleManager->OnAppStateChanged(info);
3500 uiAbilityLifecycleManager.reset();
3501 }
3502
3503 /**
3504 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0400
3505 * @tc.desc: OnAppStateChanged
3506 * @tc.type: FUNC
3507 */
3508 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_004, TestSize.Level1)
3509 {
3510 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3511 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3512 AbilityRequest abilityRequest;
3513 abilityRequest.appInfo.bundleName = "com.example.unittest";
3514 abilityRequest.abilityInfo.name = "MainAbility";
3515 abilityRequest.abilityInfo.process = "AbilityProcess";
3516 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3517 AppInfo info;
3518 info.processName = "com.example.unittest";
3519 info.state = AppState::END;
3520 uiAbilityLifecycleManager->terminateAbilityList_.emplace_back(abilityRecord);
3521 uiAbilityLifecycleManager->OnAppStateChanged(info);
3522 uiAbilityLifecycleManager.reset();
3523 }
3524
3525 /**
3526 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0500
3527 * @tc.desc: OnAppStateChanged
3528 * @tc.type: FUNC
3529 */
3530 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_005, TestSize.Level1)
3531 {
3532 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3533 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3534 AbilityRequest abilityRequest;
3535 abilityRequest.appInfo.bundleName = "com.example.unittest";
3536 abilityRequest.abilityInfo.name = "MainAbility";
3537 abilityRequest.abilityInfo.process = "AbilityProcess";
3538 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3539 AppInfo info;
3540 info.processName = "com.example.unittest";
3541 info.state = AppState::COLD_START;
3542 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3543 uiAbilityLifecycleManager->OnAppStateChanged(info);
3544 uiAbilityLifecycleManager.reset();
3545 }
3546
3547 /**
3548 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0600
3549 * @tc.desc: OnAppStateChanged
3550 * @tc.type: FUNC
3551 */
3552 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_006, TestSize.Level1)
3553 {
3554 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3555 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3556 AbilityRequest abilityRequest;
3557 abilityRequest.appInfo.bundleName = "com.example.unittest";
3558 abilityRequest.abilityInfo.name = "MainAbility";
3559 abilityRequest.abilityInfo.process = "AbilityProcess";
3560 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3561 AppInfo info;
3562 info.processName = "AbilityProcess";
3563 info.state = AppState::COLD_START;
3564 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3565 uiAbilityLifecycleManager->OnAppStateChanged(info);
3566 uiAbilityLifecycleManager.reset();
3567 }
3568
3569 /**
3570 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0700
3571 * @tc.desc: OnAppStateChanged
3572 * @tc.type: FUNC
3573 */
3574 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_007, TestSize.Level1)
3575 {
3576 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3577 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3578 AbilityRequest abilityRequest;
3579 abilityRequest.appInfo.bundleName = "com.example.unittest";
3580 abilityRequest.abilityInfo.name = "MainAbility";
3581 abilityRequest.abilityInfo.process = "AbilityProcess";
3582 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3583 AppInfo info;
3584 info.processName = "com.example.unittest";
3585 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3586 uiAbilityLifecycleManager->OnAppStateChanged(info);
3587 uiAbilityLifecycleManager.reset();
3588 }
3589
3590 /**
3591 * @tc.name: UIAbilityLifecycleManager_OnAppStateChanged_0800
3592 * @tc.desc: OnAppStateChanged
3593 * @tc.type: FUNC
3594 */
3595 HWTEST_F(UIAbilityLifecycleManagerTest, OnAppStateChanged_008, TestSize.Level1)
3596 {
3597 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3598 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3599 AbilityRequest abilityRequest;
3600 abilityRequest.appInfo.bundleName = "com.example.unittest";
3601 abilityRequest.abilityInfo.name = "MainAbility";
3602 abilityRequest.abilityInfo.process = "AbilityProcess";
3603 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3604 AppInfo info;
3605 info.processName = "AbilityProcess";
3606 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3607 uiAbilityLifecycleManager->OnAppStateChanged(info);
3608 uiAbilityLifecycleManager.reset();
3609 }
3610
3611 /**
3612 * @tc.name: UIAbilityLifecycleManager_UninstallApp_0100
3613 * @tc.desc: UninstallApp
3614 * @tc.type: FUNC
3615 */
3616 HWTEST_F(UIAbilityLifecycleManagerTest, UninstallApp_001, TestSize.Level1)
3617 {
3618 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3619 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3620 AbilityRequest abilityRequest;
3621 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3622 abilityRequest.abilityInfo.name = "MainAbility";
3623 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3624 AppInfo info;
3625 std::string bundleName = "com.example.unittest";
3626 int32_t uid = 0;
3627 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3628 uiAbilityLifecycleManager->UninstallApp(bundleName, uid);
3629 uiAbilityLifecycleManager.reset();
3630 }
3631
3632 /**
3633 * @tc.name: UIAbilityLifecycleManager_GetAbilityRunningInfos_0100
3634 * @tc.desc: GetAbilityRunningInfos
3635 * @tc.type: FUNC
3636 */
3637 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRunningInfos_001, TestSize.Level1)
3638 {
3639 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3640 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3641 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3642 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3643 std::vector<AbilityRunningInfo> info;
3644 bool isPerm = true;
3645 uiAbilityLifecycleManager->GetAbilityRunningInfos(info, isPerm);
3646 uiAbilityLifecycleManager.reset();
3647 }
3648
3649 /**
3650 * @tc.name: UIAbilityLifecycleManager_GetAbilityRunningInfos_0200
3651 * @tc.desc: GetAbilityRunningInfos
3652 * @tc.type: FUNC
3653 */
3654 HWTEST_F(UIAbilityLifecycleManagerTest, GetAbilityRunningInfos_002, TestSize.Level1)
3655 {
3656 auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
3657 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3658 AbilityRequest abilityRequest;
3659 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
3660 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3661 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3662 std::vector<AbilityRunningInfo> info;
3663 bool isPerm = false;
3664 uiAbilityLifecycleManager->GetAbilityRunningInfos(info, isPerm);
3665 uiAbilityLifecycleManager.reset();
3666 }
3667
3668 /**
3669 * @tc.name: UIAbilityLifecycleManager_MoveMissionToFront_0100
3670 * @tc.desc: MoveMissionToFront
3671 * @tc.type: FUNC
3672 */
3673 HWTEST_F(UIAbilityLifecycleManagerTest, MoveMissionToFront_001, TestSize.Level1)
3674 {
3675 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3676 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3677 uiAbilityLifecycleManager->rootSceneSession_ = nullptr;
3678 int32_t sessionId = 100;
3679 std::shared_ptr<StartOptions> startOptions;
3680 EXPECT_EQ(uiAbilityLifecycleManager->MoveMissionToFront(sessionId, startOptions), ERR_INVALID_VALUE);
3681 }
3682
3683 /**
3684 * @tc.name: UIAbilityLifecycleManager_MoveMissionToFront_0200
3685 * @tc.desc: MoveMissionToFront
3686 * @tc.type: FUNC
3687 */
3688 HWTEST_F(UIAbilityLifecycleManagerTest, MoveMissionToFront_002, TestSize.Level1)
3689 {
3690 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3691 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3692 Rosen::SessionInfo info;
3693 uiAbilityLifecycleManager->rootSceneSession_ = new Rosen::Session(info);
3694 int32_t sessionId = 100;
3695 std::shared_ptr<StartOptions> startOptions;
3696 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3697 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(0, abilityRecord);
3698 EXPECT_EQ(uiAbilityLifecycleManager->MoveMissionToFront(sessionId, startOptions), ERR_INVALID_VALUE);
3699 }
3700
3701 /**
3702 * @tc.name: UIAbilityLifecycleManager_MoveMissionToFront_0300
3703 * @tc.desc: MoveMissionToFront
3704 * @tc.type: FUNC
3705 */
3706 HWTEST_F(UIAbilityLifecycleManagerTest, MoveMissionToFront_003, TestSize.Level1)
3707 {
3708 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3709 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3710 Rosen::SessionInfo info;
3711 uiAbilityLifecycleManager->rootSceneSession_ = new Rosen::Session(info);
3712 int32_t sessionId = 100;
3713 std::shared_ptr<StartOptions> startOptions;
3714 AbilityRequest abilityRequest;
3715 sptr<SessionInfo> sessionInfo = nullptr;
3716 abilityRequest.sessionInfo = sessionInfo;
3717 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3718 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionId, abilityRecord);
3719 EXPECT_EQ(uiAbilityLifecycleManager->MoveMissionToFront(sessionId, startOptions), ERR_INVALID_VALUE);
3720 }
3721
3722 /**
3723 * @tc.name: UIAbilityLifecycleManager_MoveMissionToFront_0400
3724 * @tc.desc: MoveMissionToFront
3725 * @tc.type: FUNC
3726 */
3727 HWTEST_F(UIAbilityLifecycleManagerTest, MoveMissionToFront_004, TestSize.Level1)
3728 {
3729 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3730 ASSERT_NE(uiAbilityLifecycleManager, nullptr);
3731 int32_t sessionId = 100;
3732 std::shared_ptr<StartOptions> startOptions;
3733 Rosen::SessionInfo info;
3734 uiAbilityLifecycleManager->rootSceneSession_ = new Rosen::Session(info);
3735 AbilityRequest abilityRequest;
3736 sptr<SessionInfo> sessionInfo = (new SessionInfo());
3737 abilityRequest.sessionInfo = sessionInfo;
3738 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3739 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionId, abilityRecord);
3740 EXPECT_EQ(uiAbilityLifecycleManager->MoveMissionToFront(sessionId, startOptions), ERR_OK);
3741 }
3742
3743 /**
3744 * @tc.name: UIAbilityLifecycleManager_GetReusedCollaboratorPersistentId_0100
3745 * @tc.desc: GetReusedCollaboratorPersistentId
3746 * @tc.type: FUNC
3747 */
3748 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedCollaboratorPersistentId_001, TestSize.Level1)
3749 {
3750 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3751 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3752 AbilityRequest abilityRequest;
3753 Want want;
3754 want.SetParam("ohos.anco.param.missionAffinity", false);
3755 abilityRequest.want = want;
3756 sptr<SessionInfo> sessionInfo(new SessionInfo());
3757 sessionInfo->persistentId = 100;
3758 abilityRequest.sessionInfo = sessionInfo;
3759 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3760 abilityRecord->collaboratorType_ = CollaboratorType::DEFAULT_TYPE;
3761 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3762 bool reuse = false;
3763 EXPECT_NE(uiAbilityLifecycleManager->GetReusedCollaboratorPersistentId(abilityRequest, reuse),
3764 sessionInfo->persistentId);
3765 }
3766
3767 /**
3768 * @tc.name: UIAbilityLifecycleManager_GetReusedCollaboratorPersistentId_0200
3769 * @tc.desc: GetReusedCollaboratorPersistentId
3770 * @tc.type: FUNC
3771 */
3772 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedCollaboratorPersistentId_002, TestSize.Level1)
3773 {
3774 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3775 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3776 AbilityRequest abilityRequest;
3777 Want want;
3778 want.SetParam("ohos.anco.param.missionAffinity", false);
3779 abilityRequest.want = want;
3780 sptr<SessionInfo> sessionInfo(new SessionInfo());
3781 sessionInfo->persistentId = 100;
3782 abilityRequest.sessionInfo = sessionInfo;
3783 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3784 abilityRecord->collaboratorType_ = CollaboratorType::RESERVE_TYPE;
3785 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3786 bool reuse = false;
3787 EXPECT_EQ(uiAbilityLifecycleManager->GetReusedCollaboratorPersistentId(abilityRequest, reuse),
3788 sessionInfo->persistentId);
3789 }
3790
3791 /**
3792 * @tc.name: UIAbilityLifecycleManager_GetReusedCollaboratorPersistentId_0300
3793 * @tc.desc: GetReusedCollaboratorPersistentId
3794 * @tc.type: FUNC
3795 */
3796 HWTEST_F(UIAbilityLifecycleManagerTest, GetReusedCollaboratorPersistentId_003, TestSize.Level1)
3797 {
3798 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3799 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3800 AbilityRequest abilityRequest;
3801 Want want;
3802 want.SetParam("ohos.anco.param.missionAffinity", false);
3803 abilityRequest.want = want;
3804 sptr<SessionInfo> sessionInfo(new SessionInfo());
3805 sessionInfo->persistentId = 100;
3806 abilityRequest.sessionInfo = sessionInfo;
3807 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3808 abilityRecord->collaboratorType_ = CollaboratorType::OTHERS_TYPE;
3809 uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
3810 bool reuse = false;
3811 EXPECT_EQ(uiAbilityLifecycleManager->GetReusedCollaboratorPersistentId(abilityRequest, reuse),
3812 sessionInfo->persistentId);
3813 }
3814
3815 /**
3816 * @tc.name: UIAbilityLifecycleManager_DispatchTerminate_0100
3817 * @tc.desc: DispatchTerminate
3818 * @tc.type: FUNC
3819 */
3820 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchTerminate_001, TestSize.Level1)
3821 {
3822 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3823 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3824 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
3825 EXPECT_EQ(uiAbilityLifecycleManager->DispatchTerminate(abilityRecord), ERR_INVALID_VALUE);
3826 }
3827
3828 /**
3829 * @tc.name: UIAbilityLifecycleManager_DispatchTerminate_0200
3830 * @tc.desc: DispatchTerminate
3831 * @tc.type: FUNC
3832 */
3833 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchTerminate_002, TestSize.Level1)
3834 {
3835 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3836 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3837 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3838 abilityRecord->currentState_ = AbilityState::INITIAL;
3839 EXPECT_EQ(uiAbilityLifecycleManager->DispatchTerminate(abilityRecord), INNER_ERR);
3840 }
3841
3842 /**
3843 * @tc.name: UIAbilityLifecycleManager_DispatchTerminate_0300
3844 * @tc.desc: DispatchTerminate
3845 * @tc.type: FUNC
3846 */
3847 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchTerminate_003, TestSize.Level1)
3848 {
3849 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3850 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3851 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3852 abilityRecord->currentState_ = AbilityState::TERMINATING;
3853 EXPECT_EQ(uiAbilityLifecycleManager->DispatchTerminate(abilityRecord), ERR_INVALID_VALUE);
3854 }
3855
3856 /**
3857 * @tc.name: UIAbilityLifecycleManager_DispatchBackground_0100
3858 * @tc.desc: DispatchBackground
3859 * @tc.type: FUNC
3860 */
3861 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchBackground_001, TestSize.Level1)
3862 {
3863 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3864 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3865 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3866 EXPECT_EQ(uiAbilityLifecycleManager->DispatchBackground(abilityRecord), ERR_INVALID_VALUE);
3867 }
3868
3869 /**
3870 * @tc.name: UIAbilityLifecycleManager_DispatchBackground_0200
3871 * @tc.desc: DispatchBackground
3872 * @tc.type: FUNC
3873 */
3874 HWTEST_F(UIAbilityLifecycleManagerTest, DispatchBackground_002, TestSize.Level1)
3875 {
3876 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3877 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3878 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
3879 EXPECT_EQ(uiAbilityLifecycleManager->DispatchBackground(abilityRecord), ERR_INVALID_VALUE);
3880 }
3881
3882 #ifdef WITH_DLP
3883 /**
3884 * @tc.name: UIAbilityLifecycleManager_CheckProperties_0100
3885 * @tc.desc: CheckProperties
3886 * @tc.type: FUNC
3887 */
3888 HWTEST_F(UIAbilityLifecycleManagerTest, CheckProperties_001, TestSize.Level1)
3889 {
3890 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3891 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3892 Want want;
3893 AbilityRequest abilityRequest;
3894 want.SetParam(DLP_INDEX, 1);
3895 abilityRequest.want = want;
3896 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3897 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3898 abilityRequest.abilityInfo.name = "MainAbility";
3899 abilityRequest.abilityInfo.moduleName = "entry";
3900 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3901 abilityRecord->SetAppIndex(2);
3902 AppExecFwk::LaunchMode launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3903 auto ret = uiAbilityLifecycleManager->CheckProperties(abilityRecord, abilityRequest, launchMode);
3904 EXPECT_EQ(ret, false);
3905 }
3906
3907 /**
3908 * @tc.name: UIAbilityLifecycleManager_CheckProperties_0200
3909 * @tc.desc: CheckProperties
3910 * @tc.type: FUNC
3911 */
3912 HWTEST_F(UIAbilityLifecycleManagerTest, CheckProperties_002, TestSize.Level1)
3913 {
3914 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3915 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3916 Want want;
3917 AbilityRequest abilityRequest;
3918 want.SetParam(DLP_INDEX, 1);
3919 abilityRequest.want = want;
3920 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3921 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3922 abilityRequest.abilityInfo.name = "MainAbility";
3923 abilityRequest.abilityInfo.moduleName = "entry";
3924 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3925 abilityRecord->SetAppIndex(1);
3926 AppExecFwk::LaunchMode launchMode = AppExecFwk::LaunchMode::STANDARD;
3927 auto ret = uiAbilityLifecycleManager->CheckProperties(abilityRecord, abilityRequest, launchMode);
3928 EXPECT_EQ(ret, false);
3929 }
3930
3931 /**
3932 * @tc.name: UIAbilityLifecycleManager_CheckProperties_0300
3933 * @tc.desc: CheckProperties
3934 * @tc.type: FUNC
3935 */
3936 HWTEST_F(UIAbilityLifecycleManagerTest, CheckProperties_003, TestSize.Level1)
3937 {
3938 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3939 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3940 Want want;
3941 AbilityRequest abilityRequest;
3942 want.SetParam(DLP_INDEX, 1);
3943 abilityRequest.want = want;
3944 abilityRequest.abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3945 abilityRequest.abilityInfo.bundleName = "com.example.unittest";
3946 abilityRequest.abilityInfo.name = "MainAbility";
3947 abilityRequest.abilityInfo.moduleName = "entry";
3948 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3949 abilityRecord->SetAppIndex(1);
3950 AppExecFwk::LaunchMode launchMode = AppExecFwk::LaunchMode::SPECIFIED;
3951 auto ret = uiAbilityLifecycleManager->CheckProperties(abilityRecord, abilityRequest, launchMode);
3952 EXPECT_EQ(ret, true);
3953 }
3954 #endif // WITH_DLP
3955
3956 /**
3957 * @tc.name: UIAbilityLifecycleManager_ResolveAbility_0100
3958 * @tc.desc: ResolveAbility
3959 * @tc.type: FUNC
3960 */
3961 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveAbility_001, TestSize.Level1)
3962 {
3963 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3964 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3965 AbilityRequest abilityRequest;
3966 std::shared_ptr<AbilityRecord> targetAbility = nullptr;
3967 EXPECT_EQ(uiAbilityLifecycleManager->ResolveAbility(targetAbility, abilityRequest),
3968 ResolveResultType::NG_INNER_ERROR);
3969 }
3970
3971 /**
3972 * @tc.name: UIAbilityLifecycleManager_ResolveAbility_0200
3973 * @tc.desc: ResolveAbility
3974 * @tc.type: FUNC
3975 */
3976 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveAbility_002, TestSize.Level1)
3977 {
3978 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3979 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3980 AbilityRequest abilityRequest;
3981 abilityRequest.callType = AbilityCallType::START_OPTIONS_TYPE;
3982 auto targetAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
3983 EXPECT_EQ(uiAbilityLifecycleManager->ResolveAbility(targetAbility, abilityRequest),
3984 ResolveResultType::NG_INNER_ERROR);
3985 }
3986
3987 /**
3988 * @tc.name: UIAbilityLifecycleManager_ResolveAbility_0300
3989 * @tc.desc: ResolveAbility
3990 * @tc.type: FUNC
3991 */
3992 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveAbility_003, TestSize.Level1)
3993 {
3994 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
3995 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
3996 AbilityRequest abilityRequest;
3997 abilityRequest.connect = new UIAbilityLifcecycleManagerTestStub();
3998 abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
3999 auto targetAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
4000 targetAbility->callContainer_ = std::make_shared<CallContainer>();
4001 EXPECT_EQ(uiAbilityLifecycleManager->ResolveAbility(targetAbility, abilityRequest),
4002 ResolveResultType::OK_NO_REMOTE_OBJ);
4003 }
4004
4005 /**
4006 * @tc.name: UIAbilityLifecycleManager_ResolveAbility_0400
4007 * @tc.desc: ResolveAbility
4008 * @tc.type: FUNC
4009 */
4010 HWTEST_F(UIAbilityLifecycleManagerTest, ResolveAbility_004, TestSize.Level1)
4011 {
4012 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4013 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4014 AbilityRequest abilityRequest;
4015 abilityRequest.connect = new UIAbilityLifcecycleManagerTestStub();
4016 abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
4017 auto targetAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
4018 targetAbility->isReady_ = true;
4019 EXPECT_EQ(uiAbilityLifecycleManager->ResolveAbility(targetAbility, abilityRequest),
4020 ResolveResultType::OK_HAS_REMOTE_OBJ);
4021 }
4022
4023 /**
4024 * @tc.name: UIAbilityLifecycleManager_CheckPrepareTerminateEnable_0100
4025 * @tc.desc: CheckPrepareTerminateEnable
4026 * @tc.type: FUNC
4027 */
4028 HWTEST_F(UIAbilityLifecycleManagerTest, CheckPrepareTerminateEnable_001, TestSize.Level1)
4029 {
4030 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4031 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4032 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
4033 EXPECT_EQ(uiAbilityLifecycleManager->CheckPrepareTerminateEnable(abilityRecord), false);
4034 }
4035
4036 /**
4037 * @tc.name: UIAbilityLifecycleManager_CheckPrepareTerminateEnable_0200
4038 * @tc.desc: CheckPrepareTerminateEnable
4039 * @tc.type: FUNC
4040 */
4041 HWTEST_F(UIAbilityLifecycleManagerTest, CheckPrepareTerminateEnable_002, TestSize.Level1)
4042 {
4043 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4044 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4045 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
4046 abilityRecord->isTerminating_ = true;
4047 EXPECT_EQ(uiAbilityLifecycleManager->CheckPrepareTerminateEnable(abilityRecord), false);
4048 }
4049
4050 /**
4051 * @tc.name: UIAbilityLifecycleManager_CheckPrepareTerminateEnable_0300
4052 * @tc.desc: CheckPrepareTerminateEnable
4053 * @tc.type: FUNC
4054 */
4055 HWTEST_F(UIAbilityLifecycleManagerTest, CheckPrepareTerminateEnable_003, TestSize.Level1)
4056 {
4057 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4058 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4059 AbilityRequest abilityRequest;
4060 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
4061 abilityRequest.abilityInfo.isStageBasedModel = false;
4062 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
4063 abilityRecord->isTerminating_ = false;
4064 EXPECT_EQ(uiAbilityLifecycleManager->CheckPrepareTerminateEnable(abilityRecord), false);
4065 }
4066
4067 /**
4068 * @tc.name: UIAbilityLifecycleManager_CheckPrepareTerminateEnable_0400
4069 * @tc.desc: CheckPrepareTerminateEnable
4070 * @tc.type: FUNC
4071 */
4072 HWTEST_F(UIAbilityLifecycleManagerTest, CheckPrepareTerminateEnable_004, TestSize.Level1)
4073 {
4074 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4075 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4076 AbilityRequest abilityRequest;
4077 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::SERVICE;
4078 abilityRequest.abilityInfo.isStageBasedModel = true;
4079 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
4080 abilityRecord->isTerminating_ = false;
4081 EXPECT_EQ(uiAbilityLifecycleManager->CheckPrepareTerminateEnable(abilityRecord), false);
4082 }
4083
4084 /**
4085 * @tc.name: UIAbilityLifecycleManager_CheckPrepareTerminateEnable_0500
4086 * @tc.desc: CheckPrepareTerminateEnable
4087 * @tc.type: FUNC
4088 */
4089 HWTEST_F(UIAbilityLifecycleManagerTest, CheckPrepareTerminateEnable_005, TestSize.Level1)
4090 {
4091 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4092 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4093 AbilityRequest abilityRequest;
4094 abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
4095 abilityRequest.abilityInfo.isStageBasedModel = true;
4096 abilityRequest.appInfo.accessTokenId = IPCSkeleton::GetCallingTokenID();
4097 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
4098 abilityRecord->isTerminating_ = false;
4099 EXPECT_EQ(uiAbilityLifecycleManager->CheckPrepareTerminateEnable(abilityRecord), false);
4100 }
4101
4102 /**
4103 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0100
4104 * @tc.desc: GetContentAndTypeId
4105 * @tc.type: FUNC
4106 */
4107 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_001, TestSize.Level1)
4108 {
4109 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4110 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4111 uint32_t msgId = AbilityManagerService::LOAD_TIMEOUT_MSG;
4112 std::string msgContent = "content";
4113 int typeId;
4114 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), true);
4115 }
4116
4117 /**
4118 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0200
4119 * @tc.desc: GetContentAndTypeId
4120 * @tc.type: FUNC
4121 */
4122 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_002, TestSize.Level1)
4123 {
4124 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4125 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4126 uint32_t msgId = AbilityManagerService::FOREGROUND_TIMEOUT_MSG;
4127 std::string msgContent = "content";
4128 int typeId;
4129 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), true);
4130 }
4131
4132 /**
4133 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0300
4134 * @tc.desc: GetContentAndTypeId
4135 * @tc.type: FUNC
4136 */
4137 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_003, TestSize.Level1)
4138 {
4139 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4140 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4141 uint32_t msgId = AbilityManagerService::BACKGROUND_TIMEOUT_MSG;
4142 std::string msgContent = "content";
4143 int typeId;
4144 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), true);
4145 }
4146
4147 /**
4148 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0400
4149 * @tc.desc: GetContentAndTypeId
4150 * @tc.type: FUNC
4151 */
4152 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_004, TestSize.Level1)
4153 {
4154 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4155 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4156 uint32_t msgId = AbilityManagerService::TERMINATE_TIMEOUT_MSG;
4157 std::string msgContent = "content";
4158 int typeId;
4159 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), true);
4160 }
4161
4162 /**
4163 * @tc.name: UIAbilityLifecycleManager_GetContentAndTypeId_0500
4164 * @tc.desc: GetContentAndTypeId
4165 * @tc.type: FUNC
4166 */
4167 HWTEST_F(UIAbilityLifecycleManagerTest, GetContentAndTypeId_005, TestSize.Level1)
4168 {
4169 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4170 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4171 uint32_t msgId = AbilityManagerService::ACTIVE_TIMEOUT_MSG;
4172 std::string msgContent = "content";
4173 int typeId;
4174 EXPECT_EQ(uiAbilityLifecycleManager->GetContentAndTypeId(msgId, msgContent, typeId), false);
4175 }
4176
4177 /**
4178 * @tc.name: UIAbilityLifecycleManager_CheckCallerFromBackground_0100
4179 * @tc.desc: CheckCallerFromBackground
4180 * @tc.type: FUNC
4181 */
4182 HWTEST_F(UIAbilityLifecycleManagerTest, CheckCallerFromBackground_0100, TestSize.Level1)
4183 {
4184 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4185 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4186 sptr<SessionInfo> info = nullptr;
4187 uiAbilityLifecycleManager->CheckCallerFromBackground(nullptr, info);
4188 }
4189
4190 /**
4191 * @tc.name: UIAbilityLifecycleManager_CheckCallerFromBackground_0200
4192 * @tc.desc: CheckCallerFromBackground
4193 * @tc.type: FUNC
4194 */
4195 HWTEST_F(UIAbilityLifecycleManagerTest, CheckCallerFromBackground_0200, TestSize.Level1)
4196 {
4197 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4198 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4199 sptr<SessionInfo> info = nullptr;
4200 sptr<SessionInfo> sessionInfo(new SessionInfo());
4201 AbilityRequest abilityRequest;
4202 abilityRequest.sessionInfo = sessionInfo;
4203 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
4204 uiAbilityLifecycleManager->CheckCallerFromBackground(abilityRecord, info);
4205 }
4206
4207 /**
4208 * @tc.name: UIAbilityLifecycleManager_CheckCallerFromBackground_0300
4209 * @tc.desc: CheckCallerFromBackground
4210 * @tc.type: FUNC
4211 */
4212 HWTEST_F(UIAbilityLifecycleManagerTest, CheckCallerFromBackground_0300, TestSize.Level1)
4213 {
4214 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4215 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4216 sptr<SessionInfo> sessionInfo(new SessionInfo());
4217 uiAbilityLifecycleManager->CheckCallerFromBackground(nullptr, sessionInfo);
4218 }
4219
4220 /**
4221 * @tc.name: UIAbilityLifecycleManager_CheckCallerFromBackground_0400
4222 * @tc.desc: CheckCallerFromBackground
4223 * @tc.type: FUNC
4224 */
4225 HWTEST_F(UIAbilityLifecycleManagerTest, CheckCallerFromBackground_0400, TestSize.Level1)
4226 {
4227 auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
4228 EXPECT_NE(uiAbilityLifecycleManager, nullptr);
4229 sptr<SessionInfo> sessionInfo(new SessionInfo());
4230 AbilityRequest abilityRequest;
4231 abilityRequest.sessionInfo = sessionInfo;
4232 auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
4233 uiAbilityLifecycleManager->CheckCallerFromBackground(abilityRecord, sessionInfo);
4234 }
4235 } // namespace AAFwk
4236 } // namespace OHOS
4237