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 #define protected public
18 #include <gtest/gtest.h>
19 #include "heif_image.h"
20 #include "heif_stream.h"
21 #include "heif_parser.h"
22 #include "heif_utils.h"
23 #include "item_property_transform_box.h"
24
25 using namespace testing::ext;
26 namespace OHOS {
27 namespace ImagePlugin {
28 static const heif_item_id MOCK_ITEM_ID = UINT32_MAX;
29 static const heif_item_id IT35_TRUE_ID = 1;
30 static const heif_item_id IT35_MOCK_ID = 2;
31 static const heif_item_id TMAP_TRUE_ID = 3;
32 static const heif_item_id TMAP_MOCK_ID = 4;
33 static const heif_item_id IDEN_TRUE_ID = 5;
34 static const heif_item_id MIME_TRUE_ID = 6;
35 static const uint16_t INDEX_1 = 1;
36 static const uint16_t INDEX_2 = 2;
37 static const uint16_t INDEX_3 = 3;
38 static const uint8_t MOCK_DATA_1 = 1;
39 static const uint8_t MOCK_DATA_2 = 2;
40 static const uint32_t MOCK_DATA_SIZE = 5;
41 static const uint32_t NUM_1 = 1;
42
43 class HeifParserTest : public testing::Test {
44 public:
HeifParserTest()45 HeifParserTest() {}
~HeifParserTest()46 ~HeifParserTest() {}
47 void AddHdlrBox(HeifParser& heifParser);
48 void AddPtimBox(HeifParser& heifParser);
49 void AddIinfBox(HeifParser& heifParser);
50 void AddIprpBox(HeifParser& heifParser);
51 void AddIpcoBox(HeifParser& heifParser);
52 void AddIpmaBox(HeifParser& heifParser);
53 };
54
AddHdlrBox(HeifParser & heifParser)55 void HeifParserTest::AddHdlrBox(HeifParser& heifParser)
56 {
57 std::shared_ptr<HeifHdlrBox> mockHdlr = std::make_shared<HeifHdlrBox>();
58 mockHdlr->boxType_ = BOX_TYPE_HDLR;
59 mockHdlr->handlerType_ = HANDLER_TYPE_PICT;
60 heifParser.metaBox_->AddChild(mockHdlr);
61 }
62
AddPtimBox(HeifParser & heifParser)63 void HeifParserTest::AddPtimBox(HeifParser& heifParser)
64 {
65 std::shared_ptr<HeifPtimBox> mockPtim = std::make_shared<HeifPtimBox>();
66 mockPtim->boxType_ = BOX_TYPE_PITM;
67 heifParser.metaBox_->AddChild(mockPtim);
68 }
69
AddIinfBox(HeifParser & heifParser)70 void HeifParserTest::AddIinfBox(HeifParser& heifParser)
71 {
72 std::shared_ptr<HeifIinfBox> mockIinf = std::make_shared<HeifIinfBox>();
73 mockIinf->boxType_ = BOX_TYPE_IINF;
74 heifParser.metaBox_->AddChild(mockIinf);
75 }
76
AddIprpBox(HeifParser & heifParser)77 void HeifParserTest::AddIprpBox(HeifParser& heifParser)
78 {
79 std::shared_ptr<HeifIprpBox> mockIprp = std::make_shared<HeifIprpBox>();
80 mockIprp->boxType_ = BOX_TYPE_IPRP;
81 heifParser.metaBox_->AddChild(mockIprp);
82 }
83
AddIpcoBox(HeifParser & heifParser)84 void HeifParserTest::AddIpcoBox(HeifParser& heifParser)
85 {
86 std::shared_ptr<HeifIprpBox> mockIprp = std::make_shared<HeifIprpBox>();
87 mockIprp->boxType_ = BOX_TYPE_IPRP;
88
89 std::shared_ptr<HeifIpcoBox> mockIpco = std::make_shared<HeifIpcoBox>();
90 mockIpco->boxType_ = BOX_TYPE_IPCO;
91 mockIprp->AddChild(mockIpco);
92
93 heifParser.metaBox_->AddChild(mockIprp);
94 }
95
AddIpmaBox(HeifParser & heifParser)96 void HeifParserTest::AddIpmaBox(HeifParser& heifParser)
97 {
98 std::shared_ptr<HeifIprpBox> mockIprp = std::make_shared<HeifIprpBox>();
99 mockIprp->boxType_ = BOX_TYPE_IPRP;
100
101 std::shared_ptr<HeifIpcoBox> mockIpco = std::make_shared<HeifIpcoBox>();
102 mockIpco->boxType_ = BOX_TYPE_IPCO;
103 mockIprp->AddChild(mockIpco);
104
105 std::shared_ptr<HeifIpmaBox> mockIpma = std::make_shared<HeifIpmaBox>();
106 mockIpma->boxType_ = BOX_TYPE_IPMA;
107 mockIprp->AddChild(mockIpma);
108
109 heifParser.metaBox_->AddChild(mockIprp);
110 }
111
112 /**
113 * @tc.name: ReadTest001
114 * @tc.desc: HeifBufferInputStream
115 * @tc.type: FUNC
116 */
117 HWTEST_F(HeifParserTest, ReadTest001, TestSize.Level3)
118 {
119 GTEST_LOG_(INFO) << "HeifParserTest: ReadTest001 start";
120 HeifBufferInputStream heifBuffer(nullptr, 0, true);
121 void *data = nullptr;
122 size_t size = 0;
123 heifBuffer.pos_ = 1;
124 heifBuffer.copied_ = true;
125 ASSERT_TRUE((heifBuffer.pos_ + size) > heifBuffer.length_);
126 bool ret = heifBuffer.Read(data, size);
127 ASSERT_EQ(ret, false);
128 GTEST_LOG_(INFO) << "HeifParserTest: ReadTest001 end";
129 }
130
131 /**
132 * @tc.name: SeekTest001
133 * @tc.desc: HeifBufferInputStream
134 * @tc.type: FUNC
135 */
136 HWTEST_F(HeifParserTest, SeekTest001, TestSize.Level3)
137 {
138 GTEST_LOG_(INFO) << "HeifParserTest: SeekTest001 start";
139 HeifBufferInputStream heifBuffer(nullptr, 0, false);
140 int64_t position = 1;
141 bool ret = heifBuffer.Seek(position);
142 ASSERT_EQ(ret, false);
143 GTEST_LOG_(INFO) << "HeifParserTest: SeekTest001 end";
144 }
145
146 /**
147 * @tc.name: ReadTest002
148 * @tc.desc: HeifStreamReader
149 * @tc.type: FUNC
150 */
151 HWTEST_F(HeifParserTest, ReadTest002, TestSize.Level3)
152 {
153 GTEST_LOG_(INFO) << "HeifParserTest: ReadTest002 start";
154 auto inputStream = std::make_shared<HeifBufferInputStream>(nullptr, 0, true);
155 inputStream->pos_ = 1;
156 HeifStreamReader heifReader(inputStream, 0, 0);
157 uint8_t ret1 = heifReader.Read8();
158 ASSERT_EQ(ret1, 0);
159 uint16_t ret2 = heifReader.Read16();
160 ASSERT_EQ(ret2, 0);
161 uint32_t ret3 = heifReader.Read32();
162 ASSERT_EQ(ret3, 0);
163 uint64_t ret4 = heifReader.Read64();
164 ASSERT_EQ(ret4, 0);
165
166 heifReader.end_ = 128;
167 inputStream->length_ = 10;
168 inputStream->pos_ = 16;
169 ret1 = heifReader.Read8();
170 ASSERT_EQ(heifReader.hasError_, true);
171 ASSERT_EQ(ret1, 0);
172 ret2 = heifReader.Read16();
173 ASSERT_EQ(heifReader.hasError_, true);
174 ASSERT_EQ(ret2, 0);
175 ret3 = heifReader.Read32();
176 ASSERT_EQ(heifReader.hasError_, true);
177 ASSERT_EQ(ret3, 0);
178 ret4 = heifReader.Read64();
179 ASSERT_EQ(heifReader.hasError_, true);
180 ASSERT_EQ(ret4, 0);
181 GTEST_LOG_(INFO) << "HeifParserTest: ReadTest002 end";
182 }
183
184 /**
185 * @tc.name: ReadDataTest001
186 * @tc.desc: HeifStreamReader
187 * @tc.type: FUNC
188 */
189 HWTEST_F(HeifParserTest, ReadDataTest001, TestSize.Level3)
190 {
191 GTEST_LOG_(INFO) << "HeifParserTest: ReadDataTest001 start";
192 auto inputStream = std::make_shared<HeifBufferInputStream>(nullptr, 0, true);
193 HeifStreamReader heifReader(inputStream, 0, 0);
194 uint8_t data;
195 size_t size = 1;
196 bool ret = heifReader.ReadData(&data, size);
197 ASSERT_EQ(ret, false);
198 size = 0;
199 inputStream->pos_ = 1;
200 ret = heifReader.ReadData(&data, size);
201 ASSERT_EQ(ret, false);
202 GTEST_LOG_(INFO) << "HeifParserTest: ReadDataTest001 end";
203 }
204
205 /**
206 * @tc.name: ReadStringTest001
207 * @tc.desc: HeifStreamReader
208 * @tc.type: FUNC
209 */
210 HWTEST_F(HeifParserTest, ReadStringTest001, TestSize.Level3)
211 {
212 GTEST_LOG_(INFO) << "HeifParserTest: ReadStringTest001 start";
213 auto inputStream = std::make_shared<HeifBufferInputStream>(nullptr, 0, true);
214 HeifStreamReader heifReader(inputStream, 0, 0);
215 heifReader.end_ = 1;
216 std::string ret = heifReader.ReadString();
217 ASSERT_EQ(ret, "");
218 inputStream->length_ = 1;
219 inputStream->pos_ = 1;
220 ret = heifReader.ReadString();
221 ASSERT_EQ(ret, "");
222 GTEST_LOG_(INFO) << "HeifParserTest: ReadStringTest001 end";
223 }
224
225 /**
226 * @tc.name: CheckSizeTest001
227 * @tc.desc: HeifStreamWriter
228 * @tc.type: FUNC
229 */
230 HWTEST_F(HeifParserTest, CheckSizeTest001, TestSize.Level3)
231 {
232 GTEST_LOG_(INFO) << "HeifParserTest: CheckSizeTest001 start";
233 HeifStreamWriter heifWriter;
234 size_t size = 1;
235 ASSERT_EQ(heifWriter.data_.size(), 0);
236 heifWriter.CheckSize(size);
237 ASSERT_EQ(heifWriter.data_.size(), 1);
238 GTEST_LOG_(INFO) << "HeifParserTest: CheckSizeTest001 end";
239 }
240
241 /**
242 * @tc.name: WriteTest001
243 * @tc.desc: HeifStreamWriter
244 * @tc.type: FUNC
245 */
246 HWTEST_F(HeifParserTest, WriteTest001, TestSize.Level3)
247 {
248 GTEST_LOG_(INFO) << "HeifParserTest: WriteTest001 start";
249 HeifStreamWriter heifWriter;
250 uint8_t value = 0;
251 ASSERT_TRUE(heifWriter.position_ == heifWriter.data_.size());
252 heifWriter.Write8(value);
253 ASSERT_EQ(heifWriter.data_.size(), 1);
254 ASSERT_EQ(heifWriter.position_, 1);
255 heifWriter.position_ = 0;
256 heifWriter.Write8(value);
257 ASSERT_EQ(heifWriter.data_[0], 0);
258
259 heifWriter.Write16(0xFF);
260 heifWriter.Write32(0xFFFF);
261 heifWriter.Write64(0xFFFFFFFF);
262 heifWriter.Write(UINT8_BYTES_NUM, 0);
263 heifWriter.Write(UINT16_BYTES_NUM, 0);
264 heifWriter.Write(UINT32_BYTES_NUM, 0);
265 heifWriter.Write(UINT64_BYTES_NUM, 0);
266 heifWriter.Write(BUFFER_INDEX_ZERO, 0);
267 GTEST_LOG_(INFO) << "HeifParserTest: WriteTest001 end";
268 }
269
270 /**
271 * @tc.name: WriteTest002
272 * @tc.desc: HeifStreamWriter
273 * @tc.type: FUNC
274 */
275 HWTEST_F(HeifParserTest, WriteTest002, TestSize.Level3)
276 {
277 GTEST_LOG_(INFO) << "HeifParserTest: WriteTest002 start";
278 HeifStreamWriter heifWriter;
279 std::string str = "HeifWrite";
280 ASSERT_EQ(str.size(), 9);
281 heifWriter.Write(str);
282 ASSERT_EQ(heifWriter.data_[3], 'f');
283 ASSERT_EQ(heifWriter.data_[9], 0);
284 const std::vector<uint8_t> data;
285 heifWriter.Write(data);
286 heifWriter.Skip(1);
287 heifWriter.Insert(0);
288 heifWriter.Insert(2);
289 GTEST_LOG_(INFO) << "HeifParserTest: WriteTest002 end";
290 }
291
292 /**
293 * @tc.name: HeifImageTest001
294 * @tc.desc: HeifImage
295 * @tc.type: FUNC
296 */
297 HWTEST_F(HeifParserTest, HeifImageTest001, TestSize.Level3)
298 {
299 GTEST_LOG_(INFO) << "HeifParserTest: HeifImageTest001 start";
300 HeifImage heifImage(3);
301 heifImage.SetPrimaryImage(true);
302 bool ret = heifImage.IsPrimaryImage();
303 ASSERT_EQ(ret, true);
304 heifImage.GetMirrorDirection();
305 heifImage.SetMirrorDirection(HeifTransformMirrorDirection::VERTICAL);
306 heifImage.IsResolutionReverse();
307 heifImage.GetWidth();
308 heifImage.GetHeight();
309 heifImage.IsThumbnailImage();
310 heifImage.GetThumbnailImages();
311 heifImage.IsAuxImage();
312 heifImage.GetAuxImageType();
313 heifImage.GetAuxImages();
314 heifImage.GetAllMetadata();
315 heifImage.GetNclxColorProfile();
316 GTEST_LOG_(INFO) << "HeifParserTest: HeifImageTest001 end";
317 }
318
319 /**
320 * @tc.name: WriteTest003
321 * @tc.desc: HeifParser
322 * @tc.type: FUNC
323 */
324 HWTEST_F(HeifParserTest, WriteTest003, TestSize.Level3)
325 {
326 GTEST_LOG_(INFO) << "HeifParserTest: WriteTest003 start";
327 HeifParser heifParser;
328 HeifStreamWriter write;
329 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
330 heifParser.Write(write);
331 ASSERT_EQ(heifParser.ilocBox_->WriteMdatBox(write), heif_error_ok);
332 GTEST_LOG_(INFO) << "HeifParserTest: WriteTest003 end";
333 }
334
335 /**
336 * @tc.name: GetItemTypeTest001
337 * @tc.desc: HeifParser
338 * @tc.type: FUNC
339 */
340 HWTEST_F(HeifParserTest, GetItemTypeTest001, TestSize.Level3)
341 {
342 GTEST_LOG_(INFO) << "HeifParserTest: GetItemTypeTest001 start";
343 HeifParser heifParser;
344 heif_item_id itemId = 0;
345 heifParser.infeBoxes_.clear();
346 std::string ret = heifParser.GetItemType(itemId);
347 ASSERT_EQ(ret, "");
348 ret = heifParser.GetItemContentType(itemId);
349 ASSERT_EQ(ret, "");
350 ret = heifParser.GetItemUriType(itemId);
351 ASSERT_EQ(ret, "");
352 GTEST_LOG_(INFO) << "HeifParserTest: GetItemTypeTest001 end";
353 }
354
355 /**
356 * @tc.name: GetAllPropertiesTest001
357 * @tc.desc: HeifParser
358 * @tc.type: FUNC
359 */
360 HWTEST_F(HeifParserTest, GetAllPropertiesTest001, TestSize.Level3)
361 {
362 GTEST_LOG_(INFO) << "HeifParserTest: GetAllPropertiesTest001 start";
363 HeifParser heifParser;
364 heif_item_id itemId = 0;
365 std::vector<std::shared_ptr<HeifBox>> properties;
366 heifParser.ipcoBox_ = nullptr;
367 heif_error ret = heifParser.GetAllProperties(itemId, properties);
368 ASSERT_EQ(ret, heif_error_no_ipco);
369 heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
370 heifParser.ipmaBox_ = nullptr;
371 ret = heifParser.GetAllProperties(itemId, properties);
372 ASSERT_EQ(ret, heif_error_no_ipma);
373 GTEST_LOG_(INFO) << "HeifParserTest: GetAllPropertiesTest001 end";
374 }
375
376 /**
377 * @tc.name: GetItemDataTest001
378 * @tc.desc: HeifParser
379 * @tc.type: FUNC
380 */
381 HWTEST_F(HeifParserTest, GetItemDataTest001, TestSize.Level3)
382 {
383 GTEST_LOG_(INFO) << "HeifParserTest: GetItemDataTest001 start";
384 HeifParser heifParser;
385 heif_item_id itemId = 1;
386 std::vector<uint8_t> *out = nullptr;
387 heif_header_option option = heif_header_option::heif_header_data;
388 heifParser.infeBoxes_.clear();
389 heif_error ret = heifParser.GetItemData(itemId, out, option);
390 ASSERT_EQ(ret, heif_error_item_not_found);
391 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
392 auto heifBox = std::make_shared<HeifInfeBox>();
393 heifParser.infeBoxes_.insert(std::make_pair(0, heifBox));
394 heifParser.infeBoxes_.insert(std::make_pair(1, heifBox));
395 ret = heifParser.GetItemData(itemId, out, option);
396 ASSERT_EQ(ret, heif_error_item_data_not_found);
397 GTEST_LOG_(INFO) << "HeifParserTest: GetItemDataTest001 end";
398 }
399
400 /**
401 * @tc.name: GetTileImagesTest001
402 * @tc.desc: HeifParser
403 * @tc.type: FUNC
404 */
405 HWTEST_F(HeifParserTest, GetTileImagesTest001, TestSize.Level3)
406 {
407 GTEST_LOG_(INFO) << "HeifParserTest: GetTileImagesTest001 start";
408 HeifParser heifParser;
409 heif_item_id gridItemId = 0;
410 std::vector<std::shared_ptr<HeifImage>> out;
411 heifParser.infeBoxes_.clear();
412 ASSERT_EQ(heifParser.GetInfeBox(gridItemId), nullptr);
413 heifParser.GetTileImages(gridItemId, out);
414 GTEST_LOG_(INFO) << "HeifParserTest: GetTileImagesTest001 end";
415 }
416
417 /**
418 * @tc.name: ExtractDerivedImagePropertiesTest001
419 * @tc.desc: HeifParser
420 * @tc.type: FUNC
421 */
422 HWTEST_F(HeifParserTest, ExtractDerivedImagePropertiesTest001, TestSize.Level3)
423 {
424 GTEST_LOG_(INFO) << "HeifParserTest: ExtractDerivedImagePropertiesTest001 start";
425 HeifParser heifParser;
426 auto heifImage = std::make_shared<HeifImage>(0);
427 heifParser.images_.insert(std::make_pair(0, heifImage));
428 auto heifBox = std::make_shared<HeifInfeBox>();
429 heifBox->itemType_ = "grid";
430 heifParser.infeBoxes_.insert(std::make_pair(0, heifBox));
431 heifParser.irefBox_ = std::make_shared<HeifIrefBox>();
432 struct HeifIrefBox::Reference ref {.fromItemId = 1};
433 heifParser.irefBox_->references_.push_back(ref);
434 ASSERT_NE(heifParser.irefBox_->references_.size(), 0);
435 heifParser.ExtractDerivedImageProperties();
436 GTEST_LOG_(INFO) << "HeifParserTest: ExtractDerivedImagePropertiesTest001 end";
437 }
438
439 /**
440 * @tc.name: ExtractThumbnailImageTest001
441 * @tc.desc: HeifParser:ExtractThumbnailImage And ExtractAuxImage
442 * @tc.type: FUNC
443 */
444 HWTEST_F(HeifParserTest, ExtractThumbnailImageTest001, TestSize.Level3)
445 {
446 GTEST_LOG_(INFO) << "HeifParserTest: ExtractThumbnailImageTest001 start";
447 HeifParser heifParser;
448 std::shared_ptr<HeifImage> thumbnailImage = std::make_shared<HeifImage>(0);
449 HeifIrefBox::Reference ref;
450 ref.toItemIds.clear();
451 heifParser.ExtractThumbnailImage(thumbnailImage, ref);
452 heifParser.ExtractAuxImage(thumbnailImage, ref);
453 ref.toItemIds.push_back(0);
454 ASSERT_EQ(ref.toItemIds.empty(), false);
455 ASSERT_EQ(ref.toItemIds[0], thumbnailImage->itemId_);
456 heifParser.ExtractThumbnailImage(thumbnailImage, ref);
457 heifParser.ExtractAuxImage(thumbnailImage, ref);
458 thumbnailImage->itemId_ = 1;
459 ASSERT_NE(ref.toItemIds[0], thumbnailImage->itemId_);
460 ASSERT_EQ(heifParser.images_.empty(), true);
461 heifParser.ExtractThumbnailImage(thumbnailImage, ref);
462 heifParser.ExtractAuxImage(thumbnailImage, ref);
463 GTEST_LOG_(INFO) << "HeifParserTest: ExtractThumbnailImageTest001 end";
464 }
465
466 /**
467 * @tc.name: ExtractMetadataTest001
468 * @tc.desc: HeifParser
469 * @tc.type: FUNC
470 */
471 HWTEST_F(HeifParserTest, ExtractMetadataTest001, TestSize.Level3)
472 {
473 GTEST_LOG_(INFO) << "HeifParserTest: ExtractMetadataTest001 start";
474 HeifParser heifParser;
475 std::vector<heif_item_id> allItemIds;
476 allItemIds.push_back(0);
477 heifParser.irefBox_ = std::make_shared<HeifIrefBox>();
478 struct HeifIrefBox::Reference ref {
479 .fromItemId = 1,
480 .box.boxType_ = BOX_TYPE_CDSC,
481 };
482 ref.toItemIds.push_back(0);
483 ASSERT_EQ(ref.toItemIds[0], 0);
484 heifParser.irefBox_->references_.push_back(ref);
485 heifParser.ExtractMetadata(allItemIds);
486 ref.toItemIds.clear();
487 ref.toItemIds.push_back(1);
488 ASSERT_EQ(heifParser.images_.empty(), true);
489 heifParser.ExtractMetadata(allItemIds);
490 auto heifImage = std::make_shared<HeifImage>(0);
491 heifParser.images_.insert(std::make_pair(0, heifImage));
492 heifParser.images_.insert(std::make_pair(1, heifImage));
493 heifParser.infeBoxes_.clear();
494 heifParser.ExtractMetadata(allItemIds);
495 GTEST_LOG_(INFO) << "HeifParserTest: ExtractMetadataTest001 end";
496 }
497
498 /**
499 * @tc.name: HeifParserTest001
500 * @tc.desc: HeifParser
501 * @tc.type: FUNC
502 */
503 HWTEST_F(HeifParserTest, HeifParserTest001, TestSize.Level3)
504 {
505 GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest001 start";
506 HeifParser heifParser;
507 heifParser.iinfBox_ = std::make_shared<HeifIinfBox>();
508 heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
509 heifParser.ipmaBox_ = std::make_shared<HeifIpmaBox>();
510 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
511 heifParser.idatBox_ = std::make_shared<HeifIdatBox>();
512 std::shared_ptr<HeifBox> property = std::make_shared<HeifBox>(0);
513 std::string type;
514 heif_item_id ret = heifParser.GetNextItemId();
515 ASSERT_EQ(ret, 1);
516 heifParser.AddIspeProperty(0, 0, 0);
517 heifParser.AddProperty(0, property, false);
518 heifParser.AddPixiProperty(0, 0, 0, 0);
519 heifParser.AddHvccProperty(0);
520 heifParser.SetAuxcProperty(0, type);
521 heifParser.CheckExtentData();
522 GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest001 end";
523 }
524
525 /**
526 * @tc.name: HeifParserTest002
527 * @tc.desc: HeifParser
528 * @tc.type: FUNC
529 */
530 HWTEST_F(HeifParserTest, HeifParserTest002, TestSize.Level3)
531 {
532 GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest002 start";
533 HeifParser heifParser;
534 heif_item_id itemId = 0;
535 ImagePlugin::HvccConfig config;
536 heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
537 heifParser.ipmaBox_ = std::make_shared<HeifIpmaBox>();
538 ASSERT_EQ(heifParser.GetImage(itemId), nullptr);
539 heifParser.SetHvccConfig(itemId, config);
540 GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest002 end";
541 }
542
543 /**
544 * @tc.name: HeifParserTest003
545 * @tc.desc: HeifParser
546 * @tc.type: FUNC
547 */
548 HWTEST_F(HeifParserTest, HeifParserTest003, TestSize.Level3)
549 {
550 GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest003 start";
551 HeifParser heifParser;
552 heif_item_id itemId = 0;
553 std::vector<uint8_t> data;
554 uint8_t construction_method = 0;
555 heif_item_id fromItemId = 0;
556 uint32_t type = 0;
557 const std::vector<heif_item_id> toItemIds;
558 heifParser.ilocBox_ = nullptr;
559 heifParser.pitmBox_ = nullptr;
560 heifParser.irefBox_ = nullptr;
561 heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
562 ASSERT_NE(heifParser.metaBox_, nullptr);
563 heifParser.AppendIlocData(itemId, data, construction_method);
564 heifParser.SetPrimaryItemId(itemId);
565 heifParser.AddReference(fromItemId, type, toItemIds);
566 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
567 heifParser.pitmBox_ = std::make_shared<HeifPtimBox>();
568 heifParser.irefBox_ = std::make_shared<HeifIrefBox>();
569 heifParser.AppendIlocData(itemId, data, construction_method);
570 heifParser.SetPrimaryItemId(itemId);
571 heifParser.AddReference(fromItemId, type, toItemIds);
572 GTEST_LOG_(INFO) << "HeifParserTest: HeifParserTest003 end";
573 }
574
575 /**
576 * @tc.name: SetPrimaryImageTest001
577 * @tc.desc: HeifParser
578 * @tc.type: FUNC
579 */
580 HWTEST_F(HeifParserTest, SetPrimaryImageTest001, TestSize.Level3)
581 {
582 GTEST_LOG_(INFO) << "HeifParserTest: SetPrimaryImageTest001 start";
583 HeifParser heifParser;
584 std::shared_ptr<HeifImage> image = std::make_shared<HeifImage>(0);
585 heifParser.primaryImage_ = std::make_shared<HeifImage>(0);
586 ASSERT_EQ(heifParser.primaryImage_->GetItemId(), image->GetItemId());
587 heifParser.SetPrimaryImage(image);
588 heifParser.primaryImage_->itemId_ = 1;
589 ASSERT_NE(heifParser.primaryImage_->GetItemId(), image->GetItemId());
590 heifParser.pitmBox_ = nullptr;
591 heifParser.SetPrimaryImage(image);
592 GTEST_LOG_(INFO) << "HeifParserTest: SetPrimaryImageTest001 end";
593 }
594
595 /**
596 * @tc.name: ParseContentChildrenTest001
597 * @tc.desc: Test ParseContentChildren of HeifIprpBox when recursionCount over than MAX_RECURSION_COUNT
598 * @tc.type: FUNC
599 */
600 HWTEST_F(HeifParserTest, ParseContentChildrenTest001, TestSize.Level3)
601 {
602 GTEST_LOG_(INFO) << "HeifParserBoxTest: ParseContentChildrenTest001 start";
603 HeifIprpBox heifIprpBox;
604 auto stream = std::make_shared<HeifBufferInputStream>(nullptr, 0, true);
605 ASSERT_NE(stream, nullptr);
606 HeifStreamReader reader(stream, 0, 0);
607
608 uint32_t recursionCount = heifIprpBox.MAX_RECURSION_COUNT;
609 heif_error error = heifIprpBox.ParseContentChildren(reader, recursionCount);
610 EXPECT_EQ(error, heif_error_too_many_recursion);
611 GTEST_LOG_(INFO) << "HeifParserBoxTest: ParseContentChildrenTest001 end";
612 }
613
614 /**
615 * @tc.name: ParseContentChildrenTest002
616 * @tc.desc: Test ParseContentChildren of HeifIpcoBox when recursionCount over than MAX_RECURSION_COUNT
617 * @tc.type: FUNC
618 */
619 HWTEST_F(HeifParserTest, ParseContentChildrenTest002, TestSize.Level3)
620 {
621 GTEST_LOG_(INFO) << "HeifParserBoxTest: ParseContentChildrenTest002 start";
622 HeifIpcoBox heifIpcoBox;
623 auto stream = std::make_shared<HeifBufferInputStream>(nullptr, 0, true);
624 ASSERT_NE(stream, nullptr);
625 HeifStreamReader reader(stream, 0, 0);
626
627 uint32_t recursionCount = heifIpcoBox.MAX_RECURSION_COUNT;
628 heif_error error = heifIpcoBox.ParseContentChildren(reader, recursionCount);
629 EXPECT_EQ(error, heif_error_too_many_recursion);
630 GTEST_LOG_(INFO) << "HeifParserBoxTest: ParseContentChildrenTest002 end";
631 }
632
633 /**
634 * @tc.name: ParseContentChildrenTest003
635 * @tc.desc: Test ParseContentChildren of HeifIpcoBox when recursionCount over than MAX_RECURSION_COUNT
636 * @tc.type: FUNC
637 */
638 HWTEST_F(HeifParserTest, ParseContentChildrenTest003, TestSize.Level3)
639 {
640 GTEST_LOG_(INFO) << "HeifParserBoxTest: ParseContentChildrenTest003Test001 start";
641 HeifMetaBox heifMetaBox;
642 auto stream = std::make_shared<HeifBufferInputStream>(nullptr, 0, true);
643 ASSERT_NE(stream, nullptr);
644 HeifStreamReader reader(stream, 0, 0);
645
646 uint32_t recursionCount = heifMetaBox.MAX_RECURSION_COUNT;
647 heif_error error = heifMetaBox.ParseContentChildren(reader, recursionCount);
648 EXPECT_EQ(error, heif_error_too_many_recursion);
649 GTEST_LOG_(INFO) << "HeifParserBoxTest: ParseContentChildrenTest003Test001 end";
650 }
651
652 /**
653 * @tc.name: MakeFromMemoryTest001
654 * @tc.desc: Verify that HeifParser call MakeFromMemory when data is nullptr.
655 * @tc.type: FUNC
656 */
657 HWTEST_F(HeifParserTest, MakeFromMemoryTest001, TestSize.Level3)
658 {
659 GTEST_LOG_(INFO) << "HeifParserTest: MakeFromMemoryTest001 start";
660 HeifParser heifParser;
661 auto ret = heifParser.MakeFromMemory(nullptr, 0, false, nullptr);
662 ASSERT_EQ(ret, heif_error_no_data);
663 GTEST_LOG_(INFO) << "HeifParserTest: MakeFromMemoryTest001 end";
664 }
665
666 /**
667 * @tc.name: MakeFromStreamTest001
668 * @tc.desc: Verify that HeifParser call MakeFromStream when stream is nullptr.
669 * @tc.type: FUNC
670 */
671 HWTEST_F(HeifParserTest, MakeFromStreamTest001, TestSize.Level3)
672 {
673 GTEST_LOG_(INFO) << "HeifParserTest: MakeFromStreamTest001 start";
674 HeifParser heifParser;
675 std::shared_ptr<HeifInputStream> stream;
676 auto ret = heifParser.MakeFromStream(stream, nullptr);
677 ASSERT_EQ(ret, heif_error_no_data);
678 GTEST_LOG_(INFO) << "HeifParserTest: MakeFromStreamTest001 end";
679 }
680
681 /**
682 * @tc.name: GetGridLengthTest001
683 * @tc.desc: Verify that HeifParser call GetGridLength when item id is mock.
684 * @tc.type: FUNC
685 */
686 HWTEST_F(HeifParserTest, GetGridLengthTest001, TestSize.Level3)
687 {
688 GTEST_LOG_(INFO) << "HeifParserTest: GetGridLengthTest001 start";
689 HeifParser heifParser;
690 size_t mockSize = 0;
691 auto ret = heifParser.GetGridLength(MOCK_ITEM_ID, mockSize);
692 ASSERT_EQ(ret, heif_error_item_not_found);
693 GTEST_LOG_(INFO) << "HeifParserTest: GetGridLengthTest001 end";
694 }
695
696 /**
697 * @tc.name: GetIdenImageTest001
698 * @tc.desc: Verify that HeifParser call GetIdenImage when item id is mock.
699 * @tc.type: FUNC
700 */
701 HWTEST_F(HeifParserTest, GetIdenImageTest001, TestSize.Level3)
702 {
703 GTEST_LOG_(INFO) << "HeifParserTest: GetIdenImageTest001 start";
704 HeifParser heifParser;
705 std::shared_ptr<HeifImage> resImage;
706 heifParser.GetIdenImage(MOCK_ITEM_ID, resImage);
707 ASSERT_EQ(resImage, nullptr);
708 GTEST_LOG_(INFO) << "HeifParserTest: GetIdenImageTest001 end";
709 }
710
711 /**
712 * @tc.name: GetIdenImageTest002
713 * @tc.desc: Verify that HeifParser call GetIdenImage when irefBox_ is nullptr.
714 * @tc.type: FUNC
715 */
716 HWTEST_F(HeifParserTest, GetIdenImageTest002, TestSize.Level3)
717 {
718 GTEST_LOG_(INFO) << "HeifParserTest: GetIdenImageTest002 start";
719 HeifParser heifParser;
720 std::shared_ptr<HeifInfeBox> mockBox = std::make_shared<HeifInfeBox>(MOCK_ITEM_ID, "iden", false);
721 ASSERT_NE(mockBox, nullptr);
722 heifParser.infeBoxes_[MOCK_ITEM_ID] = mockBox;
723 heifParser.irefBox_.reset();
724 std::shared_ptr<HeifImage> resImage;
725 heifParser.GetIdenImage(MOCK_ITEM_ID, resImage);
726 ASSERT_EQ(resImage, nullptr);
727 GTEST_LOG_(INFO) << "HeifParserTest: GetIdenImageTest002 end";
728 }
729
730 /**
731 * @tc.name: GetIdenImageTest003
732 * @tc.desc: Verify that HeifParser call GetIdenImage when infe's itemType is not iden.
733 * @tc.type: FUNC
734 */
735 HWTEST_F(HeifParserTest, GetIdenImageTest003, TestSize.Level3)
736 {
737 GTEST_LOG_(INFO) << "HeifParserTest: GetIdenImageTest003 start";
738 HeifParser heifParser;
739 std::shared_ptr<HeifInfeBox> mockBox = std::make_shared<HeifInfeBox>(MOCK_ITEM_ID, "mock", false);
740 ASSERT_NE(mockBox, nullptr);
741 heifParser.infeBoxes_[MOCK_ITEM_ID] = mockBox;
742 std::shared_ptr<HeifImage> resImage;
743 heifParser.GetIdenImage(MOCK_ITEM_ID, resImage);
744 ASSERT_EQ(resImage, nullptr);
745 GTEST_LOG_(INFO) << "HeifParserTest: GetIdenImageTest003 end";
746 }
747
748 /**
749 * @tc.name: AssembleImagesTest001
750 * @tc.desc: Verify that HeifParser call AssembleImages when primaryImage_ is invalid.
751 * @tc.type: FUNC
752 */
753 HWTEST_F(HeifParserTest, AssembleImagesTest001, TestSize.Level3)
754 {
755 GTEST_LOG_(INFO) << "HeifParserTest: AssembleImagesTest001 start";
756 HeifParser heifParser;
757 decltype(heifParser.infeBoxes_) mockMap;
758 heifParser.infeBoxes_.swap(mockMap);
759 heifParser.infeBoxes_[MOCK_ITEM_ID] = std::make_shared<HeifInfeBox>(0, "hollow", false);
760 heifParser.primaryImage_.reset();
761 auto ret = heifParser.AssembleImages();
762 ASSERT_EQ(ret, heif_error_primary_item_not_found);
763 GTEST_LOG_(INFO) << "HeifParserTest: AssembleImagesTest001 end";
764 }
765
766 /**
767 * @tc.name: AssembleImagesTest002
768 * @tc.desc: Verify that HeifParser call AssembleImages when primaryImage_ is valid.
769 * @tc.type: FUNC
770 */
771 HWTEST_F(HeifParserTest, AssembleImagesTest002, TestSize.Level3)
772 {
773 GTEST_LOG_(INFO) << "HeifParserTest: AssembleImagesTest002 start";
774 HeifParser heifParser;
775 decltype(heifParser.infeBoxes_) mockMap;
776 mockMap[MOCK_ITEM_ID] = std::make_shared<HeifInfeBox>(0, "hollow", false);
777 mockMap[IT35_TRUE_ID] = std::make_shared<HeifInfeBox>(IT35_TRUE_ID, "it35", false);
778 mockMap[IT35_MOCK_ID] = std::make_shared<HeifInfeBox>(TMAP_MOCK_ID, "it35", false);
779 mockMap[TMAP_TRUE_ID] = std::make_shared<HeifInfeBox>(TMAP_TRUE_ID, "tmap", false);
780 mockMap[TMAP_MOCK_ID] = std::make_shared<HeifInfeBox>(IT35_MOCK_ID, "tmap", false);
781 mockMap[IDEN_TRUE_ID] = std::make_shared<HeifInfeBox>(IDEN_TRUE_ID, "iden", false);
782 mockMap[MIME_TRUE_ID] = std::make_shared<HeifInfeBox>(MIME_TRUE_ID, "mime", false);
783 mockMap[MIME_TRUE_ID]->SetItemName(std::string{"RfDataB\0"});
784 heifParser.infeBoxes_.swap(mockMap);
785 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
786 heifParser.pitmBox_ = std::make_shared<HeifPtimBox>();
787 heifParser.pitmBox_->itemId_ = IDEN_TRUE_ID;
788 heifParser.ipcoBox_.reset();
789 heifParser.ipmaBox_.reset();
790 auto ret = heifParser.AssembleImages();
791 ASSERT_EQ(ret, heif_error_ok);
792 GTEST_LOG_(INFO) << "HeifParserTest: AssembleImagesTest002 end";
793 }
794
795 /**
796 * @tc.name: AssembleImagesTest003
797 * @tc.desc: Verify that HeifParser call AssembleImages when satisfy imir mdvc clli property.
798 * @tc.type: FUNC
799 */
800 HWTEST_F(HeifParserTest, AssembleImagesTest003, TestSize.Level3)
801 {
802 GTEST_LOG_(INFO) << "HeifParserTest: AssembleImagesTest003 start";
803 HeifParser heifParser;
804 decltype(heifParser.infeBoxes_) mockMap;
805 mockMap[TMAP_TRUE_ID] = std::make_shared<HeifInfeBox>(TMAP_TRUE_ID, "tmap", false);
806 heifParser.infeBoxes_.swap(mockMap);
807 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
808 heifParser.pitmBox_ = std::make_shared<HeifPtimBox>();
809
810 heifParser.ipmaBox_ = std::make_shared<HeifIpmaBox>();
811 heifParser.ipmaBox_->AddProperty(TMAP_TRUE_ID, PropertyAssociation{.essential = false, .propertyIndex = INDEX_1});
812 heifParser.ipmaBox_->AddProperty(TMAP_TRUE_ID, PropertyAssociation{.essential = false, .propertyIndex = INDEX_2});
813 heifParser.ipmaBox_->AddProperty(TMAP_TRUE_ID, PropertyAssociation{.essential = false, .propertyIndex = INDEX_3});
814
815 heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
816 heifParser.ipcoBox_->AddChild(std::make_shared<HeifImirBox>());
817 heifParser.ipcoBox_->AddChild(std::make_shared<HeifMdcvBox>());
818 heifParser.ipcoBox_->AddChild(std::make_shared<HeifClliBox>());
819
820 auto ret = heifParser.AssembleImages();
821 ASSERT_EQ(ret, heif_error_primary_item_not_found);
822 GTEST_LOG_(INFO) << "HeifParserTest: AssembleImagesTest003 end";
823 }
824
825 /**
826 * @tc.name: AppendHvccNalDataTest001
827 * @tc.desc: Verify that HeifParser call AppendHvccNalData when hvcc is invalid.
828 * @tc.type: FUNC
829 */
830 HWTEST_F(HeifParserTest, AppendHvccNalDataTest001, TestSize.Level3)
831 {
832 GTEST_LOG_(INFO) << "HeifParserTest: AppendHvccNalDataTest001 start";
833 HeifParser heifParser;
834 heifParser.ipmaBox_ = std::make_shared<HeifIpmaBox>();
835 heifParser.ipmaBox_->AddProperty(TMAP_TRUE_ID, PropertyAssociation{.essential = false, .propertyIndex = INDEX_1});
836 heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
837 std::vector<uint8_t> mockData;
838 auto ret = heifParser.AppendHvccNalData(TMAP_TRUE_ID, mockData);
839 ASSERT_EQ(ret, heif_error_no_hvcc);
840 GTEST_LOG_(INFO) << "HeifParserTest: AppendHvccNalDataTest001 end";
841 }
842
843 /**
844 * @tc.name: AppendHvccNalDataTest002
845 * @tc.desc: Verify that HeifParser call AppendHvccNalData when hvcc is valid.
846 * @tc.type: FUNC
847 */
848 HWTEST_F(HeifParserTest, AppendHvccNalDataTest002, TestSize.Level3)
849 {
850 GTEST_LOG_(INFO) << "HeifParserTest: AppendHvccNalDataTest002 start";
851 HeifParser heifParser;
852 heifParser.ipmaBox_ = std::make_shared<HeifIpmaBox>();
853 heifParser.ipmaBox_->AddProperty(TMAP_TRUE_ID, PropertyAssociation{.essential = false, .propertyIndex = INDEX_1});
854 heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
855 heifParser.ipcoBox_->AddChild(std::make_shared<HeifHvccBox>());
856 std::vector<uint8_t> mockData{MOCK_DATA_1, MOCK_DATA_2};
857 auto ret = heifParser.AppendHvccNalData(TMAP_TRUE_ID, mockData);
858 ASSERT_EQ(ret, heif_error_ok);
859 GTEST_LOG_(INFO) << "HeifParserTest: AppendHvccNalDataTest002 end";
860 }
861
862 /**
863 * @tc.name: SetHvccConfigTest001
864 * @tc.desc: Verify that HeifParser call SetHvccConfig when hvcc is valid.
865 * @tc.type: FUNC
866 */
867 HWTEST_F(HeifParserTest, SetHvccConfigTest001, TestSize.Level3)
868 {
869 GTEST_LOG_(INFO) << "HeifParserTest: SetHvccConfigTest001 start";
870 HeifParser heifParser;
871 heifParser.ipmaBox_ = std::make_shared<HeifIpmaBox>();
872 heifParser.ipmaBox_->AddProperty(TMAP_TRUE_ID, PropertyAssociation{.essential = false, .propertyIndex = INDEX_1});
873 heifParser.ipcoBox_ = std::make_shared<HeifIpcoBox>();
874 heifParser.ipcoBox_->AddChild(std::make_shared<HeifHvccBox>());
875 HvccConfig mockConfig;
876 auto ret = heifParser.SetHvccConfig(TMAP_TRUE_ID, mockConfig);
877 ASSERT_EQ(ret, heif_error_ok);
878 GTEST_LOG_(INFO) << "HeifParserTest: SetHvccConfigTest001 end";
879 }
880
881 /**
882 * @tc.name: GetExifHeaderOffsetTest001
883 * @tc.desc: Verify that HeifParser call GetExifHeaderOffset when data is mock.
884 * @tc.type: FUNC
885 */
886 HWTEST_F(HeifParserTest, GetExifHeaderOffsetTest001, TestSize.Level3)
887 {
888 GTEST_LOG_(INFO) << "HeifParserTest: GetExifHeaderOffsetTest001 start";
889 HeifParser heifParser;
890 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(MOCK_DATA_SIZE);
891 auto ret = heifParser.GetExifHeaderOffset(mockData.get(), MOCK_DATA_SIZE);
892 ASSERT_EQ(ret, NUM_1);
893 GTEST_LOG_(INFO) << "HeifParserTest: GetExifHeaderOffsetTest001 end";
894 }
895
896 /**
897 * @tc.name: SetExifMetadataTest001
898 * @tc.desc: Verify that HeifParser call SetExifMetadata when data is mock.
899 * @tc.type: FUNC
900 */
901 HWTEST_F(HeifParserTest, SetExifMetadataTest001, TestSize.Level3)
902 {
903 GTEST_LOG_(INFO) << "HeifParserTest: SetExifMetadataTest001 start";
904 HeifParser heifParser;
905 auto ret = heifParser.SetExifMetadata(nullptr, nullptr, 0);
906 ASSERT_EQ(ret, heif_invalid_exif_data);
907 GTEST_LOG_(INFO) << "HeifParserTest: SetExifMetadataTest001 end";
908 }
909
910 /**
911 * @tc.name: UpdateExifMetadataTest001
912 * @tc.desc: Verify that HeifParser call UpdateExifMetadata when data is mock.
913 * @tc.type: FUNC
914 */
915 HWTEST_F(HeifParserTest, UpdateExifMetadataTest001, TestSize.Level3)
916 {
917 GTEST_LOG_(INFO) << "HeifParserTest: UpdateExifMetadataTest001 start";
918 HeifParser heifParser;
919 auto ret = heifParser.UpdateExifMetadata(nullptr, nullptr, 0, MOCK_ITEM_ID);
920 ASSERT_EQ(ret, heif_invalid_exif_data);
921 GTEST_LOG_(INFO) << "HeifParserTest: UpdateExifMetadataTest001 end";
922 }
923
924 /**
925 * @tc.name: GetTiffOffsetTest001
926 * @tc.desc: Verify that HeifParser call GetTiffOffset when tiffoffset_ is invalid.
927 * @tc.type: FUNC
928 */
929 HWTEST_F(HeifParserTest, GetTiffOffsetTest001, TestSize.Level3)
930 {
931 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest001 start";
932 HeifParser heifParser;
933 heifParser.tiffOffset_ = NUM_1;
934 auto ret = heifParser.GetTiffOffset();
935 ASSERT_EQ(ret, NUM_1);
936 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest001 end";
937 }
938
939 /**
940 * @tc.name: GetTiffOffsetTest002
941 * @tc.desc: Verify that HeifParser call GetTiffOffset when primaryImage_ is invalid.
942 * @tc.type: FUNC
943 */
944 HWTEST_F(HeifParserTest, GetTiffOffsetTest002, TestSize.Level3)
945 {
946 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest002 start";
947 HeifParser heifParser;
948 heifParser.tiffOffset_ = 0;
949 heifParser.primaryImage_.reset();
950 auto ret = heifParser.GetTiffOffset();
951 ASSERT_EQ(ret, 0);
952 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest002 end";
953 }
954
955 /**
956 * @tc.name: GetTiffOffsetTest003
957 * @tc.desc: Verify that HeifParser call GetTiffOffset when exifId is 0.
958 * @tc.type: FUNC
959 */
960 HWTEST_F(HeifParserTest, GetTiffOffsetTest003, TestSize.Level3)
961 {
962 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest003 start";
963 HeifParser heifParser;
964 heifParser.tiffOffset_ = 0;
965 heifParser.primaryImage_ = std::make_shared<HeifImage>(MOCK_ITEM_ID);
966 auto ret = heifParser.GetTiffOffset();
967 ASSERT_EQ(ret, 0);
968 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest003 end";
969 }
970
971 /**
972 * @tc.name: GetTiffOffsetTest004
973 * @tc.desc: Verify that HeifParser call GetTiffOffset when infeBoxes_ is empty.
974 * @tc.type: FUNC
975 */
976 HWTEST_F(HeifParserTest, GetTiffOffsetTest004, TestSize.Level3)
977 {
978 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest004 start";
979 HeifParser heifParser;
980 heifParser.tiffOffset_ = 0;
981 heifParser.primaryImage_ = std::make_shared<HeifImage>(MOCK_ITEM_ID);
982 std::shared_ptr<HeifMetadata> mockMetaData = std::make_shared<HeifMetadata>();
983 mockMetaData->itemId = MOCK_ITEM_ID;
984 mockMetaData->itemType = std::string{"Exif\0\0"};
985 heifParser.primaryImage_->AddMetadata(mockMetaData);
986 auto ret = heifParser.GetTiffOffset();
987 ASSERT_EQ(ret, 0);
988 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest004 end";
989 }
990
991 /**
992 * @tc.name: GetTiffOffsetTest005
993 * @tc.desc: Verify that HeifParser call GetTiffOffset when ilocItem is nullptr.
994 * @tc.type: FUNC
995 */
996 HWTEST_F(HeifParserTest, GetTiffOffsetTest005, TestSize.Level3)
997 {
998 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest005 start";
999 HeifParser heifParser;
1000 heifParser.tiffOffset_ = 0;
1001 heifParser.primaryImage_ = std::make_shared<HeifImage>(MOCK_ITEM_ID);
1002 std::shared_ptr<HeifMetadata> mockMetaData = std::make_shared<HeifMetadata>();
1003 mockMetaData->itemId = MOCK_ITEM_ID;
1004 mockMetaData->itemType = std::string{"Exif\0\0"};
1005 heifParser.primaryImage_->AddMetadata(mockMetaData);
1006 heifParser.infeBoxes_[MOCK_ITEM_ID] = std::make_shared<HeifInfeBox>(MOCK_ITEM_ID, "mock", false);
1007 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
1008 auto ret = heifParser.GetTiffOffset();
1009 ASSERT_EQ(ret, 0);
1010 GTEST_LOG_(INFO) << "HeifParserTest: GetTiffOffsetTest005 end";
1011 }
1012
1013 /**
1014 * @tc.name: AssembleImagesTest004
1015 * @tc.desc: Verify that HeifParser call AssembleImages when ExtractGainmap include invalid data.
1016 * @tc.type: FUNC
1017 */
1018 HWTEST_F(HeifParserTest, AssembleImagesTest004, TestSize.Level3)
1019 {
1020 GTEST_LOG_(INFO) << "HeifParserTest: AssembleImagesTest004 start";
1021 HeifParser heifParser;
1022 decltype(heifParser.infeBoxes_) mockMap;
1023 mockMap[IDEN_TRUE_ID] = std::make_shared<HeifInfeBox>(IDEN_TRUE_ID, "iden", false);
1024 mockMap[TMAP_TRUE_ID] = std::make_shared<HeifInfeBox>(TMAP_TRUE_ID, "tmap", false);
1025
1026 heifParser.infeBoxes_.swap(mockMap);
1027 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
1028 heifParser.pitmBox_ = std::make_shared<HeifPtimBox>();
1029 heifParser.pitmBox_->itemId_ = IDEN_TRUE_ID;
1030 heifParser.ipcoBox_.reset();
1031 heifParser.ipmaBox_.reset();
1032
1033 heifParser.irefBox_ = std::make_shared<HeifIrefBox>();
1034 heifParser.irefBox_->AddReferences(TMAP_TRUE_ID, BOX_TYPE_THMB, std::vector<heif_item_id>{});
1035 heifParser.irefBox_->AddReferences(TMAP_TRUE_ID, BOX_TYPE_DIMG, std::vector<heif_item_id>{});
1036
1037 auto ret = heifParser.AssembleImages();
1038 ASSERT_EQ(ret, heif_error_ok);
1039
1040 heifParser.irefBox_->references_[INDEX_1].toItemIds = std::vector<heif_item_id>{MOCK_ITEM_ID, TMAP_TRUE_ID};
1041 ret = heifParser.AssembleImages();
1042 ASSERT_EQ(ret, heif_error_ok);
1043
1044 heifParser.irefBox_->references_[INDEX_1].toItemIds = std::vector<heif_item_id>{IDEN_TRUE_ID, MOCK_ITEM_ID};
1045 ret = heifParser.AssembleImages();
1046 ASSERT_EQ(ret, heif_error_ok);
1047 GTEST_LOG_(INFO) << "HeifParserTest: AssembleImagesTest004 end";
1048 }
1049
1050 /**
1051 * @tc.name: MakeFromMemoryTest002
1052 * @tc.desc: Verify that HeifParser call MakeFromMemory when ftypBox_ is nullptr.
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(HeifParserTest, MakeFromMemoryTest002, TestSize.Level3)
1056 {
1057 GTEST_LOG_(INFO) << "HeifParserTest: MakeFromMemoryTest002 start";
1058 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(NUM_1);
1059 std::shared_ptr<HeifParser> heifParser;
1060 auto ret = HeifParser::MakeFromMemory(mockData.get(), NUM_1, false, &heifParser);
1061 ASSERT_EQ(ret, heif_error_no_ftyp);
1062 GTEST_LOG_(INFO) << "HeifParserTest: MakeFromMemoryTest002 end";
1063 }
1064
1065 /**
1066 * @tc.name: AssembleBoxesTest001
1067 * @tc.desc: Verify that HeifParser call AssembleBoxes when metaBox_ is nullptr.
1068 * @tc.type: FUNC
1069 */
1070 HWTEST_F(HeifParserTest, AssembleBoxesTest001, TestSize.Level3)
1071 {
1072 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest001 start";
1073 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(NUM_1);
1074 auto stream = std::make_shared<HeifBufferInputStream>(mockData.get(), NUM_1, false);
1075
1076 HeifParser heifParser(stream);
1077 heifParser.ftypBox_ = std::make_shared<HeifFtypBox>();
1078
1079 auto maxSize = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
1080 HeifStreamReader reader(stream, 0, maxSize);
1081
1082 auto ret = heifParser.AssembleBoxes(reader);
1083 ASSERT_EQ(ret, heif_error_no_meta);
1084 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest001 end";
1085 }
1086
1087 /**
1088 * @tc.name: AssembleBoxesTest002
1089 * @tc.desc: Verify that HeifParser call AssembleBoxes when hdlrBox_ is nullptr.
1090 * @tc.type: FUNC
1091 */
1092 HWTEST_F(HeifParserTest, AssembleBoxesTest002, TestSize.Level3)
1093 {
1094 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest002 start";
1095 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(NUM_1);
1096 auto stream = std::make_shared<HeifBufferInputStream>(mockData.get(), NUM_1, false);
1097
1098 HeifParser heifParser(stream);
1099 heifParser.ftypBox_ = std::make_shared<HeifFtypBox>();
1100 heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
1101
1102 auto maxSize = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
1103 HeifStreamReader reader(stream, 0, maxSize);
1104
1105 auto ret = heifParser.AssembleBoxes(reader);
1106 ASSERT_EQ(ret, heif_error_invalid_handler);
1107 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest002 end";
1108 }
1109
1110 /**
1111 * @tc.name: AssembleBoxesTest003
1112 * @tc.desc: Verify that HeifParser call AssembleBoxes when pitmBox_ is nullptr.
1113 * @tc.type: FUNC
1114 */
1115 HWTEST_F(HeifParserTest, AssembleBoxesTest003, TestSize.Level3)
1116 {
1117 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest003 start";
1118 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(NUM_1);
1119 auto stream = std::make_shared<HeifBufferInputStream>(mockData.get(), NUM_1, false);
1120
1121 HeifParser heifParser(stream);
1122 heifParser.ftypBox_ = std::make_shared<HeifFtypBox>();
1123 heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
1124
1125 AddHdlrBox(heifParser);
1126
1127 auto maxSize = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
1128 HeifStreamReader reader(stream, 0, maxSize);
1129
1130 auto ret = heifParser.AssembleBoxes(reader);
1131 ASSERT_EQ(ret, heif_error_no_pitm);
1132 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest003 end";
1133 }
1134
1135 /**
1136 * @tc.name: AssembleBoxesTest004
1137 * @tc.desc: Verify that HeifParser call AssembleBoxes when iinfBox_ is nullptr.
1138 * @tc.type: FUNC
1139 */
1140 HWTEST_F(HeifParserTest, AssembleBoxesTest004, TestSize.Level3)
1141 {
1142 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest004 start";
1143 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(NUM_1);
1144 auto stream = std::make_shared<HeifBufferInputStream>(mockData.get(), NUM_1, false);
1145
1146 HeifParser heifParser(stream);
1147 heifParser.ftypBox_ = std::make_shared<HeifFtypBox>();
1148 heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
1149
1150 AddHdlrBox(heifParser);
1151 AddPtimBox(heifParser);
1152
1153 auto maxSize = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
1154 HeifStreamReader reader(stream, 0, maxSize);
1155
1156 auto ret = heifParser.AssembleBoxes(reader);
1157 ASSERT_EQ(ret, heif_error_no_iinf);
1158 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest004 end";
1159 }
1160
1161 /**
1162 * @tc.name: AssembleBoxesTest005
1163 * @tc.desc: Verify that HeifParser call AssembleBoxes when iprpBox_ is nullptr.
1164 * @tc.type: FUNC
1165 */
1166 HWTEST_F(HeifParserTest, AssembleBoxesTest005, TestSize.Level3)
1167 {
1168 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest005 start";
1169 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(NUM_1);
1170 auto stream = std::make_shared<HeifBufferInputStream>(mockData.get(), NUM_1, false);
1171
1172 HeifParser heifParser(stream);
1173 heifParser.ftypBox_ = std::make_shared<HeifFtypBox>();
1174 heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
1175
1176 AddHdlrBox(heifParser);
1177 AddPtimBox(heifParser);
1178 AddIinfBox(heifParser);
1179
1180 auto maxSize = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
1181 HeifStreamReader reader(stream, 0, maxSize);
1182
1183 auto ret = heifParser.AssembleBoxes(reader);
1184 ASSERT_EQ(ret, heif_error_no_iprp);
1185 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest005 end";
1186 }
1187
1188 /**
1189 * @tc.name: AssembleBoxesTest006
1190 * @tc.desc: Verify that HeifParser call AssembleBoxes when ipcoBox_ is nullptr.
1191 * @tc.type: FUNC
1192 */
1193 HWTEST_F(HeifParserTest, AssembleBoxesTest006, TestSize.Level3)
1194 {
1195 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest006 start";
1196 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(NUM_1);
1197 auto stream = std::make_shared<HeifBufferInputStream>(mockData.get(), NUM_1, false);
1198
1199 HeifParser heifParser(stream);
1200 heifParser.ftypBox_ = std::make_shared<HeifFtypBox>();
1201 heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
1202
1203 AddHdlrBox(heifParser);
1204 AddPtimBox(heifParser);
1205 AddIinfBox(heifParser);
1206 AddIprpBox(heifParser);
1207
1208 auto maxSize = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
1209 HeifStreamReader reader(stream, 0, maxSize);
1210
1211 auto ret = heifParser.AssembleBoxes(reader);
1212 ASSERT_EQ(ret, heif_error_no_ipco);
1213 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest006 end";
1214 }
1215
1216 /**
1217 * @tc.name: AssembleBoxesTest007
1218 * @tc.desc: Verify that HeifParser call AssembleBoxes when ipmas is empty.
1219 * @tc.type: FUNC
1220 */
1221 HWTEST_F(HeifParserTest, AssembleBoxesTest007, TestSize.Level3)
1222 {
1223 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest007 start";
1224 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(NUM_1);
1225 auto stream = std::make_shared<HeifBufferInputStream>(mockData.get(), NUM_1, false);
1226
1227 HeifParser heifParser(stream);
1228 heifParser.ftypBox_ = std::make_shared<HeifFtypBox>();
1229 heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
1230
1231 AddHdlrBox(heifParser);
1232 AddPtimBox(heifParser);
1233 AddIinfBox(heifParser);
1234 AddIpcoBox(heifParser);
1235
1236 auto maxSize = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
1237 HeifStreamReader reader(stream, 0, maxSize);
1238
1239 auto ret = heifParser.AssembleBoxes(reader);
1240 ASSERT_EQ(ret, heif_error_no_ipma);
1241 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest007 end";
1242 }
1243
1244 /**
1245 * @tc.name: AssembleBoxesTest008
1246 * @tc.desc: Verify that HeifParser call AssembleBoxes when ilocBox_ is nullptr.
1247 * @tc.type: FUNC
1248 */
1249 HWTEST_F(HeifParserTest, AssembleBoxesTest008, TestSize.Level3)
1250 {
1251 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest008 start";
1252 std::unique_ptr<uint8_t[]> mockData = std::make_unique<uint8_t[]>(NUM_1);
1253 auto stream = std::make_shared<HeifBufferInputStream>(mockData.get(), NUM_1, false);
1254
1255 HeifParser heifParser(stream);
1256 heifParser.ftypBox_ = std::make_shared<HeifFtypBox>();
1257 heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
1258
1259 AddHdlrBox(heifParser);
1260 AddPtimBox(heifParser);
1261 AddIinfBox(heifParser);
1262 AddIpmaBox(heifParser);
1263
1264 auto maxSize = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
1265 HeifStreamReader reader(stream, 0, maxSize);
1266
1267 auto ret = heifParser.AssembleBoxes(reader);
1268 ASSERT_EQ(ret, heif_error_no_iloc);
1269 GTEST_LOG_(INFO) << "HeifParserTest: AssembleBoxesTest008 end";
1270 }
1271
1272 /**
1273 * @tc.name: GetGridLengthTest002
1274 * @tc.desc: Verify that HeifParser call GetGridLength when item data id is mock.
1275 * @tc.type: FUNC
1276 */
1277 HWTEST_F(HeifParserTest, GetGridLengthTest002, TestSize.Level3)
1278 {
1279 GTEST_LOG_(INFO) << "HeifParserTest: GetGridLengthTest002 start";
1280 HeifParser heifParser;
1281 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
1282 heifParser.infeBoxes_[MOCK_ITEM_ID] = std::make_shared<HeifInfeBox>();
1283
1284 size_t mockSize = 0;
1285 auto ret = heifParser.GetGridLength(MOCK_ITEM_ID, mockSize);
1286 ASSERT_EQ(ret, heif_error_item_data_not_found);
1287 GTEST_LOG_(INFO) << "HeifParserTest: GetGridLengthTest002 end";
1288 }
1289
1290 /**
1291 * @tc.name: GetItemDataTest002
1292 * @tc.desc: Verify that HeifParser call GetItemData when hvcc id is nullptr.
1293 * @tc.type: FUNC
1294 */
1295 HWTEST_F(HeifParserTest, GetItemDataTest002, TestSize.Level3)
1296 {
1297 GTEST_LOG_(INFO) << "HeifParserTest: GetItemDataTest002 start";
1298 HeifParser heifParser;
1299 heifParser.ilocBox_ = std::make_shared<HeifIlocBox>();
1300 heifParser.ilocBox_->AppendData(MOCK_ITEM_ID, std::vector<uint8_t>());
1301
1302 heifParser.infeBoxes_[MOCK_ITEM_ID] = std::make_shared<HeifInfeBox>(MOCK_ITEM_ID, "hvc1", false);
1303
1304 auto ret = heifParser.GetItemData(MOCK_ITEM_ID, nullptr);
1305 ASSERT_EQ(ret, heif_error_no_hvcc);
1306 GTEST_LOG_(INFO) << "HeifParserTest: GetItemDataTest002 end";
1307 }
1308
1309 /**
1310 * @tc.name: AddItemTest001
1311 * @tc.desc: Verify that HeifParser call AddItem when iinfBox_ is nullptr.
1312 * @tc.type: FUNC
1313 */
1314 HWTEST_F(HeifParserTest, AddItemTest001, TestSize.Level3)
1315 {
1316 GTEST_LOG_(INFO) << "HeifParserTest: AddItemTest001 start";
1317 HeifParser heifParser;
1318 heifParser.iinfBox_.reset();
1319 auto ret = heifParser.AddItem("mock", false);
1320 ASSERT_EQ(ret, nullptr);
1321 GTEST_LOG_(INFO) << "HeifParserTest: AddItemTest001 end";
1322 }
1323
1324 /**
1325 * @tc.name: SetMetadataTest001
1326 * @tc.desc: Verify that HeifParser call SetMetadata when content_type is not nullptr.
1327 * @tc.type: FUNC
1328 */
1329 HWTEST_F(HeifParserTest, SetMetadataTest001, TestSize.Level3)
1330 {
1331 GTEST_LOG_(INFO) << "HeifParserTest: SetMetadataTest001 start";
1332 HeifParser heifParser;
1333 heifParser.iinfBox_ = std::make_shared<HeifIinfBox>();
1334 heifParser.metaBox_ = std::make_shared<HeifMetaBox>();
1335 std::shared_ptr<HeifImage> mockImage = std::make_shared<HeifImage>(MOCK_ITEM_ID);
1336 auto ret = heifParser.SetMetadata(mockImage, std::vector<uint8_t>(), "mock", "mock");
1337 ASSERT_EQ(ret, heif_error_ok);
1338 GTEST_LOG_(INFO) << "HeifParserTest: SetMetadataTest001 end";
1339 }
1340 }
1341 }