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
27using namespace testing::ext;
28using namespace OHOS::AppExecFwk;
29
30namespace OHOS {
31namespace AAFwk {
32class MissionTest : public testing::Test {
33public:
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
47void MissionTest::SetUpTestCase(void)
48{}
49void MissionTest::TearDownTestCase(void)
50{}
51void MissionTest::SetUp(void)
52{}
53void MissionTest::TearDown(void)
54{}
55
56AbilityRequest 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 */
85HWTEST_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 */
99HWTEST_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 */
114HWTEST_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 */
130HWTEST_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 */
148HWTEST_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 */
162HWTEST_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 */
181HWTEST_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 */
200HWTEST_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 */
219HWTEST_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 */
238HWTEST_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 */
257HWTEST_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 */
276HWTEST_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 */
296HWTEST_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 */
318HWTEST_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 */
346HWTEST_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 */
360HWTEST_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 */
379HWTEST_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 */
398HWTEST_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 */
412HWTEST_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 */
427HWTEST_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 */
442HWTEST_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 */
458HWTEST_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 */
473HWTEST_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 */
488HWTEST_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 */
503HWTEST_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 */
518HWTEST_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 */
538HWTEST_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