1 /* 2 * Copyright (C) 2021 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 #include <gtest/gtest.h> 16 #define IMAGE_COLORSPACE_FLAG 17 #define private public 18 #define protected public 19 #include <fcntl.h> 20 #include "buffer_source_stream.h" 21 #include "exif_info.h" 22 #include "plugin_export.h" 23 #include "icc_profile_info.h" 24 #include "jpeg_decoder.h" 25 #include "jpeg_encoder.h" 26 #include "media_errors.h" 27 28 using namespace testing::ext; 29 using namespace OHOS::Media; 30 using namespace OHOS::ImagePlugin; 31 namespace OHOS { 32 namespace Media { 33 static const std::string IMAGE_INPUT_NULL_JPEG_PATH = "/data/local/tmp/image/test_null.jpg"; 34 static const std::string IMAGE_INPUT_JPEG_PATH = "/data/local/tmp/image/test_exif.jpg"; 35 static const std::string IMAGE_INPUT_TXT_PATH = "/data/local/tmp/image/test.txt"; 36 constexpr uint32_t COMPONENT_NUM_RGBA = 4; 37 constexpr uint32_t COMPONENT_NUM_BGRA = 4; 38 constexpr uint32_t COMPONENT_NUM_RGB = 3; 39 constexpr uint32_t COMPONENT_NUM_GRAY = 1; 40 constexpr uint8_t COMPONENT_NUM_YUV420SP = 3; 41 constexpr uint8_t SAMPLE_FACTOR_TWO = 2; 42 class PluginLibJpegTest : public testing::Test { 43 public: PluginLibJpegTest()44 PluginLibJpegTest() {} ~PluginLibJpegTest()45 ~PluginLibJpegTest() {} 46 }; 47 48 /** 49 * @tc.name: exif_info001 50 * @tc.desc: ParseExifData 51 * @tc.type: FUNC 52 */ 53 HWTEST_F(PluginLibJpegTest, exif_info001, TestSize.Level3) 54 { 55 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001 start"; 56 EXIFInfo exinfo; 57 unsigned char *buf = nullptr; 58 unsigned len = 1000; 59 exinfo.ParseExifData(buf, len); 60 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001 end"; 61 } 62 63 /** 64 * @tc.name: exif_info001_1 65 * @tc.desc: ParseExifData 66 * @tc.type: FUNC 67 */ 68 HWTEST_F(PluginLibJpegTest, exif_info001_1, TestSize.Level3) 69 { 70 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001_1 start"; 71 EXIFInfo exinfo; 72 unsigned char buf = 'n'; 73 unsigned len = 1000; 74 exinfo.ParseExifData(&buf, len); 75 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001_1 end"; 76 } 77 78 /** 79 * @tc.name: exif_info001_2 80 * @tc.desc: ParseExifData 81 * @tc.type: FUNC 82 */ 83 HWTEST_F(PluginLibJpegTest, exif_info001_2, TestSize.Level3) 84 { 85 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001_2 start"; 86 EXIFInfo exinfo; 87 unsigned char *buf = nullptr; 88 unsigned len = 0; 89 exinfo.ParseExifData(buf, len); 90 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001_2 end"; 91 } 92 93 /** 94 * @tc.name: exif_info001_3 95 * @tc.desc: ParseExifData 96 * @tc.type: FUNC 97 */ 98 HWTEST_F(PluginLibJpegTest, exif_info001_3, TestSize.Level3) 99 { 100 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001_3 start"; 101 EXIFInfo exinfo; 102 string data = ""; 103 exinfo.ParseExifData(data); 104 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001_3 end"; 105 } 106 107 /** 108 * @tc.name: exif_info001_4 109 * @tc.desc: ParseExifData 110 * @tc.type: FUNC 111 */ 112 HWTEST_F(PluginLibJpegTest, exif_info001_4, TestSize.Level3) 113 { 114 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001_4 start"; 115 EXIFInfo exinfo; 116 string data = "aaaaaaa"; 117 exinfo.ParseExifData(data); 118 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info001_4 end"; 119 } 120 121 /** 122 * @tc.name: exif_info002 123 * @tc.desc: ModifyExifData 124 * @tc.type: FUNC 125 */ 126 HWTEST_F(PluginLibJpegTest, exif_info002, TestSize.Level3) 127 { 128 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info002 start"; 129 EXIFInfo exinfo; 130 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 131 string value = "111"; 132 uint32_t ret = exinfo.ModifyExifData(tag, value, ""); 133 ASSERT_EQ(ret, ERR_MEDIA_IO_ABNORMAL); 134 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info002 end"; 135 } 136 137 /** 138 * @tc.name: exif_info003 139 * @tc.desc: ModifyExifData 140 * @tc.type: FUNC 141 */ 142 HWTEST_F(PluginLibJpegTest, exif_info003, TestSize.Level3) 143 { 144 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info003 start"; 145 EXIFInfo exinfo; 146 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 147 string value = "111"; 148 uint32_t ret = exinfo.ModifyExifData(tag, value, IMAGE_INPUT_NULL_JPEG_PATH); 149 ASSERT_EQ(ret, ERR_MEDIA_BUFFER_TOO_SMALL); 150 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info003 end"; 151 } 152 153 /** 154 * @tc.name: exif_info004 155 * @tc.desc: ModifyExifData 156 * @tc.type: FUNC 157 */ 158 HWTEST_F(PluginLibJpegTest, exif_info004, TestSize.Level3) 159 { 160 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info004 start"; 161 EXIFInfo exinfo; 162 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 163 string value = "111"; 164 uint32_t ret = exinfo.ModifyExifData(tag, value, IMAGE_INPUT_TXT_PATH); 165 ASSERT_NE(ret, SUCCESS); 166 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info004 end"; 167 } 168 169 /** 170 * @tc.name: exif_info005 171 * @tc.desc: ModifyExifData 172 * @tc.type: FUNC 173 */ 174 HWTEST_F(PluginLibJpegTest, exif_info005, TestSize.Level3) 175 { 176 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info005 start"; 177 EXIFInfo exinfo; 178 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 179 string value = "111"; 180 int fd = open("/data/local/tmp/image/test_noexit.jpg", O_RDWR, S_IRUSR | S_IWUSR); 181 uint32_t ret = exinfo.ModifyExifData(tag, value, fd); 182 ASSERT_NE(ret, SUCCESS); 183 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info005 end"; 184 } 185 186 /** 187 * @tc.name: exif_info006 188 * @tc.desc: ModifyExifData 189 * @tc.type: FUNC 190 */ 191 HWTEST_F(PluginLibJpegTest, exif_info006, TestSize.Level3) 192 { 193 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info006 start"; 194 EXIFInfo exinfo; 195 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 196 string value = "111"; 197 const int fd = open("/data/local/tmp/image/test_null.jpg", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); 198 uint32_t ret = exinfo.ModifyExifData(tag, value, fd); 199 ASSERT_EQ(ret, ERR_MEDIA_BUFFER_TOO_SMALL); 200 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info006 end"; 201 } 202 203 /** 204 * @tc.name: exif_info007 205 * @tc.desc: ModifyExifData 206 * @tc.type: FUNC 207 */ 208 HWTEST_F(PluginLibJpegTest, exif_info007, TestSize.Level3) 209 { 210 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info007 start"; 211 EXIFInfo exinfo; 212 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 213 string value = "111"; 214 const int fd = open("/data/local/tmp/image/test.txt", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); 215 uint32_t ret = exinfo.ModifyExifData(tag, value, fd); 216 ASSERT_NE(ret, SUCCESS); 217 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info007 end"; 218 } 219 220 /** 221 * @tc.name: exif_info008 222 * @tc.desc: ModifyExifData 223 * @tc.type: FUNC 224 */ 225 HWTEST_F(PluginLibJpegTest, exif_info008, TestSize.Level3) 226 { 227 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info008 start"; 228 EXIFInfo exinfo; 229 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 230 unsigned char *data = nullptr; 231 string value = "111"; 232 uint32_t size = 0; 233 uint32_t ret = exinfo.ModifyExifData(tag, value, data, size); 234 ASSERT_EQ(ret, ERR_IMAGE_SOURCE_DATA); 235 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info008 end"; 236 } 237 238 /** 239 * @tc.name: exif_info009 240 * @tc.desc: ModifyExifData 241 * @tc.type: FUNC 242 */ 243 HWTEST_F(PluginLibJpegTest, exif_info009, TestSize.Level3) 244 { 245 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info009 start"; 246 EXIFInfo exinfo; 247 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 248 unsigned char data = 'n'; 249 string value = "111"; 250 uint32_t size = 0; 251 uint32_t ret = exinfo.ModifyExifData(tag, value, &data, size); 252 ASSERT_EQ(ret, ERR_MEDIA_BUFFER_TOO_SMALL); 253 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info009 end"; 254 } 255 256 /** 257 * @tc.name: exif_info010 258 * @tc.desc: ModifyExifData 259 * @tc.type: FUNC 260 */ 261 HWTEST_F(PluginLibJpegTest, exif_info010, TestSize.Level3) 262 { 263 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info010 start"; 264 EXIFInfo exinfo; 265 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 266 unsigned char data = 'n'; 267 std::string value = "111"; 268 uint32_t size = 1; 269 uint32_t ret = exinfo.ModifyExifData(tag, value, &data, size); 270 ASSERT_EQ(ret, ERR_IMAGE_MISMATCHED_FORMAT); 271 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info010 end"; 272 } 273 274 /** 275 * @tc.name: exif_info011 276 * @tc.desc: ModifyExifData 277 * @tc.type: FUNC 278 */ 279 HWTEST_F(PluginLibJpegTest, exif_info011, TestSize.Level3) 280 { 281 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info011 start"; 282 EXIFInfo exinfo; 283 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 284 unsigned char data = 0xFF; 285 std::string value = "111"; 286 uint32_t size = 1; 287 uint32_t ret = exinfo.ModifyExifData(tag, value, &data, size); 288 ASSERT_EQ(ret, ERR_IMAGE_MISMATCHED_FORMAT); 289 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info011 end"; 290 } 291 292 /** 293 * @tc.name: exif_info012 294 * @tc.desc: GetFilterArea 295 * @tc.type: FUNC 296 */ 297 HWTEST_F(PluginLibJpegTest, exif_info012, TestSize.Level3) 298 { 299 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info012 start"; 300 EXIFInfo exinfo; 301 const uint32_t bufSize = 5; 302 uint8_t buf[bufSize] = "exif"; 303 int filterType = 0; 304 std::vector<std::pair<uint32_t, uint32_t>> ranges; 305 exinfo.GetFilterArea(buf, bufSize, filterType, ranges); 306 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info012 end"; 307 } 308 309 /** 310 * @tc.name: exif_info013 311 * @tc.desc: GetFilterArea 312 * @tc.type: FUNC 313 */ 314 HWTEST_F(PluginLibJpegTest, exif_info013, TestSize.Level3) 315 { 316 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info013 start"; 317 EXIFInfo exinfo; 318 const uint32_t bufSize = 5; 319 uint8_t buf[bufSize] = "exif"; 320 int filterType = 0; 321 std::vector<std::pair<uint32_t, uint32_t>> ranges; 322 uint32_t ret = exinfo.GetFilterArea(buf, bufSize, filterType, ranges); 323 ASSERT_EQ(ret, 1); 324 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info013 end"; 325 } 326 327 /** 328 * @tc.name: exif_info014 329 * @tc.desc: IsIFDPointerTag 330 * @tc.type: FUNC 331 */ 332 HWTEST_F(PluginLibJpegTest, exif_info014, TestSize.Level3) 333 { 334 GTEST_LOG_(INFO) << "PluginLibJpegTest: IsIFDPointerTag start"; 335 const uint8_t *buf = new uint8_t; 336 ByteOrderedBuffer byteorder(buf, 10); 337 bool ret; 338 ret = byteorder.IsIFDPointerTag(0x014a); 339 ASSERT_EQ(ret, true); 340 ret = byteorder.IsIFDPointerTag(0x8769); 341 ASSERT_EQ(ret, true); 342 ret = byteorder.IsIFDPointerTag(0x8825); 343 ASSERT_EQ(ret, true); 344 ret = byteorder.IsIFDPointerTag(0xa005); 345 ASSERT_EQ(ret, true); 346 ret = byteorder.IsIFDPointerTag(0xa301); 347 ASSERT_EQ(ret, false); 348 ret = byteorder.IsIFDPointerTag(-1); 349 ASSERT_EQ(ret, false); 350 GTEST_LOG_(INFO) << "PluginLibJpegTest: IsIFDPointerTag end"; 351 } 352 353 /** 354 * @tc.name: exif_info015 355 * @tc.desc: GetIFDOfIFDPointerTag 356 * @tc.type: FUNC 357 */ 358 HWTEST_F(PluginLibJpegTest, exif_info015, TestSize.Level3) 359 { 360 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetIFDOfIFDPointerTag start"; 361 const uint8_t *buf = new uint8_t; 362 ByteOrderedBuffer byteorder(buf, 10); 363 ExifIfd ret; 364 ret = byteorder.GetIFDOfIFDPointerTag(0x8769); 365 ASSERT_EQ(ret, EXIF_IFD_EXIF); 366 ret = byteorder.GetIFDOfIFDPointerTag(0x8825); 367 ASSERT_EQ(ret, EXIF_IFD_GPS); 368 ret = byteorder.GetIFDOfIFDPointerTag(0xa005); 369 ASSERT_EQ(ret, EXIF_IFD_INTEROPERABILITY); 370 ret = byteorder.GetIFDOfIFDPointerTag(-1); 371 ASSERT_EQ(ret, EXIF_IFD_COUNT); 372 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetIFDOfIFDPointerTag end"; 373 } 374 375 /** 376 * @tc.name: exif_info016 377 * @tc.desc: CheckExifEntryValid 378 * @tc.type: FUNC 379 */ 380 HWTEST_F(PluginLibJpegTest, exif_info016, TestSize.Level3) 381 { 382 GTEST_LOG_(INFO) << "PluginLibJpegTest: CheckExifEntryValid start"; 383 EXIFInfo exinfo; 384 bool ret; 385 ret = exinfo.CheckExifEntryValid(EXIF_IFD_0, EXIF_TAG_ORIENTATION); 386 ASSERT_EQ(ret, true); 387 ret = exinfo.CheckExifEntryValid(EXIF_IFD_EXIF, EXIF_TAG_DATE_TIME_ORIGINAL); 388 ASSERT_EQ(ret, true); 389 ret = exinfo.CheckExifEntryValid(EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE); 390 ASSERT_EQ(ret, true); 391 GTEST_LOG_(INFO) << "PluginLibJpegTest: CheckExifEntryValid end"; 392 } 393 394 /** 395 * @tc.name: CreateExifData001 396 * @tc.desc: CreateExifData 397 * @tc.type: FUNC 398 */ 399 HWTEST_F(PluginLibJpegTest, CreateExifData001, TestSize.Level3) 400 { 401 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifData001 start"; 402 EXIFInfo exinfo; 403 unsigned char buf[20] = "ttttttExif"; 404 ExifData *ptrData = exif_data_new(); 405 bool isNewExifData = true; 406 bool ret = exinfo.CreateExifData(buf, 5, &ptrData, isNewExifData); 407 ASSERT_EQ(ret, true); 408 if (ptrData != nullptr) { 409 exif_data_unref(ptrData); 410 ptrData = nullptr; 411 } 412 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifData001 end"; 413 } 414 415 /** 416 * @tc.name: CreateExifData002 417 * @tc.desc: CreateExifData 418 * @tc.type: FUNC 419 */ 420 HWTEST_F(PluginLibJpegTest, CreateExifData002, TestSize.Level3) 421 { 422 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifData002 start"; 423 EXIFInfo exinfo; 424 unsigned char buf[20] = "tttttttttt"; 425 ExifData *ptrData = exif_data_new(); 426 bool isNewExifData = true; 427 bool ret = exinfo.CreateExifData(buf, 5, &ptrData, isNewExifData); 428 ASSERT_EQ(ret, true); 429 if (ptrData != nullptr) { 430 exif_data_unref(ptrData); 431 ptrData = nullptr; 432 } 433 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifData002 end"; 434 } 435 436 /** 437 * @tc.name: GetExifByteOrder001 438 * @tc.desc: GetExifByteOrder 439 * @tc.type: FUNC 440 */ 441 HWTEST_F(PluginLibJpegTest, GetExifByteOrder001, TestSize.Level3) 442 { 443 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifByteOrder001 start"; 444 EXIFInfo exinfo; 445 unsigned char *buf = new unsigned char; 446 ExifByteOrder ret = exinfo.GetExifByteOrder(true, buf); 447 ASSERT_EQ(ret, EXIF_BYTE_ORDER_INTEL); 448 delete buf; 449 buf = nullptr; 450 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifByteOrder001 end"; 451 } 452 453 /** 454 * @tc.name: GetExifByteOrder002 455 * @tc.desc: GetExifByteOrder 456 * @tc.type: FUNC 457 */ 458 HWTEST_F(PluginLibJpegTest, GetExifByteOrder002, TestSize.Level3) 459 { 460 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifByteOrder002 start"; 461 EXIFInfo exinfo; 462 unsigned char buf[20] = "ttttttttttttMM"; 463 ExifByteOrder ret = exinfo.GetExifByteOrder(false, buf); 464 ASSERT_EQ(ret, EXIF_BYTE_ORDER_MOTOROLA); 465 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifByteOrder002 end"; 466 } 467 468 /** 469 * @tc.name: GetExifByteOrder003 470 * @tc.desc: GetExifByteOrder 471 * @tc.type: FUNC 472 */ 473 HWTEST_F(PluginLibJpegTest, GetExifByteOrder003, TestSize.Level3) 474 { 475 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifByteOrder003 start"; 476 EXIFInfo exinfo; 477 unsigned char buf[20] = "tttttttttttttt"; 478 ExifByteOrder ret = exinfo.GetExifByteOrder(false, buf); 479 ASSERT_EQ(ret, EXIF_BYTE_ORDER_INTEL); 480 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifByteOrder003 end"; 481 } 482 483 /** 484 * @tc.name: WriteExifDataToFile001 485 * @tc.desc: WriteExifDataToFile 486 * @tc.type: FUNC 487 */ 488 HWTEST_F(PluginLibJpegTest, WriteExifDataToFile001, TestSize.Level3) 489 { 490 GTEST_LOG_(INFO) << "PluginLibJpegTest: WriteExifDataToFile001 start"; 491 EXIFInfo exinfo; 492 bool ret = exinfo.WriteExifDataToFile(nullptr, 5, 20, nullptr, nullptr); 493 ASSERT_EQ(ret, false); 494 GTEST_LOG_(INFO) << "PluginLibJpegTest: WriteExifDataToFile001 end"; 495 } 496 497 /** 498 * @tc.name: ReleaseSource001 499 * @tc.desc: ReleaseSource 500 * @tc.type: FUNC 501 */ 502 HWTEST_F(PluginLibJpegTest, ReleaseSource001, TestSize.Level3) 503 { 504 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReleaseSource001 start"; 505 EXIFInfo exinfo; 506 unsigned char *ptrBuf = new unsigned char; 507 FILE *file = fopen("/data/local/tmp/image/test.txt", "r+"); 508 exinfo.ReleaseSource(&ptrBuf, &file); 509 ASSERT_EQ(ptrBuf, nullptr); 510 ASSERT_EQ(file, nullptr); 511 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReleaseSource001 end"; 512 } 513 514 /** 515 * @tc.name: UpdateCacheExifData001 516 * @tc.desc: UpdateCacheExifData 517 * @tc.type: FUNC 518 */ 519 HWTEST_F(PluginLibJpegTest, UpdateCacheExifData001, TestSize.Level3) 520 { 521 GTEST_LOG_(INFO) << "PluginLibJpegTest: UpdateCacheExifData001 start"; 522 EXIFInfo exinfo; 523 FILE *file = fopen("/data/local/tmp/image/test.txt", "rb"); 524 exinfo.UpdateCacheExifData(file); 525 fclose(file); 526 GTEST_LOG_(INFO) << "PluginLibJpegTest: UpdateCacheExifData001 end"; 527 } 528 529 /** 530 * @tc.name: GetAreaFromExifEntries001 531 * @tc.desc: GetAreaFromExifEntries 532 * @tc.type: FUNC 533 */ 534 HWTEST_F(PluginLibJpegTest, GetAreaFromExifEntries001, TestSize.Level3) 535 { 536 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetAreaFromExifEntries001 start"; 537 EXIFInfo exinfo; 538 const uint8_t *buf = new uint8_t; 539 ByteOrderedBuffer byteOrderedBuffer(buf, 10); 540 byteOrderedBuffer.GenerateDEArray(); 541 std::vector<std::pair<uint32_t, uint32_t>> ranges; 542 exinfo.GetAreaFromExifEntries(1, byteOrderedBuffer.directoryEntryArray_, ranges); 543 delete buf; 544 buf = nullptr; 545 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetAreaFromExifEntries001 end"; 546 } 547 548 /** 549 * @tc.name: TransformTiffOffsetToFilePos001 550 * @tc.desc: TransformTiffOffsetToFilePos 551 * @tc.type: FUNC 552 */ 553 HWTEST_F(PluginLibJpegTest, TransformTiffOffsetToFilePos001, TestSize.Level3) 554 { 555 GTEST_LOG_(INFO) << "PluginLibJpegTest: TransformTiffOffsetToFilePos001 start"; 556 const uint8_t *buf = new uint8_t; 557 ByteOrderedBuffer byteorder(buf, 10); 558 uint32_t ret = byteorder.TransformTiffOffsetToFilePos(20); 559 ASSERT_EQ(ret, 32); 560 delete buf; 561 buf = nullptr; 562 GTEST_LOG_(INFO) << "PluginLibJpegTest: TransformTiffOffsetToFilePos001 end"; 563 } 564 565 /** 566 * @tc.name: ReadShort001 567 * @tc.desc: ReadShort 568 * @tc.type: FUNC 569 */ 570 HWTEST_F(PluginLibJpegTest, ReadShort001, TestSize.Level3) 571 { 572 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReadShort001 start"; 573 const uint8_t *buf = new uint8_t; 574 ByteOrderedBuffer byteorder(buf, 10); 575 byteorder.curPosition_ = 5; 576 byteorder.bufferLength_ = 1; 577 int16_t ret = byteorder.ReadShort(); 578 ASSERT_EQ(ret, -1); 579 delete buf; 580 buf = nullptr; 581 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReadShort001 end"; 582 } 583 584 /** 585 * @tc.name: ReadShort002 586 * @tc.desc: ReadShort 587 * @tc.type: FUNC 588 */ 589 HWTEST_F(PluginLibJpegTest, ReadShort002, TestSize.Level3) 590 { 591 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReadShort002 start"; 592 const uint8_t *buf = new uint8_t; 593 ByteOrderedBuffer byteorder(buf, 10); 594 byteorder.bufferLength_ = 100; 595 byteorder.byteOrder_ = EXIF_BYTE_ORDER_MOTOROLA; 596 int16_t ret = byteorder.ReadShort(); 597 ASSERT_NE(ret, -1); 598 delete buf; 599 buf = nullptr; 600 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReadShort002 end"; 601 } 602 603 /** 604 * @tc.name: ReadShort003 605 * @tc.desc: ReadShort 606 * @tc.type: FUNC 607 */ 608 HWTEST_F(PluginLibJpegTest, ReadShort003, TestSize.Level3) 609 { 610 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReadShort003 start"; 611 const uint8_t *buf = new uint8_t; 612 ByteOrderedBuffer byteorder(buf, 10); 613 byteorder.bufferLength_ = 100; 614 byteorder.byteOrder_ = EXIF_BYTE_ORDER_INTEL; 615 int16_t ret = byteorder.ReadShort(); 616 ASSERT_NE(ret, -1); 617 delete buf; 618 buf = nullptr; 619 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReadShort003 end"; 620 } 621 622 /** 623 * @tc.name: GetDataRangeFromIFD001 624 * @tc.desc: GetDataRangeFromIFD 625 * @tc.type: FUNC 626 */ 627 HWTEST_F(PluginLibJpegTest, GetDataRangeFromIFD001, TestSize.Level3) 628 { 629 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetDataRangeFromIFD001 start"; 630 const uint8_t *buf = new uint8_t; 631 ByteOrderedBuffer byteorder(buf, 10); 632 byteorder.curPosition_ = 0; 633 byteorder.bufferLength_ = 20; 634 byteorder.GetDataRangeFromIFD(EXIF_IFD_0); 635 delete buf; 636 buf = nullptr; 637 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetDataRangeFromIFD001 end"; 638 } 639 640 /** 641 * @tc.name: GetDataRangeFromIFD002 642 * @tc.desc: GetDataRangeFromIFD 643 * @tc.type: FUNC 644 */ 645 HWTEST_F(PluginLibJpegTest, GetDataRangeFromIFD002, TestSize.Level3) 646 { 647 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetDataRangeFromIFD002 start"; 648 const uint8_t *buf = new uint8_t; 649 ByteOrderedBuffer byteorder(buf, 10); 650 byteorder.bufferLength_ = 8; 651 byteorder.GetDataRangeFromIFD(EXIF_IFD_0); 652 delete buf; 653 buf = nullptr; 654 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetDataRangeFromIFD002 end"; 655 } 656 657 /** 658 * @tc.name: ParseIFDPointerTag001 659 * @tc.desc: ParseIFDPointerTag 660 * @tc.type: FUNC 661 */ 662 HWTEST_F(PluginLibJpegTest, ParseIFDPointerTag001, TestSize.Level3) 663 { 664 GTEST_LOG_(INFO) << "PluginLibJpegTest: ParseIFDPointerTag001 start"; 665 const uint8_t *buf = new uint8_t; 666 ByteOrderedBuffer byteorder(buf, 10); 667 uint16_t tagNumber = byteorder.ReadUnsignedShort(); 668 const ExifIfd ifd = byteorder.GetIFDOfIFDPointerTag(tagNumber);; 669 const uint16_t dataFormat = byteorder.ReadUnsignedShort(); 670 byteorder.ParseIFDPointerTag(ifd, dataFormat); 671 delete buf; 672 buf = nullptr; 673 GTEST_LOG_(INFO) << "PluginLibJpegTest: ParseIFDPointerTag001 end"; 674 } 675 676 /** 677 * @tc.name: IsIFDhandled001 678 * @tc.desc: IsIFDhandled 679 * @tc.type: FUNC 680 */ 681 HWTEST_F(PluginLibJpegTest, IsIFDhandled001, TestSize.Level3) 682 { 683 GTEST_LOG_(INFO) << "PluginLibJpegTest: IsIFDhandled001 start"; 684 const uint8_t *buf = new uint8_t; 685 ByteOrderedBuffer byteorder(buf, 10); 686 byteorder.handledIfdOffsets_.clear(); 687 bool ret = byteorder.IsIFDhandled(1); 688 ASSERT_EQ(ret, false); 689 delete buf; 690 buf = nullptr; 691 GTEST_LOG_(INFO) << "PluginLibJpegTest: IsIFDhandled001 end"; 692 } 693 694 /** 695 * @tc.name: IsIFDhandled002 696 * @tc.desc: IsIFDhandled 697 * @tc.type: FUNC 698 */ 699 HWTEST_F(PluginLibJpegTest, IsIFDhandled002, TestSize.Level3) 700 { 701 GTEST_LOG_(INFO) << "PluginLibJpegTest: IsIFDhandled002 start"; 702 const uint8_t *buf = new uint8_t; 703 ByteOrderedBuffer byteorder(buf, 10); 704 byteorder.handledIfdOffsets_.push_back(1); 705 bool ret = byteorder.IsIFDhandled(1); 706 ASSERT_EQ(ret, true); 707 delete buf; 708 buf = nullptr; 709 GTEST_LOG_(INFO) << "PluginLibJpegTest: IsIFDhandled002 end"; 710 } 711 712 /** 713 * @tc.name: GetNextIfdFromLinkList001 714 * @tc.desc: GetNextIfdFromLinkList 715 * @tc.type: FUNC 716 */ 717 HWTEST_F(PluginLibJpegTest, GetNextIfdFromLinkList001, TestSize.Level3) 718 { 719 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetNextIfdFromLinkList001 start"; 720 const uint8_t *buf = new uint8_t; 721 ByteOrderedBuffer byteorder(buf, 10); 722 ExifIfd ret = byteorder.GetNextIfdFromLinkList(EXIF_IFD_0); 723 ASSERT_EQ(ret, EXIF_IFD_1); 724 delete buf; 725 buf = nullptr; 726 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetNextIfdFromLinkList001 end"; 727 } 728 729 /** 730 * @tc.name: GetNextIfdFromLinkList002 731 * @tc.desc: GetNextIfdFromLinkList 732 * @tc.type: FUNC 733 */ 734 HWTEST_F(PluginLibJpegTest, GetNextIfdFromLinkList002, TestSize.Level3) 735 { 736 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetNextIfdFromLinkList002 start"; 737 const uint8_t *buf = new uint8_t; 738 ByteOrderedBuffer byteorder(buf, 10); 739 ExifIfd ret = byteorder.GetNextIfdFromLinkList(EXIF_IFD_EXIF); 740 ASSERT_EQ(ret, EXIF_IFD_COUNT); 741 delete buf; 742 buf = nullptr; 743 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetNextIfdFromLinkList002 end"; 744 } 745 746 /** 747 * @tc.name: IsExifDataParsed001 748 * @tc.desc: IsExifDataParsed 749 * @tc.type: FUNC 750 */ 751 HWTEST_F(PluginLibJpegTest, IsExifDataParsed001, TestSize.Level3) 752 { 753 GTEST_LOG_(INFO) << "PluginLibJpegTest: IsExifDataParsed001 start"; 754 EXIFInfo exinfo; 755 exinfo.isExifDataParsed_ = false; 756 bool ret = exinfo.IsExifDataParsed(); 757 ASSERT_EQ(ret, false); 758 GTEST_LOG_(INFO) << "PluginLibJpegTest: IsExifDataParsed001 end"; 759 } 760 761 /** 762 * @tc.name: SetExifTagValues001 763 * @tc.desc: SetExifTagValues 764 * @tc.type: FUNC 765 */ 766 HWTEST_F(PluginLibJpegTest, SetExifTagValues001, TestSize.Level3) 767 { 768 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues001 start"; 769 EXIFInfo exinfo; 770 const std::string val = "111"; 771 exinfo.SetExifTagValues(EXIF_TAG_BITS_PER_SAMPLE, val); 772 ASSERT_EQ(exinfo.bitsPerSample_, val); 773 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues001 end"; 774 } 775 776 /** 777 * @tc.name: SetExifTagValues002 778 * @tc.desc: SetExifTagValues 779 * @tc.type: FUNC 780 */ 781 HWTEST_F(PluginLibJpegTest, SetExifTagValues002, TestSize.Level3) 782 { 783 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues002 start"; 784 EXIFInfo exinfo; 785 const std::string val = "222"; 786 exinfo.SetExifTagValues(EXIF_TAG_ORIENTATION, val); 787 ASSERT_EQ(exinfo.orientation_, val); 788 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues002 end"; 789 } 790 791 /** 792 * @tc.name: SetExifTagValues003 793 * @tc.desc: SetExifTagValues 794 * @tc.type: FUNC 795 */ 796 HWTEST_F(PluginLibJpegTest, SetExifTagValues003, TestSize.Level3) 797 { 798 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues003 start"; 799 EXIFInfo exinfo; 800 const std::string val = "333"; 801 exinfo.SetExifTagValues(EXIF_TAG_IMAGE_LENGTH, val); 802 ASSERT_EQ(exinfo.imageLength_, val); 803 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues003 end"; 804 } 805 806 /** 807 * @tc.name: SetExifTagValues004 808 * @tc.desc: SetExifTagValues 809 * @tc.type: FUNC 810 */ 811 HWTEST_F(PluginLibJpegTest, SetExifTagValues004, TestSize.Level3) 812 { 813 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues004 start"; 814 EXIFInfo exinfo; 815 const std::string val = "444"; 816 exinfo.SetExifTagValues(EXIF_TAG_IMAGE_WIDTH, val); 817 ASSERT_EQ(exinfo.imageWidth_, val); 818 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues004 end"; 819 } 820 821 /** 822 * @tc.name: SetExifTagValues005 823 * @tc.desc: SetExifTagValues 824 * @tc.type: FUNC 825 */ 826 HWTEST_F(PluginLibJpegTest, SetExifTagValues005, TestSize.Level3) 827 { 828 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues005 start"; 829 EXIFInfo exinfo; 830 const std::string val = "test"; 831 exinfo.SetExifTagValues(EXIF_TAG_GPS_LATITUDE, val); 832 ASSERT_EQ(exinfo.gpsLatitude_, val); 833 exinfo.SetExifTagValues(EXIF_TAG_GPS_LONGITUDE, val); 834 ASSERT_EQ(exinfo.gpsLongitude_, val); 835 exinfo.SetExifTagValues(EXIF_TAG_GPS_LATITUDE_REF, val); 836 ASSERT_EQ(exinfo.gpsLatitudeRef_, val); 837 exinfo.SetExifTagValues(EXIF_TAG_GPS_LONGITUDE_REF, val); 838 ASSERT_EQ(exinfo.gpsLongitudeRef_, val); 839 exinfo.SetExifTagValues(EXIF_TAG_DATE_TIME_ORIGINAL, val); 840 ASSERT_EQ(exinfo.dateTimeOriginal_, val); 841 exinfo.SetExifTagValues(EXIF_TAG_EXPOSURE_TIME, val); 842 ASSERT_EQ(exinfo.exposureTime_, val); 843 exinfo.SetExifTagValues(EXIF_TAG_FNUMBER, val); 844 ASSERT_EQ(exinfo.fNumber_, val); 845 exinfo.SetExifTagValues(EXIF_TAG_ISO_SPEED_RATINGS, val); 846 ASSERT_EQ(exinfo.isoSpeedRatings_, val); 847 exinfo.SetExifTagValues(EXIF_TAG_SCENE_TYPE, val); 848 ASSERT_EQ(exinfo.sceneType_, val); 849 exinfo.SetExifTagValues(EXIF_TAG_COMPRESSED_BITS_PER_PIXEL, val); 850 ASSERT_EQ(exinfo.compressedBitsPerPixel_, val); 851 exinfo.SetExifTagValues(EXIF_TAG_DATE_TIME, val); 852 ASSERT_EQ(exinfo.dateTime_, val); 853 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValues005 end"; 854 } 855 856 /** 857 * @tc.name: SetExifTagValuesEx001 858 * @tc.desc: SetExifTagValuesEx 859 * @tc.type: FUNC 860 */ 861 HWTEST_F(PluginLibJpegTest, SetExifTagValuesEx001, TestSize.Level3) 862 { 863 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValuesEx001 start"; 864 EXIFInfo exinfo; 865 const std::string val = "test"; 866 exinfo.SetExifTagValuesEx(EXIF_TAG_DATE_TIME, val); 867 ASSERT_EQ(exinfo.dateTime_, val); 868 exinfo.SetExifTagValuesEx(EXIF_TAG_GPS_TIME_STAMP, val); 869 ASSERT_EQ(exinfo.gpsTimeStamp_, val); 870 exinfo.SetExifTagValuesEx(EXIF_TAG_GPS_DATE_STAMP, val); 871 ASSERT_EQ(exinfo.gpsDateStamp_, val); 872 exinfo.SetExifTagValuesEx(EXIF_TAG_IMAGE_DESCRIPTION, val); 873 ASSERT_EQ(exinfo.imageDescription_, val); 874 exinfo.SetExifTagValuesEx(EXIF_TAG_MAKE, val); 875 ASSERT_EQ(exinfo.make_, val); 876 exinfo.SetExifTagValuesEx(EXIF_TAG_MODEL, val); 877 ASSERT_EQ(exinfo.model_, val); 878 exinfo.SetExifTagValuesEx(EXIF_TAG_JPEG_PROC, val); 879 ASSERT_EQ(exinfo.photoMode_, val); 880 exinfo.SetExifTagValuesEx(static_cast<ExifTag>(0x8830), val); 881 ASSERT_EQ(exinfo.sensitivityType_, val); 882 exinfo.SetExifTagValuesEx(static_cast<ExifTag>(0x8831), val); 883 ASSERT_EQ(exinfo.standardOutputSensitivity_, val); 884 exinfo.SetExifTagValuesEx(static_cast<ExifTag>(0x8832), val); 885 ASSERT_EQ(exinfo.recommendedExposureIndex_, val); 886 exinfo.SetExifTagValuesEx(EXIF_TAG_APERTURE_VALUE, val); 887 ASSERT_EQ(exinfo.apertureValue_, val); 888 exinfo.SetExifTagValuesEx(EXIF_TAG_EXPOSURE_BIAS_VALUE, val); 889 ASSERT_EQ(exinfo.exposureBiasValue_, val); 890 exinfo.SetExifTagValuesEx(EXIF_TAG_METERING_MODE, val); 891 ASSERT_EQ(exinfo.meteringMode_, val); 892 exinfo.SetExifTagValuesEx(EXIF_TAG_FLASH, val); 893 ASSERT_EQ(exinfo.flash_, val); 894 exinfo.SetExifTagValuesEx(EXIF_TAG_FOCAL_LENGTH, val); 895 ASSERT_EQ(exinfo.focalLength_, val); 896 exinfo.SetExifTagValuesEx(EXIF_TAG_USER_COMMENT, val); 897 ASSERT_EQ(exinfo.userComment_, val); 898 exinfo.SetExifTagValuesEx(EXIF_TAG_PIXEL_X_DIMENSION, val); 899 ASSERT_EQ(exinfo.pixelXDimension_, val); 900 exinfo.SetExifTagValuesEx(EXIF_TAG_PIXEL_Y_DIMENSION, val); 901 ASSERT_EQ(exinfo.pixelYDimension_, val); 902 exinfo.SetExifTagValuesEx(EXIF_TAG_WHITE_BALANCE, val); 903 ASSERT_EQ(exinfo.whiteBalance_, val); 904 exinfo.SetExifTagValuesEx(EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM, val); 905 ASSERT_EQ(exinfo.focalLengthIn35mmFilm_, val); 906 exinfo.SetExifTagValuesEx(EXIF_TAG_COMPRESSED_BITS_PER_PIXEL, val); 907 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValuesEx001 end"; 908 } 909 910 /** 911 * @tc.name: CreateExifEntry001 912 * @tc.desc: CreateExifEntry 913 * @tc.type: FUNC 914 */ 915 HWTEST_F(PluginLibJpegTest, CreateExifEntry001, TestSize.Level3) 916 { 917 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry001 start"; 918 EXIFInfo exinfo; 919 ExifData *ptrExifData; 920 bool isNewExifData = false; 921 unsigned long fileLength = 100; 922 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 923 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 924 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 925 ExifEntry *entry = nullptr; 926 const std::string value = "test,test,test,test,test,test"; 927 bool ret = exinfo.CreateExifEntry(EXIF_TAG_BITS_PER_SAMPLE, ptrExifData, value, order, &entry); 928 ASSERT_EQ(ret, false); 929 ExifEntry *ptrEntry = new ExifEntry; 930 ret = exinfo.CreateExifEntry(EXIF_TAG_BITS_PER_SAMPLE, ptrExifData, value, order, &ptrEntry); 931 ASSERT_EQ(ret, false); 932 ret = exinfo.CreateExifEntry(EXIF_TAG_BITS_PER_SAMPLE, ptrExifData, "test,test", order, &ptrEntry); 933 ASSERT_EQ(ret, true); 934 delete ptrEntry; 935 ptrEntry = nullptr; 936 free(fileBuf); 937 fileBuf = nullptr; 938 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry001 end"; 939 } 940 941 /** 942 * @tc.name: CreateExifEntry002 943 * @tc.desc: CreateExifEntry 944 * @tc.type: FUNC 945 */ 946 HWTEST_F(PluginLibJpegTest, CreateExifEntry002, TestSize.Level3) 947 { 948 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry002 start"; 949 EXIFInfo exinfo; 950 ExifData *ptrExifData; 951 bool isNewExifData = false; 952 unsigned long fileLength = 100; 953 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 954 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 955 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 956 ExifEntry *entry = nullptr; 957 const std::string value = "test"; 958 bool ret = exinfo.CreateExifEntry(EXIF_TAG_ORIENTATION, ptrExifData, value, order, &entry); 959 ASSERT_EQ(ret, true); 960 free(fileBuf); 961 fileBuf = nullptr; 962 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry002 end"; 963 } 964 965 /** 966 * @tc.name: CreateExifEntry003 967 * @tc.desc: CreateExifEntry 968 * @tc.type: FUNC 969 */ 970 HWTEST_F(PluginLibJpegTest, CreateExifEntry003, TestSize.Level3) 971 { 972 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry003 start"; 973 EXIFInfo exinfo; 974 ExifData *ptrExifData; 975 bool isNewExifData = false; 976 unsigned long fileLength = 100; 977 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 978 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 979 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 980 ExifEntry *entry = nullptr; 981 const std::string value = "test"; 982 bool ret = exinfo.CreateExifEntry(EXIF_TAG_IMAGE_LENGTH, ptrExifData, value, order, &entry); 983 ASSERT_EQ(ret, true); 984 free(fileBuf); 985 fileBuf = nullptr; 986 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry003 end"; 987 } 988 989 /** 990 * @tc.name: CreateExifEntry004 991 * @tc.desc: CreateExifEntry 992 * @tc.type: FUNC 993 */ 994 HWTEST_F(PluginLibJpegTest, CreateExifEntry004, TestSize.Level3) 995 { 996 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry004 start"; 997 EXIFInfo exinfo; 998 ExifData *ptrExifData; 999 bool isNewExifData = false; 1000 unsigned long fileLength = 100; 1001 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1002 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1003 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1004 ExifEntry *entry = nullptr; 1005 const std::string value = "test"; 1006 bool ret = exinfo.CreateExifEntry(EXIF_TAG_IMAGE_WIDTH, ptrExifData, value, order, &entry); 1007 ASSERT_EQ(ret, true); 1008 free(fileBuf); 1009 fileBuf = nullptr; 1010 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry004 end"; 1011 } 1012 1013 /** 1014 * @tc.name: CreateExifEntry005 1015 * @tc.desc: CreateExifEntry 1016 * @tc.type: FUNC 1017 */ 1018 HWTEST_F(PluginLibJpegTest, CreateExifEntry005, TestSize.Level3) 1019 { 1020 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry005 start"; 1021 EXIFInfo exinfo; 1022 ExifData *ptrExifData; 1023 bool isNewExifData = false; 1024 unsigned long fileLength = 100; 1025 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1026 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1027 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1028 ExifEntry *entry = nullptr; 1029 const std::string value = "1.0"; 1030 bool ret = exinfo.CreateExifEntry(EXIF_TAG_COMPRESSED_BITS_PER_PIXEL, ptrExifData, value, order, &entry); 1031 ASSERT_EQ(ret, true); 1032 free(fileBuf); 1033 fileBuf = nullptr; 1034 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry005 end"; 1035 } 1036 1037 /** 1038 * @tc.name: CreateExifEntry006 1039 * @tc.desc: CreateExifEntry 1040 * @tc.type: FUNC 1041 */ 1042 HWTEST_F(PluginLibJpegTest, CreateExifEntry006, TestSize.Level3) 1043 { 1044 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry006 start"; 1045 EXIFInfo exinfo; 1046 ExifData *ptrExifData; 1047 bool isNewExifData = false; 1048 unsigned long fileLength = 100; 1049 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1050 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1051 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1052 ExifEntry *entry = nullptr; 1053 const std::string value = "test,test,test,test,test,test"; 1054 bool ret = exinfo.CreateExifEntry(EXIF_TAG_GPS_LATITUDE, ptrExifData, value, order, &entry); 1055 ASSERT_EQ(ret, false); 1056 ExifEntry *ptrEntry = new ExifEntry; 1057 ret = exinfo.CreateExifEntry(EXIF_TAG_GPS_LATITUDE, ptrExifData, "test,test", order, &ptrEntry); 1058 ASSERT_EQ(ret, true); 1059 delete ptrEntry; 1060 ptrEntry = nullptr; 1061 free(fileBuf); 1062 fileBuf = nullptr; 1063 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry006 end"; 1064 } 1065 1066 /** 1067 * @tc.name: CreateExifEntry007 1068 * @tc.desc: CreateExifEntry 1069 * @tc.type: FUNC 1070 */ 1071 HWTEST_F(PluginLibJpegTest, CreateExifEntry007, TestSize.Level3) 1072 { 1073 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry007 start"; 1074 EXIFInfo exinfo; 1075 ExifData *ptrExifData; 1076 bool isNewExifData = false; 1077 unsigned long fileLength = 100; 1078 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1079 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1080 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1081 ExifEntry *entry = nullptr; 1082 const std::string value = "test,test,test,test,test,test"; 1083 bool ret = exinfo.CreateExifEntry(EXIF_TAG_GPS_LONGITUDE, ptrExifData, value, order, &entry); 1084 ASSERT_EQ(ret, false); 1085 ExifEntry *ptrEntry = nullptr; 1086 ret = exinfo.CreateExifEntry(EXIF_TAG_GPS_LONGITUDE, ptrExifData, "test,test", order, &ptrEntry); 1087 ASSERT_EQ(ret, true); 1088 free(fileBuf); 1089 fileBuf = nullptr; 1090 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry007 end"; 1091 } 1092 1093 /** 1094 * @tc.name: CreateExifEntry008 1095 * @tc.desc: CreateExifEntry 1096 * @tc.type: FUNC 1097 */ 1098 HWTEST_F(PluginLibJpegTest, CreateExifEntry008, TestSize.Level3) 1099 { 1100 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry008 start"; 1101 EXIFInfo exinfo; 1102 ExifData *ptrExifData; 1103 bool isNewExifData = false; 1104 unsigned long fileLength = 100; 1105 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1106 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1107 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1108 ExifEntry *entry = nullptr; 1109 const std::string value = "test,test,test,test,test,test"; 1110 bool ret = exinfo.CreateExifEntry(EXIF_TAG_GPS_LATITUDE_REF, ptrExifData, value, order, &entry); 1111 ASSERT_EQ(ret, true); 1112 free(fileBuf); 1113 fileBuf = nullptr; 1114 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry008 end"; 1115 } 1116 1117 /** 1118 * @tc.name: CreateExifEntry009 1119 * @tc.desc: CreateExifEntry 1120 * @tc.type: FUNC 1121 */ 1122 HWTEST_F(PluginLibJpegTest, CreateExifEntry009, TestSize.Level3) 1123 { 1124 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry009 start"; 1125 EXIFInfo exinfo; 1126 ExifData *ptrExifData; 1127 bool isNewExifData = false; 1128 unsigned long fileLength = 100; 1129 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1130 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1131 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1132 ExifEntry *entry = nullptr; 1133 const std::string value = "test,test,test,test,test,test"; 1134 bool ret = exinfo.CreateExifEntry(EXIF_TAG_GPS_LONGITUDE_REF, ptrExifData, value, order, &entry); 1135 ASSERT_EQ(ret, true); 1136 free(fileBuf); 1137 fileBuf = nullptr; 1138 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry009 end"; 1139 } 1140 1141 /** 1142 * @tc.name: CreateExifEntry0010 1143 * @tc.desc: CreateExifEntry 1144 * @tc.type: FUNC 1145 */ 1146 HWTEST_F(PluginLibJpegTest, CreateExifEntry0010, TestSize.Level3) 1147 { 1148 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry0010 start"; 1149 EXIFInfo exinfo; 1150 ExifData *ptrExifData; 1151 bool isNewExifData = false; 1152 unsigned long fileLength = 100; 1153 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1154 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1155 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1156 ExifEntry *entry = nullptr; 1157 const std::string value = "test,test,test,test,test,test"; 1158 bool ret = exinfo.CreateExifEntry(EXIF_TAG_WHITE_BALANCE, ptrExifData, value, order, &entry); 1159 ASSERT_EQ(ret, true); 1160 ret = exinfo.CreateExifEntry(EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM, ptrExifData, value, order, &entry); 1161 ASSERT_EQ(ret, true); 1162 ret = exinfo.CreateExifEntry(EXIF_TAG_FLASH, ptrExifData, value, order, &entry); 1163 ASSERT_EQ(ret, true); 1164 free(fileBuf); 1165 fileBuf = nullptr; 1166 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry0010 end"; 1167 } 1168 1169 /** 1170 * @tc.name: CreateExifEntry0011 1171 * @tc.desc: CreateExifEntry 1172 * @tc.type: FUNC 1173 */ 1174 HWTEST_F(PluginLibJpegTest, CreateExifEntry0011, TestSize.Level3) 1175 { 1176 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry0011 start"; 1177 EXIFInfo exinfo; 1178 ExifData *ptrExifData; 1179 bool isNewExifData = false; 1180 unsigned long fileLength = 100; 1181 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1182 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1183 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1184 ExifEntry *entry = nullptr; 1185 const std::string value = "test/test/test/test/test"; 1186 bool ret = exinfo.CreateExifEntry(EXIF_TAG_APERTURE_VALUE, ptrExifData, value, order, &entry); 1187 ASSERT_EQ(ret, false); 1188 ret = exinfo.CreateExifEntry(EXIF_TAG_APERTURE_VALUE, ptrExifData, "test/test", order, &entry); 1189 ASSERT_EQ(ret, true); 1190 ret = exinfo.CreateExifEntry(EXIF_TAG_DATE_TIME_ORIGINAL, ptrExifData, "test", order, &entry); 1191 ASSERT_EQ(ret, true); 1192 ret = exinfo.CreateExifEntry(EXIF_TAG_DATE_TIME, ptrExifData, "test", order, &entry); 1193 ASSERT_EQ(ret, true); 1194 free(fileBuf); 1195 fileBuf = nullptr; 1196 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry0011 end"; 1197 } 1198 1199 /** 1200 * @tc.name: CreateExifEntry0012 1201 * @tc.desc: CreateExifEntry 1202 * @tc.type: FUNC 1203 */ 1204 HWTEST_F(PluginLibJpegTest, CreateExifEntry0012, TestSize.Level3) 1205 { 1206 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry0012 start"; 1207 EXIFInfo exinfo; 1208 ExifData *ptrExifData; 1209 bool isNewExifData = false; 1210 unsigned long fileLength = 100; 1211 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1212 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1213 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1214 ExifEntry *entry = nullptr; 1215 const std::string value = "test/test/test/test/test"; 1216 bool ret = exinfo.CreateExifEntry(EXIF_TAG_EXPOSURE_BIAS_VALUE, ptrExifData, value, order, &entry); 1217 ASSERT_EQ(ret, false); 1218 ret = exinfo.CreateExifEntry(EXIF_TAG_EXPOSURE_BIAS_VALUE, ptrExifData, "test/test", order, &entry); 1219 ASSERT_EQ(ret, true); 1220 ret = exinfo.CreateExifEntry(EXIF_TAG_EXPOSURE_TIME, ptrExifData, value, order, &entry); 1221 ASSERT_EQ(ret, false); 1222 ret = exinfo.CreateExifEntry(EXIF_TAG_EXPOSURE_TIME, ptrExifData, "test/test", order, &entry); 1223 ASSERT_EQ(ret, true); 1224 ret = exinfo.CreateExifEntry(EXIF_TAG_FNUMBER, ptrExifData, value, order, &entry); 1225 ASSERT_EQ(ret, false); 1226 ret = exinfo.CreateExifEntry(EXIF_TAG_FNUMBER, ptrExifData, "test/test", order, &entry); 1227 ASSERT_EQ(ret, true); 1228 ret = exinfo.CreateExifEntry(EXIF_TAG_FOCAL_LENGTH, ptrExifData, value, order, &entry); 1229 ASSERT_EQ(ret, false); 1230 ret = exinfo.CreateExifEntry(EXIF_TAG_FOCAL_LENGTH, ptrExifData, "test/test", order, &entry); 1231 ASSERT_EQ(ret, true); 1232 ret = exinfo.CreateExifEntry(EXIF_TAG_GPS_TIME_STAMP, ptrExifData, "test:test", order, &entry); 1233 ASSERT_EQ(ret, false); 1234 ret = exinfo.CreateExifEntry(EXIF_TAG_GPS_TIME_STAMP, ptrExifData, "test:test:test", order, &entry); 1235 ASSERT_EQ(ret, true); 1236 free(fileBuf); 1237 fileBuf = nullptr; 1238 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry0012 end"; 1239 } 1240 1241 /** 1242 * @tc.name: CreateExifEntry0013 1243 * @tc.desc: CreateExifEntry 1244 * @tc.type: FUNC 1245 */ 1246 HWTEST_F(PluginLibJpegTest, CreateExifEntry0013, TestSize.Level3) 1247 { 1248 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry0013 start"; 1249 EXIFInfo exinfo; 1250 ExifData *ptrExifData; 1251 bool isNewExifData = false; 1252 unsigned long fileLength = 100; 1253 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1254 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1255 ExifByteOrder order = exinfo.GetExifByteOrder(isNewExifData, fileBuf); 1256 ExifEntry *entry = nullptr; 1257 const std::string value = "test/test/test/test/test"; 1258 bool ret = exinfo.CreateExifEntry(EXIF_TAG_GPS_DATE_STAMP, ptrExifData, value, order, &entry); 1259 ASSERT_EQ(ret, true); 1260 ret = exinfo.CreateExifEntry(EXIF_TAG_IMAGE_DESCRIPTION, ptrExifData, value, order, &entry); 1261 ASSERT_EQ(ret, true); 1262 ret = exinfo.CreateExifEntry(EXIF_TAG_ISO_SPEED_RATINGS, ptrExifData, value, order, &entry); 1263 ASSERT_EQ(ret, true); 1264 ret = exinfo.CreateExifEntry(EXIF_TAG_ISO_SPEED, ptrExifData, value, order, &entry); 1265 ASSERT_EQ(ret, true); 1266 ret = exinfo.CreateExifEntry(EXIF_TAG_LIGHT_SOURCE, ptrExifData, value, order, &entry); 1267 ASSERT_EQ(ret, true); 1268 ret = exinfo.CreateExifEntry(EXIF_TAG_MAKE, ptrExifData, value, order, &entry); 1269 ASSERT_EQ(ret, true); 1270 ret = exinfo.CreateExifEntry(EXIF_TAG_METERING_MODE, ptrExifData, value, order, &entry); 1271 ASSERT_EQ(ret, true); 1272 ret = exinfo.CreateExifEntry(EXIF_TAG_MODEL, ptrExifData, value, order, &entry); 1273 ASSERT_EQ(ret, true); 1274 ret = exinfo.CreateExifEntry(EXIF_TAG_PIXEL_X_DIMENSION, ptrExifData, value, order, &entry); 1275 ASSERT_EQ(ret, true); 1276 ret = exinfo.CreateExifEntry(EXIF_TAG_PIXEL_Y_DIMENSION, ptrExifData, value, order, &entry); 1277 ASSERT_EQ(ret, true); 1278 ret = exinfo.CreateExifEntry(EXIF_TAG_RECOMMENDED_EXPOSURE_INDEX, ptrExifData, value, order, &entry); 1279 ASSERT_EQ(ret, true); 1280 ret = exinfo.CreateExifEntry(EXIF_TAG_SCENE_TYPE, ptrExifData, value, order, &entry); 1281 ASSERT_EQ(ret, true); 1282 ret = exinfo.CreateExifEntry(EXIF_TAG_SENSITIVITY_TYPE, ptrExifData, value, order, &entry); 1283 ASSERT_EQ(ret, true); 1284 ret = exinfo.CreateExifEntry(EXIF_TAG_STANDARD_OUTPUT_SENSITIVITY, ptrExifData, value, order, &entry); 1285 ASSERT_EQ(ret, true); 1286 ret = exinfo.CreateExifEntry(EXIF_TAG_USER_COMMENT, ptrExifData, value, order, &entry); 1287 ASSERT_EQ(ret, true); 1288 free(fileBuf); 1289 fileBuf = nullptr; 1290 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifEntry0013 end"; 1291 } 1292 1293 /** 1294 * @tc.name: SetDEDataByteCount001 1295 * @tc.desc: SetDEDataByteCount 1296 * @tc.type: FUNC 1297 */ 1298 HWTEST_F(PluginLibJpegTest, SetDEDataByteCount001, TestSize.Level3) 1299 { 1300 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetDEDataByteCount001 start"; 1301 const uint8_t *buf = new uint8_t; 1302 ByteOrderedBuffer byteorder(buf, 10); 1303 uint16_t dataFormat = byteorder.ReadUnsignedShort(); 1304 int32_t numberOfComponents = byteorder.ReadInt32(); 1305 uint32_t byteCount = 0; 1306 bool ret = byteorder.SetDEDataByteCount(0x0000, dataFormat, numberOfComponents, byteCount); 1307 ASSERT_EQ(ret, false); 1308 ret = byteorder.SetDEDataByteCount(0x0133, -1, numberOfComponents, byteCount); 1309 ASSERT_EQ(ret, false); 1310 ret = byteorder.SetDEDataByteCount(0x0133, 1, numberOfComponents, byteCount); 1311 ASSERT_EQ(ret, true); 1312 delete buf; 1313 buf = nullptr; 1314 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetDEDataByteCount001 end"; 1315 } 1316 1317 /** 1318 * @tc.name: ParseIFDPointerTag002 1319 * @tc.desc: ParseIFDPointerTag 1320 * @tc.type: FUNC 1321 */ 1322 HWTEST_F(PluginLibJpegTest, ParseIFDPointerTag002, TestSize.Level3) 1323 { 1324 GTEST_LOG_(INFO) << "PluginLibJpegTest: ParseIFDPointerTag002 start"; 1325 const uint8_t *buf = new uint8_t; 1326 ByteOrderedBuffer byteorder(buf, 10); 1327 uint16_t tagNumber = byteorder.ReadUnsignedShort(); 1328 const ExifIfd ifd = byteorder.GetIFDOfIFDPointerTag(tagNumber);; 1329 byteorder.ParseIFDPointerTag(ifd, EXIF_FORMAT_SHORT); 1330 byteorder.ParseIFDPointerTag(ifd, EXIF_FORMAT_SSHORT); 1331 byteorder.ParseIFDPointerTag(ifd, EXIF_FORMAT_LONG); 1332 byteorder.ParseIFDPointerTag(ifd, EXIF_FORMAT_SLONG); 1333 delete buf; 1334 buf = nullptr; 1335 GTEST_LOG_(INFO) << "PluginLibJpegTest: ParseIFDPointerTag002 end"; 1336 } 1337 1338 /** 1339 * @tc.name: GetOrginExifDataLength001 1340 * @tc.desc: GetOrginExifDataLength 1341 * @tc.type: FUNC 1342 */ 1343 HWTEST_F(PluginLibJpegTest, GetOrginExifDataLength001, TestSize.Level3) 1344 { 1345 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetOrginExifDataLength001 start"; 1346 EXIFInfo exinfo; 1347 unsigned char buf[10] = "testtest"; 1348 unsigned int ret = exinfo.GetOrginExifDataLength(true, buf); 1349 ASSERT_EQ(ret, 0); 1350 ret = exinfo.GetOrginExifDataLength(false, buf); 1351 ASSERT_NE(ret, 0); 1352 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetOrginExifDataLength001 end"; 1353 } 1354 1355 /** 1356 * @tc.name: GenerateDEArray001 1357 * @tc.desc: GenerateDEArray 1358 * @tc.type: FUNC 1359 */ 1360 HWTEST_F(PluginLibJpegTest, GenerateDEArray001, TestSize.Level3) 1361 { 1362 GTEST_LOG_(INFO) << "PluginLibJpegTest: GenerateDEArray001 start"; 1363 EXIFInfo exinfo; 1364 const uint8_t *buf = new uint8_t; 1365 ByteOrderedBuffer byteOrderedBuffer(buf, 10); 1366 byteOrderedBuffer.bufferLength_ = 0; 1367 byteOrderedBuffer.GenerateDEArray(); 1368 delete buf; 1369 buf = nullptr; 1370 GTEST_LOG_(INFO) << "PluginLibJpegTest: GenerateDEArray001 end"; 1371 } 1372 1373 /** 1374 * @tc.name: GenerateDEArray002 1375 * @tc.desc: GenerateDEArray 1376 * @tc.type: FUNC 1377 */ 1378 HWTEST_F(PluginLibJpegTest, GenerateDEArray002, TestSize.Level3) 1379 { 1380 GTEST_LOG_(INFO) << "PluginLibJpegTest: GenerateDEArray002 start"; 1381 EXIFInfo exinfo; 1382 const uint8_t *buf = new uint8_t; 1383 ByteOrderedBuffer byteOrderedBuffer(buf, 10); 1384 byteOrderedBuffer.bufferLength_ = 21; 1385 byteOrderedBuffer.GenerateDEArray(); 1386 delete buf; 1387 buf = nullptr; 1388 GTEST_LOG_(INFO) << "PluginLibJpegTest: GenerateDEArray002 end"; 1389 } 1390 1391 /** 1392 * @tc.name: ReadInt32001 1393 * @tc.desc: ReadInt32 1394 * @tc.type: FUNC 1395 */ 1396 HWTEST_F(PluginLibJpegTest, ReadInt32001, TestSize.Level3) 1397 { 1398 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReadInt32001 start"; 1399 EXIFInfo exinfo; 1400 const uint8_t *buf = new uint8_t; 1401 ByteOrderedBuffer byteOrderedBuffer(buf, 10); 1402 byteOrderedBuffer.bufferLength_ = 1; 1403 int32_t ret = byteOrderedBuffer.ReadInt32(); 1404 ASSERT_EQ(ret, -1); 1405 byteOrderedBuffer.bufferLength_ = 100; 1406 byteOrderedBuffer.byteOrder_ = EXIF_BYTE_ORDER_MOTOROLA; 1407 ret = byteOrderedBuffer.ReadInt32(); 1408 ASSERT_NE(ret, -1); 1409 byteOrderedBuffer.byteOrder_ = EXIF_BYTE_ORDER_INTEL; 1410 ret = byteOrderedBuffer.ReadInt32(); 1411 ASSERT_NE(ret, -1); 1412 delete buf; 1413 buf = nullptr; 1414 GTEST_LOG_(INFO) << "PluginLibJpegTest: ReadInt32001 end"; 1415 } 1416 1417 /** 1418 * @tc.name: CheckExifEntryValid002 1419 * @tc.desc: CheckExifEntryValid 1420 * @tc.type: FUNC 1421 */ 1422 HWTEST_F(PluginLibJpegTest, CheckExifEntryValid002, TestSize.Level3) 1423 { 1424 GTEST_LOG_(INFO) << "PluginLibJpegTest: CheckExifEntryValid002 start"; 1425 EXIFInfo exinfo; 1426 bool ret; 1427 ret = exinfo.CheckExifEntryValid(EXIF_IFD_0, EXIF_TAG_BITS_PER_SAMPLE); 1428 ASSERT_EQ(ret, true); 1429 ret = exinfo.CheckExifEntryValid(EXIF_IFD_0, EXIF_TAG_IMAGE_LENGTH); 1430 ASSERT_EQ(ret, true); 1431 ret = exinfo.CheckExifEntryValid(EXIF_IFD_0, EXIF_TAG_IMAGE_WIDTH); 1432 ASSERT_EQ(ret, true); 1433 ret = exinfo.CheckExifEntryValid(EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_TIME); 1434 ASSERT_EQ(ret, true); 1435 ret = exinfo.CheckExifEntryValid(EXIF_IFD_EXIF, EXIF_TAG_FNUMBER); 1436 ASSERT_EQ(ret, true); 1437 ret = exinfo.CheckExifEntryValid(EXIF_IFD_EXIF, EXIF_TAG_ISO_SPEED_RATINGS); 1438 ASSERT_EQ(ret, true); 1439 ret = exinfo.CheckExifEntryValid(EXIF_IFD_EXIF, EXIF_TAG_SCENE_TYPE); 1440 ASSERT_EQ(ret, true); 1441 ret = exinfo.CheckExifEntryValid(EXIF_IFD_EXIF, EXIF_TAG_COMPRESSED_BITS_PER_PIXEL); 1442 ASSERT_EQ(ret, true); 1443 ret = exinfo.CheckExifEntryValid(EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE); 1444 ASSERT_EQ(ret, true); 1445 ret = exinfo.CheckExifEntryValid(EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE_REF); 1446 ASSERT_EQ(ret, true); 1447 ret = exinfo.CheckExifEntryValid(EXIF_IFD_GPS, EXIF_TAG_GPS_LONGITUDE_REF); 1448 ASSERT_EQ(ret, true); 1449 const ExifIfd ifd = EXIF_IFD_COUNT; 1450 ret = exinfo.CheckExifEntryValid(ifd, EXIF_TAG_GPS_DATE_STAMP); 1451 ASSERT_EQ(ret, false); 1452 GTEST_LOG_(INFO) << "PluginLibJpegTest: CheckExifEntryValid002 end"; 1453 } 1454 1455 /** 1456 * @tc.name: SetExifTagValuesEx002 1457 * @tc.desc: SetExifTagValuesEx 1458 * @tc.type: FUNC 1459 */ 1460 HWTEST_F(PluginLibJpegTest, SetExifTagValuesEx002, TestSize.Level3) 1461 { 1462 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValuesEx002 start"; 1463 EXIFInfo exinfo; 1464 const std::string val = "test"; 1465 exinfo.SetExifTagValuesEx(EXIF_TAG_LIGHT_SOURCE, val); 1466 ASSERT_EQ(exinfo.lightSource_, val); 1467 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetExifTagValuesEx002 end"; 1468 } 1469 1470 /** 1471 * @tc.name: CheckExifEntryValidEx001 1472 * @tc.desc: CheckExifEntryValidEx 1473 * @tc.type: FUNC 1474 */ 1475 HWTEST_F(PluginLibJpegTest, CheckExifEntryValidEx001, TestSize.Level3) 1476 { 1477 GTEST_LOG_(INFO) << "PluginLibJpegTest: CheckExifEntryValidEx001 start"; 1478 EXIFInfo exinfo; 1479 bool ret; 1480 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_0, EXIF_TAG_DATE_TIME); 1481 ASSERT_EQ(ret, true); 1482 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_0, EXIF_TAG_IMAGE_DESCRIPTION); 1483 ASSERT_EQ(ret, true); 1484 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_0, EXIF_TAG_MAKE); 1485 ASSERT_EQ(ret, true); 1486 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_0, EXIF_TAG_MODEL); 1487 ASSERT_EQ(ret, true); 1488 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, static_cast<ExifTag>(0x8830)); 1489 ASSERT_EQ(ret, true); 1490 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, static_cast<ExifTag>(0x8831)); 1491 ASSERT_EQ(ret, true); 1492 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, static_cast<ExifTag>(0x8832)); 1493 ASSERT_EQ(ret, true); 1494 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_APERTURE_VALUE); 1495 ASSERT_EQ(ret, true); 1496 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_EXPOSURE_BIAS_VALUE); 1497 ASSERT_EQ(ret, true); 1498 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_METERING_MODE); 1499 ASSERT_EQ(ret, true); 1500 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_LIGHT_SOURCE); 1501 ASSERT_EQ(ret, true); 1502 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_FLASH); 1503 ASSERT_EQ(ret, true); 1504 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH); 1505 ASSERT_EQ(ret, true); 1506 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_USER_COMMENT); 1507 ASSERT_EQ(ret, true); 1508 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_PIXEL_X_DIMENSION); 1509 ASSERT_EQ(ret, true); 1510 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_PIXEL_Y_DIMENSION); 1511 ASSERT_EQ(ret, true); 1512 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_WHITE_BALANCE); 1513 ASSERT_EQ(ret, true); 1514 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_EXIF, EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM); 1515 ASSERT_EQ(ret, true); 1516 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_GPS, EXIF_TAG_GPS_TIME_STAMP); 1517 ASSERT_EQ(ret, true); 1518 ret = exinfo.CheckExifEntryValidEx(EXIF_IFD_GPS, EXIF_TAG_GPS_DATE_STAMP); 1519 ASSERT_EQ(ret, true); 1520 const ExifIfd ifd = EXIF_IFD_COUNT; 1521 ret = exinfo.CheckExifEntryValidEx(ifd, EXIF_TAG_GPS_DATE_STAMP); 1522 ASSERT_EQ(ret, false); 1523 GTEST_LOG_(INFO) << "PluginLibJpegTest: CheckExifEntryValidEx001 end"; 1524 } 1525 1526 /** 1527 * @tc.name: GetExifData001 1528 * @tc.desc: GetExifData 1529 * @tc.type: FUNC 1530 */ 1531 HWTEST_F(PluginLibJpegTest, GetExifData001, TestSize.Level3) 1532 { 1533 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifData001 start"; 1534 EXIFInfo exinfo; 1535 std::string value = "test"; 1536 const std::string name = "DateTimeOriginalForMedia"; 1537 uint32_t ret; 1538 ret = exinfo.GetExifData(name, value); 1539 ASSERT_NE(ret, Media::ERR_MEDIA_STATUS_ABNORMAL); 1540 const std::string name2 = "OrientationInt"; 1541 ret = exinfo.GetExifData(name2, value); 1542 ASSERT_NE(ret, Media::ERR_MEDIA_STATUS_ABNORMAL); 1543 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifData001 end"; 1544 } 1545 1546 /** 1547 * @tc.name: ModifyExifData001 1548 * @tc.desc: ModifyExifData 1549 * @tc.type: FUNC 1550 */ 1551 HWTEST_F(PluginLibJpegTest, ModifyExifData001, TestSize.Level3) 1552 { 1553 GTEST_LOG_(INFO) << "PluginLibJpegTest: ModifyExifData001 start"; 1554 EXIFInfo exinfo; 1555 const std::string value = "test"; 1556 const std::string name = "test"; 1557 std::string path = "test"; 1558 uint32_t ret; 1559 ret = exinfo.ModifyExifData(name, value, path); 1560 ASSERT_EQ(ret, Media::ERR_IMAGE_DECODE_EXIF_UNSUPPORT); 1561 GTEST_LOG_(INFO) << "PluginLibJpegTest: ModifyExifData001 end"; 1562 } 1563 1564 /** 1565 * @tc.name: ModifyExifData002 1566 * @tc.desc: ModifyExifData 1567 * @tc.type: FUNC 1568 */ 1569 HWTEST_F(PluginLibJpegTest, ModifyExifData002, TestSize.Level3) 1570 { 1571 GTEST_LOG_(INFO) << "PluginLibJpegTest: ModifyExifData002 start"; 1572 EXIFInfo exinfo; 1573 const std::string value = "test"; 1574 const std::string name = "test"; 1575 const int fd = 0; 1576 uint32_t ret; 1577 ret = exinfo.ModifyExifData(name, value, fd); 1578 ASSERT_EQ(ret, Media::ERR_IMAGE_DECODE_EXIF_UNSUPPORT); 1579 GTEST_LOG_(INFO) << "PluginLibJpegTest: ModifyExifData002 end"; 1580 } 1581 1582 /** 1583 * @tc.name: ModifyExifData003 1584 * @tc.desc: ModifyExifData 1585 * @tc.type: FUNC 1586 */ 1587 HWTEST_F(PluginLibJpegTest, ModifyExifData003, TestSize.Level3) 1588 { 1589 GTEST_LOG_(INFO) << "PluginLibJpegTest: ModifyExifData003 start"; 1590 EXIFInfo exinfo; 1591 const std::string value = "test"; 1592 const std::string name = "test"; 1593 unsigned char data[2]; 1594 uint32_t size = 2; 1595 uint32_t ret; 1596 ret = exinfo.ModifyExifData(name, value, data, size); 1597 ASSERT_EQ(ret, Media::ERR_IMAGE_DECODE_EXIF_UNSUPPORT); 1598 GTEST_LOG_(INFO) << "PluginLibJpegTest: ModifyExifData003 end"; 1599 } 1600 1601 /** 1602 * @tc.name: WriteExifDataToFile002 1603 * @tc.desc: WriteExifDataToFile 1604 * @tc.type: FUNC 1605 */ 1606 HWTEST_F(PluginLibJpegTest, WriteExifDataToFile002, TestSize.Level3) 1607 { 1608 GTEST_LOG_(INFO) << "PluginLibJpegTest: WriteExifDataToFile002 start"; 1609 EXIFInfo exinfo; 1610 ExifData *ptrExifData = nullptr; 1611 FILE *file = fopen("/data/local/tmp/image/test_noexit.jpg", "w+"); 1612 ASSERT_NE(file, nullptr); 1613 bool isNewExifData = false; 1614 unsigned long fileLength = exinfo.GetFileSize(file); 1615 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1616 exinfo.CreateExifData(fileBuf, fileLength, &ptrExifData, isNewExifData); 1617 unsigned int orginExifDataLength = exinfo.GetOrginExifDataLength(isNewExifData, fileBuf); 1618 bool ret = exinfo.WriteExifDataToFile(ptrExifData, orginExifDataLength, fileLength, fileBuf, file); 1619 ASSERT_EQ(ret, false); 1620 free(fileBuf); 1621 GTEST_LOG_(INFO) << "PluginLibJpegTest: WriteExifDataToFile002 end"; 1622 } 1623 1624 /** 1625 * @tc.name: GetDataRangeFromDE001 1626 * @tc.desc: GetDataRangeFromDE 1627 * @tc.type: FUNC 1628 */ 1629 HWTEST_F(PluginLibJpegTest, GetDataRangeFromDE001, TestSize.Level3) 1630 { 1631 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetDataRangeFromDE001 start"; 1632 EXIFInfo exinfo; 1633 const uint8_t *buf = new uint8_t; 1634 ByteOrderedBuffer byteOrderedBuffer(buf, 10); 1635 int16_t entryCount = byteOrderedBuffer.ReadShort(); 1636 byteOrderedBuffer.GetDataRangeFromDE(EXIF_IFD_0, entryCount); 1637 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetDataRangeFromDE001 end"; 1638 } 1639 1640 /** 1641 * @tc.name: CreateExifTag001 1642 * @tc.desc: CreateExifTag 1643 * @tc.type: FUNC 1644 */ 1645 HWTEST_F(PluginLibJpegTest, CreateExifTag001, TestSize.Level3) 1646 { 1647 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifTag001 start"; 1648 EXIFInfo exinfo; 1649 ExifEntry *ptrEntry = nullptr; 1650 ExifData *data; 1651 FILE *file = fopen("/data/local/tmp/image/test_noexit.jpg", "w+"); 1652 ASSERT_NE(file, nullptr); 1653 unsigned long fileLength = exinfo.GetFileSize(file); 1654 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1655 bool isNewExifData = false; 1656 exinfo.CreateExifData(fileBuf, fileLength, &data, isNewExifData); 1657 ptrEntry = exinfo.CreateExifTag(data, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE, 20, EXIF_FORMAT_RATIONAL); 1658 ASSERT_NE(ptrEntry, nullptr); 1659 free(fileBuf); 1660 GTEST_LOG_(INFO) << "PluginLibJpegTest: CreateExifTag001 end"; 1661 } 1662 1663 /** 1664 * @tc.name: GetExifTag001 1665 * @tc.desc: GetExifTagTag 1666 * @tc.type: FUNC 1667 */ 1668 HWTEST_F(PluginLibJpegTest, GetExifTag001, TestSize.Level3) 1669 { 1670 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifTag001 start"; 1671 EXIFInfo exinfo; 1672 ExifEntry *ptrEntry = nullptr; 1673 ExifData *data; 1674 FILE *file = fopen("/data/local/tmp/image/test_noexit.jpg", "rb+"); 1675 ASSERT_NE(file, nullptr); 1676 unsigned long fileLength = exinfo.GetFileSize(file); 1677 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1678 bool isNewExifData = false; 1679 exinfo.CreateExifData(fileBuf, fileLength, &data, isNewExifData); 1680 ptrEntry = exinfo.GetExifTag(data, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE, 20); 1681 1682 // There is no latitude exif in test_noexit.jpg, modify failed 1683 ASSERT_EQ(ptrEntry, nullptr); 1684 free(fileBuf); 1685 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifTag001 end"; 1686 } 1687 1688 /** 1689 * @tc.name: GetExifTag002 1690 * @tc.desc: GetExifTag 1691 * @tc.type: FUNC 1692 */ 1693 HWTEST_F(PluginLibJpegTest, GetExifTag002, TestSize.Level3) 1694 { 1695 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifTag002 start"; 1696 EXIFInfo exinfo; 1697 ExifEntry *ptrEntry = nullptr; 1698 ExifData *data; 1699 FILE *file = fopen("/data/local/tmp/image/test_exif.jpg", "rb+"); 1700 ASSERT_NE(file, nullptr); 1701 unsigned long fileLength = exinfo.GetFileSize(file); 1702 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1703 bool isNewExifData = false; 1704 (void)fseek(file, 0L, 0); 1705 int ret = fread(fileBuf, fileLength, 1, file); 1706 ASSERT_EQ(ret, 1); 1707 exinfo.CreateExifData(fileBuf, fileLength, &data, isNewExifData); 1708 ptrEntry = exinfo.GetExifTag(data, EXIF_IFD_GPS, EXIF_TAG_GPS_LATITUDE, 20); 1709 1710 // There is latitude exif in test_exif.jpg, modify succeeded 1711 ASSERT_NE(ptrEntry, nullptr); 1712 free(fileBuf); 1713 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifTag002 end"; 1714 } 1715 1716 /** 1717 * @tc.name: ParseExifData001 1718 * @tc.desc: ParseExifData 1719 * @tc.type: FUNC 1720 */ 1721 HWTEST_F(PluginLibJpegTest, ParseExifData001, TestSize.Level3) 1722 { 1723 GTEST_LOG_(INFO) << "PluginLibJpegTest: ParseExifData001 start"; 1724 EXIFInfo exinfo; 1725 FILE *file = fopen("/data/local/tmp/image/test_noexit.jpg", "w+"); 1726 ASSERT_NE(file, nullptr); 1727 unsigned long fileLength = exinfo.GetFileSize(file); 1728 unsigned char *fileBuf = static_cast<unsigned char *>(malloc(fileLength)); 1729 bool isNewExifData = false; 1730 exinfo.CreateExifData(fileBuf, fileLength, &exinfo.exifData_, isNewExifData); 1731 unsigned char buf = 'n'; 1732 unsigned len = 0; 1733 int ret = exinfo.ParseExifData(&buf, len); 1734 ASSERT_EQ(ret, 0); 1735 free(fileBuf); 1736 GTEST_LOG_(INFO) << "PluginLibJpegTest: ParseExifData001 end"; 1737 } 1738 1739 /** 1740 * @tc.name: ByteOrderedBuffer001 1741 * @tc.desc: ByteOrderedBuffer 1742 * @tc.type: FUNC 1743 */ 1744 HWTEST_F(PluginLibJpegTest, ByteOrderedBuffer001, TestSize.Level3) 1745 { 1746 GTEST_LOG_(INFO) << "PluginLibJpegTest: ByteOrderedBuffer001 start"; 1747 uint8_t buf[20]; 1748 buf[12] = 'M'; 1749 buf[13] = 'M'; 1750 ByteOrderedBuffer byteOrderedBuffer(buf, 20); 1751 ASSERT_EQ(byteOrderedBuffer.byteOrder_, EXIF_BYTE_ORDER_MOTOROLA); 1752 GTEST_LOG_(INFO) << "PluginLibJpegTest: ByteOrderedBuffer001 end"; 1753 } 1754 1755 /** 1756 * @tc.name: ByteOrderedBuffer002 1757 * @tc.desc: ByteOrderedBuffer 1758 * @tc.type: FUNC 1759 */ 1760 HWTEST_F(PluginLibJpegTest, ByteOrderedBuffer002, TestSize.Level3) 1761 { 1762 GTEST_LOG_(INFO) << "PluginLibJpegTest: ByteOrderedBuffer002 start"; 1763 uint8_t buf[20]; 1764 buf[12] = 'M'; 1765 buf[13] = 'x'; 1766 ByteOrderedBuffer byteOrderedBuffer(buf, 20); 1767 ASSERT_EQ(byteOrderedBuffer.byteOrder_, EXIF_BYTE_ORDER_INTEL); 1768 GTEST_LOG_(INFO) << "PluginLibJpegTest: ByteOrderedBuffer002 end"; 1769 } 1770 1771 /** 1772 * @tc.name: SetDEDataByteCount002 1773 * @tc.desc: SetDEDataByteCount 1774 * @tc.type: FUNC 1775 */ 1776 HWTEST_F(PluginLibJpegTest, SetDEDataByteCount002, TestSize.Level3) 1777 { 1778 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetDEDataByteCount002 start"; 1779 const uint8_t *buf = new uint8_t; 1780 ByteOrderedBuffer byteorder(buf, 10); 1781 uint16_t dataFormat = byteorder.ReadUnsignedShort(); 1782 int32_t numberOfComponents = byteorder.ReadInt32(); 1783 uint32_t byteCount = 0; 1784 bool ret = byteorder.SetDEDataByteCount(0xa436, dataFormat, numberOfComponents, byteCount); 1785 ASSERT_EQ(ret, false); 1786 delete buf; 1787 buf = nullptr; 1788 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetDEDataByteCount002 end"; 1789 } 1790 1791 /** 1792 * @tc.name: GenerateDEArray003 1793 * @tc.desc: GenerateDEArray 1794 * @tc.type: FUNC 1795 */ 1796 HWTEST_F(PluginLibJpegTest, GenerateDEArray003, TestSize.Level3) 1797 { 1798 GTEST_LOG_(INFO) << "PluginLibJpegTest: GenerateDEArray003 start"; 1799 EXIFInfo exinfo; 1800 const uint8_t *buf = new uint8_t; 1801 ByteOrderedBuffer byteOrderedBuffer(buf, 10); 1802 byteOrderedBuffer.bufferLength_ = 1; 1803 byteOrderedBuffer.GenerateDEArray(); 1804 delete buf; 1805 buf = nullptr; 1806 GTEST_LOG_(INFO) << "PluginLibJpegTest: GenerateDEArray003 end"; 1807 } 1808 1809 /** 1810 * @tc.name: ParseExifData002 1811 * @tc.desc: ParseExifData 1812 * @tc.type: FUNC 1813 */ 1814 HWTEST_F(PluginLibJpegTest, ParseExifData002, TestSize.Level3) 1815 { 1816 GTEST_LOG_(INFO) << "PluginLibJpegTest: ParseExifData002 start"; 1817 EXIFInfo exinfo; 1818 unsigned char *buf = nullptr; 1819 unsigned len = 1000; 1820 exinfo.exifData_ = exif_data_new(); 1821 exinfo.imageFileDirectory_ = EXIF_IFD_COUNT; 1822 int ret = exinfo.ParseExifData(buf, len); 1823 ASSERT_NE(ret, 10001); 1824 exif_data_unref(exinfo.exifData_); 1825 GTEST_LOG_(INFO) << "PluginLibJpegTest: ParseExifData002 end"; 1826 } 1827 1828 /** 1829 * @tc.name: UpdateCacheExifData002 1830 * @tc.desc: UpdateCacheExifData 1831 * @tc.type: FUNC 1832 */ 1833 HWTEST_F(PluginLibJpegTest, UpdateCacheExifData002, TestSize.Level3) 1834 { 1835 GTEST_LOG_(INFO) << "PluginLibJpegTest: UpdateCacheExifData002 start"; 1836 EXIFInfo exinfo; 1837 FILE *file = fopen("/data/local/tmp/image/testtest.txt", "w+"); 1838 exinfo.UpdateCacheExifData(file); 1839 GTEST_LOG_(INFO) << "PluginLibJpegTest: UpdateCacheExifData002 end"; 1840 } 1841 1842 /** 1843 * @tc.name: GetAreaFromExifEntries002 1844 * @tc.desc: GetAreaFromExifEntries 1845 * @tc.type: FUNC 1846 */ 1847 HWTEST_F(PluginLibJpegTest, GetAreaFromExifEntries002, TestSize.Level3) 1848 { 1849 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetAreaFromExifEntries002 start"; 1850 EXIFInfo exinfo; 1851 const uint8_t *buf = new uint8_t; 1852 ByteOrderedBuffer byteOrderedBuffer(buf, 10); 1853 byteOrderedBuffer.GenerateDEArray(); 1854 std::vector<std::pair<uint32_t, uint32_t>> ranges; 1855 DirectoryEntry Direc; 1856 Direc.ifd = EXIF_IFD_GPS; 1857 byteOrderedBuffer.directoryEntryArray_.push_back(Direc); 1858 exinfo.GetAreaFromExifEntries(1, byteOrderedBuffer.directoryEntryArray_, ranges); 1859 delete buf; 1860 buf = nullptr; 1861 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetAreaFromExifEntries002 end"; 1862 } 1863 1864 /** 1865 * @tc.name: PluginExternalCreateTest001 1866 * @tc.desc: PluginExternalCreate 1867 * @tc.type: FUNC 1868 */ 1869 HWTEST_F(PluginLibJpegTest, PluginExternalCreateTest001, TestSize.Level3) 1870 { 1871 GTEST_LOG_(INFO) << "PluginExportTest: PluginExternalCreateTest001 start"; 1872 string className = ""; 1873 OHOS::MultimediaPlugin::PluginClassBase *result = PluginExternalCreate(className); 1874 ASSERT_EQ(result, nullptr); 1875 className = "#ImplClassType"; 1876 result = PluginExternalCreate(className); 1877 ASSERT_EQ(result, nullptr); 1878 GTEST_LOG_(INFO) << "PluginExportTest: PluginExternalCreateTest001 end"; 1879 } 1880 1881 /** 1882 * @tc.name: getGrColorSpaceTest001 1883 * @tc.desc: getGrColorSpace 1884 * @tc.type: FUNC 1885 */ 1886 HWTEST_F(PluginLibJpegTest, getGrColorSpaceTest001, TestSize.Level3) 1887 { 1888 GTEST_LOG_(INFO) << "IccProfileInfoTest: getGrColorSpaceTest001 start"; 1889 ICCProfileInfo iccProfileInfo; 1890 iccProfileInfo.getGrColorSpace(); 1891 GTEST_LOG_(INFO) << "IccProfileInfoTest: getGrColorSpaceTest001 end"; 1892 } 1893 1894 /** 1895 * @tc.name: PackingICCProfileTest001 1896 * @tc.desc: PackingICCProfile 1897 * @tc.type: FUNC 1898 */ 1899 HWTEST_F(PluginLibJpegTest, PackingICCProfileTest001, TestSize.Level3) 1900 { 1901 GTEST_LOG_(INFO) << "IccProfileInfoTest: PackingICCProfileTest001 start"; 1902 ICCProfileInfo iccProfileInfo; 1903 j_compress_ptr cinfo = nullptr; 1904 const SkImageInfo info; 1905 uint32_t result = iccProfileInfo.PackingICCProfile(cinfo, info); 1906 ASSERT_EQ(result, OHOS::Media::ERR_IMAGE_ENCODE_ICC_FAILED); 1907 GTEST_LOG_(INFO) << "IccProfileInfoTest: PackingICCProfileTest001 end"; 1908 } 1909 1910 /** 1911 * @tc.name: exif_info017 1912 * @tc.desc: ModifyExifData 1913 * @tc.type: FUNC 1914 */ 1915 HWTEST_F(PluginLibJpegTest, exif_info017, TestSize.Level3) 1916 { 1917 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info017 start"; 1918 EXIFInfo exinfo; 1919 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 1920 std::string value = "111"; 1921 unsigned char data[3] = {0xFF, 0xD8, 0x12}; 1922 uint32_t size = 1; 1923 uint32_t ret = exinfo.ModifyExifData(tag, value, data, size); 1924 ASSERT_EQ(ret, ERR_IMAGE_DECODE_EXIF_UNSUPPORT); 1925 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info017 end"; 1926 } 1927 1928 /** 1929 * @tc.name: exif_info018 1930 * @tc.desc: SetGpsRationals 1931 * @tc.type: FUNC 1932 */ 1933 HWTEST_F(PluginLibJpegTest, exif_info018, TestSize.Level3) 1934 { 1935 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info018 start"; 1936 EXIFInfo exinfo; 1937 ExifData *data = nullptr; 1938 ExifEntry *ptrEntry = nullptr; 1939 ExifByteOrder order = EXIF_BYTE_ORDER_INTEL; 1940 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 1941 std::vector<ExifRational> exifRationals; 1942 bool ret = exinfo.SetGpsRationals(data, &ptrEntry, order, tag, exifRationals); 1943 ASSERT_EQ(ret, false); 1944 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info018 end"; 1945 } 1946 1947 /** 1948 * @tc.name: exif_info019 1949 * @tc.desc: ModifyExifData 1950 * @tc.type: FUNC 1951 */ 1952 HWTEST_F(PluginLibJpegTest, exif_info019, TestSize.Level3) 1953 { 1954 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info019 start"; 1955 EXIFInfo exinfo; 1956 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 1957 std::string value = "111"; 1958 std::string path = IMAGE_INPUT_JPEG_PATH; 1959 uint32_t ret = exinfo.ModifyExifData(tag, value, path); 1960 ASSERT_EQ(ret, ERR_IMAGE_DECODE_EXIF_UNSUPPORT); 1961 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info019 end"; 1962 } 1963 1964 /** 1965 * @tc.name: exif_info020 1966 * @tc.desc: ModifyExifData 1967 * @tc.type: FUNC 1968 */ 1969 HWTEST_F(PluginLibJpegTest, exif_info020, TestSize.Level3) 1970 { 1971 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info020 start"; 1972 EXIFInfo exinfo; 1973 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 1974 std::string value = "111"; 1975 int fd = open("/data/local/tmp/image/test_test.text", O_RDWR | O_CREAT, 0777); 1976 char buffer[3] = {0xFF, 0xD8, 0x11}; 1977 write(fd, buffer, strlen(buffer)); 1978 uint32_t ret = exinfo.ModifyExifData(tag, value, fd); 1979 ASSERT_EQ(ret, ERR_IMAGE_DECODE_EXIF_UNSUPPORT); 1980 GTEST_LOG_(INFO) << "PluginLibJpegTest: exif_info020 end"; 1981 } 1982 1983 /** 1984 * @tc.name: Jpeg_EncoderTest001 1985 * @tc.desc: GetEncodeFormat 1986 * @tc.type: FUNC 1987 */ 1988 HWTEST_F(PluginLibJpegTest, Jpeg_EncoderTest001, TestSize.Level3) 1989 { 1990 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest001 start"; 1991 auto Jpegencoder = std::make_shared<JpegEncoder>(); 1992 PixelFormat format = PixelFormat::RGBA_F16; 1993 int32_t componentsNum = 1; 1994 Jpegencoder->GetEncodeFormat(format, componentsNum); 1995 ASSERT_EQ(componentsNum, COMPONENT_NUM_RGBA); 1996 format = PixelFormat::RGBA_8888; 1997 Jpegencoder->GetEncodeFormat(format, componentsNum); 1998 ASSERT_EQ(componentsNum, COMPONENT_NUM_RGBA); 1999 format = PixelFormat::BGRA_8888; 2000 Jpegencoder->GetEncodeFormat(format, componentsNum); 2001 ASSERT_EQ(componentsNum, COMPONENT_NUM_BGRA); 2002 format = PixelFormat::ALPHA_8; 2003 Jpegencoder->GetEncodeFormat(format, componentsNum); 2004 ASSERT_EQ(componentsNum, COMPONENT_NUM_GRAY); 2005 format = PixelFormat::RGB_565; 2006 Jpegencoder->GetEncodeFormat(format, componentsNum); 2007 ASSERT_EQ(componentsNum, COMPONENT_NUM_RGB); 2008 format = PixelFormat::RGB_888; 2009 Jpegencoder->GetEncodeFormat(format, componentsNum); 2010 ASSERT_EQ(componentsNum, COMPONENT_NUM_RGB); 2011 format = PixelFormat::NV12; 2012 Jpegencoder->GetEncodeFormat(format, componentsNum); 2013 ASSERT_EQ(componentsNum, COMPONENT_NUM_YUV420SP); 2014 format = PixelFormat::NV21; 2015 Jpegencoder->GetEncodeFormat(format, componentsNum); 2016 ASSERT_EQ(componentsNum, COMPONENT_NUM_YUV420SP); 2017 format = PixelFormat::CMYK; 2018 Jpegencoder->GetEncodeFormat(format, componentsNum); 2019 ASSERT_EQ(componentsNum, COMPONENT_NUM_RGBA); 2020 format = PixelFormat::UNKNOWN; 2021 Jpegencoder->GetEncodeFormat(format, componentsNum); 2022 ASSERT_EQ(componentsNum, 0); 2023 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest001 end"; 2024 } 2025 2026 /** 2027 * @tc.name: GenerateDEArray004 2028 * @tc.desc: GenerateDEArray 2029 * @tc.type: FUNC 2030 */ 2031 HWTEST_F(PluginLibJpegTest, GenerateDEArray004, TestSize.Level3) 2032 { 2033 GTEST_LOG_(INFO) << "PluginLibJpegTest: GenerateDEArray004 start"; 2034 const uint8_t buf = 'a'; 2035 ByteOrderedBuffer byteorder(&buf, 10); 2036 byteorder.curPosition_ = 2; 2037 byteorder.bufferLength_ = 7; 2038 byteorder.GenerateDEArray(); 2039 ASSERT_EQ(true, byteorder.curPosition_ + 2 > byteorder.bufferLength_); 2040 GTEST_LOG_(INFO) << "PluginLibJpegTest: GenerateDEArray004 end"; 2041 } 2042 2043 /** 2044 * @tc.name: GetExifData002 2045 * @tc.desc: GetExifData 2046 * @tc.type: FUNC 2047 */ 2048 HWTEST_F(PluginLibJpegTest, GetExifData002, TestSize.Level3) 2049 { 2050 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifData002 start"; 2051 EXIFInfo exinfo; 2052 std::string value = "test"; 2053 const std::string name = "test"; 2054 uint32_t ret = exinfo.GetExifData(name, value); 2055 ASSERT_EQ(ret, Media::ERR_IMAGE_DECODE_EXIF_UNSUPPORT); 2056 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifData002 end"; 2057 } 2058 2059 /** 2060 * @tc.name: GetExifIfdByExifTag001 2061 * @tc.desc: GetExifIfdByExifTag 2062 * @tc.type: FUNC 2063 */ 2064 HWTEST_F(PluginLibJpegTest, GetExifIfdByExifTag001, TestSize.Level3) 2065 { 2066 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifIfdByExifTag001 start"; 2067 EXIFInfo exinfo; 2068 ExifTag tag = static_cast<ExifTag>(0xea1c); 2069 ExifIfd ret = exinfo.GetExifIfdByExifTag(tag); 2070 ASSERT_EQ(ret, EXIF_IFD_COUNT); 2071 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifIfdByExifTag001 end"; 2072 } 2073 2074 /** 2075 * @tc.name: GetExifFormatByExifTag001 2076 * @tc.desc: GetExifFormatByExifTag 2077 * @tc.type: FUNC 2078 */ 2079 HWTEST_F(PluginLibJpegTest, GetExifFormatByExifTag001, TestSize.Level3) 2080 { 2081 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifFormatByExifTag001 start"; 2082 EXIFInfo exinfo; 2083 ExifTag tag = static_cast<ExifTag>(0xea1c); 2084 ExifFormat ret = exinfo.GetExifFormatByExifTag(tag); 2085 ASSERT_EQ(ret, EXIF_FORMAT_UNDEFINED); 2086 GTEST_LOG_(INFO) << "PluginLibJpegTest: GetExifFormatByExifTag001 end"; 2087 } 2088 2089 /** 2090 * @tc.name: SetGpsRationals001 2091 * @tc.desc: SetGpsRationals 2092 * @tc.type: FUNC 2093 */ 2094 HWTEST_F(PluginLibJpegTest, SetGpsRationals001, TestSize.Level3) 2095 { 2096 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetGpsRationals001 start"; 2097 EXIFInfo exinfo; 2098 ExifData *ptrExifData = nullptr; 2099 ExifEntry *ptrEntry = nullptr; 2100 ExifByteOrder order = EXIF_BYTE_ORDER_INTEL; 2101 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 2102 std::vector<ExifRational> exifRationals; 2103 exifRationals.resize(3); 2104 ASSERT_EQ(exifRationals.size(), 3); 2105 unsigned char data = 'a'; 2106 uint32_t size = 10; 2107 bool isNewExifData = true; 2108 exinfo.CreateExifData(&data, size, &ptrExifData, isNewExifData); 2109 bool ret = exinfo.SetGpsRationals(ptrExifData, &ptrEntry, order, tag, exifRationals); 2110 ASSERT_EQ(ret, false); 2111 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetGpsRationals001 end"; 2112 } 2113 2114 /** 2115 * @tc.name: SetGpsDegreeRational001 2116 * @tc.desc: SetGpsDegreeRational 2117 * @tc.type: FUNC 2118 */ 2119 HWTEST_F(PluginLibJpegTest, SetGpsDegreeRational001, TestSize.Level3) 2120 { 2121 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetGpsDegreeRational001 start"; 2122 EXIFInfo exinfo; 2123 ExifData *ptrExifData = nullptr; 2124 ExifEntry *ptrEntry = nullptr; 2125 ExifByteOrder order = EXIF_BYTE_ORDER_INTEL; 2126 ExifTag tag = EXIF_TAG_GPS_LATITUDE; 2127 std::vector<std::string> exifRationals; 2128 exifRationals.resize(3); 2129 ASSERT_NE(exifRationals.size(), 2); 2130 unsigned char data = 'a'; 2131 uint32_t size = 10; 2132 bool isNewExifData = true; 2133 exinfo.CreateExifData(&data, size, &ptrExifData, isNewExifData); 2134 bool ret = exinfo.SetGpsDegreeRational(ptrExifData, &ptrEntry, order, tag, exifRationals); 2135 ASSERT_EQ(ret, false); 2136 GTEST_LOG_(INFO) << "PluginLibJpegTest: SetGpsDegreeRational001 end"; 2137 } 2138 2139 /** 2140 * @tc.name: Jpeg_EncoderTest002 2141 * @tc.desc: AddImage 2142 * @tc.type: FUNC 2143 */ 2144 HWTEST_F(PluginLibJpegTest, Jpeg_EncoderTest002, TestSize.Level3) 2145 { 2146 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest002 start"; 2147 auto Jpegencoder = std::make_shared<JpegEncoder>(); 2148 Media::PixelMap pixelmap; 2149 Jpegencoder->pixelMaps_.push_back(&pixelmap); 2150 uint32_t ret = Jpegencoder->AddImage(pixelmap); 2151 ASSERT_EQ(ret, ERR_IMAGE_ADD_PIXEL_MAP_FAILED); 2152 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest002 end"; 2153 } 2154 2155 /** 2156 * @tc.name: Jpeg_EncoderTest003 2157 * @tc.desc: FinalizeEncode 2158 * @tc.type: FUNC 2159 */ 2160 HWTEST_F(PluginLibJpegTest, Jpeg_EncoderTest003, TestSize.Level3) 2161 { 2162 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest003 start"; 2163 auto Jpegencoder = std::make_shared<JpegEncoder>(); 2164 Media::PixelMap pixelmap; 2165 pixelmap.imageInfo_.pixelFormat = PixelFormat::BGRA_8888; 2166 pixelmap.data_ = nullptr; 2167 Jpegencoder->pixelMaps_.push_back(&pixelmap); 2168 uint32_t ret = Jpegencoder->FinalizeEncode(); 2169 ASSERT_EQ(ret, ERR_IMAGE_INVALID_PARAMETER); 2170 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest003 end"; 2171 } 2172 2173 /** 2174 * @tc.name: Jpeg_EncoderTest004 2175 * @tc.desc: SetCommonConfig 2176 * @tc.type: FUNC 2177 */ 2178 HWTEST_F(PluginLibJpegTest, Jpeg_EncoderTest004, TestSize.Level3) 2179 { 2180 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest004 start"; 2181 auto Jpegencoder = std::make_shared<JpegEncoder>(); 2182 Media::PixelMap pixelmap; 2183 Jpegencoder->pixelMaps_.clear(); 2184 uint32_t ret = Jpegencoder->SetCommonConfig(); 2185 ASSERT_EQ(ret, ERR_IMAGE_INVALID_PARAMETER); 2186 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest004 end"; 2187 } 2188 2189 /** 2190 * @tc.name: Jpeg_EncoderTest005 2191 * @tc.desc: SetYuv420spExtraConfig 2192 * @tc.type: FUNC 2193 */ 2194 HWTEST_F(PluginLibJpegTest, Jpeg_EncoderTest005, TestSize.Level3) 2195 { 2196 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest005 start"; 2197 auto Jpegencoder = std::make_shared<JpegEncoder>(); 2198 Jpegencoder->encodeInfo_.comp_info = new jpeg_component_info; 2199 Jpegencoder->SetYuv420spExtraConfig(); 2200 ASSERT_EQ(Jpegencoder->encodeInfo_.comp_info[0].h_samp_factor, SAMPLE_FACTOR_TWO); 2201 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest005 end"; 2202 } 2203 2204 /** 2205 * @tc.name: Jpeg_EncoderTest006 2206 * @tc.desc: Deinterweave 2207 * @tc.type: FUNC 2208 */ 2209 HWTEST_F(PluginLibJpegTest, Jpeg_EncoderTest006, TestSize.Level3) 2210 { 2211 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest006 start"; 2212 auto Jpegencoder = std::make_shared<JpegEncoder>(); 2213 Media::PixelMap pixelmap; 2214 Jpegencoder->pixelMaps_.push_back(&pixelmap); 2215 uint8_t *uvPlane = nullptr; 2216 uint8_t *uPlane = nullptr; 2217 uint8_t *vPlane = nullptr; 2218 uint32_t curRow = 0; 2219 uint32_t width = 0; 2220 uint32_t height = 0; 2221 Jpegencoder->Deinterweave(uvPlane, uPlane, vPlane, curRow, width, height); 2222 ASSERT_EQ(pixelmap.imageInfo_.pixelFormat, PixelFormat::UNKNOWN); 2223 GTEST_LOG_(INFO) << "PluginLibJpegTest: Jpeg_EncoderTest006 end"; 2224 } 2225 } // namespace Multimedia 2226 } // namespace OHOS
