1 /*
2  * Copyright (c) 2021 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 #define private public
18 #define protected public
19 #include "ability_info.h"
20 #include "mission.h"
21 #include "mission_list.h"
22 #include "want.h"
23 #include "application_info.h"
24 #undef private
25 #undef protected
26 
27 using namespace testing::ext;
28 using namespace OHOS::AppExecFwk;
29 
30 namespace OHOS {
31 namespace AAFwk {
32 class MissionTest : public testing::Test {
33 public:
34     static void SetUpTestCase(void);
35     static void TearDownTestCase(void);
36     void SetUp();
37     void TearDown();
38 
39     static AbilityRequest GenerateAbilityRequest(const std::string& deviceName, const std::string& abilityName,
40         const std::string& appName, const std::string& bundleName);
41 
42     Want want_{};
43     AbilityInfo abilityInfo_{};
44     ApplicationInfo appInfo_{};
45 };
46 
SetUpTestCase(void)47 void MissionTest::SetUpTestCase(void)
48 {}
TearDownTestCase(void)49 void MissionTest::TearDownTestCase(void)
50 {}
SetUp(void)51 void MissionTest::SetUp(void)
52 {}
TearDown(void)53 void MissionTest::TearDown(void)
54 {}
55 
GenerateAbilityRequest(const std::string & deviceName,const std::string & abilityName,const std::string & appName,const std::string & bundleName)56 AbilityRequest MissionTest::GenerateAbilityRequest(const std::string& deviceName, const std::string& abilityName,
57     const std::string& appName, const std::string& bundleName)
58 {
59     ElementName element(deviceName, abilityName, bundleName);
60     Want want;
61     want.SetElement(element);
62 
63     AbilityInfo abilityInfo;
64     abilityInfo.visible = true;
65     abilityInfo.applicationName = appName;
66     ApplicationInfo appinfo;
67     appinfo.name = appName;
68 
69     AbilityRequest abilityRequest;
70     abilityRequest.want = want;
71     abilityRequest.abilityInfo = abilityInfo;
72     abilityRequest.appInfo = appinfo;
73 
74     return abilityRequest;
75 }
76 
77 /*
78  * Feature: Mission
79  * Function: SetMissionList and GetMissionList
80  * SubFunction: NA
81  * FunctionPoints: Mission SetMissionList
82  * EnvConditions: NA
83  * CaseDescription: Verify SetMissionList
84  */
85 HWTEST_F(MissionTest, mission_set_mission_list_001, TestSize.Level1)
86 {
87     auto mission = std::make_shared<Mission>(1, nullptr);
88     EXPECT_EQ(nullptr, mission->GetMissionList());
89 }
90 
91 /*
92  * Feature: Mission
93  * Function: SetMissionList and GetMissionList
94  * SubFunction: NA
95  * FunctionPoints: Mission SetMissionList
96  * EnvConditions: NA
97  * CaseDescription: Verify SetMissionList
98  */
99 HWTEST_F(MissionTest, mission_set_mission_list_002, TestSize.Level1)
100 {
101     auto mission = std::make_shared<Mission>(1, nullptr);
102     mission->SetMissionList(nullptr);
103     EXPECT_EQ(nullptr, mission->GetMissionList());
104 }
105 
106 /*
107  * Feature: Mission
108  * Function: SetMissionList and GetMissionList
109  * SubFunction: NA
110  * FunctionPoints: Mission SetMissionList
111  * EnvConditions: NA
112  * CaseDescription: Verify SetMissionList
113  */
114 HWTEST_F(MissionTest, mission_set_mission_list_003, TestSize.Level1)
115 {
116     auto mission = std::make_shared<Mission>(1, nullptr);
117     auto missionList = std::make_shared<MissionList>();
118     mission->SetMissionList(missionList);
119     EXPECT_EQ(missionList, mission->GetMissionList());
120 }
121 
122 /*
123  * Feature: Mission
124  * Function: SetMissionList and GetMissionList
125  * SubFunction: NA
126  * FunctionPoints: Mission SetMissionList
127  * EnvConditions: NA
128  * CaseDescription: Verify SetMissionList
129  */
130 HWTEST_F(MissionTest, mission_set_mission_list_004, TestSize.Level1)
131 {
132     auto mission = std::make_shared<Mission>(1, nullptr);
133     auto missionList = std::make_shared<MissionList>();
134     mission->SetMissionList(missionList);
135     auto missionList1 = std::make_shared<MissionList>();
136     mission->SetMissionList(missionList1);
137     EXPECT_EQ(missionList1, mission->GetMissionList());
138 }
139 
140 /*
141  * Feature: Mission
142  * Function: IsSingletonAbility
143  * SubFunction: NA
144  * FunctionPoints: Mission IsSingletonAbility
145  * EnvConditions: NA
146  * CaseDescription: Verify IsSingletonAbility
147  */
148 HWTEST_F(MissionTest, mission_is_singleton_001, TestSize.Level1)
149 {
150     auto mission = std::make_shared<Mission>(1, nullptr);
151     EXPECT_FALSE(mission->IsSingletonAbility());
152 }
153 
154 /*
155  * Feature: Mission
156  * Function: IsSingletonAbility
157  * SubFunction: NA
158  * FunctionPoints: Mission IsSingletonAbility
159  * EnvConditions: NA
160  * CaseDescription: Verify IsSingletonAbility
161  */
162 HWTEST_F(MissionTest, mission_is_singleton_002, TestSize.Level1)
163 {
164     AppExecFwk::AbilityInfo abilityInfo;
165     abilityInfo.launchMode = AppExecFwk::LaunchMode::STANDARD;
166     Want want;
167     AppExecFwk::ApplicationInfo applicationInfo;
168     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
169     auto mission = std::make_shared<Mission>(0, abilityRecord);
170     EXPECT_FALSE(mission->IsSingletonAbility());
171 }
172 
173 /*
174  * Feature: Mission
175  * Function: IsSingletonAbility
176  * SubFunction: NA
177  * FunctionPoints: Mission IsSingletonAbility
178  * EnvConditions: NA
179  * CaseDescription: Verify IsSingletonAbility
180  */
181 HWTEST_F(MissionTest, mission_is_singleton_003, TestSize.Level1)
182 {
183     AppExecFwk::AbilityInfo abilityInfo;
184     abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
185     Want want;
186     AppExecFwk::ApplicationInfo applicationInfo;
187     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
188     auto mission = std::make_shared<Mission>(0, abilityRecord);
189     EXPECT_TRUE(mission->IsSingletonAbility());
190 }
191 
192 /*
193  * Feature: Mission
194  * Function: GetMissionName
195  * SubFunction: NA
196  * FunctionPoints: Mission GetMissionName
197  * EnvConditions: NA
198  * CaseDescription: Verify GetMissionName
199  */
200 HWTEST_F(MissionTest, mission_get_mission_name_001, TestSize.Level1)
201 {
202     AppExecFwk::AbilityInfo abilityInfo;
203     abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
204     Want want;
205     AppExecFwk::ApplicationInfo applicationInfo;
206     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
207     auto mission = std::make_shared<Mission>(0, abilityRecord);
208     EXPECT_TRUE("" == mission->GetMissionName());
209 }
210 
211 /*
212  * Feature: Mission
213  * Function: GetMissionName
214  * SubFunction: NA
215  * FunctionPoints: Mission GetMissionName
216  * EnvConditions: NA
217  * CaseDescription: Verify GetMissionName
218  */
219 HWTEST_F(MissionTest, mission_get_mission_name_002, TestSize.Level1)
220 {
221     AppExecFwk::AbilityInfo abilityInfo;
222     abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
223     Want want;
224     AppExecFwk::ApplicationInfo applicationInfo;
225     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
226     auto mission = std::make_shared<Mission>(0, abilityRecord, "");
227     EXPECT_TRUE("" == mission->GetMissionName());
228 }
229 
230 /*
231  * Feature: Mission
232  * Function: GetMissionName
233  * SubFunction: NA
234  * FunctionPoints: Mission GetMissionName
235  * EnvConditions: NA
236  * CaseDescription: Verify GetMissionName
237  */
238 HWTEST_F(MissionTest, mission_get_mission_name_003, TestSize.Level1)
239 {
240     AppExecFwk::AbilityInfo abilityInfo;
241     abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
242     Want want;
243     AppExecFwk::ApplicationInfo applicationInfo;
244     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
245     auto mission = std::make_shared<Mission>(0, abilityRecord, "name1");
246     EXPECT_TRUE("name1" == mission->GetMissionName());
247 }
248 
249 /*
250  * Feature: Mission
251  * Function: SetLockedState/IsLockedState
252  * SubFunction: NA
253  * FunctionPoints: Mission SetLockedState
254  * EnvConditions: NA
255  * CaseDescription: Verify SetLockedState/IsLockedState
256  */
257 HWTEST_F(MissionTest, mission_locked_state_001, TestSize.Level1)
258 {
259     AppExecFwk::AbilityInfo abilityInfo;
260     abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
261     Want want;
262     AppExecFwk::ApplicationInfo applicationInfo;
263     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
264     auto mission = std::make_shared<Mission>(0, abilityRecord, "name1");
265     EXPECT_FALSE(mission->IsLockedState());
266 }
267 
268 /*
269  * Feature: Mission
270  * Function: SetLockedState/IsLockedState
271  * SubFunction: NA
272  * FunctionPoints: Mission SetLockedState
273  * EnvConditions: NA
274  * CaseDescription: Verify SetLockedState/IsLockedState
275  */
276 HWTEST_F(MissionTest, mission_locked_state_002, TestSize.Level1)
277 {
278     AppExecFwk::AbilityInfo abilityInfo;
279     abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
280     Want want;
281     AppExecFwk::ApplicationInfo applicationInfo;
282     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
283     auto mission = std::make_shared<Mission>(0, abilityRecord, "name1");
284     mission->SetLockedState(true);
285     EXPECT_TRUE(mission->IsLockedState());
286 }
287 
288 /*
289  * Feature: Mission
290  * Function: SetLockedState/IsLockedState
291  * SubFunction: NA
292  * FunctionPoints: Mission SetLockedState
293  * EnvConditions: NA
294  * CaseDescription: Verify SetLockedState/IsLockedState
295  */
296 HWTEST_F(MissionTest, mission_locked_state_003, TestSize.Level1)
297 {
298     AppExecFwk::AbilityInfo abilityInfo;
299     abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
300     Want want;
301     AppExecFwk::ApplicationInfo applicationInfo;
302     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
303     auto mission = std::make_shared<Mission>(0, abilityRecord, "name1");
304     mission->SetLockedState(true);
305     EXPECT_TRUE(mission->IsLockedState());
306     mission->SetLockedState(false);
307     EXPECT_FALSE(mission->IsLockedState());
308 }
309 
310 /*
311  * Feature: Mission
312  * Function: copy constructor
313  * SubFunction: NA
314  * FunctionPoints: Mission copy constructor
315  * EnvConditions: NA
316  * CaseDescription: deep copy a object, with same content but different pointer address
317  */
318 HWTEST_F(MissionTest, mission_copy_constructor_001, TestSize.Level1)
319 {
320     AppExecFwk::AbilityInfo abilityInfo;
321     abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
322     Want want;
323     AppExecFwk::ApplicationInfo applicationInfo;
324     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
325     auto mission1 = std::make_shared<Mission>(0, abilityRecord, "name1");
326     auto mission2 = std::make_shared<Mission>(mission1);
327     EXPECT_NE(mission1, mission2);
328     EXPECT_NE(&(mission1->missionId_), &(mission2->missionId_));
329     EXPECT_NE(&(mission1->startMethod_), &(mission2->startMethod_));
330     EXPECT_NE(&(mission1->abilityRecord_), &(mission2->abilityRecord_));
331     EXPECT_NE(&(mission1->missionName_), &(mission2->missionName_));
332     EXPECT_EQ(mission1->missionId_, mission2->missionId_);
333     EXPECT_EQ(mission1->startMethod_, mission2->startMethod_);
334     EXPECT_EQ(mission1->abilityRecord_, mission2->abilityRecord_);
335     EXPECT_EQ(mission1->missionName_, mission2->missionName_);
336 }
337 
338 /*
339  * Feature: Mission
340  * Function: IsSpecifiedAbility
341  * SubFunction: NA
342  * FunctionPoints: Mission IsSpecifiedAbility
343  * EnvConditions: NA
344  * CaseDescription: Verify IsSpecifiedAbility
345  */
346 HWTEST_F(MissionTest, mission_is_specified_001, TestSize.Level1)
347 {
348     auto mission = std::make_shared<Mission>(1, nullptr);
349     EXPECT_FALSE(mission->IsSpecifiedAbility());
350 }
351 
352 /*
353  * Feature: Mission
354  * Function: IsSpecifiedAbility
355  * SubFunction: NA
356  * FunctionPoints: Mission IsSpecifiedAbility
357  * EnvConditions: NA
358  * CaseDescription: Verify IsSpecifiedAbility
359  */
360 HWTEST_F(MissionTest, mission_is_specified_002, TestSize.Level1)
361 {
362     AppExecFwk::AbilityInfo abilityInfo;
363     abilityInfo.launchMode = AppExecFwk::LaunchMode::STANDARD;
364     Want want;
365     AppExecFwk::ApplicationInfo applicationInfo;
366     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
367     auto mission = std::make_shared<Mission>(0, abilityRecord);
368     EXPECT_FALSE(mission->IsSpecifiedAbility());
369 }
370 
371 /*
372  * Feature: Mission
373  * Function: IsSpecifiedAbility
374  * SubFunction: NA
375  * FunctionPoints: Mission IsSpecifiedAbility
376  * EnvConditions: NA
377  * CaseDescription: Verify IsSpecifiedAbility
378  */
379 HWTEST_F(MissionTest, mission_is_specified_003, TestSize.Level1)
380 {
381     AppExecFwk::AbilityInfo abilityInfo;
382     abilityInfo.launchMode = AppExecFwk::LaunchMode::SPECIFIED;
383     Want want;
384     AppExecFwk::ApplicationInfo applicationInfo;
385     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
386     auto mission = std::make_shared<Mission>(0, abilityRecord);
387     EXPECT_TRUE(mission->IsSpecifiedAbility());
388 }
389 
390 /*
391  * Feature: Mission
392  * Function: SetSpecifiedFlag and GetSpecifiedFlag
393  * SubFunction: NA
394  * FunctionPoints: Mission SetSpecifiedFlag
395  * EnvConditions: NA
396  * CaseDescription: Verify SetSpecifiedFlag
397  */
398 HWTEST_F(MissionTest, mission_set_specified_flag_001, TestSize.Level1)
399 {
400     auto mission = std::make_shared<Mission>(1, nullptr);
401     EXPECT_EQ("", mission->GetSpecifiedFlag());
402 }
403 
404 /*
405  * Feature: Mission
406  * Function: SetSpecifiedFlag and GetSpecifiedFlag
407  * SubFunction: NA
408  * FunctionPoints: Mission SetSpecifiedFlag
409  * EnvConditions: NA
410  * CaseDescription: Verify SetSpecifiedFlag
411  */
412 HWTEST_F(MissionTest, mission_set_specified_flag_002, TestSize.Level1)
413 {
414     auto mission = std::make_shared<Mission>(1, nullptr);
415     mission->SetSpecifiedFlag("");
416     EXPECT_EQ("", mission->GetSpecifiedFlag());
417 }
418 
419 /*
420  * Feature: Mission
421  * Function: SetSpecifiedFlag and GetSpecifiedFlag
422  * SubFunction: NA
423  * FunctionPoints: Mission SetSpecifiedFlag
424  * EnvConditions: NA
425  * CaseDescription: Verify SetSpecifiedFlag
426  */
427 HWTEST_F(MissionTest, mission_set_specified_flag_003, TestSize.Level1)
428 {
429     auto mission = std::make_shared<Mission>(1, nullptr);
430     mission->SetSpecifiedFlag("test_string");
431     EXPECT_EQ("test_string", mission->GetSpecifiedFlag());
432 }
433 
434 /*
435  * Feature: Mission
436  * Function: SetSpecifiedFlag and GetSpecifiedFlag
437  * SubFunction: NA
438  * FunctionPoints: Mission SetSpecifiedFlag
439  * EnvConditions: NA
440  * CaseDescription: Verify SetSpecifiedFlag
441  */
442 HWTEST_F(MissionTest, mission_set_specified_flag_004, TestSize.Level1)
443 {
444     auto mission = std::make_shared<Mission>(1, nullptr);
445     mission->SetSpecifiedFlag("test_string");
446     mission->SetSpecifiedFlag("test_string2");
447     EXPECT_EQ("test_string2", mission->GetSpecifiedFlag());
448 }
449 
450 /*
451  * Feature: Mission
452  * Function: SetMovingState and IsMovingState
453  * SubFunction: NA
454  * FunctionPoints: Mission SetMovingState
455  * EnvConditions: NA
456  * CaseDescription: Verify SetMovingState
457  */
458 HWTEST_F(MissionTest, mission_set_moving_state_001, TestSize.Level1)
459 {
460     auto mission = std::make_shared<Mission>(1, nullptr);
461     EXPECT_EQ(false, mission->IsMovingState());
462 }
463 
464 
465 /*
466  * Feature: Mission
467  * Function: SetMovingState and IsMovingState
468  * SubFunction: NA
469  * FunctionPoints: Mission SetMovingState
470  * EnvConditions: NA
471  * CaseDescription: Verify SetMovingState
472  */
473 HWTEST_F(MissionTest, mission_set_moving_state_002, TestSize.Level1)
474 {
475     auto mission = std::make_shared<Mission>(1, nullptr);
476     mission->SetMovingState(true);
477     EXPECT_EQ(true, mission->IsMovingState());
478 }
479 
480 /*
481  * Feature: Mission
482  * Function: SetANRState and IsANRState
483  * SubFunction: NA
484  * FunctionPoints: Mission SetANRState
485  * EnvConditions: NA
486  * CaseDescription: Verify SetANRState
487  */
488 HWTEST_F(MissionTest, mission_set_anr_state_001, TestSize.Level1)
489 {
490     auto mission = std::make_shared<Mission>(1, nullptr);
491     EXPECT_EQ(false, mission->IsANRState());
492 }
493 
494 
495 /*
496  * Feature: Mission
497  * Function: SetANRState and IsANRState
498  * SubFunction: NA
499  * FunctionPoints: Mission SetANRState
500  * EnvConditions: NA
501  * CaseDescription: Verify SetANRState
502  */
503 HWTEST_F(MissionTest, mission_set_anr_state_002, TestSize.Level1)
504 {
505     auto mission = std::make_shared<Mission>(1, nullptr);
506     mission->SetANRState(true);
507     EXPECT_EQ(true, mission->IsANRState());
508 }
509 
510 /*
511  * Feature: Mission
512  * Function: Dump
513  * SubFunction: NA
514  * FunctionPoints: Mission Dump
515  * EnvConditions: NA
516  * CaseDescription: Test Dump
517  */
518 HWTEST_F(MissionTest, mission_dump, TestSize.Level1)
519 {
520     AppExecFwk::AbilityInfo abilityInfo;
521     abilityInfo.launchMode = AppExecFwk::LaunchMode::SINGLETON;
522     Want want;
523     AppExecFwk::ApplicationInfo applicationInfo;
524     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
525     auto mission = std::make_shared<Mission>(0, abilityRecord, "name1");
526     std::vector<std::string> info;
527     mission->Dump(info);
528 }
529 
530 /*
531  * Feature: Mission
532  * Function: UpdateMissionId
533  * SubFunction: NA
534  * FunctionPoints: Mission UpdateMissionId
535  * EnvConditions: NA
536  * CaseDescription: Verify UpdateMissionId
537  */
538 HWTEST_F(MissionTest, mission_update_mission_id, TestSize.Level1)
539 {
540     auto mission = std::make_shared<Mission>(1, nullptr, "name1", 0);
541     EXPECT_EQ(1, mission->GetMissionId());
542     EXPECT_EQ(false, mission->UpdateMissionId(2, 0));
543     EXPECT_EQ(1, mission->GetMissionId());
544     EXPECT_EQ(true, mission->UpdateMissionId(2, 1));
545     EXPECT_EQ(2, mission->GetMissionId());
546 }
547 }  // namespace AAFwk
548 }  // namespace OHOS