1 /* 2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "hdf_log.h" 17 #include "v2_0/codec_image_type.h" 18 #include "v1_0/display_buffer_type.h" 19 #include "v1_0/display_composer_type.h" 20 #include "v2_0/icodec_image.h" 21 #include "v1_0/include/idisplay_buffer.h" 22 #include <buffer_handle.h> 23 #include <gtest/gtest.h> 24 #define HDF_LOG_TAG codec_jpeg_test 25 26 using namespace std; 27 using namespace testing::ext; 28 using namespace OHOS::HDI::Display::Buffer::V1_0; 29 using namespace OHOS::HDI::Display::Composer::V1_0; 30 using namespace OHOS::HDI::Codec::Image::V2_0; 31 namespace { 32 constexpr int32_t WIDTH = 640; 33 constexpr int32_t HEIGHT = 480; 34 constexpr uint32_t NORMAL_BUFFER_SIZE = 1000; 35 constexpr uint32_t CODEC_IMAGE_MAX_BUFFER_SIZE = 50 * 1024 * 1024; 36 static OHOS::sptr<ICodecImage> hdiJpeg_; 37 static IDisplayBuffer *hdiBuffer_; 38 class CodecHdiJpegTestAdditional : public testing::Test { 39 public: InitOutBuffer(CodecImageBuffer & outBuffer)40 void InitOutBuffer(CodecImageBuffer &outBuffer) 41 { 42 AllocInfo alloc = {.width = WIDTH, 43 .height = HEIGHT, 44 .usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA, 45 .format = PIXEL_FMT_YCBCR_420_SP}; 46 47 BufferHandle *bufferHandle = nullptr; 48 auto err = hdiBuffer_->AllocMem(alloc, bufferHandle); 49 if (err != HDF_SUCCESS) { 50 return; 51 } 52 outBuffer.buffer = new NativeBuffer(bufferHandle); 53 } 54 SetUpTestCase()55 static void SetUpTestCase() 56 { 57 hdiJpeg_ = ICodecImage::Get(); 58 hdiBuffer_ = IDisplayBuffer::Get(); 59 } TearDownTestCase()60 static void TearDownTestCase() 61 { 62 hdiJpeg_ = nullptr; 63 hdiBuffer_ = nullptr; 64 } SetUp()65 void SetUp() 66 { 67 if (hdiJpeg_ != nullptr) { 68 auto ret = hdiJpeg_->Init(CODEC_IMAGE_JPEG); 69 if (ret != HDF_SUCCESS) { 70 GTEST_SKIP() << "jpeg is null!" << std::endl; 71 return; 72 } 73 } else { 74 GTEST_SKIP() << "hdiJpeg_ is null!" << std::endl; 75 return; 76 } 77 } TearDown()78 void TearDown() 79 { 80 if (hdiJpeg_ != nullptr) { 81 hdiJpeg_->DeInit(CODEC_IMAGE_JPEG); 82 } 83 } 84 }; 85 86 /** 87 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_0900 88 * @tc.name : testCodecDoJpegDecode001 89 * @tc.desc : Determines the result of the function when the wrong argument is passed 90 */ 91 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode001, TestSize.Level2) 92 { 93 ASSERT_TRUE(hdiJpeg_ != nullptr); 94 struct CodecImageBuffer inBuffer; 95 struct CodecImageBuffer outBuffer; 96 struct CodecJpegDecInfo decInfo; 97 inBuffer.size = -1; 98 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 99 ASSERT_NE(ret, HDF_SUCCESS); 100 } 101 102 /** 103 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1000 104 * @tc.name : testCodecDoJpegDecode002 105 * @tc.desc : Determines the result of the function when the wrong argument is passed 106 */ 107 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode002, TestSize.Level2) 108 { 109 ASSERT_TRUE(hdiJpeg_ != nullptr); 110 struct CodecImageBuffer inBuffer; 111 struct CodecImageBuffer outBuffer; 112 struct CodecJpegDecInfo decInfo; 113 inBuffer.buffer = 0; 114 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 115 ASSERT_NE(ret, HDF_SUCCESS); 116 } 117 118 /** 119 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1100 120 * @tc.name : testCodecDoJpegDecode003 121 * @tc.desc : Determines the result of the function when the wrong argument is passed 122 */ 123 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode003, TestSize.Level2) 124 { 125 ASSERT_TRUE(hdiJpeg_ != nullptr); 126 struct CodecImageBuffer inBuffer; 127 struct CodecImageBuffer outBuffer; 128 struct CodecJpegDecInfo decInfo; 129 inBuffer.fenceFd = -1; 130 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 131 ASSERT_NE(ret, HDF_SUCCESS); 132 } 133 134 /** 135 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1200 136 * @tc.name : testCodecDoJpegDecode004 137 * @tc.desc : Determines the result of the function when the wrong argument is passed 138 */ 139 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode004, TestSize.Level2) 140 { 141 ASSERT_TRUE(hdiJpeg_ != nullptr); 142 struct CodecImageBuffer inBuffer; 143 struct CodecImageBuffer outBuffer; 144 struct CodecJpegDecInfo decInfo; 145 outBuffer.id = -1; 146 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 147 ASSERT_NE(ret, HDF_SUCCESS); 148 } 149 150 /** 151 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1300 152 * @tc.name : testCodecDoJpegDecode005 153 * @tc.desc : Determines the result of the function when the wrong argument is passed 154 */ 155 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode005, TestSize.Level2) 156 { 157 ASSERT_TRUE(hdiJpeg_ != nullptr); 158 struct CodecImageBuffer inBuffer; 159 struct CodecImageBuffer outBuffer; 160 struct CodecJpegDecInfo decInfo; 161 outBuffer.size = -1; 162 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 163 ASSERT_NE(ret, HDF_SUCCESS); 164 } 165 166 /** 167 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1400 168 * @tc.name : testCodecDoJpegDecode006 169 * @tc.desc : Determines the result of the function when the wrong argument is passed 170 */ 171 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode006, TestSize.Level2) 172 { 173 ASSERT_TRUE(hdiJpeg_ != nullptr); 174 struct CodecImageBuffer inBuffer; 175 struct CodecImageBuffer outBuffer; 176 struct CodecJpegDecInfo decInfo; 177 outBuffer.buffer = 0; 178 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 179 ASSERT_NE(ret, HDF_SUCCESS); 180 } 181 182 /** 183 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1500 184 * @tc.name : testCodecDoJpegDecode007 185 * @tc.desc : Determines the result of the function when the wrong argument is passed 186 */ 187 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode007, TestSize.Level2) 188 { 189 ASSERT_TRUE(hdiJpeg_ != nullptr); 190 struct CodecImageBuffer inBuffer; 191 struct CodecImageBuffer outBuffer; 192 struct CodecJpegDecInfo decInfo; 193 outBuffer.fenceFd = -1; 194 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 195 ASSERT_NE(ret, HDF_SUCCESS); 196 } 197 198 /** 199 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1600 200 * @tc.name : testCodecDoJpegDecode008 201 * @tc.desc : Determines the result of the function when the wrong argument is passed 202 */ 203 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode008, TestSize.Level2) 204 { 205 ASSERT_TRUE(hdiJpeg_ != nullptr); 206 struct CodecImageBuffer inBuffer; 207 struct CodecImageBuffer outBuffer; 208 struct CodecJpegDecInfo decInfo; 209 decInfo.imageWidth = -1; 210 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 211 ASSERT_NE(ret, HDF_SUCCESS); 212 } 213 214 /** 215 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1700 216 * @tc.name : testCodecDoJpegDecode009 217 * @tc.desc : Determines the result of the function when the wrong argument is passed 218 */ 219 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode009, TestSize.Level2) 220 { 221 ASSERT_TRUE(hdiJpeg_ != nullptr); 222 struct CodecImageBuffer inBuffer; 223 struct CodecImageBuffer outBuffer; 224 struct CodecJpegDecInfo decInfo; 225 decInfo.imageHeight = -1; 226 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 227 ASSERT_NE(ret, HDF_SUCCESS); 228 } 229 230 /** 231 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1800 232 * @tc.name : testCodecDoJpegDecode010 233 * @tc.desc : Determines the result of the function when the wrong argument is passed 234 */ 235 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode010, TestSize.Level2) 236 { 237 ASSERT_TRUE(hdiJpeg_ != nullptr); 238 struct CodecImageBuffer inBuffer; 239 struct CodecImageBuffer outBuffer; 240 struct CodecJpegDecInfo decInfo; 241 decInfo.dataPrecision = -1; 242 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 243 ASSERT_NE(ret, HDF_SUCCESS); 244 } 245 246 /** 247 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_1900 248 * @tc.name : testCodecDoJpegDecode011 249 * @tc.desc : Determines the result of the function when the wrong argument is passed 250 */ 251 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode011, TestSize.Level2) 252 { 253 ASSERT_TRUE(hdiJpeg_ != nullptr); 254 struct CodecImageBuffer inBuffer; 255 struct CodecImageBuffer outBuffer; 256 struct CodecJpegDecInfo decInfo; 257 decInfo.numComponents = -1; 258 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 259 ASSERT_NE(ret, HDF_SUCCESS); 260 } 261 262 /** 263 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2000 264 * @tc.name : testCodecDoJpegDecode012 265 * @tc.desc : Determines the result of the function when the wrong argument is passed 266 */ 267 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode012, TestSize.Level2) 268 { 269 ASSERT_TRUE(hdiJpeg_ != nullptr); 270 struct CodecImageBuffer inBuffer; 271 struct CodecImageBuffer outBuffer; 272 struct CodecJpegDecInfo decInfo; 273 decInfo.restartInterval = -1; 274 auto ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 275 ASSERT_NE(ret, HDF_SUCCESS); 276 } 277 278 /** 279 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2100 280 * @tc.name : testCodecFreeInBuffer001 281 * @tc.desc : Determines the result of the function when the wrong argument is passed 282 */ 283 HWTEST_F(CodecHdiJpegTestAdditional, testCodecFreeInBuffer001, TestSize.Level2) 284 { 285 ASSERT_TRUE(hdiJpeg_ != nullptr); 286 struct CodecImageBuffer inBuffer; 287 inBuffer.size = -1; 288 auto ret = hdiJpeg_->FreeInBuffer(inBuffer); 289 ASSERT_EQ(ret, HDF_SUCCESS); 290 } 291 292 /** 293 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2200 294 * @tc.name : testCodecFreeInBuffer002 295 * @tc.desc : Determines the result of the function when the wrong argument is passed 296 */ 297 HWTEST_F(CodecHdiJpegTestAdditional, testCodecFreeInBuffer002, TestSize.Level2) 298 { 299 ASSERT_TRUE(hdiJpeg_ != nullptr); 300 struct CodecImageBuffer inBuffer; 301 inBuffer.buffer = 0; 302 auto ret = hdiJpeg_->FreeInBuffer(inBuffer); 303 ASSERT_EQ(ret, HDF_SUCCESS); 304 } 305 306 /** 307 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2300 308 * @tc.name : testCodecFreeInBuffer003 309 * @tc.desc : Determines the result of the function when the wrong argument is passed 310 */ 311 HWTEST_F(CodecHdiJpegTestAdditional, testCodecFreeInBuffer003, TestSize.Level2) 312 { 313 ASSERT_TRUE(hdiJpeg_ != nullptr); 314 struct CodecImageBuffer inBuffer; 315 inBuffer.fenceFd = -1; 316 auto ret = hdiJpeg_->FreeInBuffer(inBuffer); 317 ASSERT_EQ(ret, HDF_SUCCESS); 318 } 319 320 /** 321 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2400 322 * @tc.name : testCodecGetImageCapability001 323 * @tc.desc : Determine whether existing values of parameter structures affect function results 324 */ 325 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability001, TestSize.Level1) 326 { 327 ASSERT_TRUE(hdiJpeg_ != nullptr); 328 std::vector<CodecImageCapability> capList(1); 329 capList[0].role = CODEC_IMAGE_INVALID; 330 auto ret = hdiJpeg_->GetImageCapability(capList); 331 ASSERT_EQ(ret, HDF_SUCCESS); 332 } 333 334 /** 335 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2500 336 * @tc.name : testCodecGetImageCapability002 337 * @tc.desc : Determine whether existing values of parameter structures affect function results 338 */ 339 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability002, TestSize.Level1) 340 { 341 ASSERT_TRUE(hdiJpeg_ != nullptr); 342 std::vector<CodecImageCapability> capList(1); 343 capList[0].type = CODEC_IMAGE_TYPE_INVALID; 344 auto ret = hdiJpeg_->GetImageCapability(capList); 345 ASSERT_EQ(ret, HDF_SUCCESS); 346 ASSERT_TRUE(!capList[0].name.empty()); 347 } 348 /** 349 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2600 350 * @tc.name : testCodecGetImageCapability003 351 * @tc.desc : Determine whether existing values of parameter structures affect function results 352 */ 353 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability003, TestSize.Level1) 354 { 355 ASSERT_TRUE(hdiJpeg_ != nullptr); 356 std::vector<CodecImageCapability> capList(1); 357 capList[0].widthAlignment = -1; 358 auto ret = hdiJpeg_->GetImageCapability(capList); 359 ASSERT_TRUE(capList[0].widthAlignment >= 0); 360 ASSERT_EQ(ret, HDF_SUCCESS); 361 } 362 363 /** 364 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2700 365 * @tc.name : testCodecGetImageCapability004 366 * @tc.desc : Determine whether existing values of parameter structures affect function results 367 */ 368 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability004, TestSize.Level1) 369 { 370 ASSERT_TRUE(hdiJpeg_ != nullptr); 371 std::vector<CodecImageCapability> capList(1); 372 capList[0].heightAlignment = -1; 373 auto ret = hdiJpeg_->GetImageCapability(capList); 374 ASSERT_TRUE(capList[0].heightAlignment >= 0); 375 ASSERT_EQ(ret, HDF_SUCCESS); 376 } 377 378 /** 379 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2800 380 * @tc.name : testCodecGetImageCapability005 381 * @tc.desc : Determine whether existing values of parameter structures affect function results 382 */ 383 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability005, TestSize.Level1) 384 { 385 ASSERT_TRUE(hdiJpeg_ != nullptr); 386 std::vector<CodecImageCapability> capList(1); 387 capList[0].maxSample = -1; 388 auto ret = hdiJpeg_->GetImageCapability(capList); 389 ASSERT_TRUE(capList[0].maxSample >= 0); 390 ASSERT_EQ(ret, HDF_SUCCESS); 391 } 392 393 /** 394 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_2900 395 * @tc.name : testCodecGetImageCapability006 396 * @tc.desc : Determine whether existing values of parameter structures affect function results 397 */ 398 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability006, TestSize.Level1) 399 { 400 ASSERT_TRUE(hdiJpeg_ != nullptr); 401 std::vector<CodecImageCapability> capList(1); 402 capList[0].maxWidth = -1; 403 auto ret = hdiJpeg_->GetImageCapability(capList); 404 ASSERT_TRUE(capList[0].maxWidth >= 0); 405 ASSERT_EQ(ret, HDF_SUCCESS); 406 } 407 408 /** 409 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_3000 410 * @tc.name : testCodecGetImageCapability007 411 * @tc.desc : Determine whether existing values of parameter structures affect function results 412 */ 413 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability007, TestSize.Level1) 414 { 415 ASSERT_TRUE(hdiJpeg_ != nullptr); 416 std::vector<CodecImageCapability> capList(1); 417 capList[0].maxHeight = -1; 418 auto ret = hdiJpeg_->GetImageCapability(capList); 419 ASSERT_TRUE(capList[0].maxHeight >= 0); 420 ASSERT_EQ(ret, HDF_SUCCESS); 421 } 422 423 /** 424 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_3100 425 * @tc.name : testCodecGetImageCapability008 426 * @tc.desc : Determine whether existing values of parameter structures affect function results 427 */ 428 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability008, TestSize.Level1) 429 { 430 ASSERT_TRUE(hdiJpeg_ != nullptr); 431 std::vector<CodecImageCapability> capList(1); 432 capList[0].maxInst = -1; 433 auto ret = hdiJpeg_->GetImageCapability(capList); 434 ASSERT_TRUE(capList[0].maxInst >= 0); 435 ASSERT_EQ(ret, HDF_SUCCESS); 436 } 437 438 /** 439 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_3200 440 * @tc.name : testCodecAllocateInBuffer001 441 * @tc.desc : Determine whether existing values of parameter structures affect function results 442 */ 443 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer001, TestSize.Level1) 444 { 445 ASSERT_TRUE(hdiJpeg_ != nullptr); 446 struct CodecImageBuffer inBuffer; 447 inBuffer.id = -1; 448 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 449 ASSERT_EQ(ret, HDF_SUCCESS); 450 } 451 452 /** 453 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_3300 454 * @tc.name : testCodecAllocateInBuffer002 455 * @tc.desc : Determine whether existing values of parameter structures affect function results 456 */ 457 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer002, TestSize.Level1) 458 { 459 ASSERT_TRUE(hdiJpeg_ != nullptr); 460 struct CodecImageBuffer inBuffer; 461 inBuffer.size = -1; 462 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 463 ASSERT_EQ(ret, HDF_SUCCESS); 464 } 465 466 /** 467 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_3400 468 * @tc.name : testCodecAllocateInBuffer003 469 * @tc.desc : Determine whether existing values of parameter structures affect function results 470 */ 471 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer003, TestSize.Level1) 472 { 473 ASSERT_TRUE(hdiJpeg_ != nullptr); 474 struct CodecImageBuffer inBuffer; 475 inBuffer.buffer = 0; 476 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 477 ASSERT_EQ(ret, HDF_SUCCESS); 478 } 479 480 /** 481 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_3500 482 * @tc.name : testCodecAllocateInBuffer004 483 * @tc.desc : Determine whether existing values of parameter structures affect function results 484 */ 485 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer004, TestSize.Level1) 486 { 487 ASSERT_TRUE(hdiJpeg_ != nullptr); 488 struct CodecImageBuffer inBuffer; 489 inBuffer.fenceFd = -1; 490 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 491 ASSERT_EQ(ret, HDF_SUCCESS); 492 } 493 494 /** 495 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_3600 496 * @tc.name : testCodecAllocateInBuffer005 497 * @tc.desc : Determines the result of the function when the wrong argument is passed 498 */ 499 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer005, TestSize.Level2) 500 { 501 ASSERT_TRUE(hdiJpeg_ != nullptr); 502 struct CodecImageBuffer inBuffer; 503 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, -1, CODEC_IMAGE_JPEG); 504 ASSERT_NE(ret, HDF_SUCCESS); 505 } 506 507 /** 508 * @tc.number : SUB_Driver_Codec_ImageCodecHDI_3700 509 * @tc.name : testCodecAllocateInBuffer006 510 * @tc.desc : Determines the result of the function when the correct argument is passed in 511 */ 512 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer006, TestSize.Level1) 513 { 514 ASSERT_TRUE(hdiJpeg_ != nullptr); 515 struct CodecImageBuffer inBuffer; 516 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, 200, CODEC_IMAGE_JPEG); 517 ASSERT_EQ(ret, HDF_SUCCESS); 518 } 519 520 /** 521 * @tc.number : SUB_Driver_Codec_Init_0100 522 * @tc.name : testInit001 523 * @tc.desc : Determines the result of the function when the correct argument is invalid 524 */ 525 HWTEST_F(CodecHdiJpegTestAdditional, testInit001, TestSize.Level2) 526 { 527 ASSERT_TRUE(hdiJpeg_ != nullptr); 528 auto ret = hdiJpeg_->Init(CODEC_IMAGE_INVALID); 529 ASSERT_NE(ret, HDF_SUCCESS); 530 } 531 532 /** 533 * @tc.number : SUB_Driver_Codec_Init_0200 534 * @tc.name : testInit002 535 * @tc.desc : Determines the result of the function with CODEC_IMAGE_JPEG 536 */ 537 HWTEST_F(CodecHdiJpegTestAdditional, testInit002, Function | MediumTest | Level1) 538 { 539 ASSERT_TRUE(hdiJpeg_ != nullptr); 540 auto ret = hdiJpeg_->DeInit(CODEC_IMAGE_JPEG); 541 ret = hdiJpeg_->Init(CODEC_IMAGE_JPEG); 542 ASSERT_EQ(ret, HDF_SUCCESS); 543 } 544 545 /** 546 * @tc.number : SUB_Driver_Codec_Init_0300 547 * @tc.name : testInit003 548 * @tc.desc : Determines the result of the function with CODEC_IMAGE_HEIF 549 */ 550 HWTEST_F(CodecHdiJpegTestAdditional, testInit003, Function | MediumTest | Level2) 551 { 552 ASSERT_TRUE(hdiJpeg_ != nullptr); 553 auto ret = hdiJpeg_->Init(CODEC_IMAGE_HEIF); 554 ASSERT_NE(ret, HDF_SUCCESS); 555 } 556 557 /** 558 * @tc.number : SUB_Driver_Codec_DeInit_0100 559 * @tc.name : testDeInit001 560 * @tc.desc : Determines the result of the function when the correct argument is invalid 561 */ 562 HWTEST_F(CodecHdiJpegTestAdditional, testDeInit001, TestSize.Level2) 563 { 564 ASSERT_TRUE(hdiJpeg_ != nullptr); 565 auto ret = hdiJpeg_->DeInit(CODEC_IMAGE_INVALID); 566 ASSERT_NE(ret, HDF_SUCCESS); 567 } 568 569 /** 570 * @tc.number : SUB_Driver_Codec_DeInit_0200 571 * @tc.name : testDeInit002 572 * @tc.desc : Determines the result of the function with CODEC_IMAGE_JPEG 573 */ 574 HWTEST_F(CodecHdiJpegTestAdditional, testDeInit002, Function | MediumTest | Level1) 575 { 576 ASSERT_TRUE(hdiJpeg_ != nullptr); 577 auto ret = hdiJpeg_->DeInit(CODEC_IMAGE_JPEG); 578 ret = hdiJpeg_->DeInit(CODEC_IMAGE_JPEG); 579 ret = hdiJpeg_->Init(CODEC_IMAGE_JPEG); 580 } 581 582 /** 583 * @tc.number : SUB_Driver_Codec_DeInit_0300 584 * @tc.name : testDeInit003 585 * @tc.desc : Determines the result of the function with CODEC_IMAGE_HEIF 586 */ 587 HWTEST_F(CodecHdiJpegTestAdditional, testDeInit003, Function | MediumTest | Level2) 588 { 589 ASSERT_TRUE(hdiJpeg_ != nullptr); 590 auto ret = hdiJpeg_->DeInit(CODEC_IMAGE_HEIF); 591 ASSERT_NE(ret, HDF_SUCCESS); 592 } 593 594 /** 595 * @tc.number : SUB_Driver_Codec_DoJpegDecode_2100 596 * @tc.name : testCodecDoJpegDecode013 597 * @tc.desc : When the third argument CodecJpegDecInfo struct ->dataPrecision = 0, the result returns failure 598 */ 599 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode013, TestSize.Level2) 600 { 601 ASSERT_TRUE(hdiJpeg_ != nullptr); 602 struct CodecImageBuffer inBuffer; 603 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 604 ASSERT_EQ(ret, HDF_SUCCESS); 605 struct CodecImageBuffer outBuffer; 606 ASSERT_EQ(hdiJpeg_->AllocateInBuffer(outBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG), HDF_SUCCESS); 607 struct CodecJpegDecInfo decInfo; 608 decInfo.imageWidth = 1200; 609 decInfo.imageHeight = 960; 610 decInfo.dataPrecision = 0; 611 612 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 613 ASSERT_NE(ret, HDF_SUCCESS); 614 615 ASSERT_EQ(hdiJpeg_->FreeInBuffer(inBuffer), HDF_SUCCESS); 616 ASSERT_EQ(hdiJpeg_->FreeInBuffer(outBuffer), HDF_SUCCESS); 617 } 618 619 /** 620 * @tc.number : SUB_Driver_Codec_DoJpegDecode_2200 621 * @tc.name : testCodecDoJpegDecode014 622 * @tc.desc : When the second parameter CodecImageBuffer structure is empty, the result returns a failure 623 */ 624 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode014, TestSize.Level2) 625 { 626 ASSERT_TRUE(hdiJpeg_ != nullptr); 627 struct CodecImageBuffer inBuffer; 628 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 629 ASSERT_EQ(ret, HDF_SUCCESS); 630 struct CodecImageBuffer outBuffer; 631 struct CodecJpegDecInfo decInfo; 632 decInfo.imageWidth = 1200; 633 decInfo.imageHeight = 960; 634 decInfo.dataPrecision = 8; 635 636 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 637 ASSERT_NE(ret, HDF_SUCCESS); 638 639 ASSERT_EQ(hdiJpeg_->FreeInBuffer(inBuffer), HDF_SUCCESS); 640 } 641 642 /** 643 * @tc.number : SUB_Driver_Codec_DoJpegDecode_2300 644 * @tc.name : testCodecDoJpegDecode015 645 * @tc.desc : When the first argument CodecImageBuffer structure is empty, the result returns a failure 646 */ 647 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode015, TestSize.Level2) 648 { 649 ASSERT_TRUE(hdiJpeg_ != nullptr); 650 struct CodecImageBuffer inBuffer; 651 struct CodecImageBuffer outBuffer; 652 auto ret = hdiJpeg_->AllocateInBuffer(outBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 653 ASSERT_EQ(ret, HDF_SUCCESS); 654 struct CodecJpegDecInfo decInfo; 655 decInfo.imageWidth = 1200; 656 decInfo.imageHeight = 960; 657 decInfo.dataPrecision = 8; 658 659 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 660 ASSERT_NE(ret, HDF_SUCCESS); 661 662 ASSERT_EQ(hdiJpeg_->FreeInBuffer(outBuffer), HDF_SUCCESS); 663 } 664 665 /** 666 * @tc.number : SUB_Driver_Codec_DoJpegDecode_2400 667 * @tc.name : testCodecDoJpegDecode016 668 * @tc.desc : Verify that the result fails when the second entry of the first prefix function AllocateInBuffer is 0 669 */ 670 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode016, TestSize.Level2) 671 { 672 ASSERT_TRUE(hdiJpeg_ != nullptr); 673 struct CodecImageBuffer inBuffer; 674 ASSERT_NE(hdiJpeg_->AllocateInBuffer(inBuffer, 0, CODEC_IMAGE_JPEG), HDF_SUCCESS); 675 struct CodecImageBuffer outBuffer; 676 auto ret = hdiJpeg_->AllocateInBuffer(outBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 677 ASSERT_EQ(ret, HDF_SUCCESS); 678 struct CodecJpegDecInfo decInfo; 679 decInfo.imageWidth = WIDTH; 680 decInfo.imageHeight = HEIGHT; 681 decInfo.dataPrecision = 8; 682 683 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 684 ASSERT_NE(ret, HDF_SUCCESS); 685 686 ASSERT_EQ(hdiJpeg_->FreeInBuffer(outBuffer), HDF_SUCCESS); 687 } 688 689 /** 690 * @tc.number : SUB_Driver_Codec_DoJpegDecode_2500 691 * @tc.name : testCodecDoJpegDecode017 692 * @tc.desc : Failure to verify that the third entry of the first prefix function AllocateInBuffer is CODEC_IMAGE_HEIF 693 */ 694 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode017, TestSize.Level2) 695 { 696 ASSERT_TRUE(hdiJpeg_ != nullptr); 697 struct CodecImageBuffer inBuffer; 698 ASSERT_NE(hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_HEIF), HDF_SUCCESS); 699 struct CodecImageBuffer outBuffer; 700 auto ret = hdiJpeg_->AllocateInBuffer(outBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 701 ASSERT_EQ(ret, HDF_SUCCESS); 702 struct CodecJpegDecInfo decInfo; 703 decInfo.imageWidth = WIDTH; 704 decInfo.imageHeight = HEIGHT; 705 decInfo.dataPrecision = 8; 706 707 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 708 ASSERT_NE(ret, HDF_SUCCESS); 709 710 ASSERT_EQ(hdiJpeg_->FreeInBuffer(outBuffer), HDF_SUCCESS); 711 } 712 713 /** 714 * @tc.number : SUB_Driver_Codec_DoJpegDecode_2600 715 * @tc.name : testCodecDoJpegDecode018 716 * @tc.desc : Verify that a failure is returned when the third entry to 717 * the first prefix function AllocateInBuffer is CODEC_IMAGE_INVALID 718 */ 719 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode018, TestSize.Level2) 720 { 721 ASSERT_TRUE(hdiJpeg_ != nullptr); 722 struct CodecImageBuffer inBuffer; 723 ASSERT_NE(hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_INVALID), HDF_SUCCESS); 724 struct CodecImageBuffer outBuffer; 725 auto ret = hdiJpeg_->AllocateInBuffer(outBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 726 ASSERT_EQ(ret, HDF_SUCCESS); 727 struct CodecJpegDecInfo decInfo; 728 decInfo.imageWidth = WIDTH; 729 decInfo.imageHeight = HEIGHT; 730 decInfo.dataPrecision = 8; 731 732 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 733 ASSERT_NE(ret, HDF_SUCCESS); 734 735 ASSERT_EQ(hdiJpeg_->FreeInBuffer(outBuffer), HDF_SUCCESS); 736 } 737 738 /** 739 * @tc.number : SUB_Driver_Codec_DoJpegDecode_2700 740 * @tc.name : testCodecDoJpegDecode019 741 * @tc.desc : Validation failed when the second entry to the second prefix function AllocateInBuffer is 0 742 */ 743 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode019, TestSize.Level2) 744 { 745 ASSERT_TRUE(hdiJpeg_ != nullptr); 746 struct CodecImageBuffer inBuffer; 747 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 748 ASSERT_EQ(ret, HDF_SUCCESS); 749 struct CodecImageBuffer outBuffer; 750 ASSERT_NE(hdiJpeg_->AllocateInBuffer(outBuffer, 0, CODEC_IMAGE_JPEG), HDF_SUCCESS); 751 struct CodecJpegDecInfo decInfo; 752 decInfo.imageWidth = WIDTH; 753 decInfo.imageHeight = HEIGHT; 754 decInfo.dataPrecision = 8; 755 756 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 757 ASSERT_NE(ret, HDF_SUCCESS); 758 759 ASSERT_EQ(hdiJpeg_->FreeInBuffer(inBuffer), HDF_SUCCESS); 760 } 761 762 /** 763 * @tc.number : SUB_Driver_Codec_DoJpegDecode_2800 764 * @tc.name : testCodecDoJpegDecode020 765 * @tc.desc : Verification fails when the second entry of the second prefix 766 * function AllocateInBuffer is 50 * 1024 * 1024 +1 767 */ 768 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode020, TestSize.Level2) 769 { 770 ASSERT_TRUE(hdiJpeg_ != nullptr); 771 struct CodecImageBuffer inBuffer; 772 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 773 ASSERT_EQ(ret, HDF_SUCCESS); 774 struct CodecImageBuffer outBuffer; 775 ASSERT_NE(hdiJpeg_->AllocateInBuffer(outBuffer, CODEC_IMAGE_MAX_BUFFER_SIZE + 1, CODEC_IMAGE_JPEG), HDF_SUCCESS); 776 struct CodecJpegDecInfo decInfo; 777 decInfo.imageWidth = WIDTH; 778 decInfo.imageHeight = HEIGHT; 779 decInfo.dataPrecision = 8; 780 781 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 782 ASSERT_NE(ret, HDF_SUCCESS); 783 784 ASSERT_EQ(hdiJpeg_->FreeInBuffer(inBuffer), HDF_SUCCESS); 785 } 786 787 /** 788 * @tc.number : SUB_Driver_Codec_DoJpegDecode_2900 789 * @tc.name : testCodecDoJpegDecode021 790 * @tc.desc : Validation failed when the third entry to the second prefix 791 * function AllocateInBuffer is CODEC_IMAGE_HEIF 792 */ 793 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode021, TestSize.Level2) 794 { 795 ASSERT_TRUE(hdiJpeg_ != nullptr); 796 struct CodecImageBuffer inBuffer; 797 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 798 ASSERT_EQ(ret, HDF_SUCCESS); 799 struct CodecImageBuffer outBuffer; 800 ASSERT_NE(hdiJpeg_->AllocateInBuffer(outBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_HEIF), HDF_SUCCESS); 801 struct CodecJpegDecInfo decInfo; 802 decInfo.imageWidth = WIDTH; 803 decInfo.imageHeight = HEIGHT; 804 decInfo.dataPrecision = 8; 805 806 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 807 ASSERT_NE(ret, HDF_SUCCESS); 808 809 ASSERT_EQ(hdiJpeg_->FreeInBuffer(inBuffer), HDF_SUCCESS); 810 } 811 812 /** 813 * @tc.number : SUB_Driver_Codec_DoJpegDecode_3000 814 * @tc.name : testCodecDoJpegDecode022 815 * @tc.desc : Validation returns a failure when the third entry to the second prefix 816 * function AllocateInBuffer is CODEC_IMAGE_INVALID 817 */ 818 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode022, TestSize.Level2) 819 { 820 ASSERT_TRUE(hdiJpeg_ != nullptr); 821 struct CodecImageBuffer inBuffer; 822 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 823 ASSERT_EQ(ret, HDF_SUCCESS); 824 struct CodecImageBuffer outBuffer; 825 ASSERT_NE(hdiJpeg_->AllocateInBuffer(outBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_INVALID), HDF_SUCCESS); 826 struct CodecJpegDecInfo decInfo; 827 decInfo.imageWidth = WIDTH; 828 decInfo.imageHeight = HEIGHT; 829 decInfo.dataPrecision = 8; 830 831 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 832 ASSERT_NE(ret, HDF_SUCCESS); 833 834 ASSERT_EQ(hdiJpeg_->FreeInBuffer(inBuffer), HDF_SUCCESS); 835 } 836 837 /** 838 * @tc.number : SUB_Driver_Codec_DoJpegDecode_3100 839 * @tc.name : testCodecDoJpegDecode023 840 * @tc.desc : Verification fails when the second entry of the first prefix 841 * function AllocateInBuffer is 50 * 1024 * 1024 +1 842 */ 843 HWTEST_F(CodecHdiJpegTestAdditional, testCodecDoJpegDecode023, TestSize.Level2) 844 { 845 ASSERT_TRUE(hdiJpeg_ != nullptr); 846 struct CodecImageBuffer inBuffer; 847 ASSERT_NE(hdiJpeg_->AllocateInBuffer(inBuffer, CODEC_IMAGE_MAX_BUFFER_SIZE + 1, CODEC_IMAGE_JPEG), HDF_SUCCESS); 848 struct CodecImageBuffer outBuffer; 849 auto ret = hdiJpeg_->AllocateInBuffer(outBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 850 ASSERT_EQ(ret, HDF_SUCCESS); 851 struct CodecJpegDecInfo decInfo; 852 decInfo.imageWidth = WIDTH; 853 decInfo.imageHeight = HEIGHT; 854 decInfo.dataPrecision = 0; 855 856 ret = hdiJpeg_->DoJpegDecode(inBuffer, outBuffer, decInfo); 857 ASSERT_NE(ret, HDF_SUCCESS); 858 859 ASSERT_EQ(hdiJpeg_->FreeInBuffer(outBuffer), HDF_SUCCESS); 860 } 861 862 /** 863 * @tc.number : SUB_Driver_Codec_GetImageCapability_3200 864 * @tc.name : testCodecGetImageCapability009 865 * @tc.desc : Verify that the GetImageCapability function returns a successful result when its argument is null 866 */ 867 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability009, TestSize.Level1) 868 { 869 ASSERT_TRUE(hdiJpeg_ != nullptr); 870 std::vector<CodecImageCapability> capList; 871 auto ret = hdiJpeg_->GetImageCapability(capList); 872 ASSERT_EQ(ret, HDF_SUCCESS); 873 } 874 875 /** 876 * @tc.number : SUB_Driver_Codec_GetImageCapability_3300 877 * @tc.name : testCodecGetImageCapability010 878 * @tc.desc : Verify that when the GetImageCapability function argument CodecImageCapability 879 * structure->name = "abc", the result is returned successfully 880 */ 881 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability010, TestSize.Level1) 882 { 883 ASSERT_TRUE(hdiJpeg_ != nullptr); 884 std::vector<CodecImageCapability> capList(1); 885 capList[0].name = "abc"; 886 auto ret = hdiJpeg_->GetImageCapability(capList); 887 ASSERT_EQ(ret, HDF_SUCCESS); 888 ASSERT_NE(capList[0].name, "abc"); 889 } 890 891 /** 892 * @tc.number : SUB_Driver_Codec_GetImageCapability_3400 893 * @tc.name : testCodecGetImageCapability011 894 * @tc.desc : Verify that the GetImageCapability function parameter CodecImageCapability 895 * structure ->role = CODEC_IMAGE_JPEG returns a successful result 896 */ 897 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability011, TestSize.Level1) 898 { 899 ASSERT_TRUE(hdiJpeg_ != nullptr); 900 std::vector<CodecImageCapability> capList(1); 901 capList[0].role = CODEC_IMAGE_JPEG; 902 auto ret = hdiJpeg_->GetImageCapability(capList); 903 ASSERT_EQ(ret, HDF_SUCCESS); 904 } 905 906 /** 907 * @tc.number : SUB_Driver_Codec_GetImageCapability_3500 908 * @tc.name : testCodecGetImageCapability012 909 * @tc.desc : Verify that the GetImageCapability function parameter CodecImageCapability 910 * structure ->role = CODEC_IMAGE_HEIF returns a successful result 911 */ 912 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability012, TestSize.Level1) 913 { 914 ASSERT_TRUE(hdiJpeg_ != nullptr); 915 std::vector<CodecImageCapability> capList(1); 916 capList[0].role = CODEC_IMAGE_HEIF; 917 auto ret = hdiJpeg_->GetImageCapability(capList); 918 ASSERT_EQ(ret, HDF_SUCCESS); 919 } 920 921 /** 922 * @tc.number : SUB_Driver_Codec_GetImageCapability_3600 923 * @tc.name : testCodecGetImageCapability013 924 * @tc.desc : Verify that the GetImageCapability function parameter CodecImageCapability 925 * structure ->role = CODEC_IMAGE_INVALID returns a successful result 926 */ 927 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability013, TestSize.Level1) 928 { 929 ASSERT_TRUE(hdiJpeg_ != nullptr); 930 std::vector<CodecImageCapability> capList(1); 931 capList[0].role = CODEC_IMAGE_INVALID; 932 auto ret = hdiJpeg_->GetImageCapability(capList); 933 ASSERT_EQ(ret, HDF_SUCCESS); 934 } 935 936 /** 937 * @tc.number : SUB_Driver_Codec_GetImageCapability_3700 938 * @tc.name : testCodecGetImageCapability014 939 * @tc.desc : Verify that the GetImageCapability function argument CodecImageCapability 940 * structure ->minWidth = 0 returns a successful result 941 */ 942 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability014, TestSize.Level1) 943 { 944 ASSERT_TRUE(hdiJpeg_ != nullptr); 945 std::vector<CodecImageCapability> capList(1); 946 capList[0].minWidth = 0; 947 auto ret = hdiJpeg_->GetImageCapability(capList); 948 ASSERT_EQ(ret, HDF_SUCCESS); 949 } 950 951 /** 952 * @tc.number : SUB_Driver_Codec_GetImageCapability_3800 953 * @tc.name : testCodecGetImageCapability015 954 * @tc.desc : Verify that when the GetImageCapability function argument CodecImageCapability 955 * structure ->minWidth = 1000, the result is successful 956 */ 957 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability015, TestSize.Level1) 958 { 959 ASSERT_TRUE(hdiJpeg_ != nullptr); 960 std::vector<CodecImageCapability> capList(1); 961 capList[0].minWidth = 1000; 962 auto ret = hdiJpeg_->GetImageCapability(capList); 963 ASSERT_EQ(ret, HDF_SUCCESS); 964 } 965 966 /** 967 * @tc.number : SUB_Driver_Codec_GetImageCapability_3900 968 * @tc.name : testCodecGetImageCapability016 969 * @tc.desc : Verify that when the GetImageCapability function argument CodecImageCapability 970 * structure ->minHeight = 0, the result is successful 971 */ 972 HWTEST_F(CodecHdiJpegTestAdditional, testCodecGetImageCapability016, TestSize.Level1) 973 { 974 ASSERT_TRUE(hdiJpeg_ != nullptr); 975 std::vector<CodecImageCapability> capList(1); 976 capList[0].minHeight = 0; 977 auto ret = hdiJpeg_->GetImageCapability(capList); 978 ASSERT_EQ(ret, HDF_SUCCESS); 979 } 980 981 /** 982 * @tc.number : SUB_Driver_Codec_AllocateInBuffer_4000 983 * @tc.name : testCodecAllocateInBuffer007 984 * @tc.desc : Verify that the AllocateInBuffer function returns a failure 985 * when the second argument is 50 * 1024 * 1024 +1 986 */ 987 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer007, TestSize.Level2) 988 { 989 ASSERT_TRUE(hdiJpeg_ != nullptr); 990 struct CodecImageBuffer inBuffer; 991 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, CODEC_IMAGE_MAX_BUFFER_SIZE + 1, CODEC_IMAGE_JPEG); 992 ASSERT_NE(ret, HDF_SUCCESS); 993 } 994 995 /** 996 * @tc.number : SUB_Driver_Codec_AllocateInBuffer_4100 997 * @tc.name : testCodecAllocateInBuffer008 998 * @tc.desc : Verify that failure is returned when the third argument of the AllocateInBuffer 999 * function is CODEC_IMAGE_HEIF 1000 */ 1001 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer008, TestSize.Level2) 1002 { 1003 ASSERT_TRUE(hdiJpeg_ != nullptr); 1004 struct CodecImageBuffer inBuffer; 1005 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_HEIF); 1006 ASSERT_NE(ret, HDF_SUCCESS); 1007 } 1008 1009 /** 1010 * @tc.number : SUB_Driver_Codec_AllocateInBuffer_4200 1011 * @tc.name : testCodecAllocateInBuffer009 1012 * @tc.desc : Verify that a failure is returned when the third argument of 1013 * the AllocateInBuffer function is CODEC_IMAGE_INVALID 1014 */ 1015 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer009, TestSize.Level2) 1016 { 1017 ASSERT_TRUE(hdiJpeg_ != nullptr); 1018 struct CodecImageBuffer inBuffer; 1019 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_INVALID); 1020 ASSERT_NE(ret, HDF_SUCCESS); 1021 } 1022 1023 /** 1024 * @tc.number : SUB_Driver_Codec_AllocateInBuffer_4300 1025 * @tc.name : testCodecAllocateInBuffer010 1026 * @tc.desc : Determines the result of the function with inBuffer.fenceFd = -1 and CODEC_IMAGE_HEIF 1027 */ 1028 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer010, Function | MediumTest | Level2) 1029 { 1030 ASSERT_TRUE(hdiJpeg_ != nullptr); 1031 struct CodecImageBuffer inBuffer; 1032 inBuffer.fenceFd = -1; 1033 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_HEIF); 1034 if (ret == HDF_SUCCESS) { 1035 ret = hdiJpeg_->FreeInBuffer(inBuffer); 1036 ASSERT_EQ(ret, HDF_SUCCESS); 1037 } else { 1038 ASSERT_NE(ret, HDF_SUCCESS); 1039 } 1040 } 1041 1042 /** 1043 * @tc.number : SUB_Driver_Codec_AllocateInBuffer_4400 1044 * @tc.name : testCodecAllocateInBuffer011 1045 * @tc.desc : Determines the result of the function with inBuffer.buffer = 0 and CODEC_IMAGE_HEIF 1046 */ 1047 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer011, Function | MediumTest | Level2) 1048 { 1049 ASSERT_TRUE(hdiJpeg_ != nullptr); 1050 struct CodecImageBuffer inBuffer; 1051 inBuffer.buffer = 0; 1052 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_HEIF); 1053 if (ret == HDF_SUCCESS) { 1054 ret = hdiJpeg_->FreeInBuffer(inBuffer); 1055 ASSERT_EQ(ret, HDF_SUCCESS); 1056 } else { 1057 ASSERT_NE(ret, HDF_SUCCESS); 1058 } 1059 } 1060 1061 /** 1062 * @tc.number : SUB_Driver_Codec_AllocateInBuffer_4500 1063 * @tc.name : testCodecAllocateInBuffer012 1064 * @tc.desc : Determines the result of the function with inBuffer.size = -1 and CODEC_IMAGE_HEIF 1065 */ 1066 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer012, Function | MediumTest | Level2) 1067 { 1068 ASSERT_TRUE(hdiJpeg_ != nullptr); 1069 struct CodecImageBuffer inBuffer; 1070 inBuffer.size = -1; 1071 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_HEIF); 1072 if (ret == HDF_SUCCESS) { 1073 ret = hdiJpeg_->FreeInBuffer(inBuffer); 1074 ASSERT_EQ(ret, HDF_SUCCESS); 1075 } else { 1076 ASSERT_NE(ret, HDF_SUCCESS); 1077 } 1078 } 1079 1080 /** 1081 * @tc.number : SUB_Driver_Codec_AllocateInBuffer_4600 1082 * @tc.name : testCodecAllocateInBuffer013 1083 * @tc.desc : Determines the result of the function with inBuffer.id = -1 and CODEC_IMAGE_HEIF 1084 */ 1085 HWTEST_F(CodecHdiJpegTestAdditional, testCodecAllocateInBuffer013, Function | MediumTest | Level2) 1086 { 1087 ASSERT_TRUE(hdiJpeg_ != nullptr); 1088 struct CodecImageBuffer inBuffer; 1089 inBuffer.id = -1; 1090 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_HEIF); 1091 if (ret == HDF_SUCCESS) { 1092 ret = hdiJpeg_->FreeInBuffer(inBuffer); 1093 ASSERT_EQ(ret, HDF_SUCCESS); 1094 } else { 1095 ASSERT_NE(ret, HDF_SUCCESS); 1096 } 1097 } 1098 1099 /** 1100 * @tc.number : SUB_Driver_Codec_FreeInBuffer_4300 1101 * @tc.name : testCodecFreeInBuffer004 1102 * @tc.desc : Verify that the FreeInBuffer function returns a failure when its 1103 * entry is the CodecImageBuffer structure ->size = 0 1104 */ 1105 HWTEST_F(CodecHdiJpegTestAdditional, testCodecFreeInBuffer004, TestSize.Level2) 1106 { 1107 ASSERT_TRUE(hdiJpeg_ != nullptr); 1108 struct CodecImageBuffer inBuffer; 1109 inBuffer.size = 0; 1110 auto ret = hdiJpeg_->FreeInBuffer(inBuffer); 1111 ASSERT_EQ(ret, HDF_SUCCESS); 1112 } 1113 1114 /** 1115 * @tc.number : SUB_Driver_Codec_FreeInBuffer_4400 1116 * @tc.name : testCodecFreeInBuffer005 1117 * @tc.desc : Verify that the FreeInBuffer function returns a failure when its entry is 1118 * CodecImageBuffer structure ->size = 50 * 1024 * 1024 +1 1119 */ 1120 HWTEST_F(CodecHdiJpegTestAdditional, testCodecFreeInBuffer005, TestSize.Level2) 1121 { 1122 ASSERT_TRUE(hdiJpeg_ != nullptr); 1123 struct CodecImageBuffer inBuffer; 1124 inBuffer.size = CODEC_IMAGE_MAX_BUFFER_SIZE + 1; 1125 auto ret = hdiJpeg_->FreeInBuffer(inBuffer); 1126 ASSERT_EQ(ret, HDF_SUCCESS); 1127 } 1128 1129 /** 1130 * @tc.number : SUB_Driver_Codec_FreeInBuffer_4500 1131 * @tc.name : testCodecFreeInBuffer006 1132 * @tc.desc : Verify that when the input to the FreeInBuffer function is CodecImageBuffer structure ->size = 1000 1133 * bufferRole = CODEC_IMAGE_JPEG, the result returns success 1134 */ 1135 HWTEST_F(CodecHdiJpegTestAdditional, testCodecFreeInBuffer006, TestSize.Level1) 1136 { 1137 ASSERT_TRUE(hdiJpeg_ != nullptr); 1138 struct CodecImageBuffer inBuffer; 1139 auto ret = hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_JPEG); 1140 ASSERT_EQ(ret, HDF_SUCCESS); 1141 ret = hdiJpeg_->FreeInBuffer(inBuffer); 1142 ASSERT_EQ(ret, HDF_SUCCESS); 1143 } 1144 1145 /** 1146 * @tc.number : SUB_Driver_Codec_FreeInBuffer_4600 1147 * @tc.name : testCodecFreeInBuffer007 1148 * @tc.desc : Verify that the FreeInBuffer function returns a failure when the entry to the function is 1149 * CodecImageBuffer structure ->bufferRole = CODEC_IMAGE_HEIF 1150 */ 1151 HWTEST_F(CodecHdiJpegTestAdditional, testCodecFreeInBuffer007, TestSize.Level2) 1152 { 1153 ASSERT_TRUE(hdiJpeg_ != nullptr); 1154 struct CodecImageBuffer inBuffer; 1155 ASSERT_NE(hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_HEIF), HDF_SUCCESS); 1156 auto ret = hdiJpeg_->FreeInBuffer(inBuffer); 1157 ASSERT_EQ(ret, HDF_SUCCESS); 1158 } 1159 1160 /** 1161 * @tc.number : SUB_Driver_Codec_FreeInBuffer_4700 1162 * @tc.name : testCodecFreeInBuffer008 1163 * @tc.desc : Verify that the FreeInBuffer function returns a failure when the entry to the function is 1164 * CodecImageBuffer structure ->bufferRole = CODEC_IMAGE_INVALID 1165 */ 1166 HWTEST_F(CodecHdiJpegTestAdditional, testCodecFreeInBuffer008, TestSize.Level2) 1167 { 1168 ASSERT_TRUE(hdiJpeg_ != nullptr); 1169 struct CodecImageBuffer inBuffer; 1170 ASSERT_NE(hdiJpeg_->AllocateInBuffer(inBuffer, NORMAL_BUFFER_SIZE, CODEC_IMAGE_INVALID), HDF_SUCCESS); 1171 auto ret = hdiJpeg_->FreeInBuffer(inBuffer); 1172 ASSERT_EQ(ret, HDF_SUCCESS); 1173 } 1174 } // namespace