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