1 /*
2  * Copyright (c) 2024 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 <cstring>
17 #include <cstdint>
18 #include <securec.h>
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21 
22 #define private public
23 #include "pixel_map.h"
24 #include "directory_ex.h"
25 #include "image_source.h"
26 #include "image_utils.h"
27 #include "ohos_image_decoder_adapter_impl.h"
28 #undef private
29 
30 using namespace testing;
31 using namespace testing::ext;
32 
33 namespace OHOS {
34 
35 namespace NWeb {
36 namespace {
37 
38 static const std::string IMAGE_FILE_PATH = "/data/local/tmp/image/test.heic";
39 
ReadFileToBuffer(const std::string & filePath,uint8_t * buffer,size_t bufferSize)40 bool ReadFileToBuffer(const std::string &filePath, uint8_t *buffer, size_t bufferSize)
41 {
42     std::string realPath;
43     if (!OHOS::PathToRealPath(filePath, realPath)) {
44         return false;
45     }
46 
47     if (buffer == nullptr) {
48         return false;
49     }
50 
51     FILE *fp = fopen(realPath.c_str(), "rb");
52     if (fp == nullptr) {
53         return false;
54     }
55     if (fseek(fp, 0, SEEK_END) != 0) {
56         fclose(fp);
57         return false;
58     }
59     size_t fileSize = ftell(fp);
60     if (fseek(fp, 0, SEEK_SET) != 0) {
61         fclose(fp);
62         return false;
63     }
64     if (bufferSize < fileSize) {
65         fclose(fp);
66         return false;
67     }
68     size_t retSize = fread(buffer, 1, fileSize, fp);
69     if (retSize != fileSize) {
70         fclose(fp);
71         return false;
72     }
73     int ret = fclose(fp);
74     if (ret != 0) {
75         return true;
76     }
77     return true;
78 }
79 
TestInitImage(OhosImageDecoderAdapterImpl & imageDecoderAdapterImpl,uint8_t * buffer)80 bool TestInitImage(OhosImageDecoderAdapterImpl &imageDecoderAdapterImpl, uint8_t *buffer)
81 {
82     size_t bufferSize = 0;
83     bool boolRes = Media::ImageUtils::GetFileSize(IMAGE_FILE_PATH, bufferSize);
84     if (!boolRes) {
85         return false;
86     }
87 
88     buffer = static_cast<uint8_t *>(malloc(bufferSize));
89     if (buffer == nullptr) {
90         return false;
91     }
92 
93     boolRes = ReadFileToBuffer(IMAGE_FILE_PATH, buffer, bufferSize);
94     if (!boolRes) {
95         free(buffer);
96         return false;
97     }
98 
99     boolRes = imageDecoderAdapterImpl.ParseImageInfo(buffer, bufferSize);
100     if (!boolRes) {
101         free(buffer);
102         return false;
103     }
104     return true;
105 }
106 
TestDecodeImage(OhosImageDecoderAdapterImpl & imageDecoderAdapterImpl,uint8_t * buffer,AllocatorType type)107 bool TestDecodeImage(OhosImageDecoderAdapterImpl &imageDecoderAdapterImpl, uint8_t *buffer, AllocatorType type)
108 {
109     size_t bufferSize = 0;
110     bool boolRes = Media::ImageUtils::GetFileSize(IMAGE_FILE_PATH, bufferSize);
111     if (!boolRes) {
112         return false;
113     }
114 
115     buffer = static_cast<uint8_t *>(malloc(bufferSize));
116     if (buffer == nullptr) {
117         return false;
118     }
119 
120     boolRes = ReadFileToBuffer(IMAGE_FILE_PATH, buffer, bufferSize);
121     if (!boolRes) {
122         free(buffer);
123         return false;
124     }
125 
126     boolRes = imageDecoderAdapterImpl.Decode(buffer, bufferSize, type, false);
127     if (!boolRes) {
128         free(buffer);
129         return false;
130     }
131     return true;
132 }
133 } // namespace
134 
135 class OhosImageAdapterTest : public testing::Test {
136 public:
137     static void SetUpTestCase(void);
138     static void TearDownTestCase(void);
139     void SetUp();
140     void TearDown();
141 };
142 
SetUpTestCase(void)143 void OhosImageAdapterTest::SetUpTestCase(void)
144 {}
145 
TearDownTestCase(void)146 void OhosImageAdapterTest::TearDownTestCase(void)
147 {}
148 
SetUp(void)149 void OhosImageAdapterTest::SetUp(void)
150 {}
151 
TearDown(void)152 void OhosImageAdapterTest::TearDown(void)
153 {}
154 
155 /**
156  * @tc.name: OhosImageAdapterTest_ParseImageInfo_001
157  * @tc.desc: ParseImageInfo.
158  * @tc.type: FUNC
159  * @tc.require:
160  */
161 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_ParseImageInfo_001, TestSize.Level1)
162 {
163     uint8_t data[32] = {0};
164     uint32_t size = sizeof(data);
165     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
166 
167     bool result = imageDecoderAdapterImpl.ParseImageInfo(nullptr, size);
168     EXPECT_FALSE(result);
169 
170     result = imageDecoderAdapterImpl.ParseImageInfo(data, 0);
171     EXPECT_FALSE(result);
172 
173     result = imageDecoderAdapterImpl.ParseImageInfo(data, size);
174     EXPECT_FALSE(result);
175 
176     size_t bufferSize = 0;
177     bool boolRes = Media::ImageUtils::GetFileSize(IMAGE_FILE_PATH, bufferSize);
178     EXPECT_TRUE(boolRes);
179 
180     uint8_t *buffer = static_cast<uint8_t *>(malloc(bufferSize));
181     EXPECT_NE(buffer, nullptr);
182 
183     boolRes = ReadFileToBuffer(IMAGE_FILE_PATH, buffer, bufferSize);
184     EXPECT_TRUE(boolRes);
185 
186     boolRes = imageDecoderAdapterImpl.ParseImageInfo(buffer, (uint32_t)bufferSize);
187     EXPECT_TRUE(boolRes);
188 
189     free(buffer);
190 }
191 
192 /**
193  * @tc.name: OhosImageAdapterTest_GetEncodedFormat_002
194  * @tc.desc: GetEncodedFormat.
195  * @tc.type: FUNC
196  * @tc.require:
197  */
198 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetEncodedFormat_002, TestSize.Level1)
199 {
200     uint8_t *buffer = nullptr;
201     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
202 
203     bool ret = TestInitImage(imageDecoderAdapterImpl, buffer);
204     EXPECT_TRUE(ret);
205     std::string format = imageDecoderAdapterImpl.GetEncodedFormat();
206     EXPECT_NE(format, "");
207 
208     free(buffer);
209 }
210 
211 /**
212  * @tc.name: OhosImageAdapterTest_GetImageWidth_003
213  * @tc.desc: GetImageWidth.
214  * @tc.type: FUNC
215  * @tc.require:
216  */
217 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetImageWidth_003, TestSize.Level1)
218 {
219     uint8_t *buffer = nullptr;
220     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
221 
222     bool ret = TestInitImage(imageDecoderAdapterImpl, buffer);
223     EXPECT_TRUE(ret);
224     int32_t width = imageDecoderAdapterImpl.GetImageWidth();
225     EXPECT_NE(width, 0);
226 
227     free(buffer);
228 }
229 
230 /**
231  * @tc.name: OhosImageAdapterTest_GetImageHeight_004
232  * @tc.desc: GetImageHeight.
233  * @tc.type: FUNC
234  * @tc.require:
235  */
236 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetImageHeight_004, TestSize.Level1)
237 {
238     uint8_t *buffer = nullptr;
239     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
240 
241     bool ret = TestInitImage(imageDecoderAdapterImpl, buffer);
242     EXPECT_TRUE(ret);
243     int32_t heigth = imageDecoderAdapterImpl.GetImageHeight();
244     EXPECT_NE(heigth, 0);
245 
246     free(buffer);
247 }
248 
249 /**
250  * @tc.name: OhosImageAdapterTest_DecodeToPixelMap_005
251  * @tc.desc: DecodeToPixelMap.
252  * @tc.type: FUNC
253  * @tc.require:
254  */
255 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_DecodeToPixelMap_005, TestSize.Level1)
256 {
257     size_t bufferSize = 0;
258     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
259 
260     bool ret = imageDecoderAdapterImpl.DecodeToPixelMap(nullptr, bufferSize);
261     EXPECT_FALSE(ret);
262 
263     bool boolRes = Media::ImageUtils::GetFileSize(IMAGE_FILE_PATH, bufferSize);
264 
265     uint8_t *buffer = static_cast<uint8_t *>(malloc(bufferSize));
266 
267     boolRes = ReadFileToBuffer(IMAGE_FILE_PATH, buffer, bufferSize);
268     EXPECT_TRUE(boolRes);
269 
270     ret = imageDecoderAdapterImpl.DecodeToPixelMap(buffer, bufferSize);
271     EXPECT_TRUE(ret);
272 
273     free(buffer);
274 
275     imageDecoderAdapterImpl.ReleasePixelMap();
276 }
277 
278 /**
279  * @tc.name: OhosImageAdapterTest_GetFd_006
280  * @tc.desc: GetFd.
281  * @tc.type: FUNC
282  * @tc.require:
283  */
284 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetFd_006, TestSize.Level1)
285 {
286     uint8_t *buffer = nullptr;
287     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
288 
289     int32_t fd = imageDecoderAdapterImpl.GetFd();
290     EXPECT_EQ(fd, -1);
291 
292     bool ret = TestDecodeImage(imageDecoderAdapterImpl, buffer, AllocatorType::kDmaAlloc);
293     EXPECT_TRUE(ret);
294 
295     fd = imageDecoderAdapterImpl.GetFd();
296     EXPECT_NE(fd, -1);
297 
298     auto* pixelMap = imageDecoderAdapterImpl.GetPixelMap();
299     pixelMap->FreePixelMap();
300     fd = imageDecoderAdapterImpl.GetFd();
301     EXPECT_EQ(fd, -1);
302 
303     free(buffer);
304 
305     imageDecoderAdapterImpl.ReleasePixelMap();
306 }
307 
308 /**
309  * @tc.name: OhosImageAdapterTest_GetStride_007
310  * @tc.desc: GetStride.
311  * @tc.type: FUNC
312  * @tc.require:
313  */
314 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetStride_007, TestSize.Level1)
315 {
316     uint8_t *buffer = nullptr;
317     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
318 
319     int32_t stride = imageDecoderAdapterImpl.GetStride();
320     EXPECT_EQ(stride, 0);
321 
322     bool ret = TestDecodeImage(imageDecoderAdapterImpl, buffer, AllocatorType::kDmaAlloc);
323     EXPECT_TRUE(ret);
324 
325     stride = imageDecoderAdapterImpl.GetStride();
326     EXPECT_NE(stride, 0);
327 
328     auto* pixelMap = imageDecoderAdapterImpl.GetPixelMap();
329     pixelMap->FreePixelMap();
330     stride = imageDecoderAdapterImpl.GetStride();
331     EXPECT_EQ(stride, 0);
332 
333     free(buffer);
334     buffer = nullptr;
335 
336     imageDecoderAdapterImpl.ReleasePixelMap();
337 
338     ret = TestDecodeImage(imageDecoderAdapterImpl, buffer, AllocatorType::kShareMemAlloc);
339     EXPECT_TRUE(ret);
340 
341     stride = imageDecoderAdapterImpl.GetStride();
342     EXPECT_NE(stride, 0);
343 
344     pixelMap = imageDecoderAdapterImpl.GetPixelMap();
345     pixelMap->FreePixelMap();
346 
347     free(buffer);
348 
349     imageDecoderAdapterImpl.ReleasePixelMap();
350 }
351 
352 /**
353  * @tc.name: OhosImageAdapterTest_GetOffset_008
354  * @tc.desc: GetOffset.
355  * @tc.type: FUNC
356  * @tc.require:
357  */
358 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetOffset_008, TestSize.Level1)
359 {
360     uint8_t *buffer = nullptr;
361     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
362 
363     int32_t offset = imageDecoderAdapterImpl.GetOffset();
364     EXPECT_EQ(offset, 0);
365 
366     bool ret = TestDecodeImage(imageDecoderAdapterImpl, buffer, AllocatorType::kDmaAlloc);
367     EXPECT_TRUE(ret);
368 
369     offset = imageDecoderAdapterImpl.GetOffset();
370     EXPECT_EQ(offset, 0);
371 
372     auto* pixelMap = imageDecoderAdapterImpl.GetPixelMap();
373     pixelMap->FreePixelMap();
374     offset = imageDecoderAdapterImpl.GetOffset();
375     EXPECT_EQ(offset, 0);
376 
377     free(buffer);
378 
379     imageDecoderAdapterImpl.ReleasePixelMap();
380 }
381 
382 /**
383  * @tc.name: OhosImageAdapterTest_GetSize_009
384  * @tc.desc: GetSize.
385  * @tc.type: FUNC
386  * @tc.require:
387  */
388 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetSize_009, TestSize.Level1)
389 {
390     uint8_t *buffer = nullptr;
391     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
392 
393     uint64_t size = imageDecoderAdapterImpl.GetSize();
394     EXPECT_EQ(size, 0);
395 
396     bool ret = TestDecodeImage(imageDecoderAdapterImpl, buffer, AllocatorType::kDmaAlloc);
397     EXPECT_TRUE(ret);
398 
399     size = imageDecoderAdapterImpl.GetSize();
400     EXPECT_NE(size, 0);
401 
402     auto* pixelMap = imageDecoderAdapterImpl.GetPixelMap();
403     pixelMap->FreePixelMap();
404     size = imageDecoderAdapterImpl.GetSize();
405     EXPECT_EQ(size, 0);
406 
407     free(buffer);
408 
409     imageDecoderAdapterImpl.ReleasePixelMap();
410 }
411 
412 /**
413  * @tc.name: OhosImageAdapterTest_GetNativeWindowBuffer_010
414  * @tc.desc: GetNativeWindowBuffer.
415  * @tc.type: FUNC
416  * @tc.require:
417  */
418 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetNativeWindowBuffer_010, TestSize.Level1)
419 {
420     uint8_t *buffer = nullptr;
421     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
422 
423     void* windowBuffer = imageDecoderAdapterImpl.GetNativeWindowBuffer();
424     EXPECT_EQ(windowBuffer, nullptr);
425 
426     bool ret = TestDecodeImage(imageDecoderAdapterImpl, buffer, AllocatorType::kDmaAlloc);
427     EXPECT_TRUE(ret);
428 
429     windowBuffer = imageDecoderAdapterImpl.GetNativeWindowBuffer();
430     EXPECT_NE(windowBuffer, nullptr);
431 
432     auto* pixelMap = imageDecoderAdapterImpl.GetPixelMap();
433     pixelMap->FreePixelMap();
434     windowBuffer = imageDecoderAdapterImpl.GetNativeWindowBuffer();
435     EXPECT_NE(windowBuffer, nullptr);
436 
437     free(buffer);
438 
439     imageDecoderAdapterImpl.ReleasePixelMap();
440 }
441 
442 
443 /**
444  * @tc.name: OhosImageAdapterTest_GetPlanesCount_011
445  * @tc.desc: GetPlanesCount.
446  * @tc.type: FUNC
447  * @tc.require:
448  */
449 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetPlanesCount_011, TestSize.Level1)
450 {
451     uint8_t *buffer = nullptr;
452     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
453 
454     int32_t planesCount = imageDecoderAdapterImpl.GetPlanesCount();
455     EXPECT_EQ(planesCount, 0);
456 
457     bool ret = TestDecodeImage(imageDecoderAdapterImpl, buffer, AllocatorType::kDmaAlloc);
458     EXPECT_TRUE(ret);
459 
460     planesCount = imageDecoderAdapterImpl.GetPlanesCount();
461     EXPECT_EQ(planesCount, 0);
462 
463     auto* pixelMap = imageDecoderAdapterImpl.GetPixelMap();
464     pixelMap->FreePixelMap();
465     planesCount = imageDecoderAdapterImpl.GetPlanesCount();
466     EXPECT_EQ(planesCount, 0);
467 
468     free(buffer);
469 
470     imageDecoderAdapterImpl.ReleasePixelMap();
471 }
472 
473 /**
474  * @tc.name: OhosImageAdapterTest_Decode_012
475  * @tc.desc: Decode.
476  * @tc.type: FUNC
477  * @tc.require:
478  */
479 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_Decode_012, TestSize.Level1)
480 {
481     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
482     uint8_t data[32] = {0};
483     uint32_t size = sizeof(data);
484     bool ret = imageDecoderAdapterImpl.Decode(data, size, AllocatorType::kDmaAlloc, false);
485     EXPECT_FALSE(ret);
486 
487     ret = imageDecoderAdapterImpl.Decode(nullptr, size, AllocatorType::kDmaAlloc, false);
488     EXPECT_FALSE(ret);
489 
490     ret = imageDecoderAdapterImpl.Decode(data, 0, AllocatorType::kDmaAlloc, false);
491     EXPECT_FALSE(ret);
492 
493     size_t bufferSize = 0;
494     bool boolRes = Media::ImageUtils::GetFileSize(IMAGE_FILE_PATH, bufferSize);
495     uint8_t *buffer = static_cast<uint8_t *>(malloc(bufferSize));
496     boolRes = ReadFileToBuffer(IMAGE_FILE_PATH, buffer, bufferSize);
497     EXPECT_TRUE(boolRes);
498 
499     ret = imageDecoderAdapterImpl.Decode(buffer, bufferSize, AllocatorType::kDmaAlloc, true);
500     EXPECT_TRUE(ret);
501 
502     ret = imageDecoderAdapterImpl.Decode(buffer, bufferSize, AllocatorType::kDmaAlloc, false);
503     EXPECT_TRUE(ret);
504 
505     free(buffer);
506 
507     imageDecoderAdapterImpl.ReleasePixelMap();
508 }
509 
510 /**
511  * @tc.name: OhosImageAdapterTest_GetDecodeData_013
512  * @tc.desc: GetDecodeData.
513  * @tc.type: FUNC
514  * @tc.require:
515  */
516 HWTEST_F(OhosImageAdapterTest, OhosImageAdapterTest_GetDecodeData_013, TestSize.Level1)
517 {
518     uint8_t *buffer = nullptr;
519     OhosImageDecoderAdapterImpl imageDecoderAdapterImpl;
520 
521     void* data = imageDecoderAdapterImpl.GetDecodeData();
522     EXPECT_EQ(data, nullptr);
523 
524     bool ret = TestDecodeImage(imageDecoderAdapterImpl, buffer, AllocatorType::kShareMemAlloc);
525     EXPECT_TRUE(ret);
526 
527     data = imageDecoderAdapterImpl.GetDecodeData();
528     EXPECT_NE(data, nullptr);
529 
530     auto* pixelMap = imageDecoderAdapterImpl.GetPixelMap();
531     pixelMap->FreePixelMap();
532     data = imageDecoderAdapterImpl.GetDecodeData();
533     EXPECT_EQ(data, nullptr);
534 
535     free(buffer);
536 
537     imageDecoderAdapterImpl.ReleasePixelMap();
538 }
539 
540 } // namespace NWeb
541 } // namespace OHOS
542