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