1 /*
2 * Copyright (c) 2021-2024 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 #undef private
22 #undef protected
23
24 #include "ability_connect_callback_stub.h"
25 #include "ability_manager_service.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 "int_wrapper.h"
39 #include "uri_utils.h"
40 #ifdef SUPPORT_GRAPHICS
41 #define private public
42 #define protected public
43 #include "mission_info_mgr.h"
44 #undef private
45 #undef protected
46 #endif
47
48 using namespace testing::ext;
49 using namespace OHOS::AppExecFwk;
50 using namespace OHOS::AbilityBase::Constants;
51
52 namespace OHOS {
53 namespace AAFwk {
54 namespace {
55 const std::string DEBUG_APP = "debugApp";
56 #ifdef WITH_DLP
57 const std::string DLP_BUNDLE_NAME = "com.ohos.dlpmanager";
58 #endif // WITH_DLP
59 const std::string SHELL_ASSISTANT_BUNDLENAME = "com.huawei.shell_assistant";
60 const std::string SHOW_ON_LOCK_SCREEN = "ShowOnLockScreen";
61 const std::string URI_PERMISSION_TABLE_NAME = "uri_permission";
62 }
63 class AbilityRecordTest : public testing::TestWithParam<OHOS::AAFwk::AbilityState> {
64 public:
65 static void SetUpTestCase(void);
66 static void TearDownTestCase(void);
67 void SetUp();
68 void TearDown();
69 std::shared_ptr<AbilityRecord> GetAbilityRecord();
70
71 std::shared_ptr<AbilityRecord> abilityRecord_{ nullptr };
72 std::shared_ptr<AbilityResult> abilityResult_{ nullptr };
73 std::shared_ptr<AbilityRequest> abilityRequest_{ nullptr };
74 static constexpr unsigned int CHANGE_CONFIG_LOCALE = 0x00000001;
75 };
76
SetUpTestCase(void)77 void AbilityRecordTest::SetUpTestCase(void)
78 {
79 OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
80 OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
81 }
TearDownTestCase(void)82 void AbilityRecordTest::TearDownTestCase(void)
83 {
84 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
85 }
86
SetUp(void)87 void AbilityRecordTest::SetUp(void)
88 {
89 OHOS::AppExecFwk::AbilityInfo abilityInfo;
90 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
91 Want want;
92 abilityRecord_ = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
93 abilityResult_ = std::make_shared<AbilityResult>(-1, -1, want);
94 abilityRequest_ = std::make_shared<AbilityRequest>();
95 abilityRecord_->Init();
96 }
97
TearDown(void)98 void AbilityRecordTest::TearDown(void)
99 {
100 abilityRecord_.reset();
101 }
102
GetAbilityRecord()103 std::shared_ptr<AbilityRecord> AbilityRecordTest::GetAbilityRecord()
104 {
105 Want want;
106 OHOS::AppExecFwk::AbilityInfo abilityInfo;
107 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
108 return std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
109 }
110
IsTestAbilityExist(const std::string & data)111 bool IsTestAbilityExist(const std::string& data)
112 {
113 return std::string::npos != data.find("previous ability app name [NULL]");
114 }
115
IsTestAbilityExist1(const std::string & data)116 bool IsTestAbilityExist1(const std::string& data)
117 {
118 return std::string::npos != data.find("test_pre_app");
119 }
120
IsTestAbilityExist2(const std::string & data)121 bool IsTestAbilityExist2(const std::string& data)
122 {
123 return std::string::npos != data.find("test_next_app");
124 }
125
126 class MockWMSHandler : public IWindowManagerServiceHandler {
127 public:
NotifyWindowTransition(sptr<AbilityTransitionInfo> fromInfo,sptr<AbilityTransitionInfo> toInfo,bool & animaEnabled)128 virtual void NotifyWindowTransition(sptr<AbilityTransitionInfo> fromInfo, sptr<AbilityTransitionInfo> toInfo,
129 bool& animaEnabled)
130 {}
131
GetFocusWindow(sptr<IRemoteObject> & abilityToken)132 virtual int32_t GetFocusWindow(sptr<IRemoteObject>& abilityToken)
133 {
134 return 0;
135 }
136
StartingWindow(sptr<AbilityTransitionInfo> info,std::shared_ptr<Media::PixelMap> pixelMap,uint32_t bgColor)137 virtual void StartingWindow(sptr<AbilityTransitionInfo> info,
138 std::shared_ptr<Media::PixelMap> pixelMap, uint32_t bgColor) {}
139
StartingWindow(sptr<AbilityTransitionInfo> info,std::shared_ptr<Media::PixelMap> pixelMap)140 virtual void StartingWindow(sptr<AbilityTransitionInfo> info, std::shared_ptr<Media::PixelMap> pixelMap) {}
141
CancelStartingWindow(sptr<IRemoteObject> abilityToken)142 virtual void CancelStartingWindow(sptr<IRemoteObject> abilityToken)
143 {}
144
AsObject()145 virtual sptr<IRemoteObject> AsObject()
146 {
147 return nullptr;
148 }
149 };
150
151 /*
152 * Feature: AbilityRecord
153 * Function: GetRecordId
154 * SubFunction: GetRecordId
155 * FunctionPoints: NA
156 * EnvConditions: NA
157 * CaseDescription: Verify create one abilityRecord could through GetRecordId 1
158 */
159 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetRecordId, TestSize.Level1)
160 {
161 EXPECT_EQ(abilityRecord_->GetRecordId(), 0);
162 }
163
164 /*
165 * Feature: AbilityRecord
166 * Function: create AbilityRecord
167 * SubFunction: NA
168 * FunctionPoints: LoadAbility Activate Inactivate MoveToBackground
169 * EnvConditions: NA
170 * CaseDescription: LoadAbility Activate Inactivate MoveToBackground UT.
171 */
172 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_UpdateLifeState, TestSize.Level1)
173 {
174 abilityRecord_->LoadAbility();
175 EXPECT_EQ(abilityRecord_->GetAbilityState(), OHOS::AAFwk::AbilityState::INITIAL);
176 abilityRecord_->Activate();
177 EXPECT_EQ(abilityRecord_->GetAbilityState(), OHOS::AAFwk::AbilityState::ACTIVATING);
178 abilityRecord_->Inactivate();
179 EXPECT_EQ(abilityRecord_->GetAbilityState(), OHOS::AAFwk::AbilityState::INACTIVATING);
180 }
181
182 /*
183 * Feature: AbilityRecord
184 * Function: create AbilityRecord
185 * SubFunction: NA
186 * FunctionPoints: SetAbilityInfo GetAbilityInfo
187 * EnvConditions: NA
188 * CaseDescription: SetAbilityInfo GetAbilityInfo UT.
189 */
190 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetGetAbilityInfo, TestSize.Level1)
191 {
192 Want want;
193 OHOS::AppExecFwk::AbilityInfo abilityInfo;
194 abilityInfo.applicationName = std::string("TestApp");
195 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
196 std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
197 EXPECT_EQ(abilityRecord->GetAbilityInfo().applicationName, std::string("TestApp"));
198 }
199
200 /*
201 * Feature: AbilityRecord
202 * Function: create AbilityRecord
203 * SubFunction: NA
204 * FunctionPoints: SetApplicationInfo GetApplicationInfo
205 * EnvConditions: NA
206 * CaseDescription: SetApplicationInfo GetApplicationInfo UT.
207 */
208 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetGetApplicationInfo, TestSize.Level1)
209 {
210 Want want;
211 OHOS::AppExecFwk::AbilityInfo abilityInfo;
212 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
213 applicationInfo.name = "TestApp";
214 std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
215 EXPECT_EQ(abilityRecord->GetApplicationInfo().name, "TestApp");
216 }
217
218 /*
219 * Feature: AbilityRecord
220 * Function: create AbilityRecord
221 * SubFunction: NA
222 * FunctionPoints: SetAbilityState GetAbilityState
223 * EnvConditions: NA
224 * CaseDescription: SetAbilityState GetAbilityState UT.
225 */
226 HWTEST_P(AbilityRecordTest, AaFwk_AbilityMS_SetGetAbilityState, TestSize.Level1)
227 {
228 OHOS::AAFwk::AbilityState state = GetParam();
229 abilityRecord_->SetAbilityState(state);
230 EXPECT_EQ(static_cast<int>(state), static_cast<int>(abilityRecord_->GetAbilityState()));
231 }
232 INSTANTIATE_TEST_SUITE_P(AbilityRecordTestCaseP, AbilityRecordTest,
233 testing::Values(AbilityState::INITIAL, AbilityState::INACTIVE, AbilityState::ACTIVE, AbilityState::INACTIVATING,
234 AbilityState::ACTIVATING, AbilityState::TERMINATING, AbilityState::FOREGROUND,
235 AbilityState::BACKGROUND, AbilityState::FOREGROUNDING, AbilityState::BACKGROUNDING,
236 AbilityState::FOREGROUND_FAILED, AbilityState::FOREGROUND_INVALID_MODE));
237
238 /*
239 * Feature: AbilityRecord
240 * Function: create AbilityRecord
241 * SubFunction: NA
242 * FunctionPoints: SetAbilityState GetAbilityState
243 * EnvConditions: NA
244 * CaseDescription: SetAbilityState GetAbilityState UT.
245 */
246 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetGetToken, TestSize.Level1)
247 {
248 EXPECT_EQ(Token::GetAbilityRecordByToken(abilityRecord_->GetToken()).get(), abilityRecord_.get());
249 }
250
251 /*
252 * Feature: AbilityRecord
253 * Function: create AbilityRecord
254 * SubFunction: NA
255 * FunctionPoints: SetAbilityState GetAbilityState
256 * EnvConditions: NA
257 * CaseDescription: SetAbilityState GetAbilityState UT.
258 */
259 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetAbilityState, TestSize.Level1)
260 {
261 abilityRecord_->SetAbilityForegroundingFlag();
262 abilityRecord_->SetAbilityState(AbilityState::BACKGROUND);
263 EXPECT_FALSE(abilityRecord_->GetAbilityForegroundingFlag());
264
265 abilityRecord_->SetAbilityForegroundingFlag();
266 abilityRecord_->SetAbilityState(AbilityState::FOREGROUND);
267 EXPECT_TRUE(abilityRecord_->GetAbilityForegroundingFlag());
268 }
269
270 /*
271 * Feature: AbilityRecord
272 * Function: create AbilityRecord
273 * SubFunction: NA
274 * FunctionPoints: SetPreAbilityRecord SetNextAbilityRecord GetPreAbilityRecord GetNextAbilityRecord
275 * EnvConditions: NA
276 * CaseDescription: SetPreAbilityRecord SetNextAbilityRecord GetPreAbilityRecord GetNextAbilityRecord UT.
277 */
278 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetGetPreNextAbilityReocrd, TestSize.Level1)
279 {
280 OHOS::AppExecFwk::AbilityInfo abilityInfo;
281 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
282 Want want;
283 std::shared_ptr<AbilityRecord> preAbilityRecord =
284 std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
285 std::shared_ptr<AbilityRecord> nextAbilityRecord =
286 std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
287 abilityRecord_->SetPreAbilityRecord(preAbilityRecord);
288 abilityRecord_->SetNextAbilityRecord(nextAbilityRecord);
289 EXPECT_EQ(abilityRecord_->GetPreAbilityRecord().get(), preAbilityRecord.get());
290 EXPECT_EQ(abilityRecord_->GetNextAbilityRecord().get(), nextAbilityRecord.get());
291 }
292
293 /*
294 * Feature: AbilityRecord
295 * Function: create AbilityRecord
296 * SubFunction: NA
297 * FunctionPoints: IsReady
298 * EnvConditions: NA
299 * CaseDescription: IsReady UT.
300 */
301 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsReady, TestSize.Level1)
302 {
303 EXPECT_EQ(false, abilityRecord_->IsReady());
304 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
305 abilityRecord_->SetScheduler(scheduler);
306 EXPECT_EQ(true, abilityRecord_->IsReady());
307 }
308
309 /*
310 * Feature: AbilityRecord
311 * Function: create AbilityRecord
312 * SubFunction: NA
313 * FunctionPoints: IsLauncherAbility
314 * EnvConditions: NA
315 * CaseDescription: IsLauncherAbility UT.
316 */
317 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsLauncherAbility, TestSize.Level1)
318 {
319 EXPECT_EQ(false, abilityRecord_->IsLauncherAbility());
320 Want launcherWant;
321 launcherWant.AddEntity(Want::ENTITY_HOME);
322 OHOS::AppExecFwk::AbilityInfo abilityInfo;
323 OHOS::AppExecFwk::ApplicationInfo applicationInfo;
324 std::unique_ptr<AbilityRecord> launcherAbilityRecord =
325 std::make_unique<AbilityRecord>(launcherWant, abilityInfo, applicationInfo);
326 launcherAbilityRecord->Init();
327 EXPECT_EQ(false, launcherAbilityRecord->IsLauncherAbility());
328 }
329
330 /*
331 * Feature: AbilityRecord
332 * Function: Add connection record to ability record' list
333 * SubFunction: NA
334 * FunctionPoints: AddConnectRecordToList
335 * EnvConditions: NA
336 * CaseDescription: AddConnectRecordToList UT.
337 */
338 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_AddConnectRecordToList, TestSize.Level1)
339 {
340 // test1 for input param is null
341 abilityRecord_->AddConnectRecordToList(nullptr);
342 auto connList = abilityRecord_->GetConnectRecordList();
343 EXPECT_EQ(0, static_cast<int>(connList.size()));
344
345 // test2 for adding new connection record to empty list
346 OHOS::sptr<IAbilityConnection> callback1 = new AbilityConnectCallback();
347 auto newConnRecord1 =
348 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback1);
349 abilityRecord_->AddConnectRecordToList(newConnRecord1);
350 connList = abilityRecord_->GetConnectRecordList();
351 EXPECT_EQ(1, static_cast<int>(connList.size()));
352
353 // test3 for adding new connection record to non-empty list
354 OHOS::sptr<IAbilityConnection> callback2 = new AbilityConnectCallback();
355 auto newConnRecord2 =
356 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback2);
357 abilityRecord_->AddConnectRecordToList(newConnRecord2);
358 connList = abilityRecord_->GetConnectRecordList();
359 EXPECT_EQ(2, static_cast<int>(connList.size()));
360
361 // test4 for adding old connection record to non-empty list
362 abilityRecord_->AddConnectRecordToList(newConnRecord2);
363 connList = abilityRecord_->GetConnectRecordList();
364 EXPECT_EQ(2, static_cast<int>(connList.size()));
365
366 // test5 for delete nullptr from list
367 abilityRecord_->RemoveConnectRecordFromList(nullptr);
368 connList = abilityRecord_->GetConnectRecordList();
369 EXPECT_EQ(2, static_cast<int>(connList.size()));
370
371 // test6 for delete no-match member from list
372 auto newConnRecord3 =
373 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback2);
374 abilityRecord_->RemoveConnectRecordFromList(newConnRecord3);
375 connList = abilityRecord_->GetConnectRecordList();
376 EXPECT_EQ(2, static_cast<int>(connList.size()));
377
378 // test7 for delete match member from list
379 abilityRecord_->RemoveConnectRecordFromList(newConnRecord2);
380 connList = abilityRecord_->GetConnectRecordList();
381 EXPECT_EQ(1, static_cast<int>(connList.size()));
382
383 // test8 for get ability unknown type
384 EXPECT_EQ(OHOS::AppExecFwk::AbilityType::UNKNOWN, abilityRecord_->GetAbilityInfo().type);
385 }
386
387 /*
388 * Feature: AbilityRecord
389 * Function: ConvertAbilityState
390 * SubFunction: NA
391 * FunctionPoints: NA
392 * EnvConditions: NA
393 * CaseDescription: Verify ConvertAbilityState convert success
394 */
395 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ConvertAbilityState, TestSize.Level1)
396 {
397 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::INITIAL);
398 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "INITIAL");
399 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::INACTIVE);
400 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "INACTIVE");
401 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
402 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "ACTIVE");
403 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::INACTIVATING);
404 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "INACTIVATING");
405 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVATING);
406 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "ACTIVATING");
407 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::TERMINATING);
408 EXPECT_EQ(abilityRecord_->ConvertAbilityState(abilityRecord_->GetAbilityState()), "TERMINATING");
409 }
410
411 /*
412 * Feature: AbilityRecord
413 * Function: IsTerminating
414 * SubFunction: IsTerminating SetTerminatingState
415 * FunctionPoints: NA
416 * EnvConditions: NA
417 * CaseDescription: Verify IsTerminating SetTerminatingState success
418 */
419 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsTerminating, TestSize.Level1)
420 {
421 abilityRecord_->SetTerminatingState();
422 EXPECT_EQ(abilityRecord_->IsTerminating(), true);
423 }
424
425 /*
426 * Feature: AbilityRecord
427 * Function: Activate
428 * SubFunction: Activate
429 * FunctionPoints: NA
430 * EnvConditions: NA
431 * CaseDescription: Verify lifecycleDeal_ is nullptr cause Activate is not call
432 */
433 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Activate, TestSize.Level1)
434 {
435 abilityRecord_->lifecycleDeal_ = nullptr;
436 abilityRecord_->currentState_ = OHOS::AAFwk::AbilityState::INITIAL;
437 abilityRecord_->Activate();
438 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::INITIAL);
439 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
440 abilityRecord_->Activate();
441 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::ACTIVATING);
442 }
443
444 /*
445 * Feature: AbilityRecord
446 * Function: Inactivate
447 * SubFunction: Inactivate
448 * FunctionPoints: NA
449 * EnvConditions: NA
450 * CaseDescription: Verify lifecycleDeal_ is nullptr cause Inactivate is not call
451 */
452 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Inactivate, TestSize.Level1)
453 {
454 abilityRecord_->lifecycleDeal_ = nullptr;
455 abilityRecord_->currentState_ = OHOS::AAFwk::AbilityState::INITIAL;
456 abilityRecord_->Inactivate();
457 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::INITIAL);
458 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
459 abilityRecord_->Inactivate();
460 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::INACTIVATING);
461 }
462
463 /*
464 * Feature: AbilityRecord
465 * Function: Terminate
466 * SubFunction: Terminate
467 * FunctionPoints: NA
468 * EnvConditions: NA
469 * CaseDescription: Verify lifecycleDeal_ is nullptr cause Terminate is not call
470 */
471 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Terminate, TestSize.Level1)
472 {
473 abilityRecord_->lifecycleDeal_ = nullptr;
474 abilityRecord_->currentState_ = OHOS::AAFwk::AbilityState::INITIAL;
__anonb641e6f80202() 475 abilityRecord_->Terminate([]() {
476
477 });
478 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::INITIAL);
479 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
__anonb641e6f80302() 480 abilityRecord_->Terminate([]() {
481
482 });
483 EXPECT_EQ(abilityRecord_->currentState_, OHOS::AAFwk::AbilityState::TERMINATING);
484 }
485
486 /*
487 * Feature: AbilityRecord
488 * Function: SetScheduler
489 * SubFunction: SetScheduler
490 * FunctionPoints: NA
491 * EnvConditions: NA
492 * CaseDescription: Verify AbilityRecord SetScheduler success
493 */
494 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetScheduler, TestSize.Level1)
495 {
496 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
497 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
498 EXPECT_EQ(false, abilityRecord_->IsReady());
499 abilityRecord_->SetScheduler(scheduler);
500 EXPECT_EQ(true, abilityRecord_->IsReady());
501 }
502
503 /*
504 * Feature: Token
505 * Function: GetAbilityRecordByToken
506 * SubFunction: GetAbilityRecordByToken
507 * FunctionPoints: NA
508 * EnvConditions: NA
509 * CaseDescription: Verify AbilityRecord token GetAbilityRecordByToken success
510 */
511 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetAbilityRecordByToken, TestSize.Level1)
512 {
513 EXPECT_EQ(Token::GetAbilityRecordByToken(abilityRecord_->GetToken()).get(), abilityRecord_.get());
514 EXPECT_EQ(abilityRecord_->GetToken()->GetAbilityRecord(), abilityRecord_);
515 }
516
517 /*
518 * Feature: AbilityRecord
519 * Function: Dump
520 * SubFunction: Dump
521 * FunctionPoints: NA
522 * EnvConditions: NA
523 * CaseDescription: Verify Dump success
524 */
525 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Dump, TestSize.Level1)
526 {
527 std::vector<std::string> info;
528 info.push_back(std::string("0"));
529 abilityRecord_->Dump(info);
530 EXPECT_EQ(std::find_if(info.begin(), info.end(), IsTestAbilityExist) != info.end(), true);
531 Want wantPre;
532 std::string entity = Want::ENTITY_HOME;
533 wantPre.AddEntity(entity);
534
535 std::string testAppName = "test_pre_app";
536 OHOS::AppExecFwk::AbilityInfo abilityInfoPre;
537 abilityInfoPre.applicationName = testAppName;
538 OHOS::AppExecFwk::ApplicationInfo appinfoPre;
539 appinfoPre.name = testAppName;
540
541 auto preAbilityRecord = std::make_shared<AbilityRecord>(wantPre, abilityInfoPre, appinfoPre);
542 abilityRecord_->SetPreAbilityRecord(nullptr);
543 abilityRecord_->Dump(info);
544 abilityRecord_->SetPreAbilityRecord(preAbilityRecord);
545 abilityRecord_->Dump(info);
546
547 Want wantNext;
548 std::string entityNext = Want::ENTITY_HOME;
549 wantNext.AddEntity(entityNext);
550 std::string testAppNameNext = "test_next_app";
551 OHOS::AppExecFwk::AbilityInfo abilityInfoNext;
552 abilityInfoNext.applicationName = testAppNameNext;
553 OHOS::AppExecFwk::ApplicationInfo appinfoNext;
554 appinfoNext.name = testAppNameNext;
555 auto nextAbilityRecord = std::make_shared<AbilityRecord>(wantNext, abilityInfoNext, appinfoNext);
556 abilityRecord_->SetNextAbilityRecord(nullptr);
557 abilityRecord_->Dump(info);
558 abilityRecord_->SetNextAbilityRecord(nextAbilityRecord);
559 abilityRecord_->Dump(info);
560 } // namespace AAFwk
561
562 /*
563 * Feature: AbilityRecord
564 * Function: SetWant GetWant
565 * SubFunction: SetWant GetWant
566 * FunctionPoints: NA
567 * EnvConditions: NA
568 * CaseDescription: Verify SetWant GetWant can get,set success
569 */
570 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Want, TestSize.Level1)
571 {
572 Want want;
573 want.SetFlags(100);
574 want.SetParam("multiThread", true);
575 abilityRecord_->SetWant(want);
576 EXPECT_EQ(want.GetFlags(), abilityRecord_->GetWant().GetFlags());
577 EXPECT_EQ(want.GetBoolParam("multiThread", false), abilityRecord_->GetWant().GetBoolParam("multiThread", false));
578
579 AppExecFwk::AbilityInfo abilityInfo;
580 AppExecFwk::ApplicationInfo applicationInfo;
581 Want debugWant;
582 debugWant.SetParam(DEBUG_APP, true);
583 Want noDebugWant;
584 noDebugWant.SetParam(DEBUG_APP, false);
585
586 AbilityRecord debugAbilityRecord(debugWant, abilityInfo, applicationInfo, 0);
587 EXPECT_TRUE(debugAbilityRecord.GetWant().GetBoolParam(DEBUG_APP, false));
588 debugAbilityRecord.SetWant(noDebugWant);
589 EXPECT_TRUE(debugAbilityRecord.GetWant().GetBoolParam(DEBUG_APP, false));
590
591 AbilityRecord noDebugAbilityRecord(noDebugWant, abilityInfo, applicationInfo, 0);
592 EXPECT_FALSE(noDebugAbilityRecord.GetWant().GetBoolParam(DEBUG_APP, false));
593 debugAbilityRecord.SetWant(debugWant);
594 EXPECT_FALSE(noDebugAbilityRecord.GetWant().GetBoolParam(DEBUG_APP, false));
595 }
596
597 /*
598 * Feature: AbilityRecord
599 * Function: GetRequestCode
600 * SubFunction: GetRequestCode
601 * FunctionPoints: NA
602 * EnvConditions: NA
603 * CaseDescription: Verify GetRequestCode success
604 */
605 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetRequestCode, TestSize.Level1)
606 {
607 EXPECT_EQ(abilityRecord_->GetRequestCode(), -1);
608 }
609
610 /*
611 * Feature: AbilityRecord
612 * Function: GetAbilityTypeString
613 * SubFunction: GetAbilityTypeString
614 * FunctionPoints: NA
615 * EnvConditions: NA
616 * CaseDescription: Verify GetAbilityTypeString can get success
617 */
618 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetAbilityTypeString, TestSize.Level1)
619 {
620 std::string typeStr;
621 std::shared_ptr<AbilityRecord> recordUn;
622 OHOS::AppExecFwk::AbilityInfo ability;
623 OHOS::AppExecFwk::ApplicationInfo appInfo;
624 Want wantUn;
625 recordUn = std::make_shared<AbilityRecord>(wantUn, ability, appInfo);
626 recordUn->GetAbilityTypeString(typeStr);
627 EXPECT_EQ(typeStr, "UNKNOWN");
628
629 std::shared_ptr<AbilityRecord> recordService;
630 OHOS::AppExecFwk::AbilityInfo abilityService;
631 abilityService.type = OHOS::AppExecFwk::AbilityType::SERVICE;
632 OHOS::AppExecFwk::ApplicationInfo appInfoService;
633 Want wantService;
634 recordService = std::make_shared<AbilityRecord>(wantService, abilityService, appInfoService);
635 recordService->GetAbilityTypeString(typeStr);
636 EXPECT_EQ(typeStr, "SERVICE");
637
638 std::shared_ptr<AbilityRecord> recordPage;
639 OHOS::AppExecFwk::AbilityInfo abilityPage;
640 abilityPage.type = OHOS::AppExecFwk::AbilityType::PAGE;
641 OHOS::AppExecFwk::ApplicationInfo appInfoPage;
642 Want wantPage;
643 recordPage = std::make_shared<AbilityRecord>(wantPage, abilityPage, appInfoPage);
644 recordPage->GetAbilityTypeString(typeStr);
645 EXPECT_EQ(typeStr, "PAGE");
646
647 std::shared_ptr<AbilityRecord> recordData;
648 OHOS::AppExecFwk::AbilityInfo abilityData;
649 abilityData.type = OHOS::AppExecFwk::AbilityType::DATA;
650 OHOS::AppExecFwk::ApplicationInfo appInfoData;
651 Want wantData;
652 recordData = std::make_shared<AbilityRecord>(wantData, abilityData, appInfoData);
653 recordData->GetAbilityTypeString(typeStr);
654 EXPECT_EQ(typeStr, "DATA");
655 }
656
657 /*
658 * Feature: AbilityRecord
659 * Function: SetResult GetResult
660 * SubFunction: SetResult GetResult
661 * FunctionPoints: NA
662 * EnvConditions: NA
663 * CaseDescription: Verify SetResult GetResult can get,set success
664 */
665 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_Result, TestSize.Level1)
666 {
667 abilityResult_->requestCode_ = 10;
668 abilityRecord_->SetResult(abilityResult_);
669 EXPECT_EQ(10, abilityRecord_->GetResult()->requestCode_);
670 }
671
672 /*
673 * Feature: AbilityRecord
674 * Function: SendResult
675 * SubFunction: SendResult
676 * FunctionPoints: NA
677 * EnvConditions: NA
678 * CaseDescription: Verify SendResult scheduler is nullptr
679 */
680 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SendResult, TestSize.Level1)
681 {
682 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
683 abilityRecord_->SetScheduler(scheduler);
684 abilityRecord_->SetResult(abilityResult_);
685 abilityRecord_->SendResult(0, 0);
686 EXPECT_EQ(nullptr, abilityRecord_->GetResult());
687 }
688
689 /*
690 * Feature: AbilityRecord
691 * Function: SetConnRemoteObject GetConnRemoteObject
692 * SubFunction: SetConnRemoteObject GetConnRemoteObject
693 * FunctionPoints: NA
694 * EnvConditions: NA
695 * CaseDescription: Verify SetConnRemoteObject GetConnRemoteObject UT
696 */
697 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ConnRemoteObject, TestSize.Level1)
698 {
699 OHOS::sptr<OHOS::IRemoteObject> remote;
700 abilityRecord_->SetConnRemoteObject(remote);
701 EXPECT_EQ(remote, abilityRecord_->GetConnRemoteObject());
702 }
703
704 /*
705 * Feature: AbilityRecord
706 * Function: IsCreateByConnect SetCreateByConnectMode
707 * SubFunction: IsCreateByConnect SetCreateByConnectMode
708 * FunctionPoints: NA
709 * EnvConditions: NA
710 * CaseDescription: Verify IsCreateByConnect SetCreateByConnectMode UT
711 */
712 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateByConnect, TestSize.Level1)
713 {
714 abilityRecord_->SetCreateByConnectMode();
715 EXPECT_EQ(true, abilityRecord_->IsCreateByConnect());
716 }
717
718 /*
719 * Feature: AbilityRecord
720 * Function: IsActiveState
721 * SubFunction: NA
722 * FunctionPoints: NA
723 * EnvConditions: NA
724 * CaseDescription: NA
725 */
726 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_IsActiveState_001, TestSize.Level1)
727 {
728 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::TERMINATING);
729 EXPECT_EQ(false, abilityRecord_->IsActiveState());
730
731 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
732 EXPECT_EQ(true, abilityRecord_->IsActiveState());
733 }
734
735 /*
736 * Feature: AbilityRecord
737 * Function: SetAbilityState
738 * SubFunction: NA
739 * FunctionPoints: NA
740 * EnvConditions: NA
741 * CaseDescription: NA
742 */
743 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetAbilityState_001, TestSize.Level1)
744 {
745 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::TERMINATING);
746 auto state = abilityRecord_->GetAbilityState();
747 EXPECT_EQ(state, OHOS::AAFwk::AbilityState::TERMINATING);
748
749 abilityRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
750 state = abilityRecord_->GetAbilityState();
751 EXPECT_EQ(state, OHOS::AAFwk::AbilityState::ACTIVE);
752 }
753
754 /*
755 * Feature: AbilityRecord
756 * Function: SetSpecifiedFlag
757 * SubFunction: NA
758 * FunctionPoints: NA
759 * EnvConditions: NA
760 * CaseDescription: NA
761 */
762 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetSpecifiedFlag_001, TestSize.Level1)
763 {
764 abilityRecord_->SetSpecifiedFlag("flag");
765 auto flag = abilityRecord_->GetSpecifiedFlag();
766 EXPECT_EQ(flag, "flag");
767 }
768
769 /*
770 * Feature: AbilityRecord
771 * Function: GetAbilityRecordByToken
772 * SubFunction: GetAbilityRecordByToken
773 * FunctionPoints: NA
774 * EnvConditions: NA
775 * CaseDescription: Verify AbilityRecord token GetAbilityRecordByToken
776 */
777 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetAbilityRecordByToken_001, TestSize.Level1)
778 {
779 EXPECT_EQ(Token::GetAbilityRecordByToken(nullptr), nullptr);
780 }
781
782 /*
783 * Feature: AbilityRecord
784 * Function: CreateAbilityRecord
785 * SubFunction: CreateAbilityRecord
786 * FunctionPoints: NA
787 * EnvConditions: NA
788 * CaseDescription: Verify AbilityRecord CreateAbilityRecord
789 */
790 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityRecord_001, TestSize.Level1)
791 {
792 AbilityRequest abilityRequest;
793 std::shared_ptr<AbilityStartSetting> abilityStartSetting = std::make_shared<AbilityStartSetting>();
794 abilityRequest.startSetting = abilityStartSetting;
795 abilityRequest.callType = AbilityCallType::CALL_REQUEST_TYPE;
796 auto res = abilityRecord_->CreateAbilityRecord(abilityRequest);
797 EXPECT_NE(res, nullptr);
798 }
799
800 /*
801 * Feature: AbilityRecord
802 * Function: LoadAbility
803 * SubFunction: LoadAbility
804 * FunctionPoints: NA
805 * EnvConditions: NA
806 * CaseDescription: Verify AbilityRecord LoadAbility
807 */
808 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_LoadAbility_001, TestSize.Level1)
809 {
810 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
811 abilityRecord->abilityInfo_.type = AbilityType::DATA;
812 abilityRecord->applicationInfo_.name = "app";
813 abilityRecord->isLauncherRoot_ = true;
814 abilityRecord->isRestarting_ = true;
815 abilityRecord->isLauncherAbility_ = true;
816 abilityRecord->restartCount_ = 0;
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_002, TestSize.Level1)
830 {
831 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
832 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, abilityRecord);
833 abilityRecord->abilityInfo_.type = AbilityType::DATA;
834 abilityRecord->applicationInfo_.name = "app";
835 abilityRecord->isLauncherRoot_ = true;
836 abilityRecord->isRestarting_ = true;
837 abilityRecord->isLauncherAbility_ = false;
838 abilityRecord->callerList_.push_back(caller);
839 int res = abilityRecord->LoadAbility();
840 EXPECT_EQ(res, ERR_INVALID_VALUE);
841 }
842
843 /*
844 * Feature: AbilityRecord
845 * Function: LoadAbility
846 * SubFunction: LoadAbility
847 * FunctionPoints: NA
848 * EnvConditions: NA
849 * CaseDescription: Verify AbilityRecord LoadAbility
850 */
851 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_LoadAbility_003, TestSize.Level1)
852 {
853 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
854 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, nullptr);
855 abilityRecord->abilityInfo_.type = AbilityType::DATA;
856 abilityRecord->applicationInfo_.name = "app";
857 abilityRecord->isLauncherRoot_ = true;
858 abilityRecord->isRestarting_ = true;
859 abilityRecord->isLauncherAbility_ = true;
860 abilityRecord->restartCount_ = 1;
861 abilityRecord->callerList_.push_back(caller);
862 int res = abilityRecord->LoadAbility();
863 EXPECT_EQ(res, ERR_INVALID_VALUE);
864 }
865
866 /*
867 * Feature: AbilityRecord
868 * Function: LoadAbility
869 * SubFunction: LoadAbility
870 * FunctionPoints: NA
871 * EnvConditions: NA
872 * CaseDescription: Verify AbilityRecord LoadAbility
873 */
874 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_LoadAbility_004, TestSize.Level1)
875 {
876 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
877 abilityRecord->abilityInfo_.type = AbilityType::DATA;
878 abilityRecord->applicationInfo_.name = "app";
879 abilityRecord->isLauncherRoot_ = false;
880 abilityRecord->callerList_.push_back(nullptr);
881 int res = abilityRecord->LoadAbility();
882 EXPECT_EQ(res, ERR_INVALID_VALUE);
883 }
884
885 /*
886 * Feature: AbilityRecord
887 * Function: ForegroundAbility
888 * SubFunction: ForegroundAbility
889 * FunctionPoints: NA
890 * EnvConditions: NA
891 * CaseDescription: Verify AbilityRecord ForegroundAbility
892 */
893 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ForegroundAbility_001, TestSize.Level1)
894 {
895 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
896 uint32_t sceneFlag = 0;
897 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
898 abilityRecord->SetIsNewWant(true);
899 abilityRecord->SetPreAbilityRecord(abilityRecord_);
900 abilityRecord->ForegroundAbility(sceneFlag);
901 }
902
903 /*
904 * Feature: AbilityRecord
905 * Function: ForegroundAbility
906 * SubFunction: ForegroundAbility
907 * FunctionPoints: NA
908 * EnvConditions: NA
909 * CaseDescription: Verify AbilityRecord ForegroundAbility
910 */
911 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ForegroundAbility_002, TestSize.Level1)
912 {
913 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
914 uint32_t sceneFlag = 0;
915 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
916 abilityRecord->SetIsNewWant(true);
917 abilityRecord->SetPreAbilityRecord(nullptr);
918 abilityRecord->ForegroundAbility(sceneFlag);
919 }
920
921 /*
922 * Feature: AbilityRecord
923 * Function: ForegroundAbility
924 * SubFunction: ForegroundAbility
925 * FunctionPoints: NA
926 * EnvConditions: NA
927 * CaseDescription: Verify AbilityRecord ForegroundAbility
928 */
929 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ForegroundAbility_003, TestSize.Level1)
930 {
931 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
932 uint32_t sceneFlag = 0;
933 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
934 abilityRecord->SetIsNewWant(false);
935 abilityRecord->ForegroundAbility(sceneFlag);
936 }
937
938 /*
939 * Feature: AbilityRecord
940 * Function: ForegroundUIExtensionAbility
941 * SubFunction: ForegroundUIExtensionAbility
942 * FunctionPoints: NA
943 * EnvConditions: NA
944 * CaseDescription: Verify AbilityRecord ForegroundUIExtensionAbility
945 */
946 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ForegroundAbility_004, TestSize.Level1)
947 {
948 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
949 EXPECT_NE(abilityRecord, nullptr);
950 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
951 abilityRecord->ForegroundUIExtensionAbility();
952 }
953
954 /*
955 * Feature: AbilityRecord
956 * Function: ProcessForegroundAbility
957 * SubFunction: ProcessForegroundAbility
958 * FunctionPoints: NA
959 * EnvConditions: NA
960 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
961 */
962 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_001, TestSize.Level1)
963 {
964 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
965 uint32_t sceneFlag = 0;
966 abilityRecord->isReady_ = true;
967 abilityRecord->currentState_ = AbilityState::FOREGROUND;
968 abilityRecord->ProcessForegroundAbility(sceneFlag);
969 }
970
971 /*
972 * Feature: AbilityRecord
973 * Function: ProcessForegroundAbility
974 * SubFunction: ProcessForegroundAbility
975 * FunctionPoints: NA
976 * EnvConditions: NA
977 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
978 */
979 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_002, TestSize.Level1)
980 {
981 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
982 uint32_t sceneFlag = 0;
983 abilityRecord->isReady_ = true;
984 abilityRecord->currentState_ = AbilityState::BACKGROUND;
985 abilityRecord->ProcessForegroundAbility(sceneFlag);
986 }
987
988 /*
989 * Feature: AbilityRecord
990 * Function: ProcessForegroundAbility
991 * SubFunction: ProcessForegroundAbility
992 * FunctionPoints: NA
993 * EnvConditions: NA
994 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
995 */
996 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_003, TestSize.Level1)
997 {
998 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
999 uint32_t sceneFlag = 0;
1000 abilityRecord->isReady_ = false;
1001 abilityRecord->ProcessForegroundAbility(sceneFlag);
1002 }
1003
1004 /*
1005 * Feature: AbilityRecord
1006 * Function: GetLabel
1007 * SubFunction: GetLabel
1008 * FunctionPoints: NA
1009 * EnvConditions: NA
1010 * CaseDescription: Verify AbilityRecord GetLabel
1011 */
1012 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetLabel_001, TestSize.Level1)
1013 {
1014 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1015 abilityRecord->applicationInfo_.label = "label";
1016 abilityRecord->abilityInfo_.resourcePath = "resource";
1017 std::string res = abilityRecord->GetLabel();
1018 EXPECT_EQ(res, "label");
1019 }
1020
1021 #ifdef SUPPORT_GRAPHICS
1022 /*
1023 * Feature: AbilityRecord
1024 * Function: ProcessForegroundAbility
1025 * SubFunction: ProcessForegroundAbility
1026 * FunctionPoints: NA
1027 * EnvConditions: NA
1028 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
1029 */
1030 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_004, TestSize.Level1)
1031 {
1032 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1033 std::shared_ptr<AbilityRecord> callerAbility = GetAbilityRecord();
1034 uint32_t sceneFlag = 0;
1035 abilityRecord->currentState_ = AbilityState::FOREGROUND;
1036 abilityRecord->ProcessForegroundAbility(callerAbility, sceneFlag);
1037 }
1038
1039 /*
1040 * Feature: AbilityRecord
1041 * Function: ProcessForegroundAbility
1042 * SubFunction: ProcessForegroundAbility
1043 * FunctionPoints: NA
1044 * EnvConditions: NA
1045 * CaseDescription: Verify AbilityRecord ProcessForegroundAbility
1046 */
1047 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ProcessForegroundAbility_008, TestSize.Level1)
1048 {
1049 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1050 bool isRecent = false;
1051 AbilityRequest abilityRequest;
1052 std::shared_ptr<StartOptions> startOptions = nullptr ;
1053 std::shared_ptr<AbilityRecord> callerAbility;
1054 uint32_t sceneFlag = 1;
1055 abilityRecord->isReady_ = false;
1056 abilityRecord->ProcessForegroundAbility(isRecent, abilityRequest, startOptions, callerAbility, sceneFlag);
1057 }
1058
1059 /*
1060 * Feature: AbilityRecord
1061 * Function: GetWantFromMission
1062 * SubFunction: GetWantFromMission
1063 * FunctionPoints: NA
1064 * EnvConditions: NA
1065 * CaseDescription: Verify AbilityRecord GetWantFromMission
1066 */
1067 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetWantFromMission_001, TestSize.Level1)
1068 {
1069 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1070 auto res = abilityRecord->GetWantFromMission();
1071 EXPECT_EQ(res, nullptr);
1072 }
1073
1074 /*
1075 * Feature: AbilityRecord
1076 * Function: GetWantFromMission
1077 * SubFunction: GetWantFromMission
1078 * FunctionPoints: NA
1079 * EnvConditions: NA
1080 * CaseDescription: Verify AbilityRecord GetWantFromMission
1081 */
1082 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_GetWantFromMission_002, TestSize.Level1)
1083 {
1084 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1085 int32_t missionId = 1;
1086 InnerMissionInfo innerMissionInfo;
1087 Want want;
1088 innerMissionInfo.missionInfo.id = missionId;
1089 innerMissionInfo.missionInfo.want = want;
1090 DelayedSingleton<MissionInfoMgr>::GetInstance()->missionIdMap_[missionId] = true;
1091 DelayedSingleton<MissionInfoMgr>::GetInstance()->missionInfoList_.push_back(innerMissionInfo);
1092 abilityRecord->missionId_ = 1;
1093 int id = DelayedSingleton<MissionInfoMgr>::GetInstance()->GetInnerMissionInfoById(1, innerMissionInfo);
1094 abilityRecord->GetWantFromMission();
1095 EXPECT_EQ(id, 0);
1096 }
1097
1098 /*
1099 * Feature: AbilityRecord
1100 * Function: AnimationTask
1101 * SubFunction: AnimationTask
1102 * FunctionPoints: NA
1103 * EnvConditions: NA
1104 * CaseDescription: Verify AbilityRecord AnimationTask
1105 */
1106 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_AnimationTask_001, TestSize.Level1)
1107 {
1108 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1109 EXPECT_NE(abilityRecord, nullptr);
1110 bool isRecent = true;
1111 AbilityRequest abilityRequest;
1112 std::shared_ptr<StartOptions> startOptions = nullptr ;
1113 std::shared_ptr<AbilityRecord> callerAbility;
1114 abilityRecord->AnimationTask(isRecent, abilityRequest, startOptions, callerAbility);
1115 }
1116
1117 /*
1118 * Feature: AbilityRecord
1119 * Function: SetShowWhenLocked
1120 * SubFunction: SetShowWhenLocked
1121 * FunctionPoints: NA
1122 * EnvConditions: NA
1123 * CaseDescription: Verify AbilityRecord SetShowWhenLocked
1124 */
1125 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetShowWhenLocked_001, TestSize.Level1)
1126 {
1127 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1128 EXPECT_NE(abilityRecord, nullptr);
1129 AbilityInfo abilityInfo;
1130 sptr<AbilityTransitionInfo> info = new AbilityTransitionInfo();
1131 CustomizeData data1;
1132 CustomizeData data2;
1133 data1.name = SHOW_ON_LOCK_SCREEN;
1134 data2.name = "";
1135 abilityInfo.metaData.customizeData.push_back(data1);
1136 abilityInfo.metaData.customizeData.push_back(data2);
1137 info->isShowWhenLocked_ = false;
1138 abilityRecord->SetShowWhenLocked(abilityInfo, info);
1139 }
1140
1141 /*
1142 * Feature: AbilityRecord
1143 * Function: NotifyAnimationFromStartingAbility
1144 * SubFunction: NotifyAnimationFromStartingAbility
1145 * FunctionPoints: NA
1146 * EnvConditions: NA
1147 * CaseDescription: Verify AbilityRecord NotifyAnimationFromStartingAbility
1148 */
1149 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_NotifyAnimationFromStartingAbility_002, TestSize.Level1)
1150 {
1151 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1152 EXPECT_NE(abilityRecord, nullptr);
1153 std::shared_ptr<AbilityRecord> callerAbility = nullptr;
1154 AbilityRequest abilityRequest;
1155 abilityRecord->NotifyAnimationFromStartingAbility(callerAbility, abilityRequest);
1156 }
1157
1158 /*
1159 * Feature: AbilityRecord
1160 * Function: StartingWindowTask
1161 * SubFunction: StartingWindowTask
1162 * FunctionPoints: NA
1163 * EnvConditions: NA
1164 * CaseDescription: Verify AbilityRecord StartingWindowTask
1165 */
1166 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_StartingWindowTask_001, TestSize.Level1)
1167 {
1168 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1169 EXPECT_NE(abilityRecord, nullptr);
1170 bool isRecent = true;
1171 AbilityRequest abilityRequest;
1172 std::shared_ptr<StartOptions> startOptions = std::make_shared<StartOptions>();
1173 abilityRecord->StartingWindowTask(isRecent, true, abilityRequest, startOptions);
1174 abilityRecord->StartingWindowTask(isRecent, false, abilityRequest, startOptions);
1175 }
1176
1177 /*
1178 * Feature: AbilityRecord
1179 * Function: SetWindowModeAndDisplayId
1180 * SubFunction: SetWindowModeAndDisplayId
1181 * FunctionPoints: NA
1182 * EnvConditions: NA
1183 * CaseDescription: Verify AbilityRecord SetWindowModeAndDisplayId
1184 */
1185 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetWindowModeAndDisplayId_001, TestSize.Level1)
1186 {
1187 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1188 EXPECT_NE(abilityRecord, nullptr);
1189 sptr<AbilityTransitionInfo> info = nullptr;
1190 std::shared_ptr<Want> want = nullptr;
1191 abilityRecord->SetWindowModeAndDisplayId(info, want);
1192 }
1193
1194 /*
1195 * Feature: AbilityRecord
1196 * Function: SetWindowModeAndDisplayId
1197 * SubFunction: SetWindowModeAndDisplayId
1198 * FunctionPoints: NA
1199 * EnvConditions: NA
1200 * CaseDescription: Verify AbilityRecord SetWindowModeAndDisplayId
1201 */
1202 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetWindowModeAndDisplayId_002, TestSize.Level1)
1203 {
1204 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1205 EXPECT_NE(abilityRecord, nullptr);
1206 sptr<AbilityTransitionInfo> info = new AbilityTransitionInfo();
1207 std::shared_ptr<Want> want = std::make_shared<Want>();
1208 want->SetParam(Want::PARAM_RESV_WINDOW_MODE, 1);
1209 want->SetParam(Want::PARAM_RESV_DISPLAY_ID, 1);
1210 abilityRecord->SetWindowModeAndDisplayId(info, want);
1211 }
1212
1213 /*
1214 * Feature: AbilityRecord
1215 * Function: SetWindowModeAndDisplayId
1216 * SubFunction: SetWindowModeAndDisplayId
1217 * FunctionPoints: NA
1218 * EnvConditions: NA
1219 * CaseDescription: Verify AbilityRecord SetWindowModeAndDisplayId
1220 */
1221 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_SetWindowModeAndDisplayId_003, TestSize.Level1)
1222 {
1223 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1224 EXPECT_NE(abilityRecord, nullptr);
1225 sptr<AbilityTransitionInfo> info = new AbilityTransitionInfo();
1226 std::shared_ptr<Want> want = std::make_shared<Want>();
1227 want->SetParam(Want::PARAM_RESV_WINDOW_MODE, -1);
1228 want->SetParam(Want::PARAM_RESV_DISPLAY_ID, -1);
1229 abilityRecord->SetWindowModeAndDisplayId(info, want);
1230 }
1231
1232 /*
1233 * Feature: AbilityRecord
1234 * Function: CreateAbilityTransitionInfo
1235 * SubFunction: CreateAbilityTransitionInfo
1236 * FunctionPoints: NA
1237 * EnvConditions: NA
1238 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1239 */
1240 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_001, TestSize.Level1)
1241 {
1242 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1243 EXPECT_NE(abilityRecord, nullptr);
1244 std::shared_ptr<StartOptions> startOptions = nullptr;
1245 std::shared_ptr<Want> want = std::make_shared<Want>();
1246 abilityRecord->CreateAbilityTransitionInfo(startOptions, want);
1247 }
1248
1249 /*
1250 * Feature: AbilityRecord
1251 * Function: CreateAbilityTransitionInfo
1252 * SubFunction: CreateAbilityTransitionInfo
1253 * FunctionPoints: NA
1254 * EnvConditions: NA
1255 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1256 */
1257 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_002, TestSize.Level1)
1258 {
1259 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1260 EXPECT_NE(abilityRecord, nullptr);
1261 std::shared_ptr<StartOptions> startOptions = std::make_shared<StartOptions>();
1262 std::shared_ptr<Want> want = std::make_shared<Want>();
1263 startOptions->SetWindowMode(1);
1264 startOptions->SetDisplayID(1);
1265 abilityRecord->CreateAbilityTransitionInfo(startOptions, want);
1266 }
1267
1268 /*
1269 * Feature: AbilityRecord
1270 * Function: CreateAbilityTransitionInfo
1271 * SubFunction: CreateAbilityTransitionInfo
1272 * FunctionPoints: NA
1273 * EnvConditions: NA
1274 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1275 */
1276 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_003, TestSize.Level1)
1277 {
1278 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1279 EXPECT_NE(abilityRecord, nullptr);
1280 AbilityRequest abilityRequest;
1281 abilityRequest.startSetting = nullptr;
1282 abilityRecord->CreateAbilityTransitionInfo(abilityRequest);
1283 }
1284
1285 /*
1286 * Feature: AbilityRecord
1287 * Function: CreateAbilityTransitionInfo
1288 * SubFunction: CreateAbilityTransitionInfo
1289 * FunctionPoints: NA
1290 * EnvConditions: NA
1291 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1292 */
1293 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_004, TestSize.Level1)
1294 {
1295 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1296 EXPECT_NE(abilityRecord, nullptr);
1297 AbilityRequest abilityRequest;
1298 std::shared_ptr<AbilityStartSetting> startSetting = std::make_shared<AbilityStartSetting>();
1299 startSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, "windowMode");
1300 startSetting->AddProperty(AbilityStartSetting::WINDOW_DISPLAY_ID_KEY, "displayId");
1301 abilityRequest.startSetting = startSetting;
1302 abilityRecord->CreateAbilityTransitionInfo(abilityRequest);
1303 }
1304
1305 /*
1306 * Feature: AbilityRecord
1307 * Function: CreateAbilityTransitionInfo
1308 * SubFunction: CreateAbilityTransitionInfo
1309 * FunctionPoints: NA
1310 * EnvConditions: NA
1311 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1312 */
1313 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_005, TestSize.Level1)
1314 {
1315 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1316 EXPECT_NE(abilityRecord, nullptr);
1317 std::shared_ptr<StartOptions> startOptions = nullptr;
1318 std::shared_ptr<Want> want = std::make_shared<Want>();
1319 AbilityRequest abilityRequest;
1320 std::shared_ptr<AbilityStartSetting> startSetting = std::make_shared<AbilityStartSetting>();
1321 startSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, "windowMode");
1322 startSetting->AddProperty(AbilityStartSetting::WINDOW_DISPLAY_ID_KEY, "displayId");
1323 abilityRequest.startSetting = startSetting;
1324 abilityRecord->CreateAbilityTransitionInfo(startOptions, want, abilityRequest);
1325 }
1326
1327 /*
1328 * Feature: AbilityRecord
1329 * Function: CreateAbilityTransitionInfo
1330 * SubFunction: CreateAbilityTransitionInfo
1331 * FunctionPoints: NA
1332 * EnvConditions: NA
1333 * CaseDescription: Verify AbilityRecord CreateAbilityTransitionInfo
1334 */
1335 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateAbilityTransitionInfo_006, TestSize.Level1)
1336 {
1337 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1338 EXPECT_NE(abilityRecord, nullptr);
1339 std::shared_ptr<StartOptions> startOptions = std::make_shared<StartOptions>();
1340 std::shared_ptr<Want> want = std::make_shared<Want>();
1341 AbilityRequest abilityRequest;
1342 abilityRecord->CreateAbilityTransitionInfo(startOptions, want, abilityRequest);
1343 }
1344
1345 /*
1346 * Feature: AbilityRecord
1347 * Function: CreateResourceManager
1348 * SubFunction: CreateResourceManager
1349 * FunctionPoints: NA
1350 * EnvConditions: NA
1351 * CaseDescription: Verify AbilityRecord CreateResourceManager
1352 */
1353 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_CreateResourceManager_001, TestSize.Level1)
1354 {
1355 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1356 system::SetParameter(COMPRESS_PROPERTY, "1");
1357 abilityRecord->abilityInfo_.hapPath = "path";
1358 auto res = abilityRecord->CreateResourceManager();
1359 EXPECT_EQ(res, nullptr);
1360 }
1361
1362 /*
1363 * Feature: AbilityRecord
1364 * Function: GetPixelMap
1365 * SubFunction: GetPixelMap
1366 * FunctionPoints: NA
1367 * EnvConditions: NA
1368 * CaseDescription: Verify AbilityRecord GetPixelMap
1369 */
1370 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPixelMap_001, TestSize.Level1)
1371 {
1372 EXPECT_EQ(abilityRecord_->GetPixelMap(1, nullptr), nullptr);
1373 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager());
1374 EXPECT_EQ(abilityRecord_->GetPixelMap(1, resourceMgr), nullptr);
1375 }
1376
1377 /*
1378 * Feature: AbilityRecord
1379 * Function: GetPixelMap
1380 * SubFunction: GetPixelMap
1381 * FunctionPoints: NA
1382 * EnvConditions: NA
1383 * CaseDescription: Verify AbilityRecord GetPixelMap
1384 */
1385 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPixelMap_002, TestSize.Level1)
1386 {
1387 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1388 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager());
1389 system::SetParameter(COMPRESS_PROPERTY, "1");
1390 abilityRecord->abilityInfo_.hapPath = "path";
1391 auto res = abilityRecord->GetPixelMap(1, resourceMgr);
1392 EXPECT_EQ(res, nullptr);
1393 }
1394
1395 /*
1396 * Feature: AbilityRecord
1397 * Function: StartingWindowHot
1398 * SubFunction: StartingWindowHot
1399 * FunctionPoints: NA
1400 * EnvConditions: NA
1401 * CaseDescription: Verify AbilityRecord StartingWindowHot
1402 */
1403 HWTEST_F(AbilityRecordTest, AbilityRecord_StartingWindowHot_001, TestSize.Level1)
1404 {
1405 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1406 EXPECT_NE(abilityRecord, nullptr);
1407 std::shared_ptr<StartOptions> startOptions = std::make_shared<StartOptions>();
1408 std::shared_ptr<Want> want = std::make_shared<Want>();
1409 AbilityRequest abilityRequest;
1410 abilityRecord->StartingWindowHot(startOptions, want, abilityRequest);
1411 }
1412
1413 /*
1414 * Feature: AbilityRecord
1415 * Function: GetColdStartingWindowResource
1416 * SubFunction: GetColdStartingWindowResource
1417 * FunctionPoints: NA
1418 * EnvConditions: NA
1419 * CaseDescription: Verify AbilityRecord GetColdStartingWindowResource
1420 */
1421 HWTEST_F(AbilityRecordTest, AbilityRecord_GetColdStartingWindowResource_001, TestSize.Level1)
1422 {
1423 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1424 EXPECT_NE(abilityRecord, nullptr);
1425 std::shared_ptr<Media::PixelMap> bg;
1426 uint32_t bgColor = 0;
1427 abilityRecord->startingWindowBg_ = std::make_shared<Media::PixelMap>();
1428 abilityRecord->GetColdStartingWindowResource(bg, bgColor);
1429 abilityRecord->startingWindowBg_ = nullptr;
1430 abilityRecord->GetColdStartingWindowResource(bg, bgColor);
1431 }
1432
1433 /*
1434 * Feature: AbilityRecord
1435 * Function: InitColdStartingWindowResource
1436 * SubFunction: InitColdStartingWindowResource
1437 * FunctionPoints: NA
1438 * EnvConditions: NA
1439 * CaseDescription: Verify AbilityRecord InitColdStartingWindowResource
1440 */
1441 HWTEST_F(AbilityRecordTest, AbilityRecord_InitColdStartingWindowResource_001, TestSize.Level1)
1442 {
1443 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1444 EXPECT_NE(abilityRecord, nullptr);
1445 std::shared_ptr<Global::Resource::ResourceManager> resourceMgr(Global::Resource::CreateResourceManager());
1446 abilityRecord->InitColdStartingWindowResource(nullptr);
1447 abilityRecord->InitColdStartingWindowResource(resourceMgr);
1448 }
1449 #endif
1450
1451 /*
1452 * Feature: AbilityRecord
1453 * Function: SetPendingState
1454 * SubFunction: SetPendingState
1455 * FunctionPoints: NA
1456 * EnvConditions: NA
1457 * CaseDescription: set AbilityRecord pending state
1458 */
1459 HWTEST_F(AbilityRecordTest, AbilityRecord_SetPendingState_001, TestSize.Level1)
1460 {
1461 abilityRecord_->SetPendingState(OHOS::AAFwk::AbilityState::FOREGROUND);
1462 EXPECT_EQ(abilityRecord_->GetPendingState(), OHOS::AAFwk::AbilityState::FOREGROUND);
1463 }
1464
1465 #ifdef SUPPORT_GRAPHICS
1466 /*
1467 * Feature: AbilityRecord
1468 * Function: PostCancelStartingWindowHotTask
1469 * FunctionPoints: NA
1470 * EnvConditions: NA
1471 * CaseDescription: PostCancelStartingWindowHotTask
1472 */
1473 HWTEST_F(AbilityRecordTest, AbilityRecord_PostCancelStartingWindowHotTask_001, TestSize.Level1)
1474 {
1475 AppExecFwk::AbilityInfo abilityInfo;
1476 AppExecFwk::ApplicationInfo applicationInfo;
1477
1478 Want debugWant;
1479 debugWant.SetParam(DEBUG_APP, true);
1480 AbilityRecord debugAbilityRecord(debugWant, abilityInfo, applicationInfo, 0);
1481 debugAbilityRecord.PostCancelStartingWindowHotTask();
1482 EXPECT_TRUE(debugAbilityRecord.GetWant().GetBoolParam(DEBUG_APP, false));
1483
1484 Want noDebugWant;
1485 noDebugWant.SetParam(DEBUG_APP, false);
1486 AbilityRecord noDebugAbilityRecord(noDebugWant, abilityInfo, applicationInfo, 0);
1487 noDebugAbilityRecord.PostCancelStartingWindowHotTask();
1488 EXPECT_FALSE(noDebugAbilityRecord.GetWant().GetBoolParam(DEBUG_APP, false));
1489 }
1490
1491 /*
1492 * Feature: AbilityRecord
1493 * Function: PostCancelStartingWindowColdTask
1494 * SubFunction: PostCancelStartingWindowColdTask
1495 * FunctionPoints: NA
1496 * EnvConditions: NA
1497 * CaseDescription: PostCancelStartingWindowColdTask
1498 */
1499 HWTEST_F(AbilityRecordTest, AbilityRecord_PostCancelStartingWindowColdTask_001, TestSize.Level1)
1500 {
1501 AppExecFwk::AbilityInfo abilityInfo;
1502 AppExecFwk::ApplicationInfo applicationInfo;
1503
1504 Want debugWant;
1505 debugWant.SetParam(DEBUG_APP, true);
1506 AbilityRecord debugAbilityRecord(debugWant, abilityInfo, applicationInfo, 0);
1507 debugAbilityRecord.PostCancelStartingWindowColdTask();
1508 EXPECT_TRUE(debugAbilityRecord.GetWant().GetBoolParam(DEBUG_APP, false));
1509
1510 Want noDebugWant;
1511 noDebugWant.SetParam(DEBUG_APP, false);
1512 AbilityRecord noDebugAbilityRecord(noDebugWant, abilityInfo, applicationInfo, 0);
1513 noDebugAbilityRecord.PostCancelStartingWindowColdTask();
1514 EXPECT_FALSE(noDebugAbilityRecord.GetWant().GetBoolParam(DEBUG_APP, false));
1515 }
1516
1517 /*
1518 * Feature: AbilityRecord
1519 * Function: CreateResourceManager
1520 * SubFunction: CreateResourceManager
1521 * FunctionPoints: NA
1522 * EnvConditions: NA
1523 * CaseDescription: CreateResourceManager
1524 */
1525 HWTEST_F(AbilityRecordTest, AbilityRecord_CreateResourceManager_001, TestSize.Level1)
1526 {
1527 Want want;
1528 AppExecFwk::AbilityInfo abilityInfo;
1529 AppExecFwk::ApplicationInfo applicationInfo;
1530 AbilityRecord abilityRecord(want, abilityInfo, applicationInfo, 0);
1531 EXPECT_TRUE(abilityRecord.CreateResourceManager() == nullptr);
1532
1533 abilityInfo.hapPath = "abc";
1534 EXPECT_TRUE(abilityRecord.CreateResourceManager() == nullptr);
1535
1536 abilityInfo.resourcePath = "abc";
1537 abilityInfo.hapPath = "";
1538 EXPECT_TRUE(abilityRecord.CreateResourceManager() == nullptr);
1539
1540 abilityInfo.hapPath = "abc";
1541 EXPECT_TRUE(abilityRecord.CreateResourceManager() == nullptr);
1542 }
1543 #endif
1544
1545 /*
1546 * Feature: AbilityRecord
1547 * Function: BackgroundAbility
1548 * SubFunction: BackgroundAbility
1549 * FunctionPoints: NA
1550 * EnvConditions: NA
1551 * CaseDescription: Verify AbilityRecord BackgroundAbility
1552 */
1553 HWTEST_F(AbilityRecordTest, AbilityRecord_BackgroundAbility_001, TestSize.Level1)
1554 {
1555 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1556 Closure task;
1557 EXPECT_FALSE(task);
1558 abilityRecord->lifecycleDeal_ = nullptr;
1559 abilityRecord->BackgroundAbility(task);
1560 }
1561
1562 /*
1563 * Feature: AbilityRecord
1564 * Function: BackgroundAbility
1565 * SubFunction: BackgroundAbility
1566 * FunctionPoints: NA
1567 * EnvConditions: NA
1568 * CaseDescription: Verify AbilityRecord BackgroundAbility
1569 */
1570 HWTEST_F(AbilityRecordTest, AbilityRecord_BackgroundAbility_002, TestSize.Level1)
1571 {
1572 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
__anonb641e6f80402() 1573 Closure task = []() {};
1574 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
1575 abilityRecord->want_.SetParam(DEBUG_APP, false);
1576 abilityRecord->SetTerminatingState();
1577 abilityRecord->SetRestarting(false, 0);
1578 abilityRecord->BackgroundAbility(task);
1579 }
1580
1581 /*
1582 * Feature: AbilityRecord
1583 * Function: BackgroundAbility
1584 * SubFunction: BackgroundAbility
1585 * FunctionPoints: NA
1586 * EnvConditions: NA
1587 * CaseDescription: Verify AbilityRecord BackgroundAbility
1588 */
1589 HWTEST_F(AbilityRecordTest, AbilityRecord_BackgroundAbility_003, TestSize.Level1)
1590 {
1591 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
__anonb641e6f80502() 1592 Closure task = []() {};
1593 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
1594 abilityRecord->want_.SetParam(DEBUG_APP, true);
1595 abilityRecord->SetTerminatingState();
1596 abilityRecord->SetRestarting(true, 0);
1597 abilityRecord->BackgroundAbility(task);
1598 }
1599
1600 /*
1601 * Feature: AbilityRecord
1602 * Function: SetScheduler
1603 * SubFunction: SetScheduler
1604 * FunctionPoints: NA
1605 * EnvConditions: NA
1606 * CaseDescription: Verify AbilityRecord SetScheduler
1607 */
1608 HWTEST_F(AbilityRecordTest, AbilityRecord_SetScheduler_001, TestSize.Level1)
1609 {
1610 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1611 sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
1612 abilityRecord->scheduler_ = scheduler;
1613 abilityRecord->schedulerDeathRecipient_ =
__anonb641e6f80602(const wptr<IRemoteObject> &remote) 1614 new AbilitySchedulerRecipient([abilityRecord](const wptr<IRemoteObject> &remote) {});
1615 abilityRecord->SetScheduler(scheduler);
1616 }
1617
1618 /*
1619 * Feature: AbilityRecord
1620 * Function: SetScheduler
1621 * SubFunction: SetScheduler
1622 * FunctionPoints: NA
1623 * EnvConditions: NA
1624 * CaseDescription: Verify AbilityRecord SetScheduler
1625 */
1626 HWTEST_F(AbilityRecordTest, AbilityRecord_SetScheduler_002, TestSize.Level1)
1627 {
1628 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1629 sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
1630 abilityRecord->scheduler_ = scheduler;
1631 abilityRecord->schedulerDeathRecipient_ = nullptr;
1632 abilityRecord->SetScheduler(scheduler);
1633 }
1634
1635 /*
1636 * Feature: AbilityRecord
1637 * Function: SetScheduler
1638 * SubFunction: SetScheduler
1639 * FunctionPoints: NA
1640 * EnvConditions: NA
1641 * CaseDescription: Verify AbilityRecord SetScheduler
1642 */
1643 HWTEST_F(AbilityRecordTest, AbilityRecord_SetScheduler_003, TestSize.Level1)
1644 {
1645 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1646 sptr<IAbilityScheduler> scheduler = nullptr;
1647 abilityRecord->scheduler_ = new AbilityScheduler();
1648 abilityRecord->schedulerDeathRecipient_ = nullptr;
1649 abilityRecord->SetScheduler(scheduler);
1650 }
1651
1652 /*
1653 * Feature: AbilityRecord
1654 * Function: Activate
1655 * SubFunction: Activate
1656 * FunctionPoints: NA
1657 * EnvConditions: NA
1658 * CaseDescription: Verify AbilityRecord Activate
1659 */
1660 HWTEST_F(AbilityRecordTest, AbilityRecord_Activate_001, TestSize.Level1)
1661 {
1662 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1663 abilityRecord->SetIsNewWant(true);
1664 abilityRecord->SetPreAbilityRecord(abilityRecord_);
1665 abilityRecord->Activate();
1666 }
1667
1668 /*
1669 * Feature: AbilityRecord
1670 * Function: Activate
1671 * SubFunction: Activate
1672 * FunctionPoints: NA
1673 * EnvConditions: NA
1674 * CaseDescription: Verify AbilityRecord Activate
1675 */
1676 HWTEST_F(AbilityRecordTest, AbilityRecord_Activate_002, TestSize.Level1)
1677 {
1678 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1679 abilityRecord->SetIsNewWant(true);
1680 abilityRecord->SetPreAbilityRecord(nullptr);
1681 abilityRecord->Activate();
1682 }
1683
1684 /*
1685 * Feature: AbilityRecord
1686 * Function: Terminate
1687 * SubFunction: Terminate
1688 * FunctionPoints: NA
1689 * EnvConditions: NA
1690 * CaseDescription: Verify AbilityRecord Terminate
1691 */
1692 HWTEST_F(AbilityRecordTest, AbilityRecord_Terminate_001, TestSize.Level1)
1693 {
1694 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
__anonb641e6f80702() 1695 Closure task = []() {};
1696 abilityRecord->want_.SetParam(DEBUG_APP, true);
1697 abilityRecord->Terminate(task);
1698 }
1699
1700 /*
1701 * Feature: AbilityRecord
1702 * Function: SendResultToCallers
1703 * SubFunction: SendResultToCallers
1704 * FunctionPoints: NA
1705 * EnvConditions: NA
1706 * CaseDescription: Verify AbilityRecord SendResultToCallers
1707 */
1708 HWTEST_F(AbilityRecordTest, AbilityRecord_SendResultToCallers_001, TestSize.Level1)
1709 {
1710 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1711 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1712 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1713 std::shared_ptr<AbilityResult> result = std::make_shared<AbilityResult>();
1714 callerAbilityRecord->SetResult(result);
1715 abilityRecord->callerList_.push_back(nullptr);
1716 abilityRecord->callerList_.push_back(caller);
1717 abilityRecord->SendResultToCallers();
1718 }
1719
1720 /*
1721 * Feature: AbilityRecord
1722 * Function: SendResultToCallers
1723 * SubFunction: SendResultToCallers
1724 * FunctionPoints: NA
1725 * EnvConditions: NA
1726 * CaseDescription: Verify AbilityRecord SendResultToCallers
1727 */
1728 HWTEST_F(AbilityRecordTest, AbilityRecord_SendResultToCallers_002, TestSize.Level1)
1729 {
1730 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1731 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1732 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1733 std::shared_ptr<AbilityResult> result = std::make_shared<AbilityResult>();
1734 std::string srcAbilityId = "id";
1735 callerAbilityRecord->SetResult(nullptr);
1736 caller->saCaller_ = std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, abilityRecord->GetToken());
1737 abilityRecord->callerList_.push_back(caller);
1738 abilityRecord->SendResultToCallers();
1739 }
1740
1741 /*
1742 * Feature: AbilityRecord
1743 * Function: SendResultToCallers
1744 * SubFunction: SendResultToCallers
1745 * FunctionPoints: NA
1746 * EnvConditions: NA
1747 * CaseDescription: Verify AbilityRecord SendResultToCallers
1748 */
1749 HWTEST_F(AbilityRecordTest, AbilityRecord_SendResultToCallers_003, TestSize.Level1)
1750 {
1751 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1752 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, nullptr);
1753 caller->saCaller_ = nullptr;
1754 abilityRecord->callerList_.push_back(caller);
1755 abilityRecord->SendResultToCallers();
1756 }
1757
1758 /*
1759 * Feature: AbilityRecord
1760 * Function: SaveResultToCallers
1761 * SubFunction: SaveResultToCallers
1762 * FunctionPoints: NA
1763 * EnvConditions: NA
1764 * CaseDescription: Verify AbilityRecord SaveResultToCallers
1765 */
1766 HWTEST_F(AbilityRecordTest, AbilityRecord_SaveResultToCallers_001, TestSize.Level1)
1767 {
1768 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1769 EXPECT_NE(abilityRecord, nullptr);
1770 int resultCode = 0;
1771 Want *resultWant;
1772 abilityRecord->callerList_.clear();
1773 abilityRecord->SaveResultToCallers(resultCode, resultWant);
1774 }
1775
1776 /*
1777 * Feature: AbilityRecord
1778 * Function: SaveResultToCallers
1779 * SubFunction: SaveResultToCallers
1780 * FunctionPoints: NA
1781 * EnvConditions: NA
1782 * CaseDescription: Verify AbilityRecord SaveResultToCallers
1783 */
1784 HWTEST_F(AbilityRecordTest, AbilityRecord_SaveResultToCallers_002, TestSize.Level1)
1785 {
1786 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1787 EXPECT_NE(abilityRecord, nullptr);
1788 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1789 std::shared_ptr<CallerRecord> caller1 = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1790 std::shared_ptr<CallerRecord> caller2 = std::make_shared<CallerRecord>();
1791 int resultCode = 0;
1792 Want *resultWant = new Want();
1793 abilityRecord->callerList_.push_back(nullptr);
1794 abilityRecord->callerList_.push_back(caller1);
1795 abilityRecord->callerList_.push_back(caller2);
1796 abilityRecord->SaveResultToCallers(resultCode, resultWant);
1797 }
1798
1799 /*
1800 * Feature: AbilityRecord
1801 * Function: SaveResult
1802 * SubFunction: SaveResult
1803 * FunctionPoints: NA
1804 * EnvConditions: NA
1805 * CaseDescription: Verify AbilityRecord SaveResult
1806 */
1807 HWTEST_F(AbilityRecordTest, AbilityRecord_SaveResult_001, TestSize.Level1)
1808 {
1809 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1810 EXPECT_NE(abilityRecord, nullptr);
1811 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1812 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1813 int resultCode = 0;
1814 Want *resultWant = new Want();
1815 caller->saCaller_ = nullptr;
1816 abilityRecord->SaveResult(resultCode, resultWant, caller);
1817 }
1818
1819 /*
1820 * Feature: AbilityRecord
1821 * Function: SaveResult
1822 * SubFunction: SaveResult
1823 * FunctionPoints: NA
1824 * EnvConditions: NA
1825 * CaseDescription: Verify AbilityRecord SaveResult
1826 */
1827 HWTEST_F(AbilityRecordTest, AbilityRecord_SaveResult_002, TestSize.Level1)
1828 {
1829 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1830 EXPECT_NE(abilityRecord, nullptr);
1831 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, nullptr);
1832 std::string srcAbilityId = "id";
1833 int resultCode = 0;
1834 Want *resultWant = new Want();
1835 caller->saCaller_ = std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, abilityRecord->GetToken());
1836 abilityRecord->SaveResult(resultCode, resultWant, caller);
1837 }
1838
1839 /*
1840 * Feature: AbilityRecord
1841 * Function: SetResultToSystemAbility
1842 * SubFunction: SetResultToSystemAbility
1843 * FunctionPoints: NA
1844 * EnvConditions: NA
1845 * CaseDescription: Verify SystemAbilityCallerRecord SetResultToSystemAbility
1846 */
1847 HWTEST_F(AbilityRecordTest, SystemAbilityCallerRecord_SetResultToSystemAbility_001, TestSize.Level1)
1848 {
1849 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1850 EXPECT_NE(abilityRecord, nullptr);
1851 std::string srcAbilityId = "srcAbility_id";
1852 std::shared_ptr<SystemAbilityCallerRecord> systemAbilityRecord =
1853 std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, abilityRecord->GetToken());
1854 Want resultWant;
1855 int resultCode = 1;
1856 systemAbilityRecord->SetResultToSystemAbility(systemAbilityRecord, resultWant, resultCode);
1857 }
1858
1859 /*
1860 * Feature: AbilityRecord
1861 * Function: SendResultToSystemAbility
1862 * SubFunction: SendResultToSystemAbility
1863 * FunctionPoints: NA
1864 * EnvConditions: NA
1865 * CaseDescription: Verify SystemAbilityCallerRecord SendResultToSystemAbility
1866 */
1867 HWTEST_F(AbilityRecordTest, SystemAbilityCallerRecord_SendResultToSystemAbility_001, TestSize.Level1)
1868 {
1869 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1870 std::string srcAbilityId = "srcAbility_id";
1871 std::shared_ptr<SystemAbilityCallerRecord> systemAbilityRecord =
1872 std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, abilityRecord->GetToken());
1873 int requestCode = 0;
1874 int32_t callerUid = 0;
1875 uint32_t accessToken = 0;
1876 systemAbilityRecord->SendResultToSystemAbility(requestCode, systemAbilityRecord, callerUid, accessToken, false);
1877 }
1878
1879 /*
1880 * Feature: AbilityRecord
1881 * Function: AddCallerRecord
1882 * SubFunction: AddCallerRecord
1883 * FunctionPoints: NA
1884 * EnvConditions: NA
1885 * CaseDescription: Verify AbilityRecord AddCallerRecord
1886 */
1887 HWTEST_F(AbilityRecordTest, AbilityRecord_AddCallerRecord_001, TestSize.Level1)
1888 {
1889 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1890 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1891 callerAbilityRecord->Init();
1892 sptr<IRemoteObject> callerToken = callerAbilityRecord->GetToken();
1893 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(0, callerAbilityRecord);
1894 abilityRecord->callerList_.push_back(caller);
1895 int requestCode = 0;
1896 Want want;
1897 std::string srcAbilityId = "srcAbility_id";
1898 abilityRecord->AddCallerRecord(callerToken, requestCode, want, srcAbilityId);
1899 }
1900
1901 /*
1902 * Feature: AbilityRecord
1903 * Function: IsSystemAbilityCall
1904 * SubFunction: IsSystemAbilityCall
1905 * FunctionPoints: NA
1906 * EnvConditions: NA
1907 * CaseDescription: Verify AbilityRecord IsSystemAbilityCall
1908 */
1909 HWTEST_F(AbilityRecordTest, AbilityRecord_IsSystemAbilityCall_001, TestSize.Level1)
1910 {
1911 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1912 bool res1 = abilityRecord->IsSystemAbilityCall(nullptr);
1913 EXPECT_FALSE(res1);
1914 std::shared_ptr<AbilityRecord> callerAbilityRecord = GetAbilityRecord();
1915 sptr<IRemoteObject> callerToken = callerAbilityRecord->GetToken();
1916 bool res2 = abilityRecord->IsSystemAbilityCall(callerToken);
1917 EXPECT_FALSE(res2);
1918 callerAbilityRecord->Init();
1919 callerToken = callerAbilityRecord->GetToken();
1920 bool res3 = abilityRecord->IsSystemAbilityCall(callerToken);
1921 EXPECT_FALSE(res3);
1922 }
1923
1924 /*
1925 * Feature: AbilityRecord
1926 * Function: AddSystemAbilityCallerRecord
1927 * SubFunction: AddSystemAbilityCallerRecord
1928 * FunctionPoints: NA
1929 * EnvConditions: NA
1930 * CaseDescription: Verify AbilityRecord AddSystemAbilityCallerRecord
1931 */
1932 HWTEST_F(AbilityRecordTest, AbilityRecord_AddSystemAbilityCallerRecord_001, TestSize.Level1)
1933 {
1934 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1935 EXPECT_NE(abilityRecord, nullptr);
1936 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
1937 int requestCode = 0;
1938 std::string srcAbilityId = "srcAbility_id";
1939 abilityRecord->callerList_.clear();
1940 abilityRecord->AddSystemAbilityCallerRecord(callerToken, requestCode, srcAbilityId);
1941 }
1942
1943 /*
1944 * Feature: AbilityRecord
1945 * Function: AddSystemAbilityCallerRecord
1946 * SubFunction: AddSystemAbilityCallerRecord
1947 * FunctionPoints: NA
1948 * EnvConditions: NA
1949 * CaseDescription: Verify AbilityRecord AddSystemAbilityCallerRecord
1950 */
1951 HWTEST_F(AbilityRecordTest, AbilityRecord_AddSystemAbilityCallerRecord_002, TestSize.Level1)
1952 {
1953 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1954 EXPECT_NE(abilityRecord, nullptr);
1955 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
1956 int requestCode = 0;
1957 std::string srcAbilityId = "srcAbility_id";
1958 std::shared_ptr<SystemAbilityCallerRecord> saCaller =
1959 std::make_shared<SystemAbilityCallerRecord>(srcAbilityId, callerToken);
1960 std::shared_ptr<CallerRecord> caller = std::make_shared<CallerRecord>(requestCode, saCaller);
1961 abilityRecord->callerList_.push_back(caller);
1962 abilityRecord->AddSystemAbilityCallerRecord(callerToken, requestCode, srcAbilityId);
1963 }
1964
1965 /*
1966 * Feature: AbilityRecord
1967 * Function: GetConnectingRecordList
1968 * SubFunction: GetConnectingRecordList
1969 * FunctionPoints: NA
1970 * EnvConditions: NA
1971 * CaseDescription: Verify AbilityRecord GetConnectingRecordList
1972 */
1973 HWTEST_F(AbilityRecordTest, AbilityRecord_GetConnectingRecordList_001, TestSize.Level1)
1974 {
1975 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
1976 EXPECT_NE(abilityRecord, nullptr);
1977 OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1978 std::shared_ptr<ConnectionRecord> connection1 =
1979 std::make_shared<ConnectionRecord>(abilityRecord->GetToken(), abilityRecord, callback);
1980 std::shared_ptr<ConnectionRecord> connection2 =
1981 std::make_shared<ConnectionRecord>(abilityRecord->GetToken(), abilityRecord, callback);
1982 connection1->SetConnectState(ConnectionState::CONNECTING);
1983 connection2->SetConnectState(ConnectionState::CONNECTED);
1984 abilityRecord->connRecordList_.push_back(connection1);
1985 abilityRecord->connRecordList_.push_back(connection2);
1986 abilityRecord->GetConnectingRecordList();
1987 }
1988
1989 /*
1990 * Feature: AbilityRecord
1991 * Function: DumpAbilityState
1992 * SubFunction: DumpAbilityState
1993 * FunctionPoints: NA
1994 * EnvConditions: NA
1995 * CaseDescription: Verify AbilityRecord DumpAbilityState
1996 */
1997 HWTEST_F(AbilityRecordTest, AbilityRecord_DumpAbilityState_001, TestSize.Level1)
1998 {
1999 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2000 EXPECT_NE(abilityRecord, nullptr);
2001 std::vector<std::string> info;
2002 bool isClient = false;
2003 std::vector<std::string> params;
2004 abilityRecord->callContainer_ = std::make_shared<CallContainer>();
2005 abilityRecord->isLauncherRoot_ = true;
2006 abilityRecord->DumpAbilityState(info, isClient, params);
2007 }
2008
2009 /*
2010 * Feature: AbilityRecord
2011 * Function: SetStartTime
2012 * SubFunction: SetStartTime
2013 * FunctionPoints: NA
2014 * EnvConditions: NA
2015 * CaseDescription: Verify AbilityRecord SetStartTime
2016 */
2017 HWTEST_F(AbilityRecordTest, AbilityRecord_SetStartTime_001, TestSize.Level1)
2018 {
2019 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2020 EXPECT_NE(abilityRecord, nullptr);
2021 abilityRecord->startTime_ = 1;
2022 abilityRecord->SetStartTime();
2023 }
2024
2025 /*
2026 * Feature: AbilityRecord
2027 * Function: DumpService
2028 * SubFunction: DumpService
2029 * FunctionPoints: NA
2030 * EnvConditions: NA
2031 * CaseDescription: Verify AbilityRecord DumpService
2032 */
2033 HWTEST_F(AbilityRecordTest, AbilityRecord_DumpService_001, TestSize.Level1)
2034 {
2035 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2036 EXPECT_NE(abilityRecord, nullptr);
2037 std::vector<std::string> info;
2038 std::vector<std::string> params;
2039 bool isClient = false;
2040 OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
2041 std::shared_ptr<ConnectionRecord> connection =
2042 std::make_shared<ConnectionRecord>(abilityRecord->GetToken(), abilityRecord, callback);
2043 abilityRecord->isLauncherRoot_ = true;
2044 abilityRecord->connRecordList_.push_back(nullptr);
2045 abilityRecord->connRecordList_.push_back(connection);
2046 abilityRecord->DumpService(info, params, isClient);
2047 }
2048
2049 /*
2050 * Feature: AbilityRecord
2051 * Function: SendEvent
2052 * SubFunction: SendEvent
2053 * FunctionPoints: NA
2054 * EnvConditions: NA
2055 * CaseDescription: Verify AbilityRecord SendEvent
2056 */
2057 HWTEST_F(AbilityRecordTest, AbilityRecord_SendEvent_001, TestSize.Level1)
2058 {
2059 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2060 uint32_t msg = 0;
2061 uint32_t timeOut = 0;
2062 abilityRecord->want_.SetParam(DEBUG_APP, true);
2063 EXPECT_TRUE(abilityRecord->want_.GetBoolParam(DEBUG_APP, false));
2064 abilityRecord->SendEvent(msg, timeOut);
2065 }
2066
2067 /*
2068 * Feature: AbilityRecord
2069 * Function: SetRestarting
2070 * SubFunction: SetRestarting
2071 * FunctionPoints: NA
2072 * EnvConditions: NA
2073 * CaseDescription: Verify AbilityRecord SetRestarting
2074 */
2075 HWTEST_F(AbilityRecordTest, AbilityRecord_SetRestarting_001, TestSize.Level1)
2076 {
2077 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2078 EXPECT_NE(abilityRecord, nullptr);
2079 bool isRestart = false;
2080 abilityRecord->isLauncherRoot_ = true;
2081 abilityRecord->isLauncherAbility_ = true;
2082 abilityRecord->SetRestarting(isRestart);
2083 abilityRecord->isLauncherAbility_ = false;
2084 abilityRecord->SetRestarting(isRestart);
2085 abilityRecord->isLauncherRoot_ = false;
2086 abilityRecord->SetRestarting(isRestart);
2087 }
2088
2089 /*
2090 * Feature: AbilityRecord
2091 * Function: SetRestarting
2092 * SubFunction: SetRestarting
2093 * FunctionPoints: NA
2094 * EnvConditions: NA
2095 * CaseDescription: Verify AbilityRecord SetRestarting
2096 */
2097 HWTEST_F(AbilityRecordTest, AbilityRecord_SetRestarting_002, TestSize.Level1)
2098 {
2099 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2100 EXPECT_NE(abilityRecord, nullptr);
2101 bool isRestart = false;
2102 int32_t canReStartCount = 1;
2103 abilityRecord->isLauncherRoot_ = true;
2104 abilityRecord->isLauncherAbility_ = true;
2105 abilityRecord->SetRestarting(isRestart, canReStartCount);
2106 abilityRecord->isLauncherAbility_ = false;
2107 abilityRecord->SetRestarting(isRestart, canReStartCount);
2108 abilityRecord->isLauncherRoot_ = false;
2109 abilityRecord->SetRestarting(isRestart, canReStartCount);
2110 }
2111
2112 /*
2113 * Feature: AbilityRecord
2114 * Function: CallRequestDone
2115 * SubFunction: CallRequestDone
2116 * FunctionPoints: NA
2117 * EnvConditions: NA
2118 * CaseDescription: Verify AbilityRecord CallRequestDone
2119 */
2120 HWTEST_F(AbilityRecordTest, AbilityRecord_CallRequestDone_001, TestSize.Level1)
2121 {
2122 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2123 bool res1 = abilityRecord->CallRequestDone(nullptr);
2124 EXPECT_FALSE(res1);
2125 abilityRecord->callContainer_ = std::make_shared<CallContainer>();
2126 abilityRecord->Init();
2127 sptr<IRemoteObject> callStub = abilityRecord->GetToken();
2128 bool res2 = abilityRecord->CallRequestDone(callStub);
2129 EXPECT_TRUE(res2);
2130 }
2131
2132 /*
2133 * Feature: AbilityRecord
2134 * Function: DumpClientInfo
2135 * SubFunction: DumpClientInfo
2136 * FunctionPoints: NA
2137 * EnvConditions: NA
2138 * CaseDescription: Verify AbilityRecord DumpClientInfo
2139 */
2140 HWTEST_F(AbilityRecordTest, AbilityRecord_DumpClientInfo_001, TestSize.Level1)
2141 {
2142 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2143 EXPECT_NE(abilityRecord, nullptr);
2144 std::vector<std::string> info;
2145 const std::vector<std::string> params;
2146 bool isClient = true;
2147 bool dumpConfig = false;
2148 abilityRecord->scheduler_ = nullptr;
2149 abilityRecord->DumpClientInfo(info, params, isClient, dumpConfig);
2150 abilityRecord->scheduler_ = new AbilityScheduler();
2151 abilityRecord->isReady_ = false;
2152 abilityRecord->DumpClientInfo(info, params, isClient, dumpConfig);
2153 abilityRecord->isReady_ = true;
2154 abilityRecord->DumpClientInfo(info, params, isClient, dumpConfig);
2155 dumpConfig = true;
2156 abilityRecord->DumpClientInfo(info, params, isClient, dumpConfig);
2157 }
2158
2159 /*
2160 * Feature: AbilityRecord
2161 * Function: DumpAbilityInfoDone
2162 * SubFunction: DumpAbilityInfoDone
2163 * FunctionPoints: NA
2164 * EnvConditions: NA
2165 * CaseDescription: Verify AbilityRecord DumpAbilityInfoDone
2166 */
2167 HWTEST_F(AbilityRecordTest, AbilityRecord_DumpAbilityInfoDone_001, TestSize.Level1)
2168 {
2169 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2170 EXPECT_NE(abilityRecord, nullptr);
2171 std::vector<std::string> infos;
2172 abilityRecord->isDumpTimeout_ = true;
2173 abilityRecord->DumpAbilityInfoDone(infos);
2174 abilityRecord->isDumpTimeout_ = false;
2175 abilityRecord->DumpAbilityInfoDone(infos);
2176 }
2177
2178 /*
2179 * Feature: AbilityRecord
2180 * Function: GrantUriPermission
2181 * SubFunction: GrantUriPermission
2182 * FunctionPoints: NA
2183 * EnvConditions: NA
2184 * CaseDescription: Verify AbilityRecord GrantUriPermission
2185 */
2186 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_001, TestSize.Level1)
2187 {
2188 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2189 EXPECT_NE(abilityRecord, nullptr);
2190 Want want;
2191 std::string targetBundleName = "name";
2192 abilityRecord->GrantUriPermission(want, targetBundleName, true, 0);
2193 }
2194
2195 /*
2196 * Feature: AbilityRecord
2197 * Function: GrantUriPermission
2198 * SubFunction: GrantUriPermission
2199 * FunctionPoints: NA
2200 * EnvConditions: NA
2201 * CaseDescription: Verify AbilityRecord GrantUriPermission
2202 */
2203 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_002, TestSize.Level1)
2204 {
2205 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2206 EXPECT_NE(abilityRecord, nullptr);
2207 Want want;
2208 want.SetFlags(1);
2209 want.SetUri("datashare://ohos.samples.clock/data/storage/el2/base/haps/entry/files/test_A.txt");
2210 std::string targetBundleName = "name";
2211 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2212 }
2213
2214 /*
2215 * Feature: AbilityRecord
2216 * Function: GrantUriPermission
2217 * SubFunction: GrantUriPermission
2218 * FunctionPoints: NA
2219 * EnvConditions: NA
2220 * CaseDescription: Verify AbilityRecord GrantUriPermission
2221 */
2222 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_003, TestSize.Level1)
2223 {
2224 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2225 EXPECT_NE(abilityRecord, nullptr);
2226 Want want;
2227 want.SetFlags(1);
2228 want.SetUri("file://com.example.mock/data/storage/el2/base/haps/entry/files/test_A.txt");
2229 std::string targetBundleName = "name";
2230 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2231 }
2232
2233 /*
2234 * Feature: AbilityRecord
2235 * Function: GrantUriPermission
2236 * SubFunction: GrantUriPermission
2237 * FunctionPoints: NA
2238 * EnvConditions: NA
2239 * CaseDescription: Verify AbilityRecord GrantUriPermission
2240 */
2241 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_004, TestSize.Level1)
2242 {
2243 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2244 EXPECT_NE(abilityRecord, nullptr);
2245 Want want;
2246 want.SetFlags(1);
2247 want.SetUri("file://ohos.samples.clock/data/storage/el2/base/haps/entry/files/test_A.txt");
2248 std::string targetBundleName = "name";
2249 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2250 }
2251
2252 /*
2253 * Feature: AbilityRecord
2254 * Function: GrantUriPermission
2255 * SubFunction: GrantUriPermission
2256 * FunctionPoints: NA
2257 * EnvConditions: NA
2258 * CaseDescription: Verify AbilityRecord GrantUriPermission
2259 */
2260 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermission_005, TestSize.Level1)
2261 {
2262 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2263 EXPECT_NE(abilityRecord, nullptr);
2264 uint32_t targetTokenId = 56;
2265 abilityRecord->SetCallerAccessTokenId(targetTokenId);
2266 Want want;
2267 want.SetFlags(1);
2268 want.SetUri("file://ohos.samples.clock/data/storage/el2/base/haps/entry/files/test_A.txt");
2269 std::string targetBundleName = "name";
2270 abilityRecord->GrantUriPermission(want, targetBundleName, false, 0);
2271 }
2272
2273 /*
2274 * Feature: AbilityRecord
2275 * Function: GrantUriPermissionForServiceExtension
2276 * SubFunction: GrantUriPermissionForServiceExtension
2277 * FunctionPoints: NA
2278 * EnvConditions: NA
2279 * CaseDescription: Verify AbilityRecord GrantUriPermissionForServiceExtension
2280 */
2281 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermissionForServiceExtension_001, TestSize.Level1)
2282 {
2283 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2284 EXPECT_NE(abilityRecord, nullptr);
2285 abilityRecord->abilityInfo_.extensionAbilityType = AppExecFwk::ExtensionAbilityType::SERVICE;
2286 auto ret = abilityRecord->GrantUriPermissionForServiceExtension();
2287 EXPECT_TRUE(ret);
2288 }
2289
2290 /*
2291 * Feature: AbilityRecord
2292 * Function: GrantUriPermissionForServiceExtension
2293 * SubFunction: GrantUriPermissionForServiceExtension
2294 * FunctionPoints: NA
2295 * EnvConditions: NA
2296 * CaseDescription: Verify AbilityRecord GrantUriPermissionForServiceExtension
2297 */
2298 HWTEST_F(AbilityRecordTest, AbilityRecord_GrantUriPermissionForServiceExtension_002, TestSize.Level1)
2299 {
2300 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2301 EXPECT_NE(abilityRecord, nullptr);
2302 abilityRecord->abilityInfo_.extensionAbilityType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED;
2303 auto ret = abilityRecord->GrantUriPermissionForServiceExtension();
2304 EXPECT_FALSE(ret);
2305 }
2306
2307 /*
2308 * Feature: AbilityRecord
2309 * Function: RevokeUriPermission
2310 * SubFunction: RevokeUriPermission
2311 * FunctionPoints: NA
2312 * EnvConditions: NA
2313 * CaseDescription: Verify AbilityRecord RevokeUriPermission
2314 */
2315 HWTEST_F(AbilityRecordTest, AbilityRecord_RevokeUriPermission_001, TestSize.Level1)
2316 {
2317 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2318 EXPECT_NE(abilityRecord, nullptr);
2319 abilityRecord->RevokeUriPermission();
2320 }
2321
2322 #ifdef WITH_DLP
2323 /*
2324 * Feature: AbilityRecord
2325 * Function: HandleDlpClosed
2326 * SubFunction: HandleDlpClosed
2327 * FunctionPoints: NA
2328 * EnvConditions: NA
2329 * CaseDescription: Verify AbilityRecord HandleDlpClosed
2330 */
2331 HWTEST_F(AbilityRecordTest, AbilityRecord_HandleDlpClosed_001, TestSize.Level1)
2332 {
2333 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2334 EXPECT_NE(abilityRecord, nullptr);
2335 abilityRecord->abilityInfo_.bundleName = DLP_BUNDLE_NAME;
2336 abilityRecord->appIndex_ = 1;
2337 abilityRecord->HandleDlpClosed();
2338 }
2339 #endif // WITH_DLP
2340
2341 /*
2342 * Feature: AbilityRecord
2343 * Function: NotifyAnimationAbilityDied
2344 * SubFunction: NotifyAnimationAbilityDied
2345 * FunctionPoints: NA
2346 * EnvConditions: NA
2347 * CaseDescription: Verify AbilityRecord NotifyAnimationAbilityDied
2348 */
2349 HWTEST_F(AbilityRecordTest, AbilityRecord_NotifyAnimationAbilityDied_001, TestSize.Level1)
2350 {
2351 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2352 EXPECT_NE(abilityRecord, nullptr);
2353 abilityRecord->missionId_ = 1;
2354 abilityRecord->NotifyAnimationAbilityDied();
2355 }
2356
2357 /*
2358 * Feature: AbilityRecord
2359 * Function: NotifyRemoveShellProcess
2360 * SubFunction: NotifyRemoveShellProcess
2361 * FunctionPoints: NA
2362 * EnvConditions: NA
2363 * CaseDescription: Verify AbilityRecord NotifyRemoveShellProcess
2364 */
2365 HWTEST_F(AbilityRecordTest, AbilityRecord_NotifyRemoveShellProcess_001, TestSize.Level1)
2366 {
2367 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2368 EXPECT_NE(abilityRecord, nullptr);
2369 abilityRecord->abilityInfo_.bundleName = SHELL_ASSISTANT_BUNDLENAME;
2370 abilityRecord->NotifyRemoveShellProcess(CollaboratorType::RESERVE_TYPE);
2371 }
2372
2373 /*
2374 * Feature: AbilityRecord
2375 * Function: GetCurrentAccountId
2376 * SubFunction: GetCurrentAccountId
2377 * FunctionPoints: NA
2378 * EnvConditions: NA
2379 * CaseDescription: Verify AbilityRecord GetCurrentAccountId
2380 */
2381 HWTEST_F(AbilityRecordTest, AbilityRecord_GetCurrentAccountId_001, TestSize.Level1)
2382 {
2383 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2384 EXPECT_NE(abilityRecord, nullptr);
2385 abilityRecord->GetCurrentAccountId();
2386 }
2387
2388 /*
2389 * Feature: AbilityRecord
2390 * Function: CanRestartResident
2391 * SubFunction:
2392 * FunctionPoints: CanRestartResident
2393 * EnvConditions: NA
2394 * CaseDescription: Verify CanRestartResident return true when the ability is not a restart requestion.
2395 * @tc.require: issueI6588V
2396 */
2397 HWTEST_F(AbilityRecordTest, AbilityRecord_CanRestartResident_001, TestSize.Level1)
2398 {
2399 abilityRecord_->SetRestarting(true, -1);
2400 EXPECT_TRUE(abilityRecord_->isRestarting_);
2401 EXPECT_NE(abilityRecord_->restartCount_, -1);
2402
2403 abilityRecord_->restartTime_ = AbilityUtil::SystemTimeMillis();
2404 abilityRecord_->restartTime_ = 0;
2405 // restart success
2406 abilityRecord_->SetAbilityState(AbilityState::ACTIVE);
2407
2408 EXPECT_TRUE(abilityRecord_->CanRestartResident());
2409 }
2410
2411 /*
2412 * Feature: AbilityRecord
2413 * Function: CanRestartResident
2414 * SubFunction:
2415 * FunctionPoints: CanRestartResident
2416 * EnvConditions: NA
2417 * CaseDescription: Verify CanRestartResident return true when the restartCount is out of max times but the interval
2418 * time is over configuration.
2419 * @tc.require: issueI6588V
2420 */
2421 HWTEST_F(AbilityRecordTest, AbilityRecord_CanRestartResident_002, TestSize.Level1)
2422 {
2423 abilityRecord_->SetRestarting(true, -1);
2424 EXPECT_TRUE(abilityRecord_->isRestarting_);
2425 EXPECT_NE(abilityRecord_->restartCount_, -1);
2426 abilityRecord_->SetRestartTime(0);
2427 EXPECT_EQ(abilityRecord_->restartTime_, 0);
2428
2429 EXPECT_TRUE(abilityRecord_->CanRestartResident());
2430 }
2431
2432 /*
2433 * Feature: AbilityRecord
2434 * Function: UpdateRecoveryInfo
2435 * FunctionPoints: CanRestartResident
2436 * EnvConditions: NA
2437 * CaseDescription: Verify whether the UpdateRecoveryInfo interface calls normally.
2438 */
2439 HWTEST_F(AbilityRecordTest, AbilityRecord_UpdateRecoveryInfo_001, TestSize.Level1)
2440 {
2441 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2442 abilityRecord->UpdateRecoveryInfo(false);
2443 EXPECT_FALSE(abilityRecord->want_.GetBoolParam(Want::PARAM_ABILITY_RECOVERY_RESTART, false));
2444 }
2445
2446 /*
2447 * Feature: AbilityRecord
2448 * Function: UpdateRecoveryInfo
2449 * FunctionPoints: CanRestartResident
2450 * EnvConditions: NA
2451 * CaseDescription: Verify whether the UpdateRecoveryInfo interface calls normally.
2452 */
2453 HWTEST_F(AbilityRecordTest, AbilityRecord_UpdateRecoveryInfo_002, TestSize.Level1)
2454 {
2455 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2456 abilityRecord->UpdateRecoveryInfo(true);
2457 EXPECT_TRUE(abilityRecord->want_.GetBoolParam(Want::PARAM_ABILITY_RECOVERY_RESTART, false));
2458 }
2459
2460 /*
2461 * Feature: AbilityRecord
2462 * Function: GetRecoveryInfo
2463 * FunctionPoints: CanRestartResident
2464 * EnvConditions: NA
2465 * CaseDescription: Verify whether the GetRecoveryInfo interface calls normally.
2466 */
2467 HWTEST_F(AbilityRecordTest, AbilityRecord_GetRecoveryInfo_001, TestSize.Level1)
2468 {
2469 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2470 EXPECT_FALSE(abilityRecord->GetRecoveryInfo());
2471 }
2472
2473 /*
2474 * Feature: AbilityRecord
2475 * Function: IsUIExtension
2476 * SubFunction: IsUIExtension
2477 * FunctionPoints: NA
2478 * EnvConditions: NA
2479 * CaseDescription: Verify IsUIExtension
2480 */
2481 HWTEST_F(AbilityRecordTest, IsUIExtension_001, TestSize.Level1)
2482 {
2483 abilityRecord_->abilityInfo_.extensionAbilityType = AppExecFwk::ExtensionAbilityType::UI;
2484 EXPECT_EQ(UIExtensionUtils::IsUIExtension(abilityRecord_->abilityInfo_.extensionAbilityType), true);
2485 }
2486
2487 /*
2488 * Feature: AbilityRecord
2489 * Function: NotifyMoveMissionToForeground
2490 * SubFunction: NotifyMoveMissionToForeground
2491 * FunctionPoints: NA
2492 * EnvConditions: NA
2493 * CaseDescription: Verify NotifyMoveMissionToForeground
2494 * @tc.require: issueI7LJ1M
2495 */
2496 HWTEST_F(AbilityRecordTest, NotifyMoveMissionToForeground_001, TestSize.Level1)
2497 {
2498 EXPECT_NE(abilityRecord_, nullptr);
2499 abilityRecord_->collaboratorType_ = 1;
2500 abilityRecord_->SetAbilityStateInner(AbilityState::FOREGROUNDING);
2501 }
2502
2503 /*
2504 * Feature: AbilityRecord
2505 * Function: NotifyMoveMissionToBackground
2506 * SubFunction: NotifyMoveMissionToBackground
2507 * FunctionPoints: NA
2508 * EnvConditions: NA
2509 * CaseDescription: Verify NotifyMoveMissionToBackground
2510 * @tc.require: issueI7LJ1M
2511 */
2512 HWTEST_F(AbilityRecordTest, NotifyMoveMissionToBackground_001, TestSize.Level1)
2513 {
2514 EXPECT_NE(abilityRecord_, nullptr);
2515 abilityRecord_->collaboratorType_ = 1;
2516 abilityRecord_->SetAbilityStateInner(AbilityState::BACKGROUNDING);
2517 }
2518
2519 /*
2520 * Feature: AbilityRecord
2521 * Function: NotifyTerminateMission
2522 * SubFunction: NotifyTerminateMission
2523 * FunctionPoints: NA
2524 * EnvConditions: NA
2525 * CaseDescription: Verify NotifyTerminateMission
2526 * @tc.require: issueI7LJ1M
2527 */
2528 HWTEST_F(AbilityRecordTest, NotifyTerminateMission_001, TestSize.Level1)
2529 {
2530 EXPECT_NE(abilityRecord_, nullptr);
2531 abilityRecord_->collaboratorType_ = 1;
2532 abilityRecord_->SetAbilityStateInner(AbilityState::TERMINATING);
2533 }
2534
2535 /**
2536 * @tc.name: AbilityRecord_SetAttachDebug_001
2537 * @tc.desc: Test the correct value status of SetAttachDebug
2538 * @tc.type: FUNC
2539 */
2540 HWTEST_F(AbilityRecordTest, AbilityRecord_SetAttachDebug_001, TestSize.Level1)
2541 {
2542 EXPECT_NE(abilityRecord_, nullptr);
2543 bool isAttachDebug = true;
2544 abilityRecord_->SetAttachDebug(isAttachDebug);
2545 EXPECT_EQ(abilityRecord_->isAttachDebug_, true);
2546 }
2547
2548 /**
2549 * @tc.name: AbilityRecord_SetAttachDebug_002
2550 * @tc.desc: Test the error value status of SetAttachDebug
2551 * @tc.type: FUNC
2552 */
2553 HWTEST_F(AbilityRecordTest, AbilityRecord_SetAttachDebug_002, TestSize.Level1)
2554 {
2555 EXPECT_NE(abilityRecord_, nullptr);
2556 bool isAttachDebug = false;
2557 abilityRecord_->SetAttachDebug(isAttachDebug);
2558 EXPECT_EQ(abilityRecord_->isAttachDebug_, false);
2559 }
2560
2561 /**
2562 * @tc.name: AbilityRecordTest_SetLaunchReason_0100
2563 * @tc.desc: Test the state of SetLaunchReason
2564 * @tc.type: FUNC
2565 */
2566 HWTEST_F(AbilityRecordTest, SetLaunchReason_0100, TestSize.Level1)
2567 {
2568 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2569 EXPECT_NE(abilityRecord, nullptr);
2570 LaunchReason reason = LaunchReason::LAUNCHREASON_START_ABILITY;
2571 abilityRecord->isAppAutoStartup_ = true;
2572 abilityRecord->SetLaunchReason(reason);
2573 EXPECT_EQ(abilityRecord->lifeCycleStateInfo_.launchParam.launchReason, LaunchReason::LAUNCHREASON_AUTO_STARTUP);
2574 }
2575
2576 /**
2577 * @tc.name: AbilityRecordTest_SetLaunchReason_0200
2578 * @tc.desc: Test the state of SetLaunchReason
2579 * @tc.type: FUNC
2580 */
2581 HWTEST_F(AbilityRecordTest, SetLaunchReason_0200, TestSize.Level1)
2582 {
2583 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2584 EXPECT_NE(abilityRecord, nullptr);
2585 LaunchReason reason = LaunchReason::LAUNCHREASON_START_ABILITY;
2586 abilityRecord->isAppAutoStartup_ = false;
2587 abilityRecord->SetLaunchReason(reason);
2588 EXPECT_EQ(abilityRecord->lifeCycleStateInfo_.launchParam.launchReason, LaunchReason::LAUNCHREASON_START_ABILITY);
2589 }
2590
2591 /**
2592 * @tc.name: UpdateWantParams_0100
2593 * @tc.desc: Update want of ability record.
2594 * @tc.type: FUNC
2595 */
2596 HWTEST_F(AbilityRecordTest, UpdateWantParams_0100, TestSize.Level1)
2597 {
2598 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2599 ASSERT_NE(abilityRecord, nullptr);
2600 WantParams wantParams;
2601 wantParams.SetParam("ability.want.params.uiExtensionAbilityId", AAFwk::Integer::Box(1));
2602 wantParams.SetParam("ability.want.params.uiExtensionRootHostPid", AAFwk::Integer::Box(1000));
2603 abilityRecord->UpdateUIExtensionInfo(wantParams);
2604 }
2605
2606 /**
2607 * @tc.name: AbilityRecord_ReportAtomicServiceDrawnCompleteEvent_001
2608 * @tc.desc: Test ReportAtomicServiceDrawnCompleteEvent
2609 * @tc.type: FUNC
2610 */
2611 HWTEST_F(AbilityRecordTest, AbilityRecord_ReportAtomicServiceDrawnCompleteEvent_001, TestSize.Level1)
2612 {
2613 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2614 ASSERT_NE(abilityRecord, nullptr);
2615
2616 abilityRecord->applicationInfo_.bundleType = AppExecFwk::BundleType::ATOMIC_SERVICE;
2617 auto ret = abilityRecord->ReportAtomicServiceDrawnCompleteEvent();
2618 EXPECT_EQ(ret, true);
2619
2620 abilityRecord->applicationInfo_.bundleType = AppExecFwk::BundleType::APP;
2621 ret = abilityRecord->ReportAtomicServiceDrawnCompleteEvent();
2622 EXPECT_EQ(ret, false);
2623 }
2624
2625 /**
2626 * @tc.name: AbilityRecord_GetAbilityVisibilityState_001
2627 * @tc.desc: Test GetAbilityVisibilityState
2628 * @tc.type: FUNC
2629 */
2630 HWTEST_F(AbilityRecordTest, AbilityRecord_GetAbilityVisibilityState_001, TestSize.Level1)
2631 {
2632 EXPECT_NE(abilityRecord_, nullptr);
2633 EXPECT_EQ(AbilityVisibilityState::INITIAL, abilityRecord_->GetAbilityVisibilityState());
2634 abilityRecord_->SetAbilityVisibilityState(AbilityVisibilityState::FOREGROUND_HIDE);
2635 EXPECT_EQ(AbilityVisibilityState::FOREGROUND_HIDE, abilityRecord_->GetAbilityVisibilityState());
2636 }
2637
2638 /*
2639 * Feature: AbilityRecord
2640 * Function: Activate
2641 * SubFunction: Activate
2642 * FunctionPoints: NA
2643 * EnvConditions: NA
2644 * CaseDescription: Verify AbilityRecord Activate
2645 */
2646 HWTEST_F(AbilityRecordTest, AbilityRecord_Activate_003, TestSize.Level1)
2647 {
2648 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2649 abilityRecord->SetIsNewWant(true);
2650 abilityRecord->SetPreAbilityRecord(abilityRecord);
2651 abilityRecord->Activate();
2652 EXPECT_NE(abilityRecord_, nullptr);
2653 }
2654
2655 /*
2656 * Feature: AbilityRecord
2657 * Function: Terminate
2658 * SubFunction: Terminate
2659 * FunctionPoints: NA
2660 * EnvConditions: NA
2661 * CaseDescription: Verify AbilityRecord Terminate
2662 */
2663 HWTEST_F(AbilityRecordTest, AbilityRecord_Terminate_002, TestSize.Level1)
2664 {
2665 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
__anonb641e6f80802() 2666 Closure task = []() {};
2667 abilityRecord->want_.SetParam(DEBUG_APP, true);
2668 abilityRecord->applicationInfo_.asanEnabled = true;
2669 abilityRecord->Terminate(task);
2670 EXPECT_NE(abilityRecord_, nullptr);
2671 }
2672
2673 /*
2674 * Feature: AbilityRecord
2675 * Function: ShareData
2676 * SubFunction: ShareData
2677 * FunctionPoints: NA
2678 * EnvConditions: NA
2679 * CaseDescription: Verify AbilityRecord ShareData
2680 */
2681 HWTEST_F(AbilityRecordTest, AbilityRecord_ShareData_001, TestSize.Level1)
2682 {
2683 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2684 abilityRecord->abilityInfo_.type = AbilityType::DATA;
2685 abilityRecord->applicationInfo_.name = "app";
2686 abilityRecord->isAttachDebug_ = false;
2687 abilityRecord->isAssertDebug_ = false;
2688 abilityRecord->want_.SetParam(DEBUG_APP, true);
2689 abilityRecord->applicationInfo_.asanEnabled = true;
2690 int32_t uniqueId = 1;
2691 abilityRecord->ShareData(uniqueId);
2692 EXPECT_NE(abilityRecord_, nullptr);
2693 }
2694
2695 /*
2696 * Feature: AbilityRecord
2697 * Function: ConnectAbility
2698 * SubFunction: ConnectAbility
2699 * FunctionPoints: NA
2700 * EnvConditions: NA
2701 * CaseDescription: Verify AbilityRecord ConnectAbility
2702 */
2703 HWTEST_F(AbilityRecordTest, AbilityRecord_ConnectAbility_001, TestSize.Level1)
2704 {
2705 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2706 abilityRecord->lifecycleDeal_ = nullptr;
2707 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
2708 bool isConnected = true;
2709 abilityRecord->ConnectAbility();
2710 EXPECT_NE(abilityRecord_, nullptr);
2711 }
2712
2713 /*
2714 * Feature: AbilityRecord
2715 * Function: CommandAbility
2716 * SubFunction: CommandAbility
2717 * FunctionPoints: NA
2718 * EnvConditions: NA
2719 * CaseDescription: Verify AbilityRecord CommandAbility
2720 */
2721 HWTEST_F(AbilityRecordTest, AbilityRecord_CommandAbility_001, TestSize.Level1)
2722 {
2723 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2724 abilityRecord->lifecycleDeal_ = nullptr;
2725 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
2726 abilityRecord->want_.SetParam(DEBUG_APP, true);
2727 abilityRecord->CommandAbility();
2728 EXPECT_NE(abilityRecord_, nullptr);
2729 }
2730
2731 /*
2732 * Feature: AbilityRecord
2733 * Function: CommandAbilityWindow
2734 * SubFunction: CommandAbilityWindow
2735 * FunctionPoints: NA
2736 * EnvConditions: NA
2737 * CaseDescription: Verify AbilityRecord CommandAbilityWindow
2738 */
2739 HWTEST_F(AbilityRecordTest, AbilityRecord_CommandAbilityWindow_001, TestSize.Level1)
2740 {
2741 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2742 abilityRecord->lifecycleDeal_ = nullptr;
2743 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
2744 abilityRecord->want_.SetParam(DEBUG_APP, true);
2745 sptr<SessionInfo> sessionInfo = nullptr;
2746 abilityRecord->CommandAbilityWindow(sessionInfo, WIN_CMD_FOREGROUND);
2747 EXPECT_NE(abilityRecord_, nullptr);
2748 EXPECT_EQ(sessionInfo, nullptr);
2749 }
2750
2751 /*
2752 * Feature: AbilityRecord
2753 * Function: CommandAbilityWindow
2754 * SubFunction: CommandAbilityWindow
2755 * FunctionPoints: NA
2756 * EnvConditions: NA
2757 * CaseDescription: Verify AbilityRecord CommandAbilityWindow
2758 */
2759 HWTEST_F(AbilityRecordTest, AbilityRecord_CommandAbilityWindow_002, TestSize.Level1)
2760 {
2761 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2762 abilityRecord->lifecycleDeal_ = nullptr;
2763 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
2764 abilityRecord->want_.SetParam(DEBUG_APP, true);
2765 sptr<SessionInfo> sessionInfo = nullptr;
2766 abilityRecord->CommandAbilityWindow(sessionInfo, WIN_CMD_BACKGROUND);
2767 EXPECT_NE(abilityRecord_, nullptr);
2768 EXPECT_EQ(sessionInfo, nullptr);
2769 }
2770
2771 /*
2772 * Feature: AbilityRecord
2773 * Function: CommandAbilityWindow
2774 * SubFunction: CommandAbilityWindow
2775 * FunctionPoints: NA
2776 * EnvConditions: NA
2777 * CaseDescription: Verify AbilityRecord CommandAbilityWindow
2778 */
2779 HWTEST_F(AbilityRecordTest, AbilityRecord_CommandAbilityWindow_003, TestSize.Level1)
2780 {
2781 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2782 abilityRecord->lifecycleDeal_ = nullptr;
2783 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
2784 abilityRecord->want_.SetParam(DEBUG_APP, true);
2785 sptr<SessionInfo> sessionInfo = nullptr;
2786 abilityRecord->CommandAbilityWindow(sessionInfo, WIN_CMD_DESTROY);
2787 EXPECT_NE(abilityRecord_, nullptr);
2788 EXPECT_EQ(sessionInfo, nullptr);
2789 }
2790
2791 /*
2792 * Feature: AbilityRecord
2793 * Function: RestoreAbilityState
2794 * SubFunction: RestoreAbilityState
2795 * FunctionPoints: NA
2796 * EnvConditions: NA
2797 * CaseDescription: Verify AbilityRecord RestoreAbilityState
2798 */
2799 HWTEST_F(AbilityRecordTest, AbilityRecord_RestoreAbilityState_001, TestSize.Level1)
2800 {
2801 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2802 abilityRecord->lifecycleDeal_ = nullptr;
2803 abilityRecord->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
2804 PacMap stateDatas_;
2805 abilityRecord->RestoreAbilityState();
2806 EXPECT_NE(abilityRecord_, nullptr);
2807 }
2808
2809 /*
2810 * Feature: AbilityRecord
2811 * Function: SendSandboxSavefileResult
2812 * SubFunction: SendSandboxSavefileResult
2813 * FunctionPoints: NA
2814 * EnvConditions: NA
2815 * CaseDescription: Verify AbilityRecord SendSandboxSavefileResult
2816 */
2817 HWTEST_F(AbilityRecordTest, AbilityRecord_SendSandboxSavefileResult_001, TestSize.Level1)
2818 {
2819 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2820 Want want;
2821 const std::string PARAMS_FILE_SAVING_URL_KEY = "pick_path_return";
2822 abilityRecord->want_.SetParam(PARAMS_FILE_SAVING_URL_KEY, true);
2823 int resultCode = 0;
2824 int requestCode = -1;
2825 abilityRecord->SendSandboxSavefileResult(want, resultCode, requestCode);
2826 EXPECT_NE(abilityRecord_, nullptr);
2827 }
2828
2829 /*
2830 * Feature: AbilityRecord
2831 * Function: RemoveAbilityDeathRecipient
2832 * SubFunction: RemoveAbilityDeathRecipient
2833 * FunctionPoints: NA
2834 * EnvConditions: NA
2835 * CaseDescription: Verify AbilityRecord RemoveAbilityDeathRecipient
2836 */
2837 HWTEST_F(AbilityRecordTest, AbilityRecord_RemoveAbilityDeathRecipient_001, TestSize.Level1)
2838 {
2839 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2840 abilityRecord->schedulerDeathRecipient_ = nullptr;
2841 sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
2842 abilityRecord->scheduler_ = scheduler;
2843 abilityRecord->RemoveAbilityDeathRecipient();
2844 EXPECT_NE(abilityRecord_, nullptr);
2845 }
2846
2847 /*
2848 * Feature: AbilityRecord
2849 * Function: RemoveAbilityDeathRecipient
2850 * SubFunction: RemoveAbilityDeathRecipient
2851 * FunctionPoints: NA
2852 * EnvConditions: NA
2853 * CaseDescription: Verify AbilityRecord RemoveAbilityDeathRecipient
2854 */
2855 HWTEST_F(AbilityRecordTest, AbilityRecord_RemoveAbilityDeathRecipient_002, TestSize.Level1)
2856 {
2857 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2858 abilityRecord->schedulerDeathRecipient_ =
__anonb641e6f80902(const wptr<IRemoteObject> &remote) 2859 new AbilitySchedulerRecipient([abilityRecord](const wptr<IRemoteObject> &remote) {});
2860 sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
2861 abilityRecord->scheduler_ = scheduler;
2862 abilityRecord->RemoveAbilityDeathRecipient();
2863 EXPECT_NE(abilityRecord_, nullptr);
2864 }
2865
2866 /*
2867 * Feature: AbilityRecord
2868 * Function: RemoveAbilityDeathRecipient
2869 * SubFunction: RemoveAbilityDeathRecipient
2870 * FunctionPoints: NA
2871 * EnvConditions: NA
2872 * CaseDescription: Verify AbilityRecord RemoveAbilityDeathRecipient
2873 */
2874 HWTEST_F(AbilityRecordTest, AbilityRecord_RemoveAbilityDeathRecipient_003, TestSize.Level1)
2875 {
2876 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2877 abilityRecord->schedulerDeathRecipient_ =
__anonb641e6f80a02(const wptr<IRemoteObject> &remote) 2878 new AbilitySchedulerRecipient([abilityRecord](const wptr<IRemoteObject> &remote) {});
2879 sptr<IAbilityScheduler> scheduler = nullptr;
2880 abilityRecord->scheduler_ = scheduler;
2881 abilityRecord->RemoveAbilityDeathRecipient();
2882 EXPECT_NE(abilityRecord_, nullptr);
2883 }
2884
2885 /*
2886 * Feature: AbilityRecord
2887 * Function: SetRestartCount
2888 * SubFunction: SetRestartCount
2889 * FunctionPoints: NA
2890 * EnvConditions: NA
2891 * CaseDescription: Verify AbilityRecord SetRestartCount
2892 */
2893 HWTEST_F(AbilityRecordTest, AbilityRecord_SetRestartCount_001, TestSize.Level1)
2894 {
2895 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2896 int32_t restartCount = 1;
2897 abilityRecord->SetRestartCount(restartCount);
2898 EXPECT_NE(abilityRecord_, nullptr);
2899 }
2900
2901 /*
2902 * Feature: AbilityRecord
2903 * Function: GetRestartCount
2904 * SubFunction: GetRestartCount
2905 * FunctionPoints: NA
2906 * EnvConditions: NA
2907 * CaseDescription: Verify AbilityRecord GetRestartCount
2908 */
2909 HWTEST_F(AbilityRecordTest, AbilityRecord_GetRestartCount_001, TestSize.Level1)
2910 {
2911 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2912 int32_t restartCount = 1;
2913 abilityRecord->SetRestartCount(restartCount);
2914 int32_t result = abilityRecord->GetRestartCount();
2915 EXPECT_EQ(result, restartCount);
2916 }
2917
2918 /*
2919 * Feature: AbilityRecord
2920 * Function: LoadAbility
2921 * SubFunction: LoadAbility
2922 * FunctionPoints: NA
2923 * EnvConditions: NA
2924 * CaseDescription: Verify AbilityRecord LoadAbility
2925 */
2926 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_LoadAbility_005, TestSize.Level1)
2927 {
2928 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2929 abilityRecord->abilityInfo_.type = AbilityType::UNKNOWN;
2930 abilityRecord->applicationInfo_.name = "app";
2931 abilityRecord->isLauncherRoot_ = true;
2932 abilityRecord->isRestarting_ = true;
2933 abilityRecord->isLauncherAbility_ = true;
2934 abilityRecord->restartCount_ = 0;
2935 abilityRecord->applicationInfo_.asanEnabled = true;
2936 abilityRecord->applicationInfo_.tsanEnabled = true;
2937 int res = abilityRecord->LoadAbility();
2938 EXPECT_NE(abilityRecord_, nullptr);
2939 EXPECT_EQ(abilityRecord->abilityInfo_.type, AbilityType::UNKNOWN);
2940 EXPECT_EQ(res, ERR_INVALID_VALUE);
2941 }
2942
2943 /**
2944 * @tc.name: AbilityRecord_LoadUIAbility_001
2945 * @tc.desc: Test LoadUIAbility
2946 * @tc.type: FUNC
2947 */
2948 HWTEST_F(AbilityRecordTest, AbilityRecord_LoadUIAbility_001, TestSize.Level1)
2949 {
2950 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2951 abilityRecord->abilityInfo_.type = AbilityType::DATA;
2952 abilityRecord->applicationInfo_.name = "app";
2953 abilityRecord->applicationInfo_.asanEnabled = true;
2954 abilityRecord->applicationInfo_.tsanEnabled = true;
2955 abilityRecord->LoadUIAbility();
2956 EXPECT_NE(abilityRecord_, nullptr);
2957 EXPECT_EQ(abilityRecord->abilityInfo_.type, AbilityType::DATA);
2958 }
2959
2960 /*
2961 * Feature: AbilityRecord
2962 * Function: ForegroundAbility
2963 * SubFunction: ForegroundAbility
2964 * FunctionPoints: NA
2965 * EnvConditions: NA
2966 * CaseDescription: Verify AbilityRecord ForegroundAbility
2967 */
2968 HWTEST_F(AbilityRecordTest, AaFwk_AbilityMS_ForegroundAbility_005, TestSize.Level1)
2969 {
2970 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2971 uint32_t sceneFlag = 0;
2972 abilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::FOREGROUND_HIDE);
2973 abilityRecord->ForegroundAbility(sceneFlag);
2974 EXPECT_NE(abilityRecord_, nullptr);
2975 }
2976
2977 /*
2978 * Feature: AbilityRecord
2979 * Function: ForegroundAbility
2980 * SubFunction: ForegroundAbility
2981 * FunctionPoints: NA
2982 * EnvConditions: NA
2983 * CaseDescription: Verify AbilityRecord ForegroundAbility
2984 */
2985 HWTEST_F(AbilityRecordTest, AbilityRecord_ForegroundAbility_001, TestSize.Level1)
2986 {
2987 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
2988 uint32_t sceneFlag = 0;
2989 abilityRecord->abilityInfo_.type = AbilityType::DATA;
2990 abilityRecord->applicationInfo_.name = "app";
2991 abilityRecord->isAttachDebug_ = false;
2992 abilityRecord->isAssertDebug_ = false;
2993 abilityRecord->ForegroundUIExtensionAbility(sceneFlag);
2994 EXPECT_EQ(abilityRecord->abilityInfo_.type, AbilityType::DATA);
2995 EXPECT_NE(abilityRecord_, nullptr);
2996 }
2997
2998 /*
2999 * Feature: AbilityRecord
3000 * Function: ForegroundAbility
3001 * SubFunction: ForegroundAbility
3002 * FunctionPoints: NA
3003 * EnvConditions: NA
3004 * CaseDescription: Verify AbilityRecord ForegroundAbility
3005 */
3006 HWTEST_F(AbilityRecordTest, AbilityRecord_ForegroundAbility_002, TestSize.Level1)
3007 {
3008 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
3009 uint32_t sceneFlag = 0;
3010 bool isNewWant = true;
3011 abilityRecord->SetIsNewWant(isNewWant);
3012 abilityRecord->ForegroundUIExtensionAbility(sceneFlag);
3013 EXPECT_NE(abilityRecord_, nullptr);
3014 }
3015
3016 /*
3017 * Feature: AbilityRecord
3018 * Function: PostUIExtensionAbilityTimeoutTask
3019 * SubFunction: PostUIExtensionAbilityTimeoutTask
3020 * FunctionPoints: NA
3021 * EnvConditions: NA
3022 * CaseDescription: Verify AbilityRecord PostUIExtensionAbilityTimeoutTask
3023 */
3024 HWTEST_F(AbilityRecordTest, AbilityRecord_PostUIExtensionAbilityTimeoutTask_001, TestSize.Level1)
3025 {
3026 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
3027 ASSERT_NE(abilityRecord, nullptr);
3028 abilityRecord->PostUIExtensionAbilityTimeoutTask(AbilityManagerService::LOAD_TIMEOUT_MSG);
3029 abilityRecord->PostUIExtensionAbilityTimeoutTask(AbilityManagerService::FOREGROUND_TIMEOUT_MSG);
3030 abilityRecord->PostUIExtensionAbilityTimeoutTask(AbilityManagerService::BACKGROUND_TIMEOUT_MSG);
3031 }
3032
3033 /*
3034 * Feature: AbilityRecord
3035 * Function: PrepareTerminateAbility
3036 * SubFunction: PrepareTerminateAbility
3037 * FunctionPoints: NA
3038 * EnvConditions: NA
3039 * CaseDescription: Verify AbilityRecord PrepareTerminateAbility
3040 */
3041 HWTEST_F(AbilityRecordTest, AbilityRecord_PrepareTerminateAbility_001, TestSize.Level1)
3042 {
3043 abilityRecord_->lifecycleDeal_ = nullptr;
3044 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
3045 bool result = abilityRecord_->lifecycleDeal_->PrepareTerminateAbility();
3046 EXPECT_EQ(result, false);
3047 EXPECT_NE(abilityRecord_, nullptr);
3048 }
3049
3050 /*
3051 * Feature: AbilityRecord
3052 * Function: PrepareTerminateAbility
3053 * SubFunction: PrepareTerminateAbility
3054 * FunctionPoints: NA
3055 * EnvConditions: NA
3056 * CaseDescription: Verify AbilityRecord PrepareTerminateAbility
3057 */
3058 HWTEST_F(AbilityRecordTest, AbilityRecord_PrepareTerminateAbility_002, TestSize.Level1)
3059 {
3060 abilityRecord_->lifecycleDeal_ = nullptr;
3061 abilityRecord_->lifecycleDeal_ = std::make_unique<LifecycleDeal>();
3062 bool result = abilityRecord_->lifecycleDeal_->PrepareTerminateAbility();
3063 EXPECT_EQ(result, false);
3064 EXPECT_NE(abilityRecord_, nullptr);
3065 }
3066
3067 /*
3068 * Feature: AbilityRecord
3069 * Function: GetUriListFromWant
3070 * SubFunction: GetUriListFromWant
3071 * FunctionPoints: NA
3072 * EnvConditions: NA
3073 * CaseDescription: Verify AbilityRecord GetUriListFromWant
3074 */
3075 HWTEST_F(AbilityRecordTest, AbilityRecord_GetUriListFromWant_001, TestSize.Level1)
3076 {
3077 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
3078 Want want;
3079 want.SetUri("file://com.example.test/test.txt");
3080 std::vector<std::string> uriVec;
3081 UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
3082 EXPECT_EQ(uriVec.size(), 1);
3083 }
3084
3085 /*
3086 * Feature: AbilityRecord
3087 * Function: GetUriListFromWant
3088 * SubFunction: GetUriListFromWant
3089 * FunctionPoints: NA
3090 * EnvConditions: NA
3091 * CaseDescription: Verify AbilityRecord GetUriListFromWant
3092 */
3093 HWTEST_F(AbilityRecordTest, AbilityRecord_GetUriListFromWant_002, TestSize.Level1)
3094 {
3095 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
3096 Want want;
3097 std::vector<std::string> oriUriVec = { "file://com.example.test/test.txt" };
3098 want.SetParam(AbilityConfig::PARAMS_STREAM, oriUriVec);
3099 std::vector<std::string> uriVec;
3100 UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
3101 EXPECT_EQ(uriVec.size(), 1);
3102 }
3103
3104 /*
3105 * Feature: AbilityRecord
3106 * Function: GetUriListFromWant
3107 * SubFunction: GetUriListFromWant
3108 * FunctionPoints: NA
3109 * EnvConditions: NA
3110 * CaseDescription: Verify AbilityRecord GetUriListFromWant
3111 */
3112 HWTEST_F(AbilityRecordTest, AbilityRecord_GetUriListFromWant_003, TestSize.Level1)
3113 {
3114 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
3115 Want want;
3116 want.SetUri("file://com.example.test/test.txt");
3117 std::vector<std::string> oriUriVec = { "file://com.example.test/test.txt" };
3118 want.SetParam(AbilityConfig::PARAMS_STREAM, oriUriVec);
3119 std::vector<std::string> uriVec;
3120 UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
3121 EXPECT_EQ(uriVec.size(), 2);
3122 }
3123
3124 /*
3125 * Feature: AbilityRecord
3126 * Function: GetUriListFromWant
3127 * SubFunction: GetUriListFromWant
3128 * FunctionPoints: NA
3129 * EnvConditions: NA
3130 * CaseDescription: Verify AbilityRecord GetUriListFromWant
3131 */
3132 HWTEST_F(AbilityRecordTest, AbilityRecord_GetUriListFromWant_004, TestSize.Level1)
3133 {
3134 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
3135 Want want;
3136 want.SetUri("file://com.example.test/test.txt");
3137 std::vector<std::string> oriUriVec(500, "file://com.example.test/test.txt");
3138 want.SetParam(AbilityConfig::PARAMS_STREAM, oriUriVec);
3139 std::vector<std::string> uriVec;
3140 UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
3141 EXPECT_EQ(uriVec.size(), 500);
3142 }
3143
3144 /*
3145 * Feature: AbilityRecord
3146 * Function: GetUriListFromWant
3147 * SubFunction: GetUriListFromWant
3148 * FunctionPoints: NA
3149 * EnvConditions: NA
3150 * CaseDescription: Verify AbilityRecord GetUriListFromWant
3151 */
3152 HWTEST_F(AbilityRecordTest, AbilityRecord_GetUriListFromWant_005, TestSize.Level1)
3153 {
3154 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecord();
3155 Want want;
3156 std::vector<std::string> oriUriVec(501, "file://com.example.test/test.txt");
3157 want.SetParam(AbilityConfig::PARAMS_STREAM, oriUriVec);
3158 std::vector<std::string> uriVec;
3159 UriUtils::GetInstance().GetUriListFromWant(want, uriVec);
3160 EXPECT_EQ(uriVec.size(), 500);
3161 }
3162
3163 /*
3164 * Feature: AbilityRecord
3165 * Function: GetUriListFromWant
3166 * SubFunction: GetUriListFromWant
3167 * FunctionPoints: NA
3168 * EnvConditions: NA
3169 * CaseDescription: Verify AbilityRecord GetPermissionedUriList
3170 */
3171 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPermissionedUriList_001, TestSize.Level1)
3172 {
3173 std::string uri = "file://com.example.test/test.txt";
3174 Want want;
3175 want.SetUri(uri);
3176 std::vector<std::string> uriVec = { uri };
3177 std::vector<bool> checkResults = {};
3178 auto permissionUris = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
3179 EXPECT_EQ(permissionUris.size(), 0);
3180 }
3181
3182 /*
3183 * Feature: AbilityRecord
3184 * Function: GetUriListFromWant
3185 * SubFunction: GetUriListFromWant
3186 * FunctionPoints: NA
3187 * EnvConditions: NA
3188 * CaseDescription: Verify AbilityRecord GetPermissionedUriList
3189 */
3190 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPermissionedUriList_002, TestSize.Level1)
3191 {
3192 std::string uri = "file://com.example.test/test.txt";
3193 Want want;
3194 want.SetUri(uri);
3195 std::vector<std::string> uriVec = { uri };
3196 std::vector<bool> checkResults = { false };
3197 auto permissionUris = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
3198 EXPECT_EQ(permissionUris.size(), 0);
3199 EXPECT_EQ(want.GetUriString(), "");
3200 }
3201
3202 /*
3203 * Feature: AbilityRecord
3204 * Function: GetUriListFromWant
3205 * SubFunction: GetUriListFromWant
3206 * FunctionPoints: NA
3207 * EnvConditions: NA
3208 * CaseDescription: Verify AbilityRecord GetPermissionedUriList
3209 */
3210 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPermissionedUriList_003, TestSize.Level1)
3211 {
3212 std::string uri = "invalid://com.example.test/test.txt";
3213 Want want;
3214 want.SetUri(uri);
3215 std::vector<std::string> uriVec = { uri };
3216 std::vector<bool> checkResults = { false };
3217 auto permissionUris = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
3218 EXPECT_EQ(permissionUris.size(), 0);
3219 EXPECT_EQ(want.GetUriString(), uri);
3220 }
3221
3222 /*
3223 * Feature: AbilityRecord
3224 * Function: GetUriListFromWant
3225 * SubFunction: GetUriListFromWant
3226 * FunctionPoints: NA
3227 * EnvConditions: NA
3228 * CaseDescription: Verify AbilityRecord GetPermissionedUriList
3229 */
3230 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPermissionedUriList_004, TestSize.Level1)
3231 {
3232 std::string uri = "file://com.example.test/test.txt";
3233 Want want;
3234 want.SetUri(uri);
3235 std::vector<std::string> uriVec = { uri };
3236 std::vector<bool> checkResults = { true };
3237 auto permissionUris = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
3238 EXPECT_EQ(permissionUris.size(), 1);
3239 EXPECT_EQ(want.GetUriString(), uri);
3240 }
3241
3242 /*
3243 * Feature: AbilityRecord
3244 * Function: GetUriListFromWant
3245 * SubFunction: GetUriListFromWant
3246 * FunctionPoints: NA
3247 * EnvConditions: NA
3248 * CaseDescription: Verify AbilityRecord GetPermissionedUriList
3249 */
3250 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPermissionedUriList_005, TestSize.Level1)
3251 {
3252 std::string uri = "file://com.example.test/test.txt";
3253 Want want;
3254 std::vector<std::string> oriUriVec(1, uri);
3255 want.SetParam(AbilityConfig::PARAMS_STREAM, oriUriVec);
3256 std::vector<std::string> uriVec = { uri };
3257 std::vector<bool> checkResults = { true };
3258 auto permissionUris = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
3259 EXPECT_EQ(permissionUris.size(), 1);
3260 auto paramStramUris = want.GetStringArrayParam(AbilityConfig::PARAMS_STREAM);
3261 EXPECT_EQ(paramStramUris.size(), 1);
3262 }
3263
3264 /*
3265 * Feature: AbilityRecord
3266 * Function: GetUriListFromWant
3267 * SubFunction: GetUriListFromWant
3268 * FunctionPoints: NA
3269 * EnvConditions: NA
3270 * CaseDescription: Verify AbilityRecord GetPermissionedUriList
3271 */
3272 HWTEST_F(AbilityRecordTest, AbilityRecord_GetPermissionedUriList_006, TestSize.Level1)
3273 {
3274 std::string uri1 = "file://com.example.test/test1.txt";
3275 std::string uri2 = "file://com.example.test/test2.txt";
3276 Want want;
3277 want.SetUri(uri1);
3278 std::vector<std::string> oriUriVec = { uri2 };
3279 want.SetParam(AbilityConfig::PARAMS_STREAM, oriUriVec);
3280 std::vector<std::string> uriVec = { uri1, uri2 };
3281 std::vector<bool> checkResults = { true, true };
3282 auto permissionUris = UriUtils::GetInstance().GetPermissionedUriList(uriVec, checkResults, want);
3283 EXPECT_EQ(permissionUris.size(), 2);
3284 EXPECT_EQ(want.GetUriString(), uri1);
3285 auto paramStramUris = want.GetStringArrayParam(AbilityConfig::PARAMS_STREAM);
3286 EXPECT_EQ(paramStramUris.size(), 1);
3287 }
3288 } // namespace AAFwk
3289 } // namespace OHOS
3290