1 /*
2  * Copyright (c) 2022 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 "mission_data_storage.h"
20 #undef private
21 #undef protected
22 
23 using namespace testing::ext;
24 using namespace OHOS::AppExecFwk;
25 
26 namespace OHOS {
27 namespace AAFwk {
28 class MissionDataStorageTest : public testing::Test {
29 public:
30     static void SetUpTestCase(void);
31     static void TearDownTestCase(void);
32     void SetUp();
33     void TearDown();
34 };
35 
SetUpTestCase(void)36 void MissionDataStorageTest::SetUpTestCase(void)
37 {}
TearDownTestCase(void)38 void MissionDataStorageTest::TearDownTestCase(void)
39 {}
SetUp(void)40 void MissionDataStorageTest::SetUp(void)
41 {}
TearDown(void)42 void MissionDataStorageTest::TearDown(void)
43 {}
44 
45 /*
46  * Feature: MissionDataStorage
47  * Function: SaveMissionInfo
48  * SubFunction: NA
49  * FunctionPoints: MissionDataStorage SaveMissionInfo
50  * EnvConditions: NA
51  * CaseDescription: Verify SaveMissionInfo
52  */
53 HWTEST_F(MissionDataStorageTest, SaveMissionInfo_001, TestSize.Level1)
54 {
55     auto missionDataStorage = std::make_shared<MissionDataStorage>();
56     EXPECT_NE(missionDataStorage, nullptr);
57     InnerMissionInfo missionInfo;
58     missionInfo.missionInfo.id = 0;
59     missionDataStorage->SaveMissionInfo(missionInfo);
60 }
61 
62 /*
63  * Feature: MissionDataStorage
64  * Function: SaveMissionInfo
65  * SubFunction: NA
66  * FunctionPoints: MissionDataStorage SaveMissionInfo
67  * EnvConditions: NA
68  * CaseDescription: Verify SaveMissionInfo
69  */
70 HWTEST_F(MissionDataStorageTest, SaveMissionInfo_002, TestSize.Level1)
71 {
72     auto missionDataStorage = std::make_shared<MissionDataStorage>();
73     EXPECT_NE(missionDataStorage, nullptr);
74     missionDataStorage->userId_ = 10;
75     InnerMissionInfo missionInfo;
76     missionInfo.missionInfo.id = 1;
77     missionDataStorage->SaveMissionInfo(missionInfo);
78 }
79 
80 /*
81  * Feature: MissionDataStorage
82  * Function: DeleteMissionInfo
83  * SubFunction: NA
84  * FunctionPoints: MissionDataStorage DeleteMissionInfo
85  * EnvConditions: NA
86  * CaseDescription: Verify DeleteMissionInfo
87  */
88 HWTEST_F(MissionDataStorageTest, DeleteMissionInfo_001, TestSize.Level1)
89 {
90     auto missionDataStorage = std::make_shared<MissionDataStorage>();
91     EXPECT_NE(missionDataStorage, nullptr);
92     int missionId = 0;
93     missionDataStorage->DeleteMissionInfo(missionId);
94     missionId = 1;
95     missionDataStorage->DeleteMissionInfo(missionId);
96 }
97 
98 /*
99  * Feature: MissionDataStorage
100  * Function: SaveMissionSnapshot
101  * SubFunction: NA
102  * FunctionPoints: MissionDataStorage SaveMissionSnapshot
103  * EnvConditions: NA
104  * CaseDescription: Verify SaveMissionSnapshot
105  */
106 HWTEST_F(MissionDataStorageTest, SaveMissionSnapshot_001, TestSize.Level1)
107 {
108     auto missionDataStorage = std::make_shared<MissionDataStorage>();
109     EXPECT_NE(missionDataStorage, nullptr);
110     int missionId = 0;
111     MissionSnapshot missionSnapshot;
112     missionDataStorage->SaveMissionSnapshot(missionId, missionSnapshot);
113 }
114 
115 /*
116  * Feature: MissionDataStorage
117  * Function: DeleteMissionSnapshot
118  * SubFunction: NA
119  * FunctionPoints: MissionDataStorage DeleteMissionSnapshot
120  * EnvConditions: NA
121  * CaseDescription: Verify DeleteMissionSnapshot
122  */
123 HWTEST_F(MissionDataStorageTest, DeleteMissionSnapshot_001, TestSize.Level1)
124 {
125     auto missionDataStorage = std::make_shared<MissionDataStorage>();
126     EXPECT_NE(missionDataStorage, nullptr);
127     int missionId = 0;
128     missionDataStorage->DeleteMissionSnapshot(missionId);
129 }
130 
131 /*
132  * Feature: MissionDataStorage
133  * Function: DeleteMissionSnapshot
134  * SubFunction: NA
135  * FunctionPoints: MissionDataStorage DeleteMissionSnapshot
136  * EnvConditions: NA
137  * CaseDescription: Verify DeleteMissionSnapshot
138  */
139 HWTEST_F(MissionDataStorageTest, DeleteMissionSnapshot_002, TestSize.Level1)
140 {
141     auto missionDataStorage = std::make_shared<MissionDataStorage>();
142     EXPECT_NE(missionDataStorage, nullptr);
143     int32_t missionId = 0;
144     MissionSnapshot missionSnapshot;
145     missionDataStorage->SaveMissionSnapshot(missionId, missionSnapshot);
146     missionDataStorage->DeleteMissionSnapshot(missionId);
147 }
148 
149 /*
150  * Feature: MissionDataStorage
151  * Function: GetMissionSnapshot
152  * SubFunction: NA
153  * FunctionPoints: MissionDataStorage GetMissionSnapshot
154  * EnvConditions: NA
155  * CaseDescription: Verify GetMissionSnapshot
156  */
157 HWTEST_F(MissionDataStorageTest, GetMissionSnapshot_001, TestSize.Level1)
158 {
159     auto missionDataStorage = std::make_shared<MissionDataStorage>();
160     int missionId = 0;
161     MissionSnapshot missionSnapshot;
162     bool isLowResolution = true;
163     missionDataStorage->SaveCachedSnapshot(missionId, missionSnapshot);
164     bool res = missionDataStorage->GetMissionSnapshot(missionId, missionSnapshot, isLowResolution);
165     EXPECT_TRUE(res);
166 }
167 
168 /*
169  * Feature: MissionDataStorage
170  * Function: GetMissionSnapshot
171  * SubFunction: NA
172  * FunctionPoints: MissionDataStorage GetMissionSnapshot
173  * EnvConditions: NA
174  * CaseDescription: Verify GetMissionSnapshot
175  */
176 HWTEST_F(MissionDataStorageTest, GetMissionSnapshot_002, TestSize.Level1)
177 {
178     auto missionDataStorage = std::make_shared<MissionDataStorage>();
179     int missionId = 0;
180     MissionSnapshot missionSnapshot;
181     bool isLowResolution = false;
182     missionDataStorage->SaveCachedSnapshot(missionId, missionSnapshot);
183     bool res = missionDataStorage->GetMissionSnapshot(missionId, missionSnapshot, isLowResolution);
184     EXPECT_TRUE(res);
185 }
186 
187 /*
188  * Feature: MissionDataStorage
189  * Function: GetMissionSnapshot
190  * SubFunction: NA
191  * FunctionPoints: MissionDataStorage GetMissionSnapshot
192  * EnvConditions: NA
193  * CaseDescription: Verify GetMissionSnapshot
194  */
195 HWTEST_F(MissionDataStorageTest, GetMissionSnapshot_003, TestSize.Level1)
196 {
197     auto missionDataStorage = std::make_shared<MissionDataStorage>();
198     int missionId = 0;
199     MissionSnapshot missionSnapshot;
200     bool isLowResolution = true;
201     bool res = missionDataStorage->GetMissionSnapshot(missionId, missionSnapshot, isLowResolution);
202     EXPECT_FALSE(res);
203 }
204 
205 /*
206  * Feature: MissionDataStorage
207  * Function: GetMissionDataFilePath
208  * SubFunction: NA
209  * FunctionPoints: MissionDataStorage GetMissionDataFilePath
210  * EnvConditions: NA
211  * CaseDescription: Verify GetMissionDataFilePath
212  */
213 HWTEST_F(MissionDataStorageTest, GetMissionDataFilePath_001, TestSize.Level1)
214 {
215     auto missionDataStorage = std::make_shared<MissionDataStorage>();
216     int missionId = 0;
217     std::string res = missionDataStorage->GetMissionDataFilePath(missionId);
218     EXPECT_EQ(res, "/data/service/el1/public/AbilityManagerService/0/MissionInfo/mission_0.json");
219 }
220 
221 /*
222  * Feature: MissionDataStorage
223  * Function: GetMissionSnapshotPath
224  * SubFunction: NA
225  * FunctionPoints: MissionDataStorage GetMissionSnapshotPath
226  * EnvConditions: NA
227  * CaseDescription: Verify GetMissionSnapshotPath
228  */
229 HWTEST_F(MissionDataStorageTest, GetMissionSnapshotPath_001, TestSize.Level1)
230 {
231     auto missionDataStorage = std::make_shared<MissionDataStorage>();
232     int missionId = 0;
233     bool isLowResolution = true;
234     std::string res = missionDataStorage->GetMissionSnapshotPath(missionId, isLowResolution);
235     EXPECT_EQ(res, "/data/service/el1/public/AbilityManagerService/0/MissionInfo/mission_0_little.jpg");
236 }
237 
238 /*
239  * Feature: MissionDataStorage
240  * Function: GetMissionSnapshotPath
241  * SubFunction: NA
242  * FunctionPoints: MissionDataStorage GetMissionSnapshotPath
243  * EnvConditions: NA
244  * CaseDescription: Verify GetMissionSnapshotPath
245  */
246 HWTEST_F(MissionDataStorageTest, GetMissionSnapshotPath_002, TestSize.Level1)
247 {
248     auto missionDataStorage = std::make_shared<MissionDataStorage>();
249     int missionId = 0;
250     bool isLowResolution = false;
251     std::string res = missionDataStorage->GetMissionSnapshotPath(missionId, isLowResolution);
252     EXPECT_EQ(res, "/data/service/el1/public/AbilityManagerService/0/MissionInfo/mission_0.jpg");
253 }
254 
255 /*
256  * Feature: MissionDataStorage
257  * Function: SaveSnapshotFile
258  * SubFunction: NA
259  * FunctionPoints: MissionDataStorage SaveSnapshotFile
260  * EnvConditions: NA
261  * CaseDescription: Verify SaveSnapshotFile
262  */
263 HWTEST_F(MissionDataStorageTest, SaveSnapshotFile_001, TestSize.Level1)
264 {
265     auto missionDataStorage = std::make_shared<MissionDataStorage>();
266     EXPECT_NE(missionDataStorage, nullptr);
267     int32_t missionId = 0;
268     MissionSnapshot missionSnapshot;
269     missionDataStorage->SaveSnapshotFile(missionId, missionSnapshot);
270 }
271 
272 /*
273  * Feature: MissionDataStorage
274  * Function: SaveSnapshotFile
275  * SubFunction: NA
276  * FunctionPoints: MissionDataStorage SaveSnapshotFile
277  * EnvConditions: NA
278  * CaseDescription: Verify SaveSnapshotFile
279  */
280 HWTEST_F(MissionDataStorageTest, SaveSnapshotFile_002, TestSize.Level1)
281 {
282     auto missionDataStorage = std::make_shared<MissionDataStorage>();
283     EXPECT_NE(missionDataStorage, nullptr);
284     int32_t missionId = 1;
285     MissionSnapshot missionSnapshot;
286     missionSnapshot.snapshot = std::make_shared<Media::PixelMap>();
287     missionDataStorage->SaveSnapshotFile(missionId, missionSnapshot);
288 }
289 
290 /*
291  * Feature: MissionDataStorage
292  * Function: SaveSnapshotFile
293  * SubFunction: NA
294  * FunctionPoints: MissionDataStorage SaveSnapshotFile
295  * EnvConditions: NA
296  * CaseDescription: Verify SaveSnapshotFile
297  */
298 HWTEST_F(MissionDataStorageTest, SaveSnapshotFile_004, TestSize.Level1)
299 {
300     auto missionDataStorage = std::make_shared<MissionDataStorage>();
301     EXPECT_NE(missionDataStorage, nullptr);
302     int32_t missionId = 0;
303     MissionSnapshot missionSnapshot;
304     missionSnapshot.snapshot = std::make_shared<Media::PixelMap>();
305     missionSnapshot.snapshot->imageInfo_.pixelFormat = Media::PixelFormat::RGB_565;
306     missionDataStorage->SaveSnapshotFile(missionId, missionSnapshot);
307 }
308 
309 /*
310  * Feature: MissionDataStorage
311  * Function: SaveSnapshotFile
312  * SubFunction: NA
313  * FunctionPoints: MissionDataStorage SaveSnapshotFile
314  * EnvConditions: NA
315  * CaseDescription: Verify SaveSnapshotFile
316  */
317 HWTEST_F(MissionDataStorageTest, SaveSnapshotFile_005, TestSize.Level1)
318 {
319     auto missionDataStorage = std::make_shared<MissionDataStorage>();
320     EXPECT_NE(missionDataStorage, nullptr);
321     int32_t missionId = 0;
322     MissionSnapshot missionSnapshot;
323     missionSnapshot.snapshot = std::make_shared<Media::PixelMap>();
324     missionSnapshot.snapshot->imageInfo_.pixelFormat = Media::PixelFormat::RGBA_8888;
325     missionDataStorage->SaveSnapshotFile(missionId, missionSnapshot);
326 }
327 
328 /*
329  * Feature: MissionDataStorage
330  * Function: SaveSnapshotFile
331  * SubFunction: NA
332  * FunctionPoints: MissionDataStorage SaveSnapshotFile
333  * EnvConditions: NA
334  * CaseDescription: Verify SaveSnapshotFile
335  */
336 HWTEST_F(MissionDataStorageTest, SaveSnapshotFile_006, TestSize.Level1)
337 {
338     auto missionDataStorage = std::make_shared<MissionDataStorage>();
339     EXPECT_NE(missionDataStorage, nullptr);
340     int32_t missionId = 0;
341     MissionSnapshot missionSnapshot;
342     missionSnapshot.snapshot = std::make_shared<Media::PixelMap>();
343     missionSnapshot.snapshot->imageInfo_.pixelFormat = Media::PixelFormat::RGB_888;
344     missionDataStorage->SaveSnapshotFile(missionId, missionSnapshot);
345 }
346 
347 /*
348  * Feature: MissionDataStorage
349  * Function: SaveSnapshotFile
350  * SubFunction: NA
351  * FunctionPoints: MissionDataStorage SaveSnapshotFile
352  * EnvConditions: NA
353  * CaseDescription: Verify SaveSnapshotFile
354  */
355 HWTEST_F(MissionDataStorageTest, SaveSnapshotFile_007, TestSize.Level1)
356 {
357     auto missionDataStorage = std::make_shared<MissionDataStorage>();
358     EXPECT_NE(missionDataStorage, nullptr);
359     int32_t missionId = 0;
360     MissionSnapshot missionSnapshot;
361     missionSnapshot.snapshot = std::make_shared<Media::PixelMap>();
362     missionDataStorage->SaveSnapshotFile(missionId, missionSnapshot);
363 }
364 
365 /*
366  * Feature: MissionDataStorage
367  * Function: GetReducedPixelMap
368  * SubFunction: NA
369  * FunctionPoints: MissionDataStorage GetReducedPixelMap
370  * EnvConditions: NA
371  * CaseDescription: Verify GetReducedPixelMap
372  */
373 HWTEST_F(MissionDataStorageTest, GetReducedPixelMap_001, TestSize.Level1)
374 {
375     auto missionDataStorage = std::make_shared<MissionDataStorage>();
376     std::shared_ptr<OHOS::Media::PixelMap> snapshot = nullptr;
377     auto res = missionDataStorage->GetReducedPixelMap(snapshot);
378     EXPECT_EQ(res, nullptr);
379 }
380 
381 /*
382  * Feature: MissionDataStorage
383  * Function: GetReducedPixelMap
384  * SubFunction: NA
385  * FunctionPoints: MissionDataStorage GetReducedPixelMap
386  * EnvConditions: NA
387  * CaseDescription: Verify GetReducedPixelMap
388  */
389 HWTEST_F(MissionDataStorageTest, GetReducedPixelMap_002, TestSize.Level1)
390 {
391     auto missionDataStorage = std::make_shared<MissionDataStorage>();
392     std::shared_ptr<OHOS::Media::PixelMap> snapshot = std::make_shared<Media::PixelMap>();
393     auto res = missionDataStorage->GetReducedPixelMap(snapshot);
394     EXPECT_EQ(res, nullptr);
395 }
396 
397 /*
398  * Feature: MissionDataStorage
399  * Function: GetCachedSnapshot
400  * SubFunction: NA
401  * FunctionPoints: MissionDataStorage GetCachedSnapshot
402  * EnvConditions: NA
403  * CaseDescription: Verify GetCachedSnapshot
404  */
405 HWTEST_F(MissionDataStorageTest, GetCachedSnapshot_001, TestSize.Level1)
406 {
407     auto missionDataStorage = std::make_shared<MissionDataStorage>();
408     int32_t missionId = 0;
409     MissionSnapshot missionSnapshot;
410     bool res = missionDataStorage->GetCachedSnapshot(missionId, missionSnapshot);
411     EXPECT_FALSE(res);
412 }
413 
414 /*
415  * Feature: MissionDataStorage
416  * Function: GetCachedSnapshot
417  * SubFunction: NA
418  * FunctionPoints: MissionDataStorage GetCachedSnapshot
419  * EnvConditions: NA
420  * CaseDescription: Verify GetCachedSnapshot
421  */
422 HWTEST_F(MissionDataStorageTest, GetCachedSnapshot_002, TestSize.Level1)
423 {
424     auto missionDataStorage = std::make_shared<MissionDataStorage>();
425     missionDataStorage->cachedPixelMap_.insert({ 0, nullptr });
426     int32_t missionId = 0;
427     MissionSnapshot missionSnapshot;
428     bool res = missionDataStorage->GetCachedSnapshot(missionId, missionSnapshot);
429     EXPECT_TRUE(res);
430 }
431 
432 /*
433  * Feature: MissionDataStorage
434  * Function: SaveCachedSnapshot
435  * SubFunction: NA
436  * FunctionPoints: MissionDataStorage SaveCachedSnapshot
437  * EnvConditions: NA
438  * CaseDescription: Verify SaveCachedSnapshot
439  */
440 HWTEST_F(MissionDataStorageTest, SaveCachedSnapshot_001, TestSize.Level1)
441 {
442     auto missionDataStorage = std::make_shared<MissionDataStorage>();
443     int32_t missionId = 0;
444     MissionSnapshot missionSnapshot;
445     missionSnapshot.snapshot = std::make_shared<Media::PixelMap>();
446     bool res = missionDataStorage->SaveCachedSnapshot(missionId, missionSnapshot);
447     EXPECT_TRUE(res);
448 }
449 
450 /*
451  * Feature: MissionDataStorage
452  * Function: SaveCachedSnapshot
453  * SubFunction: NA
454  * FunctionPoints: MissionDataStorage SaveCachedSnapshot
455  * EnvConditions: NA
456  * CaseDescription: Verify SaveCachedSnapshot
457  */
458 HWTEST_F(MissionDataStorageTest, SaveCachedSnapshot_002, TestSize.Level1)
459 {
460     auto missionDataStorage = std::make_shared<MissionDataStorage>();
461     int32_t missionId = 0;
462     MissionSnapshot missionSnapshot;
463     missionDataStorage->SaveCachedSnapshot(missionId, missionSnapshot);
464     bool res = missionDataStorage->SaveCachedSnapshot(missionId, missionSnapshot);
465     EXPECT_FALSE(res);
466 }
467 
468 /*
469  * Feature: MissionDataStorage
470  * Function: DeleteCachedSnapshot
471  * SubFunction: NA
472  * FunctionPoints: MissionDataStorage DeleteCachedSnapshot
473  * EnvConditions: NA
474  * CaseDescription: Verify DeleteCachedSnapshot
475  */
476 HWTEST_F(MissionDataStorageTest, DeleteCachedSnapshot_001, TestSize.Level1)
477 {
478     auto missionDataStorage = std::make_shared<MissionDataStorage>();
479     int32_t missionId = 0;
480     bool res = missionDataStorage->DeleteCachedSnapshot(missionId);
481     EXPECT_FALSE(res);
482 }
483 
484 /*
485  * Feature: MissionDataStorage
486  * Function: DeleteCachedSnapshot
487  * SubFunction: NA
488  * FunctionPoints: MissionDataStorage DeleteCachedSnapshot
489  * EnvConditions: NA
490  * CaseDescription: Verify DeleteCachedSnapshot
491  */
492 HWTEST_F(MissionDataStorageTest, DeleteCachedSnapshot_002, TestSize.Level1)
493 {
494     auto missionDataStorage = std::make_shared<MissionDataStorage>();
495     missionDataStorage->cachedPixelMap_.insert({ 0, nullptr });
496     int32_t missionId = 0;
497     bool res = missionDataStorage->DeleteCachedSnapshot(missionId);
498     EXPECT_TRUE(res);
499 }
500 
501 /*
502  * Feature: MissionDataStorage
503  * Function: GetSnapshot
504  * SubFunction: NA
505  * FunctionPoints: MissionDataStorage GetSnapshot
506  * EnvConditions: NA
507  * CaseDescription: Verify GetSnapshot
508  */
509 HWTEST_F(MissionDataStorageTest, GetSnapshot_001, TestSize.Level1)
510 {
511     auto missionDataStorage = std::make_shared<MissionDataStorage>();
512     int32_t missionId = 0;
513     bool isLowResolution = true;
514     std::shared_ptr<Media::PixelMap> res = missionDataStorage->GetSnapshot(missionId, isLowResolution);
515     EXPECT_EQ(res, nullptr);
516 }
517 
518 /*
519  * Feature: MissionDataStorage
520  * Function: GetPixelMap
521  * SubFunction: NA
522  * FunctionPoints: MissionDataStorage GetPixelMap
523  * EnvConditions: NA
524  * CaseDescription: Verify GetPixelMap
525  */
526 HWTEST_F(MissionDataStorageTest, GetPixelMap_001, TestSize.Level1)
527 {
528     auto missionDataStorage = std::make_shared<MissionDataStorage>();
529     int32_t missionId = 0;
530     bool isLowResolution = true;
531     std::unique_ptr<Media::PixelMap> res = missionDataStorage->GetPixelMap(missionId, isLowResolution);
532     EXPECT_EQ(res, nullptr);
533 }
534 
535 /*
536  * Feature: MissionDataStorage
537  * Function: GetPixelMap
538  * SubFunction: NA
539  * FunctionPoints: MissionDataStorage GetPixelMap
540  * EnvConditions: NA
541  * CaseDescription: Verify GetPixelMap
542  */
543 HWTEST_F(MissionDataStorageTest, GetPixelMap_002, TestSize.Level1)
544 {
545     auto missionDataStorage = std::make_shared<MissionDataStorage>();
546     EXPECT_NE(missionDataStorage, nullptr);
547     int32_t missionId = 100;
548     bool isLowResolution = false;
549     std::unique_ptr<Media::PixelMap> res = missionDataStorage->GetPixelMap(missionId, isLowResolution);
550     EXPECT_EQ(res, nullptr);
551 }
552 }  // namespace AAFwk
553 }  // namespace OHOS
554