1 /*
2 * Copyright (c) 2021-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 #define private public
19 #define protected public
20 #include "ability_record.h"
21 #include "uri_permission_rdb.h"
22 #undef private
23 #undef protected
24
25 #include "ability_connect_callback_stub.h"
26 #include "ability_scheduler.h"
27 #include "ability_util.h"
28 #include "connection_record.h"
29 #include "constants.h"
30 #include "mock_ability_connect_callback.h"
31 #include "mock_bundle_manager.h"
32 #include "mock_my_flag.h"
33 #include "mock_permission_verification.h"
34 #include "parameters.h"
35 #include "sa_mgr_client.h"
36 #include "system_ability_definition.h"
37 #include "ui_extension_utils.h"
38 #include "hilog_wrapper.h"
39 #ifdef SUPPORT_GRAPHICS
40 #define private public
41 #define protected public
42 #include "mission_info_mgr.h"
43 #undef private
44 #undef protected
45 #endif
46
47 using namespace testing::ext;
48 using namespace OHOS::AppExecFwk;
49 using namespace OHOS::AbilityBase::Constants;
50
51 namespace OHOS {
52 namespace AAFwk {
53 namespace {
54 const std::string DEBUG_APP = "debugApp";
55 const std::string DLP_BUNDLE_NAME = "com.ohos.dlpmanager";
56 const std::string SHELL_ASSISTANT_BUNDLENAME = "com.huawei.shell_assistant";
57 const std::string SHOW_ON_LOCK_SCREEN = "ShowOnLockScreen";
58 const std::string URI_PERMISSION_TABLE_NAME = "uri_permission";
59 }
60 class AbilityRecordTest : public testing::TestWithParam<OHOS::AAFwk::AbilityState> {
61 public:
62 static void SetUpTestCase(void);
63 static void TearDownTestCase(void);
64 void SetUp();
65 void TearDown();
66 std::shared_ptr<AbilityRecord> GetAbilityRecord();
67
68 std::shared_ptr<AbilityRecord> abilityRecord_{ nullptr };
69 std::shared_ptr<AbilityResult> abilityResult_{ nullptr };
70 std::shared_ptr<AbilityRequest> abilityRequest_{ nullptr };
71 static constexpr unsigned int CHANGE_CONFIG_LOCALE = 0x00000001;
72 };
73
SetUpTestCase(void)74 void AbilityRecordTest::SetUpTestCase(void)
75 {
76 OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
77 OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
78 }
TearDownTestCase(void)79 void AbilityRecordTest::TearDownTestCase(void)
80 {
81 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
82 }
83
SetUp(void)84 void AbilityRecordTest::SetUp(void)
85 {
86 OHOS::AppExecFwk::AbilityInfo abilityInfo;
87 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
88 Want want;
89 abilityRecord_ = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
90 abilityResult_ = std::make_shared<AbilityResult>(-1, -1, want);
91 abilityRequest_ = std::make_shared<AbilityRequest>();
92 abilityRecord_->Init();
93 }
94
TearDown(void)95 void AbilityRecordTest::TearDown(void)
96 {
97 abilityRecord_.reset();
98 }
99
GetAbilityRecord()100 std::shared_ptr<AbilityRecord> AbilityRecordTest::GetAbilityRecord()
101 {
102 Want want;
103 OHOS::AppExecFwk::AbilityInfo abilityInfo;
104 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
105 return std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
106 }
107
IsTestAbilityExist(const std::string & data)108 bool IsTestAbilityExist(const std::string& data)
109 {
110 return std::string::npos != data.find("previous ability app name [NULL]");
111 }
112
IsTestAbilityExist1(const std::string & data)113 bool IsTestAbilityExist1(const std::string& data)
114 {
115 return std::string::npos != data.find("test_pre_app");
116 }
117
IsTestAbilityExist2(const std::string & data)118 bool IsTestAbilityExist2(const std::string& data)
119 {
120 return std::string::npos != data.find("test_next_app");
121 }
122
123 class MockWMSHandler : public IWindowManagerServiceHandler {
124 public:
NotifyWindowTransition(sptr<AbilityTransitionInfo> fromInfo,sptr<AbilityTransitionInfo> toInfo,bool & animaEnabled)125 virtual void NotifyWindowTransition(sptr<AbilityTransitionInfo> fromInfo, sptr<AbilityTransitionInfo> toInfo,
126 bool& animaEnabled)
127 {}
128
GetFocusWindow(sptr<IRemoteObject> & abilityToken)129 virtual int32_t GetFocusWindow(sptr<IRemoteObject>& abilityToken)
130 {
131 return 0;
132 }
133
StartingWindow(sptr<AbilityTransitionInfo> info,std::shared_ptr<Media::PixelMap> pixelMap,uint32_t bgColor)134 virtual void StartingWindow(sptr<AbilityTransitionInfo> info,
135 std::shared_ptr<Media::PixelMap> pixelMap, uint32_t bgColor) {}
136
StartingWindow(sptr<AbilityTransitionInfo> info,std::shared_ptr<Media::PixelMap> pixelMap)137 virtual void StartingWindow(sptr<AbilityTransitionInfo> info, std::shared_ptr<Media::PixelMap> pixelMap) {}
138
CancelStartingWindow(sptr<IRemoteObject> abilityToken)139 virtual void CancelStartingWindow(sptr<IRemoteObject> abilityToken)
140 {}
141
AsObject()142 virtual sptr<IRemoteObject> AsObject()
143 {
144 return nullptr;
145 }
146 };
147
148 /*
149 * Feature: AbilityRecord
150 * Function: GetRecordId
151 * SubFunction: GetRecordId
152 * FunctionPoints: NA
153 * EnvConditions: NA
154 * CaseDescription: Verify create one abilityRecord could through GetRecordId 1
155 */
156 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetRecordId, TestSize.Level1)
157 {
158 EXPECT_EQ(abilityRecord_->GetRecordId(), 0);
159 }
160
161 /*
162 * Feature: AbilityRecord
163 * Function: create AbilityRecord
164 * SubFunction: NA
165 * FunctionPoints: LoadAbility Activate Inactivate MoveToBackground
166 * EnvConditions: NA
167 * CaseDescription: LoadAbility Activate Inactivate MoveToBackground UT.
168 */
169 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_UpdateLifeState, TestSize.Level1)
170 {
171 abilityRecord_->LoadAbility();
172 EXPECT_EQ(abilityRecord_->GetAbilityState(), OHOS::AAFwk::AbilityState::INITIAL);
173 abilityRecord_->Activate();
174 EXPECT_EQ(abilityRecord_->GetAbilityState(), OHOS::AAFwk::AbilityState::ACTIVATING);
175 abilityRecord_->Inactivate();
176 EXPECT_EQ(abilityRecord_->GetAbilityState(), OHOS::AAFwk::AbilityState::INACTIVATING);
177 }
178
179 /*
180 * Feature: AbilityRecord
181 * Function: create AbilityRecord
182 * SubFunction: NA
183 * FunctionPoints: SetAbilityInfo GetAbilityInfo
184 * EnvConditions: NA
185 * CaseDescription: SetAbilityInfo GetAbilityInfo UT.
186 */
187 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetGetAbilityInfo, TestSize.Level1)
188 {
189 Want want;
190 OHOS::AppExecFwk::AbilityInfo abilityInfo;
191 abilityInfo.applicationName = std::string("TestApp");
192 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
193 std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
194 EXPECT_EQ(abilityRecord->GetAbilityInfo().applicationName, std::string("TestApp"));
195 }
196
197 /*
198 * Feature: AbilityRecord
199 * Function: create AbilityRecord
200 * SubFunction: NA
201 * FunctionPoints: SetApplicationInfo GetApplicationInfo
202 * EnvConditions: NA
203 * CaseDescription: SetApplicationInfo GetApplicationInfo UT.
204 */
205 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetGetApplicationInfo, TestSize.Level1)
206 {
207 Want want;
208 OHOS::AppExecFwk::AbilityInfo abilityInfo;
209 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
210 applicationInfo.name = "TestApp";
211 std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
212 EXPECT_EQ(abilityRecord->GetApplicationInfo().name, "TestApp");
213 }
214
215 /*
216 * Feature: AbilityRecord
217 * Function: create AbilityRecord
218 * SubFunction: NA
219 * FunctionPoints: SetAbilityState GetAbilityState
220 * EnvConditions: NA
221 * CaseDescription: SetAbilityState GetAbilityState UT.
222 */
223 HWTEST_P(AbilityRecordTest, AaFwk_AbilityMS_SetGetAbilityState, TestSize.Level1)
224 {
225 OHOS::AAFwk::AbilityState state = GetParam();
226 abilityRecord_->SetAbilityState(state);
227 EXPECT_EQ(static_cast<int>(state), static_cast<int>(abilityRecord_->GetAbilityState()));
228 }
229 INSTANTIATE_TEST_SUITE_P(AbilityRecordTestCaseP, AbilityRecordTest,
230 testing::Values(AbilityState::INITIAL, AbilityState::INACTIVE, AbilityState::ACTIVE, AbilityState::INACTIVATING,
231 AbilityState::ACTIVATING, AbilityState::TERMINATING, AbilityState::FOREGROUND,
232 AbilityState::BACKGROUND, AbilityState::FOREGROUNDING, AbilityState::BACKGROUNDING,
233 AbilityState::FOREGROUND_FAILED, AbilityState::FOREGROUND_INVALID_MODE));
234
235 /*
236 * Feature: AbilityRecord
237 * Function: create AbilityRecord
238 * SubFunction: NA
239 * FunctionPoints: SetAbilityState GetAbilityState
240 * EnvConditions: NA
241 * CaseDescription: SetAbilityState GetAbilityState UT.
242 */
243 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetGetToken, TestSize.Level1)
244 {
245 EXPECT_EQ(Token::GetAbilityRecordByToken(abilityRecord_->GetToken()).get(), abilityRecord_.get());
246 }
247
248 /*
249 * Feature: AbilityRecord
250 * Function: create AbilityRecord
251 * SubFunction: NA
252 * FunctionPoints: SetAbilityState GetAbilityState
253 * EnvConditions: NA
254 * CaseDescription: SetAbilityState GetAbilityState UT.
255 */
256 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetAbilityState, TestSize.Level1)
257 {
258 abilityRecord_->SetAbilityForegroundingFlag();
259 abilityRecord_->SetAbilityState(AbilityState::BACKGROUND);
260 EXPECT_FALSE(abilityRecord_->GetAbilityForegroundingFlag());
261
262 abilityRecord_->SetAbilityForegroundingFlag();
263 abilityRecord_->SetAbilityState(AbilityState::FOREGROUND);
264 EXPECT_TRUE(abilityRecord_->GetAbilityForegroundingFlag());
265 }
266
267 /*
268 * Feature: AbilityRecord
269 * Function: create AbilityRecord
270 * SubFunction: NA
271 * FunctionPoints: SetPreAbilityRecord SetNextAbilityRecord GetPreAbilityRecord GetNextAbilityRecord
272 * EnvConditions: NA
273 * CaseDescription: SetPreAbilityRecord SetNextAbilityRecord GetPreAbilityRecord GetNextAbilityRecord UT.
274 */
275 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetGetPreNextAbilityReocrd, TestSize.Level1)
276 {
277 OHOS::AppExecFwk::AbilityInfo abilityInfo;
278 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
279 Want want;
280 std::shared_ptr<AbilityRecord> preAbilityRecord =
281 std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
282 std::shared_ptr<AbilityRecord> nextAbilityRecord =
283 std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
284 abilityRecord_->SetPreAbilityRecord(preAbilityRecord);
285 abilityRecord_->SetNextAbilityRecord(nextAbilityRecord);
286 EXPECT_EQ(abilityRecord_->GetPreAbilityRecord().get(), preAbilityRecord.get());
287 EXPECT_EQ(abilityRecord_->GetNextAbilityRecord().get(), nextAbilityRecord.get());
288 }
289
290 /*
291 * Feature: AbilityRecord
292 * Function: create AbilityRecord
293 * SubFunction: NA
294 * FunctionPoints: IsReady
295 * EnvConditions: NA
296 * CaseDescription: IsReady UT.
297 */
298 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsReady, TestSize.Level1)
299 {
300 EXPECT_EQ(false, abilityRecord_->IsReady());
301 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
302 abilityRecord_->SetScheduler(scheduler);
303 EXPECT_EQ(true, abilityRecord_->IsReady());
304 }
305
306 /*
307 * Feature: AbilityRecord
308 * Function: create AbilityRecord
309 * SubFunction: NA
310 * FunctionPoints: IsLauncherAbility
311 * EnvConditions: NA
312 * CaseDescription: IsLauncherAbility UT.
313 */
314 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsLauncherAbility, TestSize.Level1)
315 {
316 EXPECT_EQ(false, abilityRecord_->IsLauncherAbility());
317 Want launcherWant;
318 launcherWant.AddEntity(Want::ENTITY_HOME);
319 OHOS::AppExecFwk::AbilityInfo abilityInfo;
320 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
321 std::unique_ptr<AbilityRecord> launcherAbilityRecord =
322 std::make_unique<AbilityRecord>(launcherWant, abilityInfo, applicationInfo);
323 launcherAbilityRecord->Init();
324 EXPECT_EQ(false, launcherAbilityRecord->IsLauncherAbility());
325 }
326
327 /*
328 * Feature: AbilityRecord
329 * Function: Add connection record to ability record' list
330 * SubFunction: NA
331 * FunctionPoints: AddConnectRecordToList
332 * EnvConditions: NA
333 * CaseDescription: AddConnectRecordToList UT.
334 */
335 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_AddConnectRecordToList, TestSize.Level1)
336 {
337 // test1 for input param is null
338 abilityRecord_->AddConnectRecordToList(nullptr);
339 auto connList = abilityRecord_->GetConnectRecordList();
340 EXPECT_EQ(0, static_cast<int>(connList.size()));
341
342 // test2 for adding new connection record to empty list
343 OHOS::sptr<IAbilityConnection> callback1 = new AbilityConnectCallback();
344 auto newConnRecord1 =
345 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback1);
346 abilityRecord_->AddConnectRecordToList(newConnRecord1);
347 connList = abilityRecord_->GetConnectRecordList();
348 EXPECT_EQ(1, static_cast<int>(connList.size()));
349
350 // test3 for adding new connection record to non-empty list
351 OHOS::sptr<IAbilityConnection> callback2 = new AbilityConnectCallback();
352 auto newConnRecord2 =
353 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback2);
354 abilityRecord_->AddConnectRecordToList(newConnRecord2);
355 connList = abilityRecord_->GetConnectRecordList();
356 EXPECT_EQ(2, static_cast<int>(connList.size()));
357
358 // test4 for adding old connection record to non-empty list
359 abilityRecord_->AddConnectRecordToList(newConnRecord2);
360 connList = abilityRecord_->GetConnectRecordList();
361 EXPECT_EQ(2, static_cast<int>(connList.size()));
362
363 // test5 for delete nullptr from list
364 abilityRecord_->RemoveConnectRecordFromList(nullptr);
365 connList = abilityRecord_->GetConnectRecordList();
366 EXPECT_EQ(2, static_cast<int>(connList.size()));
367
368 // test6 for delete no-match member from list
369 auto newConnRecord3 =
370 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback2);
371 abilityRecord_->RemoveConnectRecordFromList(newConnRecord3);
372 connList = abilityRecord_->GetConnectRecordList();
373 EXPECT_EQ(2, static_cast<int>(connList.size()));
374
375 // test7 for delete match member from list
376 abilityRecord_->RemoveConnectRecordFromList(newConnRecord2);
377 connList = abilityRecord_->GetConnectRecordList();
378 EXPECT_EQ(1, static_cast<int>(connList.size()));
379
380 // test8 for get ability unknown type
381 EXPECT_EQ(OHOS::AppExecFwk::AbilityType::UNKNOWN, abilityRecord_->GetAbilityInfo().type);
382 }
383
384 /*
385 * Feature: AbilityRecord
386 * Function: ConvertAbilityState
387 * SubFunction: NA
388 * FunctionPoints: NA
389 * EnvConditions: NA
390 * CaseDescription: Verify ConvertAbilityState convert success
391 */
392 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ConvertAbilityState, TestSize.Level1)
393 {
394 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::INITIAL);
395 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "INITIAL");
396 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::INACTIVE);
397 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "INACTIVE");
398 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
399 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "ACTIVE");
400 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::INACTIVATING);
401 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "INACTIVATING");
402 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVATING);
403 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "ACTIVATING");
404 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::TERMINATING);
405 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "TERMINATING");
406 }
407
408 /*
409 * Feature: AbilityRecord
410 * Function: IsTerminating
411 * SubFunction: IsTerminating SetTerminatingState
412 * FunctionPoints: NA
413 * EnvConditions: NA
414 * CaseDescription: Verify IsTerminating SetTerminatingState success
415 */
416 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsTerminating, TestSize.Level1)
417 {
418 abilityRecord_->SetTerminatingState();
419 EXPECT_EQ(abilityRecord_->IsTerminating(), true);
420 }
421
422 /*
423 * Feature: AbilityRecord
424 * Function: Activate
425 * SubFunction: Activate
426 * FunctionPoints: NA
427 * EnvConditions: NA
428 * CaseDescription: Verify lifecycleDeal_ is nullptr cause Activate is not call
429 */
430 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Activate, TestSize.Level1)
431 {
432 abilityRecord_->lifecycleDeal_ = nullptr;
433 abilityRecord_->currentState_ = OHOS::AAFwk::AbilityState::INITIAL;
434 abilityRecord_->Activate();
435 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::INITIAL);
436 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
437 abilityRecord_->Activate();
438 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::ACTIVATING);
439 }
440
441 /*
442 * Feature: AbilityRecord
443 * Function: Inactivate
444 * SubFunction: Inactivate
445 * FunctionPoints: NA
446 * EnvConditions: NA
447 * CaseDescription: Verify lifecycleDeal_ is nullptr cause Inactivate is not call
448 */
449 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Inactivate, TestSize.Level1)
450 {
451 abilityRecord_->lifecycleDeal_ = nullptr;
452 abilityRecord_->currentState_ = OHOS::AAFwk::AbilityState::INITIAL;
453 abilityRecord_->Inactivate();
454 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::INITIAL);
455 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
456 abilityRecord_->Inactivate();
457 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::INACTIVATING);
458 }
459
460 /*
461 * Feature: AbilityRecord
462 * Function: Terminate
463 * SubFunction: Terminate
464 * FunctionPoints: NA
465 * EnvConditions: NA
466 * CaseDescription: Verify lifecycleDeal_ is nullptr cause Terminate is not call
467 */
468 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Terminate, TestSize.Level1)
469 {
470 abilityRecord_->lifecycleDeal_ = nullptr;
471 abilityRecord_->currentState_ = OHOS::AAFwk::AbilityState::INITIAL;
__anon156259c10202() 472 abilityRecord_->Terminate([]() {
473
474 });
475 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::INITIAL);
476 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
__anon156259c10302() 477 abilityRecord_->Terminate([]() {
478
479 });
480 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::TERMINATING);
481 }
482
483 /*
484 * Feature: AbilityRecord
485 * Function: SetScheduler
486 * SubFunction: SetScheduler
487 * FunctionPoints: NA
488 * EnvConditions: NA
489 * CaseDescription: Verify AbilityRecord SetScheduler success
490 */
491 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetScheduler, TestSize.Level1)
492 {
493 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
494 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
495 EXPECT_EQ(false, abilityRecord_->IsReady());
496 abilityRecord_->SetScheduler(scheduler);
497 EXPECT_EQ(true, abilityRecord_->IsReady());
498 }
499
500 /*
501 * Feature: Token
502 * Function: GetAbilityRecordByToken
503 * SubFunction: GetAbilityRecordByToken
504 * FunctionPoints: NA
505 * EnvConditions: NA
506 * CaseDescription: Verify AbilityRecord token GetAbilityRecordByToken success
507 */
508 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetAbilityRecordByToken, TestSize.Level1)
509 {
510 EXPECT_EQ(Token::GetAbilityRecordByToken(abilityRecord_->GetToken()).get(), abilityRecord_.get());
511 EXPECT_EQ(abilityRecord_->GetToken()->GetAbilityRecord(), abilityRecord_);
512 }
513
514 /*
515 * Feature: AbilityRecord
516 * Function: Dump
517 * SubFunction: Dump
518 * FunctionPoints: NA
519 * EnvConditions: NA
520 * CaseDescription: Verify Dump success
521 */
522 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Dump, TestSize.Level1)
523 {
524 std::vector<std::string> info;
525 info.push_back(std::string("0"));
526 abilityRecord_->Dump(info);
527 EXPECT_EQ(std::find_if(info.begin(), info.end(), IsTestAbilityExist) != info.end(), true);
528 Want wantPre;
529 std::string entity = Want::ENTITY_HOME;
530 wantPre.AddEntity(entity);
531
532 std::string testAppName = "test_pre_app";
533 OHOS::AppExecFwk::AbilityInfo abilityInfoPre;
534 abilityInfoPre.applicationName = testAppName;
535 OHOS::AppExecFwk::ApplicationInfo appinfoPre;
536 appinfoPre.name = testAppName;
537
538 auto preAbilityRecord = std::make_shared<AbilityRecord>(wantPre, abilityInfoPre, appinfoPre);
539 abilityRecord_->SetPreAbilityRecord(nullptr);
540 abilityRecord_->Dump(info);
541 abilityRecord_->SetPreAbilityRecord(preAbilityRecord);
542 abilityRecord_->Dump(info);
543
544 Want wantNext;
545 std::string entityNext = Want::ENTITY_HOME;
546 wantNext.AddEntity(entityNext);
547 std::string testAppNameNext = "test_next_app";
548 OHOS::AppExecFwk::AbilityInfo abilityInfoNext;
549 abilityInfoNext.applicationName = testAppNameNext;
550 OHOS::AppExecFwk::ApplicationInfo appinfoNext;
551 appinfoNext.name = testAppNameNext;
552 auto nextAbilityRecord = std::make_shared<AbilityRecord>(wantNext, abilityInfoNext, appinfoNext);
553 abilityRecord_->SetNextAbilityRecord(nullptr);
554 abilityRecord_->Dump(info);
555 abilityRecord_->SetNextAbilityRecord(nextAbilityRecord);
556 abilityRecord_->Dump(info);
557 } // namespace AAFwk
558
559 /*
560 * Feature: AbilityRecord
561 * Function: SetWant GetWant
562 * SubFunction: SetWant GetWant
563 * FunctionPoints: NA
564 * EnvConditions: NA
565 * CaseDescription: Verify SetWant GetWant can get,set success
566 */
567 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Want, TestSize.Level1)
568 {
569 Want want;
570 want.SetFlags(100);
571 abilityRecord_->SetWant(want);
572 EXPECT_EQ(want.GetFlags(), abilityRecord_->GetWant().GetFlags());
573 }
574
575 /*
576 * Feature: AbilityRecord
577 * Function: GetRequestCode
578 * SubFunction: GetRequestCode
579 * FunctionPoints: NA
580 * EnvConditions: NA
581 * CaseDescription: Verify GetRequestCode success
582 */
583 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetRequestCode, TestSize.Level1)
584 {
585 EXPECT_EQ(abilityRecord_->GetRequestCode(), -1);
586 }
587
588 /*
589 * Feature: AbilityRecord
590 * Function: GetAbilityTypeString
591 * SubFunction: GetAbilityTypeString
592 * FunctionPoints: NA
593 * EnvConditions: NA
594 * CaseDescription: Verify GetAbilityTypeString can get success
595 */
596 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetAbilityTypeString, TestSize.Level1)
597 {
598 std::string typeStr;
599 std::shared_ptr<AbilityRecord> recordUn;
600 OHOS::AppExecFwk::AbilityInfo ability;
601 OHOS::AppExecFwk::ApplicationInfo appInfo;
602 Want wantUn;
603 recordUn = std::make_shared<AbilityRecord>(wantUn, ability, appInfo);
604 recordUn->GetAbilityTypeString(typeStr);
605 EXPECT_EQ(typeStr, "UNKNOWN");
606
607 std::shared_ptr<AbilityRecord> recordService;
608 OHOS::AppExecFwk::AbilityInfo abilityService;
609 abilityService.type = OHOS::AppExecFwk::AbilityType::SERVICE;
610 OHOS::AppExecFwk::ApplicationInfo appInfoService;
611 Want wantService;
612 recordService = std::make_shared<AbilityRecord>(wantService, abilityService, appInfoService);
613 recordService->GetAbilityTypeString(typeStr);
614 EXPECT_EQ(typeStr, "SERVICE");
615
616 std::shared_ptr<AbilityRecord> recordPage;
617 OHOS::AppExecFwk::AbilityInfo abilityPage;
618 abilityPage.type = OHOS::AppExecFwk::AbilityType::PAGE;
619 OHOS::AppExecFwk::ApplicationInfo appInfoPage;
620 Want wantPage;
621 recordPage = std::make_shared<AbilityRecord>(wantPage, abilityPage, appInfoPage);
622 recordPage->GetAbilityTypeString(typeStr);
623 EXPECT_EQ(typeStr, "PAGE");
624
625 std::shared_ptr<AbilityRecord> recordData;
626 OHOS::AppExecFwk::AbilityInfo abilityData;
627 abilityData.type = OHOS::AppExecFwk::AbilityType::DATA;
628 OHOS::AppExecFwk::ApplicationInfo appInfoData;
629 Want wantData;
630 recordData = std::make_shared<AbilityRecord>(wantData, abilityData, appInfoData);
631 recordData->GetAbilityTypeString(typeStr);
632 EXPECT_EQ(typeStr, "DATA");
633 }
634
635 /*
636 * Feature: AbilityRecord
637 * Function: SetResult GetResult
638 * SubFunction: SetResult GetResult
639 * FunctionPoints: NA
640 * EnvConditions: NA
641 * CaseDescription: Verify SetResult GetResult can get,set success
642 */
643 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Result, TestSize.Level1)
644 {
645 abilityResult_->requestCode_ = 10;
646 abilityRecord_->SetResult(abilityResult_);
647 EXPECT_EQ(10, abilityRecord_->GetResult()->requestCode_);
648 }
649
650 /*
651 * Feature: AbilityRecord
652 * Function: SendResult
653 * SubFunction: SendResult
654 * FunctionPoints: NA
655 * EnvConditions: NA
656 * CaseDescription: Verify SendResult scheduler is nullptr
657 */
658 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SendResult, TestSize.Level1)
659 {
660 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
661 abilityRecord_->SetScheduler(scheduler);
662 abilityRecord_->SetResult(abilityResult_);
663 abilityRecord_->SendResult(0, 0);
664 EXPECT_EQ(nullptr, abilityRecord_->GetResult());
665 }
666
667 /*
668 * Feature: AbilityRecord
669 * Function: SetConnRemoteObject GetConnRemoteObject
670 * SubFunction: SetConnRemoteObject GetConnRemoteObject
671 * FunctionPoints: NA
672 * EnvConditions: NA
673 * CaseDescription: Verify SetConnRemoteObject GetConnRemoteObject UT
674 */
675 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ConnRemoteObject, TestSize.Level1)
676 {
677 OHOS::sptr<OHOS::IRemoteObject> remote;
678 abilityRecord_->SetConnRemoteObject(remote);
679 EXPECT_EQ(remote, abilityRecord_->GetConnRemoteObject());
680 }
681
682 /*
683 * Feature: AbilityRecord
684 * Function: IsCreateByConnect SetCreateByConnectMode
685 * SubFunction: IsCreateByConnect SetCreateByConnectMode
686 * FunctionPoints: NA
687 * EnvConditions: NA
688 * CaseDescription: Verify IsCreateByConnect SetCreateByConnectMode UT
689 */
690 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateByConnect, TestSize.Level1)
691 {
692 abilityRecord_->SetCreateByConnectMode();
693 EXPECT_EQ(true, abilityRecord_->IsCreateByConnect());
694 }
695
696 /*
697 * Feature: AbilityRecord
698 * Function: IsActiveState
699 * SubFunction: NA
700 * FunctionPoints: NA
701 * EnvConditions: NA
702 * CaseDescription: NA
703 */
704 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsActiveState_001, TestSize.Level1)
705 {
706 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::TERMINATING);
707 EXPECT_EQ(false, abilityRecord_->IsActiveState());
708
709 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
710 EXPECT_EQ(true, abilityRecord_->IsActiveState());
711 }
712
713 /*
714 * Feature: AbilityRecord
715 * Function: SetAbilityState
716 * SubFunction: NA
717 * FunctionPoints: NA
718 * EnvConditions: NA
719 * CaseDescription: NA
720 */
721 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetAbilityState_001, TestSize.Level1)
722 {
723 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::TERMINATING);
724 auto state = abilityRecord_->GetAbilityState();
725 EXPECT_EQ(state, OHOS::AAFwk::AbilityState::TERMINATING);
726
727 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
728 state = abilityRecord_->GetAbilityState();
729 EXPECT_EQ(state, OHOS::AAFwk::AbilityState::ACTIVE);
730 }
731
732 /*
733 * Feature: AbilityRecord
734 * Function: SetSpecifiedFlag
735 * SubFunction: NA
736 * FunctionPoints: NA
737 * EnvConditions: NA
738 * CaseDescription: NA
739 */
740 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetSpecifiedFlag_001, TestSize.Level1)
741 {
742 abilityRecord_->SetSpecifiedFlag("flag");
743 auto flag = abilityRecord_->GetSpecifiedFlag();
744 EXPECT_EQ(flag, "flag");
745 }
746
747 /*
748 * Feature: AbilityRecord
749 * Function: GetAbilityRecordByToken
750 * SubFunction: GetAbilityRecordByToken
751 * FunctionPoints: NA
752 * EnvConditions: NA
753 * CaseDescription: Verify AbilityRecord token GetAbilityRecordByToken
754 */
755 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetAbilityRecordByToken_001, TestSize.Level1)
756 {
757 EXPECT_EQ(Token::GetAbilityRecordByToken(nullptr), nullptr);
758 }
759
760 /*
761 * Feature: AbilityRecord
762 * Function: CreateAbilityRecord
763 * SubFunction: CreateAbilityRecord
764 * FunctionPoints: NA
765 * EnvConditions: NA
766 * CaseDescription: Verify AbilityRecord CreateAbilityRecord
767 */
768 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityRecord_001, TestSize.Level1)
769 {
770 AbilityRequest abilityRequest;
771 std::shared_ptr<AbilityStartSetting> abilityStartSetting = std::make_shared<AbilityStartSetting>();
772 abilityRequest.startSetting = abilityStartSetting;
773 abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
774 auto res = abilityRecord_->CreateAbilityRecord(abilityRequest);
775 EXPECT_NE(res, nullptr);
776 }
777
778 /*
779 * Feature: AbilityRecord
780 * Function: LoadAbility
781 * SubFunction: LoadAbility
782 * FunctionPoints: NA
783 * EnvConditions: NA
784 * CaseDescription: Verify AbilityRecord LoadAbility
785 */
786 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_LoadAbility_001, TestSize.Level1)
787 {
788 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
789 abilityRecord->abilityInfo_.type = AbilityType::DATA;
790 abilityRecord->applicationInfo_.name = "app";
791 abilityRecord->isLauncherRoot_ = true;
792 abilityRecord->isRestarting_ = true;
793 abilityRecord->isLauncherAbility_ = true;
794 abilityRecord->restartCount_ = 0;
795 int res = abilityRecord->LoadAbility();
796 EXPECT_EQ(res, ERR_INVALID_VALUE);
797 }
798
799 /*
800 * Feature: AbilityRecord
801 * Function: LoadAbility
802 * SubFunction: LoadAbility
803 * FunctionPoints: NA
804 * EnvConditions: NA
805 * CaseDescription: Verify AbilityRecord LoadAbility
806 */
807 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_LoadAbility_002, TestSize.Level1)
808 {
809 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
810 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, abilityRecord);
811 abilityRecord->abilityInfo_.type = AbilityType::DATA;
812 abilityRecord->applicationInfo_.name = "app";
813 abilityRecord->isLauncherRoot_ = true;
814 abilityRecord->isRestarting_ = true;
815 abilityRecord->isLauncherAbility_ = false;
816 abilityRecord->callerList_.push_back(caller);
817 int res = abilityRecord->LoadAbility();
818 EXPECT_EQ(res, ERR_INVALID_VALUE);
819 }
820
821 /*
822 * Feature: AbilityRecord
823 * Function: LoadAbility
824 * SubFunction: LoadAbility
825 * FunctionPoints: NA
826 * EnvConditions: NA
827 * CaseDescription: Verify AbilityRecord LoadAbility
828 */
829 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_LoadAbility_003, TestSize.Level1)
830 {
831 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
832 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, nullptr);
833 abilityRecord->abilityInfo_.type = AbilityType::DATA;
834 abilityRecord->applicationInfo_.name = "app";
835 abilityRecord->isLauncherRoot_ = true;
836 abilityRecord->isRestarting_ = true;
837 abilityRecord->isLauncherAbility_ = true;
838 abilityRecord->restartCount_ = 1;
839 abilityRecord->callerList_.push_back(caller);
840 int res = abilityRecord->LoadAbility();
841 EXPECT_EQ(res, ERR_INVALID_VALUE);
842 }
843
844 /*
845 * Feature: AbilityRecord
846 * Function: LoadAbility
847 * SubFunction: LoadAbility
848 * FunctionPoints: NA
849 * EnvConditions: NA
850 * CaseDescription: Verify AbilityRecord LoadAbility
851 */
852 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_LoadAbility_004, TestSize.Level1)
853 {
854 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
855 abilityRecord->abilityInfo_.type = AbilityType::DATA;
856 abilityRecord->applicationInfo_.name = "app";
857 abilityRecord->isLauncherRoot_ = false;
858 abilityRecord->callerList_.push_back(nullptr);
859 int res = abilityRecord->LoadAbility();
860 EXPECT_EQ(res, ERR_INVALID_VALUE);
861 }
862
863 /*
864 * Feature: AbilityRecord
865 * Function: ForegroundAbility
866 * SubFunction: ForegroundAbility
867 * FunctionPoints: NA
868 * EnvConditions: NA
869 * CaseDescription: Verify AbilityRecord ForegroundAbility
870 */
871 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ForegroundAbility_001, TestSize.Level1)
872 {
873 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
874 uint32_t sceneFlag = 0;
875 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
876 abilityRecord->SetIsNewWant(true);
877 abilityRecord->SetPreAbilityRecord(abilityRecord_);
878 abilityRecord->ForegroundAbility(sceneFlag);
879 }
880
881 /*
882 * Feature: AbilityRecord
883 * Function: ForegroundAbility
884 * SubFunction: ForegroundAbility
885 * FunctionPoints: NA
886 * EnvConditions: NA
887 * CaseDescription: Verify AbilityRecord ForegroundAbility
888 */
889 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ForegroundAbility_002, TestSize.Level1)
890 {
891 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
892 uint32_t sceneFlag = 0;
893 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
894 abilityRecord->SetIsNewWant(true);
895 abilityRecord->SetPreAbilityRecord(nullptr);
896 abilityRecord->ForegroundAbility(sceneFlag);
897 }
898
899 /*
900 * Feature: AbilityRecord
901 * Function: ForegroundAbility
902 * SubFunction: ForegroundAbility
903 * FunctionPoints: NA
904 * EnvConditions: NA
905 * CaseDescription: Verify AbilityRecord ForegroundAbility
906 */
907 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ForegroundAbility_003, TestSize.Level1)
908 {
909 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
910 uint32_t sceneFlag = 0;
911 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
912 abilityRecord->SetIsNewWant(false);
913 abilityRecord->ForegroundAbility(sceneFlag);
914 }
915
916 /*
917 * Feature: AbilityRecord
918 * Function: ForegroundAbility
919 * SubFunction: ForegroundAbility
920 * FunctionPoints: NA
921 * EnvConditions: NA
922 * CaseDescription: Verify AbilityRecord ForegroundAbility
923 */
924 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ForegroundAbility_004, TestSize.Level1)
925 {
926 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
927 EXPECT_NE(abilityRecord, nullptr);
__anon156259c10402() 928 Closure task = []() {};
929 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
930 abilityRecord->ForegroundAbility(task);
931 }
932
933 /*
934 * Feature: AbilityRecord
935 * Function: ProcessForegroundAbility
936 * SubFunction: ProcessForegroundAbility
937 * FunctionPoints: NA
938 * EnvConditions: NA
939 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
940 */
941 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_001, TestSize.Level1)
942 {
943 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
944 uint32_t sceneFlag = 0;
945 abilityRecord->isReady_ = true;
946 abilityRecord->currentState_ = AbilityState::FOREGROUND;
947 abilityRecord->ProcessForegroundAbility(sceneFlag);
948 }
949
950 /*
951 * Feature: AbilityRecord
952 * Function: ProcessForegroundAbility
953 * SubFunction: ProcessForegroundAbility
954 * FunctionPoints: NA
955 * EnvConditions: NA
956 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
957 */
958 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_002, TestSize.Level1)
959 {
960 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
961 uint32_t sceneFlag = 0;
962 abilityRecord->isReady_ = true;
963 abilityRecord->currentState_ = AbilityState::BACKGROUND;
964 abilityRecord->ProcessForegroundAbility(sceneFlag);
965 }
966
967 /*
968 * Feature: AbilityRecord
969 * Function: ProcessForegroundAbility
970 * SubFunction: ProcessForegroundAbility
971 * FunctionPoints: NA
972 * EnvConditions: NA
973 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
974 */
975 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_003, TestSize.Level1)
976 {
977 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
978 uint32_t sceneFlag = 0;
979 abilityRecord->isReady_ = false;
980 abilityRecord->ProcessForegroundAbility(sceneFlag);
981 }
982
983 /*
984 * Feature: AbilityRecord
985 * Function: GetLabel
986 * SubFunction: GetLabel
987 * FunctionPoints: NA
988 * EnvConditions: NA
989 * CaseDescription: Verify AbilityRecord GetLabel
990 */
991 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetLabel_001, TestSize.Level1)
992 {
993 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
994 abilityRecord->applicationInfo_.label = "label";
995 abilityRecord->abilityInfo_.resourcePath = "resource";
996 std::string res = abilityRecord->GetLabel();
997 EXPECT_EQ(res, "label");
998 }
999
1000 #ifdef SUPPORT_GRAPHICS
1001 /*
1002 * Feature: AbilityRecord
1003 * Function: ProcessForegroundAbility
1004 * SubFunction: ProcessForegroundAbility
1005 * FunctionPoints: NA
1006 * EnvConditions: NA
1007 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
1008 */
1009 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_004, TestSize.Level1)
1010 {
1011 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1012 std::shared_ptr<AbilityRecord> callerAbility = GetAbilityRecord();
1013 uint32_t sceneFlag = 0;
1014 abilityRecord->currentState_ = AbilityState::FOREGROUND;
1015 abilityRecord->ProcessForegroundAbility(callerAbility, sceneFlag);
1016 }
1017
1018 /*
1019 * Feature: AbilityRecord
1020 * Function: ProcessForegroundAbility
1021 * SubFunction: ProcessForegroundAbility
1022 * FunctionPoints: NA
1023 * EnvConditions: NA
1024 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
1025 */
1026 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_008, TestSize.Level1)
1027 {
1028 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1029 bool isRecent = false;
1030 AbilityRequest abilityRequest;
1031 std::shared_ptr<StartOptions> startOptions = nullptr ;
1032 std::shared_ptr<AbilityRecord> callerAbility;
1033 uint32_t sceneFlag = 1;
1034 abilityRecord->isReady_ = false;
1035 abilityRecord->ProcessForegroundAbility(isRecent, abilityRequest, startOptions, callerAbility, sceneFlag);
1036 }
1037
1038 /*
1039 * Feature: AbilityRecord
1040 * Function: GetWantFromMission
1041 * SubFunction: GetWantFromMission
1042 * FunctionPoints: NA
1043 * EnvConditions: NA
1044 * CaseDescription: Verify AbilityRecord GetWantFromMission
1045 */
1046 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetWantFromMission_001, TestSize.Level1)
1047 {
1048 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1049 auto res = abilityRecord->GetWantFromMission();
1050 EXPECT_EQ(res, nullptr);
1051 }
1052
1053 /*
1054 * Feature: AbilityRecord
1055 * Function: GetWantFromMission
1056 * SubFunction: GetWantFromMission
1057 * FunctionPoints: NA
1058 * EnvConditions: NA
1059 * CaseDescription: Verify AbilityRecord GetWantFromMission
1060 */
1061 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetWantFromMission_002, TestSize.Level1)
1062 {
1063 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1064 int32_t missionId = 1;
1065 InnerMissionInfo innerMissionInfo;
1066 Want want;
1067 innerMissionInfo.missionInfo.id = missionId;
1068 innerMissionInfo.missionInfo.want = want;
1069 DelayedSingleton<MissionInfoMgr>::GetInstance()->missionIdMap_[missionId] = true;
1070 DelayedSingleton<MissionInfoMgr>::GetInstance()->missionInfoList_.push_back(innerMissionInfo);
1071 abilityRecord->missionId_ = 1;
1072 int id = DelayedSingleton<MissionInfoMgr>::GetInstance()->GetInnerMissionInfoById(1, innerMissionInfo);
1073 abilityRecord->GetWantFromMission();
1074 EXPECT_EQ(id, 0);
1075 }
1076
1077 /*
1078 * Feature: AbilityRecord
1079 * Function: AnimationTask
1080 * SubFunction: AnimationTask
1081 * FunctionPoints: NA
1082 * EnvConditions: NA
1083 * CaseDescription: Verify AbilityRecord AnimationTask
1084 */
1085 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_AnimationTask_001, TestSize.Level1)
1086 {
1087 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1088 EXPECT_NE(abilityRecord, nullptr);
1089 bool isRecent = true;
1090 AbilityRequest abilityRequest;
1091 std::shared_ptr<StartOptions> startOptions = nullptr ;
1092 std::shared_ptr<AbilityRecord> callerAbility;
1093 abilityRecord->AnimationTask(isRecent, abilityRequest, startOptions, callerAbility);
1094 }
1095
1096 /*
1097 * Feature: AbilityRecord
1098 * Function: SetShowWhenLocked
1099 * SubFunction: SetShowWhenLocked
1100 * FunctionPoints: NA
1101 * EnvConditions: NA
1102 * CaseDescription: Verify AbilityRecord SetShowWhenLocked
1103 */
1104 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetShowWhenLocked_001, TestSize.Level1)
1105 {
1106 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1107 EXPECT_NE(abilityRecord, nullptr);
1108 AbilityInfo abilityInfo;
1109 sptr<AbilityTransitionInfo> info = new AbilityTransitionInfo();
1110 CustomizeData data1;
1111 CustomizeData data2;
1112 data1.name = SHOW_ON_LOCK_SCREEN;
1113 data2.name = "";
1114 abilityInfo.metaData.customizeData.push_back(data1);
1115 abilityInfo.metaData.customizeData.push_back(data2);
1116 info->isShowWhenLocked_ = false;
1117 abilityRecord->SetShowWhenLocked(abilityInfo, info);
1118 }
1119
1120 /*
1121 * Feature: AbilityRecord
1122 * Function: NotifyAnimationFromStartingAbility
1123 * SubFunction: NotifyAnimationFromStartingAbility
1124 * FunctionPoints: NA
1125 * EnvConditions: NA
1126 * CaseDescription: Verify AbilityRecord NotifyAnimationFromStartingAbility
1127 */
1128 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_NotifyAnimationFromStartingAbility_002, TestSize.Level1)
1129 {
1130 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1131 EXPECT_NE(abilityRecord, nullptr);
1132 std::shared_ptr<AbilityRecord> callerAbility = nullptr;
1133 AbilityRequest abilityRequest;
1134 abilityRecord->NotifyAnimationFromStartingAbility(callerAbility, abilityRequest);
1135 }
1136
1137 /*
1138 * Feature: AbilityRecord
1139 * Function: StartingWindowTask
1140 * SubFunction: StartingWindowTask
1141 * FunctionPoints: NA
1142 * EnvConditions: NA
1143 * CaseDescription: Verify AbilityRecord StartingWindowTask
1144 */
1145 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_StartingWindowTask_001, TestSize.Level1)
1146 {
1147 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1148 EXPECT_NE(abilityRecord, nullptr);
1149 bool isRecent = true;
1150 AbilityRequest abilityRequest;
1151 std::shared_ptr<StartOptions> startOptions = std::make_shared<StartOptions>();
1152 abilityRecord->StartingWindowTask(isRecent, true, abilityRequest, startOptions);
1153 abilityRecord->StartingWindowTask(isRecent, false, abilityRequest, startOptions);
1154 }
1155
1156 /*
1157 * Feature: AbilityRecord
1158 * Function: SetWindowModeAndDisplayId
1159 * SubFunction: SetWindowModeAndDisplayId
1160 * FunctionPoints: NA
1161 * EnvConditions: NA
1162 * CaseDescription: Verify AbilityRecord SetWindowModeAndDisplayId
1163 */
1164 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetWindowModeAndDisplayId_001, TestSize.Level1)
1165 {
1166 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1167 EXPECT_NE(abilityRecord, nullptr);
1168 sptr<AbilityTransitionInfo> info = nullptr;
1169 std::shared_ptr<Want> want = nullptr;
1170 abilityRecord->SetWindowModeAndDisplayId(info, want);
1171 }
1172
1173 /*
1174 * Feature: AbilityRecord
1175 * Function: SetWindowModeAndDisplayId
1176 * SubFunction: SetWindowModeAndDisplayId
1177 * FunctionPoints: NA
1178 * EnvConditions: NA
1179 * CaseDescription: Verify AbilityRecord SetWindowModeAndDisplayId
1180 */
1181 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetWindowModeAndDisplayId_002, TestSize.Level1)
1182 {
1183 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1184 EXPECT_NE(abilityRecord, nullptr);
1185 sptr<AbilityTransitionInfo> info = new AbilityTransitionInfo();
1186 std::shared_ptr<Want> want = std::make_shared<Want>();
1187 want->SetParam(Want::PARAM_RESV_WINDOW_MODE, 1);
1188 want->SetParam(Want::PARAM_RESV_DISPLAY_ID, 1);
1189 abilityRecord->SetWindowModeAndDisplayId(info, want);
1190 }
1191
1192 /*
1193 * Feature: AbilityRecord
1194 * Function: SetWindowModeAndDisplayId
1195 * SubFunction: SetWindowModeAndDisplayId
1196 * FunctionPoints: NA
1197 * EnvConditions: NA
1198 * CaseDescription: Verify AbilityRecord SetWindowModeAndDisplayId
1199 */
1200 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetWindowModeAndDisplayId_003, TestSize.Level1)
1201 {
1202 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1203 EXPECT_NE(abilityRecord, nullptr);
1204 sptr<AbilityTransitionInfo> info = new AbilityTransitionInfo();
1205 std::shared_ptr<Want> want = std::make_shared<Want>();
1206 want->SetParam(Want::PARAM_RESV_WINDOW_MODE, -1);
1207 want->SetParam(Want::PARAM_RESV_DISPLAY_ID, -1);
1208 abilityRecord->SetWindowModeAndDisplayId(info, want);
1209 }
1210
1211 /*
1212 * Feature: AbilityRecord
1213 * Function: CreateAbilityTransitionInfo
1214 * SubFunction: CreateAbilityTransitionInfo
1215 * FunctionPoints: NA
1216 * EnvConditions: NA
1217 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1218 */
1219 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_001, TestSize.Level1)
1220 {
1221 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1222 EXPECT_NE(abilityRecord, nullptr);
1223 std::shared_ptr<StartOptions> startOptions = nullptr;
1224 std::shared_ptr<Want> want = std::make_shared<Want>();
1225 abilityRecord->CreateAbilityTransitionInfo(startOptions, want);
1226 }
1227
1228 /*
1229 * Feature: AbilityRecord
1230 * Function: CreateAbilityTransitionInfo
1231 * SubFunction: CreateAbilityTransitionInfo
1232 * FunctionPoints: NA
1233 * EnvConditions: NA
1234 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1235 */
1236 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_002, TestSize.Level1)
1237 {
1238 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1239 EXPECT_NE(abilityRecord, nullptr);
1240 std::shared_ptr<StartOptions> startOptions = std::make_shared<StartOptions>();
1241 std::shared_ptr<Want> want = std::make_shared<Want>();
1242 startOptions->SetWindowMode(1);
1243 startOptions->SetDisplayID(1);
1244 abilityRecord->CreateAbilityTransitionInfo(startOptions, want);
1245 }
1246
1247 /*
1248 * Feature: AbilityRecord
1249 * Function: CreateAbilityTransitionInfo
1250 * SubFunction: CreateAbilityTransitionInfo
1251 * FunctionPoints: NA
1252 * EnvConditions: NA
1253 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1254 */
1255 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_003, TestSize.Level1)
1256 {
1257 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1258 EXPECT_NE(abilityRecord, nullptr);
1259 AbilityRequest abilityRequest;
1260 abilityRequest.startSetting = nullptr;
1261 abilityRecord->CreateAbilityTransitionInfo(abilityRequest);
1262 }
1263
1264 /*
1265 * Feature: AbilityRecord
1266 * Function: CreateAbilityTransitionInfo
1267 * SubFunction: CreateAbilityTransitionInfo
1268 * FunctionPoints: NA
1269 * EnvConditions: NA
1270 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1271 */
1272 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_004, TestSize.Level1)
1273 {
1274 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1275 EXPECT_NE(abilityRecord, nullptr);
1276 AbilityRequest abilityRequest;
1277 std::shared_ptr<AbilityStartSetting> startSetting = std::make_shared<AbilityStartSetting>();
1278 startSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, "windowMode");
1279 startSetting->AddProperty(AbilityStartSetting::WINDOW_DISPLAY_ID_KEY, "displayId");
1280 abilityRequest.startSetting = startSetting;
1281 abilityRecord->CreateAbilityTransitionInfo(abilityRequest);
1282 }
1283
1284 /*
1285 * Feature: AbilityRecord
1286 * Function: CreateAbilityTransitionInfo
1287 * SubFunction: CreateAbilityTransitionInfo
1288 * FunctionPoints: NA
1289 * EnvConditions: NA
1290 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1291 */
1292 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_005, TestSize.Level1)
1293 {
1294 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1295 EXPECT_NE(abilityRecord, nullptr);
1296 std::shared_ptr<StartOptions> startOptions = nullptr;
1297 std::shared_ptr<Want> want = std::make_shared<Want>();
1298 AbilityRequest abilityRequest;
1299 std::shared_ptr<AbilityStartSetting> startSetting = std::make_shared<AbilityStartSetting>();
1300 startSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, "windowMode");
1301 startSetting->AddProperty(AbilityStartSetting::WINDOW_DISPLAY_ID_KEY, "displayId");
1302 abilityRequest.startSetting = startSetting;
1303 abilityRecord->CreateAbilityTransitionInfo(startOptions, want, abilityRequest);
1304 }
1305
1306 /*
1307 * Feature: AbilityRecord
1308 * Function: CreateAbilityTransitionInfo
1309 * SubFunction: CreateAbilityTransitionInfo
1310 * FunctionPoints: NA
1311 * EnvConditions: NA
1312 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1313 */
1314 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_006, TestSize.Level1)
1315 {
1316 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1317 EXPECT_NE(abilityRecord, nullptr);
1318 std::shared_ptr<StartOptions> startOptions = std::make_shared<StartOptions>();
1319 std::shared_ptr<Want> want = std::make_shared<Want>();
1320 AbilityRequest abilityRequest;
1321 abilityRecord->CreateAbilityTransitionInfo(startOptions, want, abilityRequest);
1322 }
1323
1324 /*
1325 * Feature: AbilityRecord
1326 * Function: CreateResourceManager
1327 * SubFunction: CreateResourceManager
1328 * FunctionPoints: NA
1329 * EnvConditions: NA
1330 * CaseDescription: Verify AbilityRecord CreateResourceManager
1331 */
1332 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateResourceManager_001, TestSize.Level1)
1333 {
1334 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1335 system::SetParameter(COMPRESS_PROPERTY, "1");
1336 abilityRecord->abilityInfo_.hapPath = "path";
1337 auto res = abilityRecord->CreateResourceManager();
1338 EXPECT_EQ(res, nullptr);
1339 }
1340
1341 /*
1342 * Feature: AbilityRecord
1343 * Function: GetPixelMap
1344 * SubFunction: GetPixelMap
1345 * FunctionPoints: NA
1346 * EnvConditions: NA
1347 * CaseDescription: Verify AbilityRecord GetPixelMap
1348 */
1349 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPixelMap_001, TestSize.Level1)
1350 {
1351 EXPECT_EQ(abilityRecord_->GetPixelMap(1, nullptr), nullptr);
1352 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager());
1353 EXPECT_EQ(abilityRecord_->GetPixelMap(1, resourceMgr), nullptr);
1354 }
1355
1356 /*
1357 * Feature: AbilityRecord
1358 * Function: GetPixelMap
1359 * SubFunction: GetPixelMap
1360 * FunctionPoints: NA
1361 * EnvConditions: NA
1362 * CaseDescription: Verify AbilityRecord GetPixelMap
1363 */
1364 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPixelMap_002, TestSize.Level1)
1365 {
1366 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1367 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager());
1368 system::SetParameter(COMPRESS_PROPERTY, "1");
1369 abilityRecord->abilityInfo_.hapPath = "path";
1370 auto res = abilityRecord->GetPixelMap(1, resourceMgr);
1371 EXPECT_EQ(res, nullptr);
1372 }
1373
1374 /*
1375 * Feature: AbilityRecord
1376 * Function: StartingWindowHot
1377 * SubFunction: StartingWindowHot
1378 * FunctionPoints: NA
1379 * EnvConditions: NA
1380 * CaseDescription: Verify AbilityRecord StartingWindowHot
1381 */
1382 HWTEST_F(AbilityRecordTest, AbilityRecord_StartingWindowHot_001, TestSize.Level1)
1383 {
1384 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1385 EXPECT_NE(abilityRecord, nullptr);
1386 std::shared_ptr<StartOptions> startOptions = std::make_shared<StartOptions>();
1387 std::shared_ptr<Want> want = std::make_shared<Want>();
1388 AbilityRequest abilityRequest;
1389 abilityRecord->StartingWindowHot(startOptions, want, abilityRequest);
1390 }
1391
1392 /*
1393 * Feature: AbilityRecord
1394 * Function: GetColdStartingWindowResource
1395 * SubFunction: GetColdStartingWindowResource
1396 * FunctionPoints: NA
1397 * EnvConditions: NA
1398 * CaseDescription: Verify AbilityRecord GetColdStartingWindowResource
1399 */
1400 HWTEST_F(AbilityRecordTest, AbilityRecord_GetColdStartingWindowResource_001, TestSize.Level1)
1401 {
1402 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1403 EXPECT_NE(abilityRecord, nullptr);
1404 std::shared_ptr<Media::PixelMap> bg;
1405 uint32_t bgColor = 0;
1406 abilityRecord->startingWindowBg_ = std::make_shared<Media::PixelMap>();
1407 abilityRecord->GetColdStartingWindowResource(bg, bgColor);
1408 abilityRecord->startingWindowBg_ = nullptr;
1409 abilityRecord->GetColdStartingWindowResource(bg, bgColor);
1410 }
1411
1412 /*
1413 * Feature: AbilityRecord
1414 * Function: InitColdStartingWindowResource
1415 * SubFunction: InitColdStartingWindowResource
1416 * FunctionPoints: NA
1417 * EnvConditions: NA
1418 * CaseDescription: Verify AbilityRecord InitColdStartingWindowResource
1419 */
1420 HWTEST_F(AbilityRecordTest, AbilityRecord_InitColdStartingWindowResource_001, TestSize.Level1)
1421 {
1422 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1423 EXPECT_NE(abilityRecord, nullptr);
1424 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager());
1425 abilityRecord->InitColdStartingWindowResource(nullptr);
1426 abilityRecord->InitColdStartingWindowResource(resourceMgr);
1427 }
1428 #endif
1429
1430 /*
1431 * Feature: AbilityRecord
1432 * Function: SetPendingState
1433 * SubFunction: SetPendingState
1434 * FunctionPoints: NA
1435 * EnvConditions: NA
1436 * CaseDescription: set AbilityRecord pending state
1437 */
1438 HWTEST_F(AbilityRecordTest, AbilityRecord_SetPendingState_001, TestSize.Level1)
1439 {
1440 abilityRecord_->SetPendingState(OHOS::AAFwk::AbilityState::FOREGROUND);
1441 EXPECT_EQ(abilityRecord_->GetPendingState(), OHOS::AAFwk::AbilityState::FOREGROUND);
1442 }
1443
1444 #ifdef SUPPORT_GRAPHICS
1445 /*
1446 * Feature: AbilityRecord
1447 * Function: PostCancelStartingWindowHotTask
1448 * FunctionPoints: NA
1449 * EnvConditions: NA
1450 * CaseDescription: PostCancelStartingWindowHotTask
1451 */
1452 HWTEST_F(AbilityRecordTest, AbilityRecord_PostCancelStartingWindowHotTask_001, TestSize.Level1)
1453 {
1454 Want want;
1455 AppExecFwk::AbilityInfo abilityInfo;
1456 AppExecFwk::ApplicationInfo applicationInfo;
1457 AbilityRecord abilityRecord(want, abilityInfo, applicationInfo, 0);
1458 want.SetParam("debugApp", true);
1459 abilityRecord.SetWant(want);
1460 abilityRecord.PostCancelStartingWindowHotTask();
1461 EXPECT_TRUE(want.GetBoolParam("debugApp", false));
1462
1463 want.SetParam("debugApp", false);
1464 abilityRecord.PostCancelStartingWindowHotTask();
1465 EXPECT_FALSE(want.GetBoolParam("debugApp", false));
1466 }
1467
1468 /*
1469 * Feature: AbilityRecord
1470 * Function: PostCancelStartingWindowColdTask
1471 * SubFunction: PostCancelStartingWindowColdTask
1472 * FunctionPoints: NA
1473 * EnvConditions: NA
1474 * CaseDescription: PostCancelStartingWindowColdTask
1475 */
1476 HWTEST_F(AbilityRecordTest, AbilityRecord_PostCancelStartingWindowColdTask_001, TestSize.Level1)
1477 {
1478 Want want;
1479 AppExecFwk::AbilityInfo abilityInfo;
1480 AppExecFwk::ApplicationInfo applicationInfo;
1481 AbilityRecord abilityRecord(want, abilityInfo, applicationInfo, 0);
1482 want.SetParam("debugApp", true);
1483 abilityRecord.SetWant(want);
1484 abilityRecord.PostCancelStartingWindowColdTask();
1485 EXPECT_TRUE(want.GetBoolParam("debugApp", false));
1486
1487 want.SetParam("debugApp", false);
1488 abilityRecord.PostCancelStartingWindowColdTask();
1489 EXPECT_FALSE(want.GetBoolParam("debugApp", false));
1490 }
1491
1492 /*
1493 * Feature: AbilityRecord
1494 * Function: CreateResourceManager
1495 * SubFunction: CreateResourceManager
1496 * FunctionPoints: NA
1497 * EnvConditions: NA
1498 * CaseDescription: CreateResourceManager
1499 */
1500 HWTEST_F(AbilityRecordTest, AbilityRecord_CreateResourceManager_001, TestSize.Level1)
1501 {
1502 Want want;
1503 AppExecFwk::AbilityInfo abilityInfo;
1504 AppExecFwk::ApplicationInfo applicationInfo;
1505 AbilityRecord abilityRecord(want, abilityInfo, applicationInfo, 0);
1506 EXPECT_TRUE(abilityRecord.CreateResourceManager() == nullptr);
1507
1508 abilityInfo.hapPath = "abc";
1509 EXPECT_TRUE(abilityRecord.CreateResourceManager() == nullptr);
1510
1511 abilityInfo.resourcePath = "abc";
1512 abilityInfo.hapPath = "";
1513 EXPECT_TRUE(abilityRecord.CreateResourceManager() == nullptr);
1514
1515 abilityInfo.hapPath = "abc";
1516 EXPECT_TRUE(abilityRecord.CreateResourceManager() == nullptr);
1517 }
1518 #endif
1519
1520 /*
1521 * Feature: AbilityRecord
1522 * Function: BackgroundAbility
1523 * SubFunction: BackgroundAbility
1524 * FunctionPoints: NA
1525 * EnvConditions: NA
1526 * CaseDescription: Verify AbilityRecord BackgroundAbility
1527 */
1528 HWTEST_F(AbilityRecordTest, AbilityRecord_BackgroundAbility_001, TestSize.Level1)
1529 {
1530 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1531 Closure task;
1532 EXPECT_FALSE(task);
1533 abilityRecord->lifecycleDeal_ = nullptr;
1534 abilityRecord->BackgroundAbility(task);
1535 }
1536
1537 /*
1538 * Feature: AbilityRecord
1539 * Function: BackgroundAbility
1540 * SubFunction: BackgroundAbility
1541 * FunctionPoints: NA
1542 * EnvConditions: NA
1543 * CaseDescription: Verify AbilityRecord BackgroundAbility
1544 */
1545 HWTEST_F(AbilityRecordTest, AbilityRecord_BackgroundAbility_002, TestSize.Level1)
1546 {
1547 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
__anon156259c10502() 1548 Closure task = []() {};
1549 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
1550 abilityRecord->want_.SetParam(DEBUG_APP, false);
1551 abilityRecord->SetTerminatingState();
1552 abilityRecord->SetRestarting(false, 0);
1553 abilityRecord->BackgroundAbility(task);
1554 }
1555
1556 /*
1557 * Feature: AbilityRecord
1558 * Function: BackgroundAbility
1559 * SubFunction: BackgroundAbility
1560 * FunctionPoints: NA
1561 * EnvConditions: NA
1562 * CaseDescription: Verify AbilityRecord BackgroundAbility
1563 */
1564 HWTEST_F(AbilityRecordTest, AbilityRecord_BackgroundAbility_003, TestSize.Level1)
1565 {
1566 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
__anon156259c10602() 1567 Closure task = []() {};
1568 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
1569 abilityRecord->want_.SetParam(DEBUG_APP, true);
1570 abilityRecord->SetTerminatingState();
1571 abilityRecord->SetRestarting(true, 0);
1572 abilityRecord->BackgroundAbility(task);
1573 }
1574
1575 /*
1576 * Feature: AbilityRecord
1577 * Function: SetScheduler
1578 * SubFunction: SetScheduler
1579 * FunctionPoints: NA
1580 * EnvConditions: NA
1581 * CaseDescription: Verify AbilityRecord SetScheduler
1582 */
1583 HWTEST_F(AbilityRecordTest, AbilityRecord_SetScheduler_001, TestSize.Level1)
1584 {
1585 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1586 sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
1587 abilityRecord->scheduler_ = scheduler;
1588 abilityRecord->schedulerDeathRecipient_ =
__anon156259c10702(const wptr<IRemoteObject> &remote) 1589 new AbilitySchedulerRecipient([abilityRecord](const wptr<IRemoteObject> &remote) {});
1590 abilityRecord->SetScheduler(scheduler);
1591 }
1592
1593 /*
1594 * Feature: AbilityRecord
1595 * Function: SetScheduler
1596 * SubFunction: SetScheduler
1597 * FunctionPoints: NA
1598 * EnvConditions: NA
1599 * CaseDescription: Verify AbilityRecord SetScheduler
1600 */
1601 HWTEST_F(AbilityRecordTest, AbilityRecord_SetScheduler_002, TestSize.Level1)
1602 {
1603 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1604 sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
1605 abilityRecord->scheduler_ = scheduler;
1606 abilityRecord->schedulerDeathRecipient_ = nullptr;
1607 abilityRecord->SetScheduler(scheduler);
1608 }
1609
1610 /*
1611 * Feature: AbilityRecord
1612 * Function: SetScheduler
1613 * SubFunction: SetScheduler
1614 * FunctionPoints: NA
1615 * EnvConditions: NA
1616 * CaseDescription: Verify AbilityRecord SetScheduler
1617 */
1618 HWTEST_F(AbilityRecordTest, AbilityRecord_SetScheduler_003, TestSize.Level1)
1619 {
1620 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1621 sptr<IAbilityScheduler> scheduler = nullptr;
1622 abilityRecord->scheduler_ = new AbilityScheduler();
1623 abilityRecord->schedulerDeathRecipient_ = nullptr;
1624 abilityRecord->SetScheduler(scheduler);
1625 }
1626
1627 /*
1628 * Feature: AbilityRecord
1629 * Function: Activate
1630 * SubFunction: Activate
1631 * FunctionPoints: NA
1632 * EnvConditions: NA
1633 * CaseDescription: Verify AbilityRecord Activate
1634 */
1635 HWTEST_F(AbilityRecordTest, AbilityRecord_Activate_001, TestSize.Level1)
1636 {
1637 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1638 abilityRecord->SetIsNewWant(true);
1639 abilityRecord->SetPreAbilityRecord(abilityRecord_);
1640 abilityRecord->Activate();
1641 }
1642
1643 /*
1644 * Feature: AbilityRecord
1645 * Function: Activate
1646 * SubFunction: Activate
1647 * FunctionPoints: NA
1648 * EnvConditions: NA
1649 * CaseDescription: Verify AbilityRecord Activate
1650 */
1651 HWTEST_F(AbilityRecordTest, AbilityRecord_Activate_002, TestSize.Level1)
1652 {
1653 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1654 abilityRecord->SetIsNewWant(true);
1655 abilityRecord->SetPreAbilityRecord(nullptr);
1656 abilityRecord->Activate();
1657 }
1658
1659 /*
1660 * Feature: AbilityRecord
1661 * Function: Terminate
1662 * SubFunction: Terminate
1663 * FunctionPoints: NA
1664 * EnvConditions: NA
1665 * CaseDescription: Verify AbilityRecord Terminate
1666 */
1667 HWTEST_F(AbilityRecordTest, AbilityRecord_Terminate_001, TestSize.Level1)
1668 {
1669 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
__anon156259c10802() 1670 Closure task = []() {};
1671 abilityRecord->want_.SetParam(DEBUG_APP, true);
1672 abilityRecord->Terminate(task);
1673 }
1674
1675 /*
1676 * Feature: AbilityRecord
1677 * Function: SendResultToCallers
1678 * SubFunction: SendResultToCallers
1679 * FunctionPoints: NA
1680 * EnvConditions: NA
1681 * CaseDescription: Verify AbilityRecord SendResultToCallers
1682 */
1683 HWTEST_F(AbilityRecordTest, AbilityRecord_SendResultToCallers_001, TestSize.Level1)
1684 {
1685 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1686 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1687 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1688 std::shared_ptr<AbilityResult> result = std::make_shared<AbilityResult>();
1689 callerAbilityRecord->SetResult(result);
1690 abilityRecord->callerList_.push_back(nullptr);
1691 abilityRecord->callerList_.push_back(caller);
1692 abilityRecord->SendResultToCallers();
1693 }
1694
1695 /*
1696 * Feature: AbilityRecord
1697 * Function: SendResultToCallers
1698 * SubFunction: SendResultToCallers
1699 * FunctionPoints: NA
1700 * EnvConditions: NA
1701 * CaseDescription: Verify AbilityRecord SendResultToCallers
1702 */
1703 HWTEST_F(AbilityRecordTest, AbilityRecord_SendResultToCallers_002, TestSize.Level1)
1704 {
1705 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1706 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1707 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1708 std::shared_ptr<AbilityResult> result = std::make_shared<AbilityResult>();
1709 std::string srcAbilityId = "id";
1710 callerAbilityRecord->SetResult(nullptr);
1711 caller->saCaller_ = std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, abilityRecord->GetToken());
1712 abilityRecord->callerList_.push_back(caller);
1713 abilityRecord->SendResultToCallers();
1714 }
1715
1716 /*
1717 * Feature: AbilityRecord
1718 * Function: SendResultToCallers
1719 * SubFunction: SendResultToCallers
1720 * FunctionPoints: NA
1721 * EnvConditions: NA
1722 * CaseDescription: Verify AbilityRecord SendResultToCallers
1723 */
1724 HWTEST_F(AbilityRecordTest, AbilityRecord_SendResultToCallers_003, TestSize.Level1)
1725 {
1726 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1727 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, nullptr);
1728 caller->saCaller_ = nullptr;
1729 abilityRecord->callerList_.push_back(caller);
1730 abilityRecord->SendResultToCallers();
1731 }
1732
1733 /*
1734 * Feature: AbilityRecord
1735 * Function: SaveResultToCallers
1736 * SubFunction: SaveResultToCallers
1737 * FunctionPoints: NA
1738 * EnvConditions: NA
1739 * CaseDescription: Verify AbilityRecord SaveResultToCallers
1740 */
1741 HWTEST_F(AbilityRecordTest, AbilityRecord_SaveResultToCallers_001, TestSize.Level1)
1742 {
1743 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1744 EXPECT_NE(abilityRecord, nullptr);
1745 int resultCode = 0;
1746 Want *resultWant;
1747 abilityRecord->callerList_.clear();
1748 abilityRecord->SaveResultToCallers(resultCode, resultWant);
1749 }
1750
1751 /*
1752 * Feature: AbilityRecord
1753 * Function: SaveResultToCallers
1754 * SubFunction: SaveResultToCallers
1755 * FunctionPoints: NA
1756 * EnvConditions: NA
1757 * CaseDescription: Verify AbilityRecord SaveResultToCallers
1758 */
1759 HWTEST_F(AbilityRecordTest, AbilityRecord_SaveResultToCallers_002, TestSize.Level1)
1760 {
1761 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1762 EXPECT_NE(abilityRecord, nullptr);
1763 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1764 std::shared_ptr<CallerRecord> caller1 = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1765 std::shared_ptr<CallerRecord> caller2 = std::make_shared<CallerRecord>();
1766 int resultCode = 0;
1767 Want *resultWant = new Want();
1768 abilityRecord->callerList_.push_back(nullptr);
1769 abilityRecord->callerList_.push_back(caller1);
1770 abilityRecord->callerList_.push_back(caller2);
1771 abilityRecord->SaveResultToCallers(resultCode, resultWant);
1772 }
1773
1774 /*
1775 * Feature: AbilityRecord
1776 * Function: SaveResult
1777 * SubFunction: SaveResult
1778 * FunctionPoints: NA
1779 * EnvConditions: NA
1780 * CaseDescription: Verify AbilityRecord SaveResult
1781 */
1782 HWTEST_F(AbilityRecordTest, AbilityRecord_SaveResult_001, TestSize.Level1)
1783 {
1784 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1785 EXPECT_NE(abilityRecord, nullptr);
1786 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1787 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1788 int resultCode = 0;
1789 Want *resultWant = new Want();
1790 caller->saCaller_ = nullptr;
1791 abilityRecord->SaveResult(resultCode, resultWant, caller);
1792 }
1793
1794 /*
1795 * Feature: AbilityRecord
1796 * Function: SaveResult
1797 * SubFunction: SaveResult
1798 * FunctionPoints: NA
1799 * EnvConditions: NA
1800 * CaseDescription: Verify AbilityRecord SaveResult
1801 */
1802 HWTEST_F(AbilityRecordTest, AbilityRecord_SaveResult_002, TestSize.Level1)
1803 {
1804 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1805 EXPECT_NE(abilityRecord, nullptr);
1806 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, nullptr);
1807 std::string srcAbilityId = "id";
1808 int resultCode = 0;
1809 Want *resultWant = new Want();
1810 caller->saCaller_ = std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, abilityRecord->GetToken());
1811 abilityRecord->SaveResult(resultCode, resultWant, caller);
1812 }
1813
1814 /*
1815 * Feature: AbilityRecord
1816 * Function: SetResultToSystemAbility
1817 * SubFunction: SetResultToSystemAbility
1818 * FunctionPoints: NA
1819 * EnvConditions: NA
1820 * CaseDescription: Verify SystemAbilityCallerRecord SetResultToSystemAbility
1821 */
1822 HWTEST_F(AbilityRecordTest, SystemAbilityCallerRecord_SetResultToSystemAbility_001, TestSize.Level1)
1823 {
1824 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1825 EXPECT_NE(abilityRecord, nullptr);
1826 std::string srcAbilityId = "srcAbility_id";
1827 std::shared_ptr<SystemAbilityCallerRecord> systemAbilityRecord =
1828 std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, abilityRecord->GetToken());
1829 Want resultWant;
1830 int resultCode = 1;
1831 systemAbilityRecord->SetResultToSystemAbility(systemAbilityRecord, resultWant, resultCode);
1832 }
1833
1834 /*
1835 * Feature: AbilityRecord
1836 * Function: SendResultToSystemAbility
1837 * SubFunction: SendResultToSystemAbility
1838 * FunctionPoints: NA
1839 * EnvConditions: NA
1840 * CaseDescription: Verify SystemAbilityCallerRecord SendResultToSystemAbility
1841 */
1842 HWTEST_F(AbilityRecordTest, SystemAbilityCallerRecord_SendResultToSystemAbility_001, TestSize.Level1)
1843 {
1844 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1845 std::string srcAbilityId = "srcAbility_id";
1846 std::shared_ptr<SystemAbilityCallerRecord> systemAbilityRecord =
1847 std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, abilityRecord->GetToken());
1848 int requestCode = 0;
1849 int32_t callerUid = 0;
1850 uint32_t accessToken = 0;
1851 systemAbilityRecord->SendResultToSystemAbility(requestCode, systemAbilityRecord, callerUid, accessToken, false);
1852 }
1853
1854 /*
1855 * Feature: AbilityRecord
1856 * Function: AddCallerRecord
1857 * SubFunction: AddCallerRecord
1858 * FunctionPoints: NA
1859 * EnvConditions: NA
1860 * CaseDescription: Verify AbilityRecord AddCallerRecord
1861 */
1862 HWTEST_F(AbilityRecordTest, AbilityRecord_AddCallerRecord_001, TestSize.Level1)
1863 {
1864 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1865 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1866 callerAbilityRecord->Init();
1867 sptr<IRemoteObject> callerToken = callerAbilityRecord->GetToken();
1868 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1869 abilityRecord->callerList_.push_back(caller);
1870 int requestCode = 0;
1871 std::string srcAbilityId = "srcAbility_id";
1872 abilityRecord->AddCallerRecord(callerToken, requestCode, srcAbilityId);
1873 }
1874
1875 /*
1876 * Feature: AbilityRecord
1877 * Function: IsSystemAbilityCall
1878 * SubFunction: IsSystemAbilityCall
1879 * FunctionPoints: NA
1880 * EnvConditions: NA
1881 * CaseDescription: Verify AbilityRecord IsSystemAbilityCall
1882 */
1883 HWTEST_F(AbilityRecordTest, AbilityRecord_IsSystemAbilityCall_001, TestSize.Level1)
1884 {
1885 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1886 bool res1 = abilityRecord->IsSystemAbilityCall(nullptr);
1887 EXPECT_FALSE(res1);
1888 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1889 sptr<IRemoteObject> callerToken = callerAbilityRecord->GetToken();
1890 bool res2 = abilityRecord->IsSystemAbilityCall(callerToken);
1891 EXPECT_FALSE(res2);
1892 callerAbilityRecord->Init();
1893 callerToken = callerAbilityRecord->GetToken();
1894 bool res3 = abilityRecord->IsSystemAbilityCall(callerToken);
1895 EXPECT_FALSE(res3);
1896 }
1897
1898 /*
1899 * Feature: AbilityRecord
1900 * Function: AddSystemAbilityCallerRecord
1901 * SubFunction: AddSystemAbilityCallerRecord
1902 * FunctionPoints: NA
1903 * EnvConditions: NA
1904 * CaseDescription: Verify AbilityRecord AddSystemAbilityCallerRecord
1905 */
1906 HWTEST_F(AbilityRecordTest, AbilityRecord_AddSystemAbilityCallerRecord_001, TestSize.Level1)
1907 {
1908 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1909 EXPECT_NE(abilityRecord, nullptr);
1910 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
1911 int requestCode = 0;
1912 std::string srcAbilityId = "srcAbility_id";
1913 abilityRecord->callerList_.clear();
1914 abilityRecord->AddSystemAbilityCallerRecord(callerToken, requestCode, srcAbilityId);
1915 }
1916
1917 /*
1918 * Feature: AbilityRecord
1919 * Function: AddSystemAbilityCallerRecord
1920 * SubFunction: AddSystemAbilityCallerRecord
1921 * FunctionPoints: NA
1922 * EnvConditions: NA
1923 * CaseDescription: Verify AbilityRecord AddSystemAbilityCallerRecord
1924 */
1925 HWTEST_F(AbilityRecordTest, AbilityRecord_AddSystemAbilityCallerRecord_002, TestSize.Level1)
1926 {
1927 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1928 EXPECT_NE(abilityRecord, nullptr);
1929 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
1930 int requestCode = 0;
1931 std::string srcAbilityId = "srcAbility_id";
1932 std::shared_ptr<SystemAbilityCallerRecord> saCaller =
1933 std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, callerToken);
1934 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(requestCode, saCaller);
1935 abilityRecord->callerList_.push_back(caller);
1936 abilityRecord->AddSystemAbilityCallerRecord(callerToken, requestCode, srcAbilityId);
1937 }
1938
1939 /*
1940 * Feature: AbilityRecord
1941 * Function: GetConnectingRecordList
1942 * SubFunction: GetConnectingRecordList
1943 * FunctionPoints: NA
1944 * EnvConditions: NA
1945 * CaseDescription: Verify AbilityRecord GetConnectingRecordList
1946 */
1947 HWTEST_F(AbilityRecordTest, AbilityRecord_GetConnectingRecordList_001, TestSize.Level1)
1948 {
1949 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1950 EXPECT_NE(abilityRecord, nullptr);
1951 OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1952 std::shared_ptr<ConnectionRecord> connection1 =
1953 std::make_shared<ConnectionRecord>(abilityRecord->GetToken(), abilityRecord, callback);
1954 std::shared_ptr<ConnectionRecord> connection2 =
1955 std::make_shared<ConnectionRecord>(abilityRecord->GetToken(), abilityRecord, callback);
1956 connection1->SetConnectState(ConnectionState::CONNECTING);
1957 connection2->SetConnectState(ConnectionState::CONNECTED);
1958 abilityRecord->connRecordList_.push_back(connection1);
1959 abilityRecord->connRecordList_.push_back(connection2);
1960 abilityRecord->GetConnectingRecordList();
1961 }
1962
1963 /*
1964 * Feature: AbilityRecord
1965 * Function: DumpAbilityState
1966 * SubFunction: DumpAbilityState
1967 * FunctionPoints: NA
1968 * EnvConditions: NA
1969 * CaseDescription: Verify AbilityRecord DumpAbilityState
1970 */
1971 HWTEST_F(AbilityRecordTest, AbilityRecord_DumpAbilityState_001, TestSize.Level1)
1972 {
1973 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1974 EXPECT_NE(abilityRecord, nullptr);
1975 std::vector<std::string> info;
1976 bool isClient = false;
1977 std::vector<std::string> params;
1978 abilityRecord->callContainer_ = std::make_shared<CallContainer>();
1979 abilityRecord->isLauncherRoot_ = true;
1980 abilityRecord->DumpAbilityState(info, isClient, params);
1981 }
1982
1983 /*
1984 * Feature: AbilityRecord
1985 * Function: SetStartTime
1986 * SubFunction: SetStartTime
1987 * FunctionPoints: NA
1988 * EnvConditions: NA
1989 * CaseDescription: Verify AbilityRecord SetStartTime
1990 */
1991 HWTEST_F(AbilityRecordTest, AbilityRecord_SetStartTime_001, TestSize.Level1)
1992 {
1993 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1994 EXPECT_NE(abilityRecord, nullptr);
1995 abilityRecord->startTime_ = 1;
1996 abilityRecord->SetStartTime();
1997 }
1998
1999 /*
2000 * Feature: AbilityRecord
2001 * Function: DumpService
2002 * SubFunction: DumpService
2003 * FunctionPoints: NA
2004 * EnvConditions: NA
2005 * CaseDescription: Verify AbilityRecord DumpService
2006 */
2007 HWTEST_F(AbilityRecordTest, AbilityRecord_DumpService_001, TestSize.Level1)
2008 {
2009 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2010 EXPECT_NE(abilityRecord, nullptr);
2011 std::vector<std::string> info;
2012 std::vector<std::string> params;
2013 bool isClient = false;
2014 OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
2015 std::shared_ptr<ConnectionRecord> connection =
2016 std::make_shared<ConnectionRecord>(abilityRecord->GetToken(), abilityRecord, callback);
2017 abilityRecord->isLauncherRoot_ = true;
2018 abilityRecord->connRecordList_.push_back(nullptr);
2019 abilityRecord->connRecordList_.push_back(connection);
2020 abilityRecord->DumpService(info, params, isClient);
2021 }
2022
2023 /*
2024 * Feature: AbilityRecord
2025 * Function: SendEvent
2026 * SubFunction: SendEvent
2027 * FunctionPoints: NA
2028 * EnvConditions: NA
2029 * CaseDescription: Verify AbilityRecord SendEvent
2030 */
2031 HWTEST_F(AbilityRecordTest, AbilityRecord_SendEvent_001, TestSize.Level1)
2032 {
2033 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2034 uint32_t msg = 0;
2035 uint32_t timeOut = 0;
2036 abilityRecord->want_.SetParam(DEBUG_APP, true);
2037 EXPECT_TRUE(abilityRecord->want_.GetBoolParam(DEBUG_APP, false));
2038 abilityRecord->SendEvent(msg, timeOut);
2039 }
2040
2041 /*
2042 * Feature: AbilityRecord
2043 * Function: SetRestarting
2044 * SubFunction: SetRestarting
2045 * FunctionPoints: NA
2046 * EnvConditions: NA
2047 * CaseDescription: Verify AbilityRecord SetRestarting
2048 */
2049 HWTEST_F(AbilityRecordTest, AbilityRecord_SetRestarting_001, TestSize.Level1)
2050 {
2051 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2052 EXPECT_NE(abilityRecord, nullptr);
2053 bool isRestart = false;
2054 abilityRecord->isLauncherRoot_ = true;
2055 abilityRecord->isLauncherAbility_ = true;
2056 abilityRecord->SetRestarting(isRestart);
2057 abilityRecord->isLauncherAbility_ = false;
2058 abilityRecord->SetRestarting(isRestart);
2059 abilityRecord->isLauncherRoot_ = false;
2060 abilityRecord->SetRestarting(isRestart);
2061 }
2062
2063 /*
2064 * Feature: AbilityRecord
2065 * Function: SetRestarting
2066 * SubFunction: SetRestarting
2067 * FunctionPoints: NA
2068 * EnvConditions: NA
2069 * CaseDescription: Verify AbilityRecord SetRestarting
2070 */
2071 HWTEST_F(AbilityRecordTest, AbilityRecord_SetRestarting_002, TestSize.Level1)
2072 {
2073 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2074 EXPECT_NE(abilityRecord, nullptr);
2075 bool isRestart = false;
2076 int32_t canReStartCount = 1;
2077 abilityRecord->isLauncherRoot_ = true;
2078 abilityRecord->isLauncherAbility_ = true;
2079 abilityRecord->SetRestarting(isRestart, canReStartCount);
2080 abilityRecord->isLauncherAbility_ = false;
2081 abilityRecord->SetRestarting(isRestart, canReStartCount);
2082 abilityRecord->isLauncherRoot_ = false;
2083 abilityRecord->SetRestarting(isRestart, canReStartCount);
2084 }
2085
2086 /*
2087 * Feature: AbilityRecord
2088 * Function: CallRequestDone
2089 * SubFunction: CallRequestDone
2090 * FunctionPoints: NA
2091 * EnvConditions: NA
2092 * CaseDescription: Verify AbilityRecord CallRequestDone
2093 */
2094 HWTEST_F(AbilityRecordTest, AbilityRecord_CallRequestDone_001, TestSize.Level1)
2095 {
2096 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2097 bool res1 = abilityRecord->CallRequestDone(nullptr);
2098 EXPECT_FALSE(res1);
2099 abilityRecord->callContainer_ = std::make_shared<CallContainer>();
2100 abilityRecord->Init();
2101 sptr<IRemoteObject> callStub = abilityRecord->GetToken();
2102 bool res2 = abilityRecord->CallRequestDone(callStub);
2103 EXPECT_TRUE(res2);
2104 }
2105
2106 /*
2107 * Feature: AbilityRecord
2108 * Function: DumpClientInfo
2109 * SubFunction: DumpClientInfo
2110 * FunctionPoints: NA
2111 * EnvConditions: NA
2112 * CaseDescription: Verify AbilityRecord DumpClientInfo
2113 */
2114 HWTEST_F(AbilityRecordTest, AbilityRecord_DumpClientInfo_001, TestSize.Level1)
2115 {
2116 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2117 EXPECT_NE(abilityRecord, nullptr);
2118 std::vector<std::string> info;
2119 const std::vector<std::string> params;
2120 bool isClient = true;
2121 bool dumpConfig = false;
2122 abilityRecord->scheduler_ = nullptr;
2123 abilityRecord->DumpClientInfo(info, params, isClient, dumpConfig);
2124 abilityRecord->scheduler_ = new AbilityScheduler();
2125 abilityRecord->isReady_ = false;
2126 abilityRecord->DumpClientInfo(info, params, isClient, dumpConfig);
2127 abilityRecord->isReady_ = true;
2128 abilityRecord->DumpClientInfo(info, params, isClient, dumpConfig);
2129 dumpConfig = true;
2130 abilityRecord->DumpClientInfo(info, params, isClient, dumpConfig);
2131 }
2132
2133 /*
2134 * Feature: AbilityRecord
2135 * Function: DumpAbilityInfoDone
2136 * SubFunction: DumpAbilityInfoDone
2137 * FunctionPoints: NA
2138 * EnvConditions: NA
2139 * CaseDescription: Verify AbilityRecord DumpAbilityInfoDone
2140 */
2141 HWTEST_F(AbilityRecordTest, AbilityRecord_DumpAbilityInfoDone_001, TestSize.Level1)
2142 {
2143 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2144 EXPECT_NE(abilityRecord, nullptr);
2145 std::vector<std::string> infos;
2146 abilityRecord->isDumpTimeout_ = true;
2147 abilityRecord->DumpAbilityInfoDone(infos);
2148 abilityRecord->isDumpTimeout_ = false;
2149 abilityRecord->DumpAbilityInfoDone(infos);
2150 }
2151
2152 /*
2153 * Feature: AbilityRecord
2154 * Function: GrantUriPermission
2155 * SubFunction: GrantUriPermission
2156 * FunctionPoints: NA
2157 * EnvConditions: NA
2158 * CaseDescription: Verify AbilityRecord GrantUriPermission
2159 */
2160 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_001, TestSize.Level1)
2161 {
2162 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2163 EXPECT_NE(abilityRecord, nullptr);
2164 Want want;
2165 std::string targetBundleName = "name";
2166 abilityRecord->GrantUriPermission(want, targetBundleName, true, 0);
2167 }
2168
2169 /*
2170 * Feature: AbilityRecord
2171 * Function: GrantUriPermission
2172 * SubFunction: GrantUriPermission
2173 * FunctionPoints: NA
2174 * EnvConditions: NA
2175 * CaseDescription: Verify AbilityRecord GrantUriPermission
2176 */
2177 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_002, TestSize.Level1)
2178 {
2179 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2180 EXPECT_NE(abilityRecord, nullptr);
2181 Want want;
2182 want.SetFlags(1);
2183 want.SetUri("datashare://ohos.samples.clock/data/storage/el2/base/haps/entry/files/test_A.txt");
2184 std::string targetBundleName = "name";
2185 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2186 }
2187
2188 /*
2189 * Feature: AbilityRecord
2190 * Function: GrantUriPermission
2191 * SubFunction: GrantUriPermission
2192 * FunctionPoints: NA
2193 * EnvConditions: NA
2194 * CaseDescription: Verify AbilityRecord GrantUriPermission
2195 */
2196 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_003, TestSize.Level1)
2197 {
2198 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2199 EXPECT_NE(abilityRecord, nullptr);
2200 Want want;
2201 want.SetFlags(1);
2202 want.SetUri("file://com.example.mock/data/storage/el2/base/haps/entry/files/test_A.txt");
2203 std::string targetBundleName = "name";
2204 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2205 }
2206
2207 /*
2208 * Feature: AbilityRecord
2209 * Function: GrantUriPermission
2210 * SubFunction: GrantUriPermission
2211 * FunctionPoints: NA
2212 * EnvConditions: NA
2213 * CaseDescription: Verify AbilityRecord GrantUriPermission
2214 */
2215 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_004, TestSize.Level1)
2216 {
2217 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2218 EXPECT_NE(abilityRecord, nullptr);
2219 Want want;
2220 want.SetFlags(1);
2221 want.SetUri("file://ohos.samples.clock/data/storage/el2/base/haps/entry/files/test_A.txt");
2222 std::string targetBundleName = "name";
2223 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2224 }
2225
2226 /*
2227 * Feature: AbilityRecord
2228 * Function: GrantUriPermission
2229 * SubFunction: GrantUriPermission
2230 * FunctionPoints: NA
2231 * EnvConditions: NA
2232 * CaseDescription: Verify AbilityRecord GrantUriPermission
2233 */
2234 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_005, TestSize.Level1)
2235 {
2236 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2237 EXPECT_NE(abilityRecord, nullptr);
2238 Want want;
2239 want.SetFlags(1);
2240 want.SetUri("file://ohos.samples.clock/data/storage/el2/base/haps/entry/files/test_A.txt");
2241 std::string targetBundleName = "name";
2242 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2243 }
2244
2245 /*
2246 * Feature: AbilityRecord
2247 * Function: GrantUriPermission
2248 * SubFunction: GrantUriPermission
2249 * FunctionPoints: NA
2250 * CaseDescription: Verify AbilityRecord GrantUriPermission
2251 */
2252 HWTEST_F(AbilityRecordTest, AbilityRecord_UriPermissionPersistableTest_001, TestSize.Level1)
2253 {
2254 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2255 EXPECT_NE(abilityRecord, nullptr);
2256 auto uprdb = std::make_shared<UriPermissionRdb>();
2257 EXPECT_NE(uprdb, nullptr);
2258 NativeRdb::AbsRdbPredicates absRdbPredicates(URI_PERMISSION_TABLE_NAME);
2259 uprdb->DeleteData(absRdbPredicates);
2260 std::string targetBundleName = "com.example.test";
2261 auto uriStr = "file://docs/storage/Users/currentUser/test.txt";
2262 unsigned int perReadFlag = Want::FLAG_AUTH_READ_URI_PERMISSION | Want::FLAG_AUTH_PERSISTABLE_URI_PERMISSION;
2263 Want want;
2264 want.SetFlags(perReadFlag);
2265 want.SetUri(uriStr);
2266 abilityRecord->isGrantPersistableUriPermissionEnable_ = true;
2267 MyFlag::flag_ = 1;
2268 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2269 MyFlag::flag_ = 0;
2270 }
2271
2272 /*
2273 * Feature: AbilityRecord
2274 * Function: GrantUriPermission
2275 * SubFunction: GrantUriPermission
2276 * FunctionPoints: NA
2277 * CaseDescription: Verify AbilityRecord GrantUriPermission
2278 */
2279 HWTEST_F(AbilityRecordTest, AbilityRecord_UriPermissionPersistableTest_002, TestSize.Level1)
2280 {
2281 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2282 EXPECT_NE(abilityRecord, nullptr);
2283 auto uprdb = std::make_shared<UriPermissionRdb>();
2284 EXPECT_NE(uprdb, nullptr);
2285 NativeRdb::AbsRdbPredicates absRdbPredicates(URI_PERMISSION_TABLE_NAME);
2286 uprdb->DeleteData(absRdbPredicates);
2287 std::string targetBundleName = "com.example.test";
2288 auto uriStr = "file://docs/storage/Users/currentUser/test.txt";
2289 unsigned int perReadFlag = Want::FLAG_AUTH_READ_URI_PERMISSION | Want::FLAG_AUTH_PERSISTABLE_URI_PERMISSION;
2290 Want want;
2291 want.SetFlags(perReadFlag);
2292 want.SetUri(uriStr);
2293 abilityRecord->isGrantPersistableUriPermissionEnable_ = true;
2294 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2295 }
2296
2297 /*
2298 * Feature: AbilityRecord
2299 * Function: GrantUriPermission
2300 * SubFunction: GrantUriPermission
2301 * FunctionPoints: NA
2302 * CaseDescription: Verify AbilityRecord GrantUriPermission
2303 */
2304 HWTEST_F(AbilityRecordTest, AbilityRecord_UriPermissionPersistableTest_003, TestSize.Level1)
2305 {
2306 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2307 EXPECT_NE(abilityRecord, nullptr);
2308 auto uprdb = std::make_shared<UriPermissionRdb>();
2309 EXPECT_NE(uprdb, nullptr);
2310 NativeRdb::AbsRdbPredicates absRdbPredicates(URI_PERMISSION_TABLE_NAME);
2311 uprdb->DeleteData(absRdbPredicates);
2312 std::string targetBundleName = "com.example.test";
2313 auto uriStr = "file://docs/storage/Users/currentUser/test.txt";
2314 unsigned int perReadFlag = Want::FLAG_AUTH_READ_URI_PERMISSION | Want::FLAG_AUTH_PERSISTABLE_URI_PERMISSION;
2315 auto callerTokenId = IPCSkeleton::GetCallingTokenID();
2316 uint32_t ret = uprdb->AddGrantInfo(uriStr, perReadFlag, 0, callerTokenId);
2317 ASSERT_EQ(ret, ERR_OK);
2318 Want want;
2319 want.SetFlags(perReadFlag);
2320 want.SetUri(uriStr);
2321 abilityRecord->isGrantPersistableUriPermissionEnable_ = true;
2322 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2323 }
2324
2325 /*
2326 * Feature: AbilityRecord
2327 * Function: RevokeUriPermission
2328 * SubFunction: RevokeUriPermission
2329 * FunctionPoints: NA
2330 * EnvConditions: NA
2331 * CaseDescription: Verify AbilityRecord RevokeUriPermission
2332 */
2333 HWTEST_F(AbilityRecordTest, AbilityRecord_RevokeUriPermission_001, TestSize.Level1)
2334 {
2335 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2336 EXPECT_NE(abilityRecord, nullptr);
2337 abilityRecord->RevokeUriPermission();
2338 }
2339
2340 /*
2341 * Feature: AbilityRecord
2342 * Function: HandleDlpClosed
2343 * SubFunction: HandleDlpClosed
2344 * FunctionPoints: NA
2345 * EnvConditions: NA
2346 * CaseDescription: Verify AbilityRecord HandleDlpClosed
2347 */
2348 HWTEST_F(AbilityRecordTest, AbilityRecord_HandleDlpClosed_001, TestSize.Level1)
2349 {
2350 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2351 EXPECT_NE(abilityRecord, nullptr);
2352 abilityRecord->abilityInfo_.bundleName = DLP_BUNDLE_NAME;
2353 abilityRecord->appIndex_ = 1;
2354 abilityRecord->HandleDlpClosed();
2355 }
2356
2357 /*
2358 * Feature: AbilityRecord
2359 * Function: NotifyAnimationAbilityDied
2360 * SubFunction: NotifyAnimationAbilityDied
2361 * FunctionPoints: NA
2362 * EnvConditions: NA
2363 * CaseDescription: Verify AbilityRecord NotifyAnimationAbilityDied
2364 */
2365 HWTEST_F(AbilityRecordTest, AbilityRecord_NotifyAnimationAbilityDied_001, TestSize.Level1)
2366 {
2367 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2368 EXPECT_NE(abilityRecord, nullptr);
2369 abilityRecord->missionId_ = 1;
2370 abilityRecord->NotifyAnimationAbilityDied();
2371 }
2372
2373 /*
2374 * Feature: AbilityRecord
2375 * Function: NotifyRemoveShellProcess
2376 * SubFunction: NotifyRemoveShellProcess
2377 * FunctionPoints: NA
2378 * EnvConditions: NA
2379 * CaseDescription: Verify AbilityRecord NotifyRemoveShellProcess
2380 */
2381 HWTEST_F(AbilityRecordTest, AbilityRecord_NotifyRemoveShellProcess_001, TestSize.Level1)
2382 {
2383 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2384 EXPECT_NE(abilityRecord, nullptr);
2385 abilityRecord->abilityInfo_.bundleName = SHELL_ASSISTANT_BUNDLENAME;
2386 abilityRecord->NotifyRemoveShellProcess(CollaboratorType::RESERVE_TYPE);
2387 }
2388
2389 /*
2390 * Feature: AbilityRecord
2391 * Function: GetCurrentAccountId
2392 * SubFunction: GetCurrentAccountId
2393 * FunctionPoints: NA
2394 * EnvConditions: NA
2395 * CaseDescription: Verify AbilityRecord GetCurrentAccountId
2396 */
2397 HWTEST_F(AbilityRecordTest, AbilityRecord_GetCurrentAccountId_001, TestSize.Level1)
2398 {
2399 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2400 EXPECT_NE(abilityRecord, nullptr);
2401 abilityRecord->GetCurrentAccountId();
2402 }
2403
2404 /*
2405 * Feature: AbilityRecord
2406 * Function: CanRestartResident
2407 * SubFunction:
2408 * FunctionPoints: CanRestartResident
2409 * EnvConditions: NA
2410 * CaseDescription: Verify CanRestartResident return true when the ability is not a restart requestion.
2411 * @tc.require: issueI6588V
2412 */
2413 HWTEST_F(AbilityRecordTest, AbilityRecord_CanRestartResident_001, TestSize.Level1)
2414 {
2415 abilityRecord_->SetKeepAlive();
2416 EXPECT_TRUE(abilityRecord_->isKeepAlive_);
2417
2418 abilityRecord_->SetRestarting(true, -1);
2419 EXPECT_TRUE(abilityRecord_->isRestarting_);
2420 EXPECT_EQ(abilityRecord_->restartCount_, -1);
2421
2422 abilityRecord_->restartTime_ = AbilityUtil::SystemTimeMillis();
2423 EXPECT_FALSE(abilityRecord_->CanRestartResident());
2424 abilityRecord_->restartTime_ = 0;
2425 // restart success
2426 abilityRecord_->SetAbilityState(AbilityState::ACTIVE);
2427
2428 EXPECT_TRUE(abilityRecord_->CanRestartResident());
2429 }
2430
2431 /*
2432 * Feature: AbilityRecord
2433 * Function: CanRestartResident
2434 * SubFunction:
2435 * FunctionPoints: CanRestartResident
2436 * EnvConditions: NA
2437 * CaseDescription: Verify CanRestartResident return true when the restartCount is out of max times but the interval
2438 * time is over configuration.
2439 * @tc.require: issueI6588V
2440 */
2441 HWTEST_F(AbilityRecordTest, AbilityRecord_CanRestartResident_002, TestSize.Level1)
2442 {
2443 abilityRecord_->SetKeepAlive();
2444 EXPECT_TRUE(abilityRecord_->isKeepAlive_);
2445
2446 abilityRecord_->SetRestarting(true, -1);
2447 EXPECT_TRUE(abilityRecord_->isRestarting_);
2448 EXPECT_EQ(abilityRecord_->restartCount_, -1);
2449 abilityRecord_->SetRestartTime(0);
2450 EXPECT_EQ(abilityRecord_->restartTime_, 0);
2451
2452 EXPECT_TRUE(abilityRecord_->CanRestartResident());
2453 }
2454
2455 /*
2456 * Feature: AbilityRecord
2457 * Function: UpdateRecoveryInfo
2458 * FunctionPoints: CanRestartResident
2459 * EnvConditions: NA
2460 * CaseDescription: Verify whether the UpdateRecoveryInfo interface calls normally.
2461 */
2462 HWTEST_F(AbilityRecordTest, AbilityRecord_UpdateRecoveryInfo_001, TestSize.Level1)
2463 {
2464 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2465 abilityRecord->UpdateRecoveryInfo(false);
2466 EXPECT_FALSE(abilityRecord->want_.GetBoolParam(Want::PARAM_ABILITY_RECOVERY_RESTART, false));
2467 }
2468
2469 /*
2470 * Feature: AbilityRecord
2471 * Function: UpdateRecoveryInfo
2472 * FunctionPoints: CanRestartResident
2473 * EnvConditions: NA
2474 * CaseDescription: Verify whether the UpdateRecoveryInfo interface calls normally.
2475 */
2476 HWTEST_F(AbilityRecordTest, AbilityRecord_UpdateRecoveryInfo_002, TestSize.Level1)
2477 {
2478 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2479 abilityRecord->UpdateRecoveryInfo(true);
2480 EXPECT_TRUE(abilityRecord->want_.GetBoolParam(Want::PARAM_ABILITY_RECOVERY_RESTART, false));
2481 }
2482
2483 /*
2484 * Feature: AbilityRecord
2485 * Function: GetRecoveryInfo
2486 * FunctionPoints: CanRestartResident
2487 * EnvConditions: NA
2488 * CaseDescription: Verify whether the GetRecoveryInfo interface calls normally.
2489 */
2490 HWTEST_F(AbilityRecordTest, AbilityRecord_GetRecoveryInfo_001, TestSize.Level1)
2491 {
2492 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2493 EXPECT_FALSE(abilityRecord->GetRecoveryInfo());
2494 }
2495
2496 /*
2497 * Feature: AbilityRecord
2498 * Function: IsUIExtension
2499 * SubFunction: IsUIExtension
2500 * FunctionPoints: NA
2501 * EnvConditions: NA
2502 * CaseDescription: Verify IsUIExtension
2503 */
2504 HWTEST_F(AbilityRecordTest, IsUIExtension_001, TestSize.Level1)
2505 {
2506 abilityRecord_->abilityInfo_.extensionAbilityType = AppExecFwk::ExtensionAbilityType::UI;
2507 EXPECT_EQ(UIExtensionUtils::IsUIExtension(abilityRecord_->abilityInfo_.extensionAbilityType), true);
2508 }
2509
2510 /*
2511 * Feature: AbilityRecord
2512 * Function: NotifyMoveMissionToForeground
2513 * SubFunction: NotifyMoveMissionToForeground
2514 * FunctionPoints: NA
2515 * EnvConditions: NA
2516 * CaseDescription: Verify NotifyMoveMissionToForeground
2517 * @tc.require: issueI7LJ1M
2518 */
2519 HWTEST_F(AbilityRecordTest, NotifyMoveMissionToForeground_001, TestSize.Level1)
2520 {
2521 EXPECT_NE(abilityRecord_, nullptr);
2522 abilityRecord_->collaboratorType_ = 1;
2523 abilityRecord_->SetAbilityStateInner(AbilityState::FOREGROUNDING);
2524 }
2525
2526 /*
2527 * Feature: AbilityRecord
2528 * Function: NotifyMoveMissionToBackground
2529 * SubFunction: NotifyMoveMissionToBackground
2530 * FunctionPoints: NA
2531 * EnvConditions: NA
2532 * CaseDescription: Verify NotifyMoveMissionToBackground
2533 * @tc.require: issueI7LJ1M
2534 */
2535 HWTEST_F(AbilityRecordTest, NotifyMoveMissionToBackground_001, TestSize.Level1)
2536 {
2537 EXPECT_NE(abilityRecord_, nullptr);
2538 abilityRecord_->collaboratorType_ = 1;
2539 abilityRecord_->SetAbilityStateInner(AbilityState::BACKGROUNDING);
2540 }
2541
2542 /*
2543 * Feature: AbilityRecord
2544 * Function: NotifyTerminateMission
2545 * SubFunction: NotifyTerminateMission
2546 * FunctionPoints: NA
2547 * EnvConditions: NA
2548 * CaseDescription: Verify NotifyTerminateMission
2549 * @tc.require: issueI7LJ1M
2550 */
2551 HWTEST_F(AbilityRecordTest, NotifyTerminateMission_001, TestSize.Level1)
2552 {
2553 EXPECT_NE(abilityRecord_, nullptr);
2554 abilityRecord_->collaboratorType_ = 1;
2555 abilityRecord_->SetAbilityStateInner(AbilityState::TERMINATING);
2556 }
2557
2558 /**
2559 * @tc.name: AbilityRecord_SetAttachDebug_001
2560 * @tc.desc: Test the correct value status of SetAttachDebug
2561 * @tc.type: FUNC
2562 */
2563 HWTEST_F(AbilityRecordTest, AbilityRecord_SetAttachDebug_001, TestSize.Level1)
2564 {
2565 EXPECT_NE(abilityRecord_, nullptr);
2566 bool isAttachDebug = true;
2567 abilityRecord_->SetAttachDebug(isAttachDebug);
2568 EXPECT_EQ(abilityRecord_->isAttachDebug_, true);
2569 }
2570
2571 /**
2572 * @tc.name: AbilityRecord_SetAttachDebug_002
2573 * @tc.desc: Test the error value status of SetAttachDebug
2574 * @tc.type: FUNC
2575 */
2576 HWTEST_F(AbilityRecordTest, AbilityRecord_SetAttachDebug_002, TestSize.Level1)
2577 {
2578 EXPECT_NE(abilityRecord_, nullptr);
2579 bool isAttachDebug = false;
2580 abilityRecord_->SetAttachDebug(isAttachDebug);
2581 EXPECT_EQ(abilityRecord_->isAttachDebug_, false);
2582 }
2583
2584 /**
2585 * @tc.name: AbilityRecordTest_SetLaunchReason_0100
2586 * @tc.desc: Test the state of SetLaunchReason
2587 * @tc.type: FUNC
2588 */
2589 HWTEST_F(AbilityRecordTest, SetLaunchReason_0100, TestSize.Level1)
2590 {
2591 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2592 EXPECT_NE(abilityRecord, nullptr);
2593 LaunchReason reason = LaunchReason::LAUNCHREASON_START_ABILITY;
2594 abilityRecord->isAppAutoStartup_ = true;
2595 abilityRecord->SetLaunchReason(reason);
2596 EXPECT_EQ(abilityRecord->lifeCycleStateInfo_.launchParam.launchReason, LaunchReason::LAUNCHREASON_AUTO_STARTUP);
2597 }
2598
2599 /**
2600 * @tc.name: AbilityRecordTest_SetLaunchReason_0200
2601 * @tc.desc: Test the state of SetLaunchReason
2602 * @tc.type: FUNC
2603 */
2604 HWTEST_F(AbilityRecordTest, SetLaunchReason_0200, TestSize.Level1)
2605 {
2606 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2607 EXPECT_NE(abilityRecord, nullptr);
2608 LaunchReason reason = LaunchReason::LAUNCHREASON_START_ABILITY;
2609 abilityRecord->isAppAutoStartup_ = false;
2610 abilityRecord->SetLaunchReason(reason);
2611 EXPECT_EQ(abilityRecord->lifeCycleStateInfo_.launchParam.launchReason, LaunchReason::LAUNCHREASON_START_ABILITY);
2612 }
2613 } // namespace AAFwk
2614 } // namespace OHOS
2615