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 #define private public
17 #include <gtest/gtest.h>
18 #include "heif_image.h"
19 #include "heif_stream.h"
20 #include "heif_parser.h"
21 #include "heif_utils.h"
22 
23 using namespace testing::ext;
24 namespace OHOS {
25 namespace ImagePlugin {
26 class HeifParserTest : public testing::Test {
27 public:
HeifParserTest()28     HeifParserTest() {}
~HeifParserTest()29     ~HeifParserTest() {}
30 };
31 
32 /**
33  * @tc.name: ReadTest001
34  * @tc.desc: HeifBufferInputStream
35  * @tc.type: FUNC
36  */
37 HWTEST_F(HeifParserTest, ReadTest001, TestSize.Level3)
38 {
39     GTEST_LOG_(INFO) << "HeifParserTest: ReadTest001 start";
40     HeifBufferInputStream heifBuffer(nullptr, 0, true);
41     void *data = nullptr;
42     size_t size = 0;
43     heifBuffer.pos_ = 1;
44     heifBuffer.copied_ = true;
45     ASSERT_TRUE((heifBuffer.pos_ + size) > heifBuffer.length_);
46     bool ret = heifBuffer.Read(data, size);
47     ASSERT_EQ(ret, false);
48     GTEST_LOG_(INFO) << "HeifParserTest: ReadTest001 end";
49 }
50 
51 /**
52  * @tc.name: SeekTest001
53  * @tc.desc: HeifBufferInputStream
54  * @tc.type: FUNC
55  */
56 HWTEST_F(HeifParserTest, SeekTest001, TestSize.Level3)
57 {
58     GTEST_LOG_(INFO) << "HeifParserTest: SeekTest001 start";
59     HeifBufferInputStream heifBuffer(nullptr, 0, false);
60     int64_t position = 1;
61     bool ret = heifBuffer.Seek(position);
62     ASSERT_EQ(ret, false);
63     GTEST_LOG_(INFO) << "HeifParserTest: SeekTest001 end";
64 }
65 
66 /**
67  * @tc.name: ReadTest002
68  * @tc.desc: HeifStreamReader
69  * @tc.type: FUNC
70  */
71 HWTEST_F(HeifParserTest, ReadTest002, TestSize.Level3)
72 {
73     GTEST_LOG_(INFO) << "HeifParserTest: ReadTest002 start";
74     auto inputStream = std::make_shared<HeifBufferInputStream>(nullptr, 0, true);
75     inputStream->pos_ = 1;
76     HeifStreamReader heifReader(inputStream, 0, 0);
77     uint8_t ret1 = heifReader.Read8();
78     ASSERT_EQ(ret1, 0);
79     uint16_t ret2 = heifReader.Read16();
80     ASSERT_EQ(ret2, 0);
81     uint32_t ret3 = heifReader.Read32();
82     ASSERT_EQ(ret3, 0);
83     uint64_t ret4 = heifReader.Read64();
84     ASSERT_EQ(ret4, 0);
85 
86     heifReader.end_ = 128;
87     inputStream->length_ = 10;
88     inputStream->pos_ = 16;
89     ret1 = heifReader.Read8();
90     ASSERT_EQ(heifReader.hasError_, true);
91     ASSERT_EQ(ret1, 0);
92     ret2 = heifReader.Read16();
93     ASSERT_EQ(heifReader.hasError_, true);
94     ASSERT_EQ(ret2, 0);
95     ret3 = heifReader.Read32();
96     ASSERT_EQ(heifReader.hasError_, true);
97     ASSERT_EQ(ret3, 0);
98     ret4 = heifReader.Read64();
99     ASSERT_EQ(heifReader.hasError_, true);
100     ASSERT_EQ(ret4, 0);
101     GTEST_LOG_(INFO) << "HeifParserTest: ReadTest002 end";
102 }
103 
104 /**
105  * @tc.name: ReadDataTest001
106  * @tc.desc: HeifStreamReader
107  * @tc.type: FUNC
108  */
109 HWTEST_F(HeifParserTest, ReadDataTest001, TestSize.Level3)
110 {
111     GTEST_LOG_(INFO) << "HeifParserTest: ReadDataTest001 start";
112     auto inputStream = std::make_shared<HeifBufferInputStream>(nullptr, 0, true);
113     HeifStreamReader heifReader(inputStream, 0, 0);
114     uint8_t data;
115     size_t size = 1;
116     bool ret = heifReader.ReadData(&data, size);
117     ASSERT_EQ(ret, false);
118     size = 0;
119     inputStream->pos_ = 1;
120     ret = heifReader.ReadData(&data, size);
121     ASSERT_EQ(ret, false);
122     GTEST_LOG_(INFO) << "HeifParserTest: ReadDataTest001 end";
123 }
124 
125 /**
126  * @tc.name: ReadStringTest001
127  * @tc.desc: HeifStreamReader
128  * @tc.type: FUNC
129  */
130 HWTEST_F(HeifParserTest, ReadStringTest001, TestSize.Level3)
131 {
132     GTEST_LOG_(INFO) << "HeifParserTest: ReadStringTest001 start";
133     auto inputStream = std::make_shared<HeifBufferInputStream>(nullptr, 0, true);
134     HeifStreamReader heifReader(inputStream, 0, 0);
135     heifReader.end_ = 1;
136     std::string ret = heifReader.ReadString();
137     ASSERT_EQ(ret, "");
138     inputStream->length_ = 1;
139     inputStream->pos_ = 1;
140     ret = heifReader.ReadString();
141     ASSERT_EQ(ret, "");
142     GTEST_LOG_(INFO) << "HeifParserTest: ReadStringTest001 end";
143 }
144 
145 /**
146  * @tc.name: CheckSizeTest001
147  * @tc.desc: HeifStreamWriter
148  * @tc.type: FUNC
149  */
150 HWTEST_F(HeifParserTest, CheckSizeTest001, TestSize.Level3)
151 {
152     GTEST_LOG_(INFO) << "HeifParserTest: CheckSizeTest001 start";
153     HeifStreamWriter heifWriter;
154     size_t size = 1;
155     ASSERT_EQ(heifWriter.data_.size(), 0);
156     heifWriter.CheckSize(size);
157     ASSERT_EQ(heifWriter.data_.size(), 1);
158     GTEST_LOG_(INFO) << "HeifParserTest: CheckSizeTest001 end";
159 }
160 
161 /**
162  * @tc.name: WriteTest001
163  * @tc.desc: HeifStreamWriter
164  * @tc.type: FUNC
165  */
166 HWTEST_F(HeifParserTest, WriteTest001, TestSize.Level3)
167 {
168     GTEST_LOG_(INFO) << "HeifParserTest: WriteTest001 start";
169     HeifStreamWriter heifWriter;
170     uint8_t value = 0;
171     ASSERT_TRUE(heifWriter.position_ == heifWriter.data_.size());
172     heifWriter.Write8(value);
173     ASSERT_EQ(heifWriter.data_.size(), 1);
174     ASSERT_EQ(heifWriter.position_, 1);
175     heifWriter.position_ = 0;
176     heifWriter.Write8(value);
177     ASSERT_EQ(heifWriter.data_[0], 0);
178 
179     heifWriter.Write16(0xFF);
180     heifWriter.Write32(0xFFFF);
181     heifWriter.Write64(0xFFFFFFFF);
182     heifWriter.Write(UINT8_BYTES_NUM, 0);
183     heifWriter.Write(UINT16_BYTES_NUM, 0);
184     heifWriter.Write(UINT32_BYTES_NUM, 0);
185     heifWriter.Write(UINT64_BYTES_NUM, 0);
186     heifWriter.Write(BUFFER_INDEX_ZERO, 0);
187     GTEST_LOG_(INFO) << "HeifParserTest: WriteTest001 end";
188 }
189 
190 /**
191  * @tc.name: WriteTest002
192  * @tc.desc: HeifStreamWriter
193  * @tc.type: FUNC
194  */
195 HWTEST_F(HeifParserTest, WriteTest002, TestSize.Level3)
196 {
197     GTEST_LOG_(INFO) << "HeifParserTest: WriteTest002 start";
198     HeifStreamWriter heifWriter;
199     std::string str = "HeifWrite";
200     ASSERT_EQ(str.size(), 9);
201     heifWriter.Write(str);
202     ASSERT_EQ(heifWriter.data_[3], 'f');
203     ASSERT_EQ(heifWriter.data_[9], 0);
204     const std::vector<uint8_t> data;
205     heifWriter.Write(data);
206     heifWriter.Skip(1);
207     heifWriter.Insert(0);
208     heifWriter.Insert(2);
209     GTEST_LOG_(INFO) << "HeifParserTest: WriteTest002 end";
210 }
211 
212 /**
213  * @tc.name: HeifImageTest001
214  * @tc.desc: HeifImage
215  * @tc.type: FUNC
216  */
217 HWTEST_F(HeifParserTest, HeifImageTest001, TestSize.Level3)
218 {
219     GTEST_LOG_(INFO) << "HeifParserTest: HeifImageTest001 start";
220     HeifImage heifImage(3);
221     heifImage.IsPrimaryImage();
222     heifImage.GetMirrorDirection();
223     heifImage.SetMirrorDirection(HeifTransformMirrorDirection::VERTICAL);
224     heifImage.IsResolutionReverse();
225     heifImage.GetWidth();
226     heifImage.GetHeight();
227     heifImage.IsThumbnailImage();
228     heifImage.GetThumbnailImages();
229     heifImage.IsAuxImage();
230     heifImage.GetAuxImageType();
231     heifImage.GetAuxImages();
232     heifImage.GetAllMetadata();
233     heifImage.GetNclxColorProfile();
234     GTEST_LOG_(INFO) << "HeifParserTest: HeifImageTest001 end";
235 }
236 
237 /**
238  * @tc.name: WriteTest003
239  * @tc.desc: HeifParser
240  * @tc.type: FUNC
241  */
242 HWTEST_F(HeifParserTest, WriteTest003, TestSize.Level3)
243 {
244     GTEST_LOG_(INFO) << "HeifParserTest: WriteTest003 start";
245     HeifParser heifParser;
246     HeifStreamWriter write;
247     heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
248     heifParser.Write(write);
249     GTEST_LOG_(INFO) << "HeifParserTest: WriteTest003 end";
250 }
251 
252 /**
253  * @tc.name: GetItemTypeTest001
254  * @tc.desc: HeifParser
255  * @tc.type: FUNC
256  */
257 HWTEST_F(HeifParserTest, GetItemTypeTest001, TestSize.Level3)
258 {
259     GTEST_LOG_(INFO) << "HeifParserTest: GetItemTypeTest001 start";
260     HeifParser heifParser;
261     heif_item_id itemId = 0;
262     heifParser.infeBoxes_.clear();
263     std::string ret = heifParser.GetItemType(itemId);
264     ASSERT_EQ(ret, "");
265     ret = heifParser.GetItemContentType(itemId);
266     ASSERT_EQ(ret, "");
267     ret = heifParser.GetItemUriType(itemId);
268     ASSERT_EQ(ret, "");
269     GTEST_LOG_(INFO) << "HeifParserTest: GetItemTypeTest001 end";
270 }
271 
272 /**
273  * @tc.name: GetAllPropertiesTest001
274  * @tc.desc: HeifParser
275  * @tc.type: FUNC
276  */
277 HWTEST_F(HeifParserTest, GetAllPropertiesTest001, TestSize.Level3)
278 {
279     GTEST_LOG_(INFO) << "HeifParserTest: GetAllPropertiesTest001 start";
280     HeifParser heifParser;
281     heif_item_id itemId = 0;
282     std::vector<std::shared_ptr<HeifBox>> properties;
283     heifParser.ipcoBox_ = nullptr;
284     heif_error ret = heifParser.GetAllProperties(itemId, properties);
285     ASSERT_EQ(ret, heif_error_no_ipco);
286     heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
287     heifParser.ipmaBox_ = nullptr;
288     ret = heifParser.GetAllProperties(itemId, properties);
289     ASSERT_EQ(ret, heif_error_no_ipma);
290     GTEST_LOG_(INFO) << "HeifParserTest: GetAllPropertiesTest001 end";
291 }
292 
293 /**
294  * @tc.name: GetItemDataTest001
295  * @tc.desc: HeifParser
296  * @tc.type: FUNC
297  */
298 HWTEST_F(HeifParserTest, GetItemDataTest001, TestSize.Level3)
299 {
300     GTEST_LOG_(INFO) << "HeifParserTest: GetItemDataTest001 start";
301     HeifParser heifParser;
302     heif_item_id itemId = 1;
303     std::vector<uint8_t> *out = nullptr;
304     heif_header_option option = heif_header_option::heif_header_data;
305     heifParser.infeBoxes_.clear();
306     heif_error ret = heifParser.GetItemData(itemId, out, option);
307     ASSERT_EQ(ret, heif_error_item_not_found);
308     heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
309     auto heifBox = std::make_shared<HeifInfeBox>();
310     heifParser.infeBoxes_.insert(std::make_pair(0, heifBox));
311     heifParser.infeBoxes_.insert(std::make_pair(1, heifBox));
312     ret = heifParser.GetItemData(itemId, out, option);
313     ASSERT_EQ(ret, heif_error_item_data_not_found);
314     GTEST_LOG_(INFO) << "HeifParserTest: GetItemDataTest001 end";
315 }
316 
317 /**
318  * @tc.name: GetTileImagesTest001
319  * @tc.desc: HeifParser
320  * @tc.type: FUNC
321  */
322 HWTEST_F(HeifParserTest, GetTileImagesTest001, TestSize.Level3)
323 {
324     GTEST_LOG_(INFO) << "HeifParserTest: GetTileImagesTest001 start";
325     HeifParser heifParser;
326     heif_item_id gridItemId = 0;
327     std::vector<std::shared_ptr<HeifImage>> out;
328     heifParser.infeBoxes_.clear();
329     heifParser.GetTileImages(gridItemId, out);
330     GTEST_LOG_(INFO) << "HeifParserTest: GetTileImagesTest001 end";
331 }
332 
333 /**
334  * @tc.name: ExtractDerivedImagePropertiesTest001
335  * @tc.desc: HeifParser
336  * @tc.type: FUNC
337  */
338 HWTEST_F(HeifParserTest, ExtractDerivedImagePropertiesTest001, TestSize.Level3)
339 {
340     GTEST_LOG_(INFO) << "HeifParserTest: ExtractDerivedImagePropertiesTest001 start";
341     HeifParser heifParser;
342     auto heifImage = std::make_shared<HeifImage>(0);
343     heifParser.images_.insert(std::make_pair(0, heifImage));
344     auto heifBox = std::make_shared<HeifInfeBox>();
345     heifBox->itemType_ = "grid";
346     heifParser.infeBoxes_.insert(std::make_pair(0, heifBox));
347     heifParser.irefBox_ = std::make_shared<HeifIrefBox>();
348     struct HeifIrefBox::Reference ref {.fromItemId = 1};
349     heifParser.irefBox_->references_.push_back(ref);
350     heifParser.ExtractDerivedImageProperties();
351     GTEST_LOG_(INFO) << "HeifParserTest: ExtractDerivedImagePropertiesTest001 end";
352 }
353 
354 /**
355  * @tc.name: ExtractThumbnailImageTest001
356  * @tc.desc: HeifParser:ExtractThumbnailImage And ExtractAuxImage
357  * @tc.type: FUNC
358  */
359 HWTEST_F(HeifParserTest, ExtractThumbnailImageTest001, TestSize.Level3)
360 {
361     GTEST_LOG_(INFO) << "HeifParserTest: ExtractThumbnailImageTest001 start";
362     HeifParser heifParser;
363     std::shared_ptr<HeifImage> thumbnailImage = std::make_shared<HeifImage>(0);
364     HeifIrefBox::Reference ref;
365     ref.toItemIds.clear();
366     heifParser.ExtractThumbnailImage(thumbnailImage, ref);
367     heifParser.ExtractAuxImage(thumbnailImage, ref);
368     ref.toItemIds.push_back(0);
369     ASSERT_EQ(ref.toItemIds.empty(), false);
370     ASSERT_EQ(ref.toItemIds[0], thumbnailImage->itemId_);
371     heifParser.ExtractThumbnailImage(thumbnailImage, ref);
372     heifParser.ExtractAuxImage(thumbnailImage, ref);
373     thumbnailImage->itemId_ = 1;
374     ASSERT_NE(ref.toItemIds[0], thumbnailImage->itemId_);
375     ASSERT_EQ(heifParser.images_.empty(), true);
376     heifParser.ExtractThumbnailImage(thumbnailImage, ref);
377     heifParser.ExtractAuxImage(thumbnailImage, ref);
378     GTEST_LOG_(INFO) << "HeifParserTest: ExtractThumbnailImageTest001 end";
379 }
380 
381 /**
382  * @tc.name: ExtractMetadataTest001
383  * @tc.desc: HeifParser
384  * @tc.type: FUNC
385  */
386 HWTEST_F(HeifParserTest, ExtractMetadataTest001, TestSize.Level3)
387 {
388     GTEST_LOG_(INFO) << "HeifParserTest: ExtractMetadataTest001 start";
389     HeifParser heifParser;
390     std::vector<heif_item_id> allItemIds;
391     allItemIds.push_back(0);
392     heifParser.irefBox_ = std::make_shared<HeifIrefBox>();
393     struct HeifIrefBox::Reference ref {
394         .fromItemId = 1,
395         .box.boxType_ = BOX_TYPE_CDSC,
396     };
397     ref.toItemIds.push_back(0);
398     ASSERT_EQ(ref.toItemIds[0], 0);
399     heifParser.irefBox_->references_.push_back(ref);
400     heifParser.ExtractMetadata(allItemIds);
401     ref.toItemIds.clear();
402     ref.toItemIds.push_back(1);
403     ASSERT_EQ(heifParser.images_.empty(), true);
404     heifParser.ExtractMetadata(allItemIds);
405     auto heifImage = std::make_shared<HeifImage>(0);
406     heifParser.images_.insert(std::make_pair(0, heifImage));
407     heifParser.images_.insert(std::make_pair(1, heifImage));
408     heifParser.infeBoxes_.clear();
409     heifParser.ExtractMetadata(allItemIds);
410     GTEST_LOG_(INFO) << "HeifParserTest: ExtractMetadataTest001 end";
411 }
412 
413 /**
414  * @tc.name: HeifParserTest001
415  * @tc.desc: HeifParser
416  * @tc.type: FUNC
417  */
418 HWTEST_F(HeifParserTest, HeifParserTest001, TestSize.Level3)
419 {
420     GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest001 start";
421     HeifParser heifParser;
422     heifParser.iinfBox_ = std::make_shared<HeifIinfBox>();
423     heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
424     heifParser.ipmaBox_ = std::make_shared<HeifIpmaBox>();
425     heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
426     heifParser.idatBox_ = std::make_shared<HeifIdatBox>();
427     std::shared_ptr<HeifBox> property = std::make_shared<HeifBox>(0);
428     std::string type;
429     heifParser.GetNextItemId();
430     heifParser.AddIspeProperty(0, 0, 0);
431     heifParser.AddProperty(0, property, false);
432     heifParser.AddPixiProperty(0, 0, 0, 0);
433     heifParser.AddHvccProperty(0);
434     heifParser.SetAuxcProperty(0, type);
435     heifParser.CheckExtentData();
436     GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest001 end";
437 }
438 
439 /**
440  * @tc.name: HeifParserTest002
441  * @tc.desc: HeifParser
442  * @tc.type: FUNC
443  */
444 HWTEST_F(HeifParserTest, HeifParserTest002, TestSize.Level3)
445 {
446     GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest002 start";
447     HeifParser heifParser;
448     heif_item_id itemId = 0;
449     ImagePlugin::HvccConfig config;
450     heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
451     heifParser.ipmaBox_ = std::make_shared<HeifIpmaBox>();
452     ASSERT_EQ(heifParser.GetImage(itemId), nullptr);
453     heifParser.SetHvccConfig(itemId, config);
454     GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest002 end";
455 }
456 
457 /**
458  * @tc.name: HeifParserTest003
459  * @tc.desc: HeifParser
460  * @tc.type: FUNC
461  */
462 HWTEST_F(HeifParserTest, HeifParserTest003, TestSize.Level3)
463 {
464     GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest003 start";
465     HeifParser heifParser;
466     heif_item_id itemId = 0;
467     std::vector<uint8_t> data;
468     uint8_t construction_method = 0;
469     heif_item_id fromItemId = 0;
470     uint32_t type = 0;
471     const std::vector<heif_item_id> toItemIds;
472     heifParser.ilocBox_ = nullptr;
473     heifParser.pitmBox_ = nullptr;
474     heifParser.irefBox_ = nullptr;
475     heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
476     heifParser.AppendIlocData(itemId, data, construction_method);
477     heifParser.SetPrimaryItemId(itemId);
478     heifParser.AddReference(fromItemId, type, toItemIds);
479     heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
480     heifParser.pitmBox_ = std::make_shared<HeifPtimBox>();
481     heifParser.irefBox_ = std::make_shared<HeifIrefBox>();
482     heifParser.AppendIlocData(itemId, data, construction_method);
483     heifParser.SetPrimaryItemId(itemId);
484     heifParser.AddReference(fromItemId, type, toItemIds);
485     GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest003 end";
486 }
487 
488 /**
489  * @tc.name: SetPrimaryImageTest001
490  * @tc.desc: HeifParser
491  * @tc.type: FUNC
492  */
493 HWTEST_F(HeifParserTest, SetPrimaryImageTest001, TestSize.Level3)
494 {
495     GTEST_LOG_(INFO) << "HeifParserTest: SetPrimaryImageTest001 start";
496     HeifParser heifParser;
497     std::shared_ptr<HeifImage> image = std::make_shared<HeifImage>(0);
498     heifParser.primaryImage_ = std::make_shared<HeifImage>(0);
499     ASSERT_EQ(heifParser.primaryImage_->GetItemId(), image->GetItemId());
500     heifParser.SetPrimaryImage(image);
501     heifParser.primaryImage_->itemId_ = 1;
502     ASSERT_NE(heifParser.primaryImage_->GetItemId(), image->GetItemId());
503     heifParser.pitmBox_ = nullptr;
504     heifParser.SetPrimaryImage(image);
505     GTEST_LOG_(INFO) << "HeifParserTest: SetPrimaryImageTest001 end";
506 }
507 }
508 }