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 16 #include <gtest/gtest.h> 17 #include "common_utils.h" 18 19 #include "image_mdk.h" 20 #include "image_mdk_kits.h" 21 #include "image_receiver_mdk.h" 22 #include "image_receiver_mdk_kits.h" 23 #include "image_source_mdk.h" 24 #include "image_source_mdk_kits.h" 25 26 using namespace testing::ext; 27 namespace OHOS { 28 namespace Media { 29 static constexpr int32_t UNSUCCESS = -1; 30 class ImageNdkTest : public testing::Test { 31 public: ImageNdkTest()32 ImageNdkTest() {} ~ImageNdkTest()33 ~ImageNdkTest() {} 34 }; 35 36 /** 37 * @tc.name: OH_Image_ClipRectTest 38 * @tc.desc: OH_Image_ClipRect 39 * @tc.type: FUNC 40 */ 41 HWTEST_F(ImageNdkTest, OH_Image_ClipRectTest, TestSize.Level3) 42 { 43 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_ClipRectTest start"; 44 const ImageNative* native = nullptr; 45 struct OhosImageRect* rect = nullptr; 46 int32_t result = OH_Image_ClipRect(native, rect); 47 ASSERT_EQ(result, UNSUCCESS); 48 49 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_ClipRectTest end"; 50 } 51 52 /** 53 * @tc.name: OH_Image_SizeTest 54 * @tc.desc: OH_Image_Size 55 * @tc.type: FUNC 56 */ 57 HWTEST_F(ImageNdkTest, OH_Image_SizeTest, TestSize.Level3) 58 { 59 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_SizeTest start"; 60 const ImageNative* native = nullptr; 61 struct OhosImageSize* size = nullptr; 62 int32_t result = OH_Image_Size(native, size); 63 ASSERT_EQ(result, UNSUCCESS); 64 65 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_SizeTest end"; 66 } 67 68 /** 69 * @tc.name: OH_Image_FormatTest 70 * @tc.desc: OH_Image_Format 71 * @tc.type: FUNC 72 */ 73 HWTEST_F(ImageNdkTest, OH_Image_FormatTest, TestSize.Level3) 74 { 75 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_FormatTest start"; 76 const ImageNative* native = nullptr; 77 int32_t* format = nullptr; 78 int32_t result = OH_Image_Format(native, format); 79 ASSERT_EQ(result, UNSUCCESS); 80 81 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_FormatTest end"; 82 } 83 84 /** 85 * @tc.name: OH_Image_GetComponentTest 86 * @tc.desc: OH_Image_GetComponent 87 * @tc.type: FUNC 88 */ 89 HWTEST_F(ImageNdkTest, OH_Image_GetComponentTest, TestSize.Level3) 90 { 91 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_GetComponentTest start"; 92 const ImageNative* native = nullptr; 93 int32_t componentType = 0; 94 struct OhosImageComponent* componentNative = nullptr; 95 int32_t result = OH_Image_GetComponent(native, componentType, componentNative); 96 ASSERT_EQ(result, UNSUCCESS); 97 98 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_GetComponentTest end"; 99 } 100 101 /** 102 * @tc.name: OH_Image_ReleaseTest 103 * @tc.desc: OH_Image_Release 104 * @tc.type: FUNC 105 */ 106 HWTEST_F(ImageNdkTest, OH_Image_ReleaseTest, TestSize.Level3) 107 { 108 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_ReleaseTest start"; 109 ImageNative* native = nullptr; 110 int32_t result = OH_Image_Release(native); 111 ASSERT_EQ(result, 0); 112 113 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_ReleaseTest end"; 114 } 115 116 /** 117 * @tc.name: OH_Image_Receiver_InitImageReceiverNativeTest 118 * @tc.desc: OH_Image_Receiver_InitImageReceiverNative 119 * @tc.type: FUNC 120 */ 121 HWTEST_F(ImageNdkTest, OH_Image_Receiver_InitImageReceiverNativeTest, TestSize.Level3) 122 { 123 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_InitImageReceiverNativeTest start"; 124 napi_env env = nullptr; 125 napi_value source = nullptr; 126 ImageReceiverNative* res = OH_Image_Receiver_InitImageReceiverNative(env, source); 127 ASSERT_EQ(res, nullptr); 128 129 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_InitImageReceiverNativeTest end"; 130 } 131 132 /** 133 * @tc.name: OH_Image_Receiver_GetReceivingSurfaceIdTest 134 * @tc.desc: OH_Image_Receiver_GetReceivingSurfaceId 135 * @tc.type: FUNC 136 */ 137 HWTEST_F(ImageNdkTest, OH_Image_Receiver_GetReceivingSurfaceIdTest, TestSize.Level3) 138 { 139 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetReceivingSurfaceIdTest start"; 140 const ImageReceiverNative *p = nullptr; 141 char* id = nullptr; 142 size_t len = 100; 143 int32_t res = OH_Image_Receiver_GetReceivingSurfaceId(p, id, len); 144 ASSERT_EQ(res, UNSUCCESS); 145 146 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetReceivingSurfaceIdTest end"; 147 } 148 149 /** 150 * @tc.name: OH_Image_Receiver_ReadLatestImageTest 151 * @tc.desc: OH_Image_Receiver_ReadLatestImage 152 * @tc.type: FUNC 153 */ 154 HWTEST_F(ImageNdkTest, OH_Image_Receiver_ReadLatestImageTest, TestSize.Level3) 155 { 156 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReadLatestImageTest start"; 157 const ImageReceiverNative *p = nullptr; 158 napi_value* image = nullptr; 159 int32_t res = OH_Image_Receiver_ReadLatestImage(p, image); 160 ASSERT_EQ(res, UNSUCCESS); 161 162 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReadLatestImageTest end"; 163 } 164 165 /** 166 * @tc.name: OH_Image_Receiver_ReadNextImageTest 167 * @tc.desc: OH_Image_Receiver_ReadNextImage 168 * @tc.type: FUNC 169 */ 170 HWTEST_F(ImageNdkTest, OH_Image_Receiver_ReadNextImageTest, TestSize.Level3) 171 { 172 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReadNextImageTest start"; 173 const ImageReceiverNative *p = nullptr; 174 napi_value* image = nullptr; 175 int32_t res = OH_Image_Receiver_ReadNextImage(p, image); 176 ASSERT_EQ(res, UNSUCCESS); 177 178 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReadNextImageTest end"; 179 } 180 181 /** 182 * @tc.name: OH_Image_Receiver_OnTest 183 * @tc.desc: OH_Image_Receiver_On 184 * @tc.type: FUNC 185 */ 186 HWTEST_F(ImageNdkTest, OH_Image_Receiver_OnTest, TestSize.Level3) 187 { 188 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_OnTest start"; 189 const ImageReceiverNative *p = nullptr; 190 OH_Image_Receiver_On_Callback callback = nullptr; 191 int32_t res = OH_Image_Receiver_On(p, callback); 192 ASSERT_EQ(res, UNSUCCESS); 193 194 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_OnTest end"; 195 } 196 197 /** 198 * @tc.name: OH_Image_Receiver_GetSizeTest 199 * @tc.desc: OH_Image_Receiver_GetSize 200 * @tc.type: FUNC 201 */ 202 HWTEST_F(ImageNdkTest, OH_Image_Receiver_GetSizeTest, TestSize.Level3) 203 { 204 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetSizeTest start"; 205 const ImageReceiverNative *p = nullptr; 206 struct OhosImageSize* size = nullptr; 207 int32_t res = OH_Image_Receiver_GetSize(p, size); 208 ASSERT_EQ(res, UNSUCCESS); 209 210 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetSizeTest end"; 211 } 212 213 /** 214 * @tc.name: OH_Image_Receiver_GetCapacityTest 215 * @tc.desc: OH_Image_Receiver_GetCapacity 216 * @tc.type: FUNC 217 */ 218 HWTEST_F(ImageNdkTest, OH_Image_Receiver_GetCapacityTest, TestSize.Level3) 219 { 220 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetCapacityTest start"; 221 const ImageReceiverNative *p = nullptr; 222 int32_t* capacity = nullptr; 223 int32_t res = OH_Image_Receiver_GetCapacity(p, capacity); 224 ASSERT_EQ(res, UNSUCCESS); 225 226 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetCapacityTest end"; 227 } 228 229 /** 230 * @tc.name: OH_Image_Receiver_GetFormatTest 231 * @tc.desc: OH_Image_Receiver_GetFormat 232 * @tc.type: FUNC 233 */ 234 HWTEST_F(ImageNdkTest, OH_Image_Receiver_GetFormatTest, TestSize.Level3) 235 { 236 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetFormatTest start"; 237 const ImageReceiverNative *p = nullptr; 238 int32_t* format = nullptr; 239 int32_t res = OH_Image_Receiver_GetFormat(p, format); 240 ASSERT_EQ(res, UNSUCCESS); 241 242 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_GetFormatTest end"; 243 } 244 245 /** 246 * @tc.name: OH_Image_Receiver_ReleaseTest 247 * @tc.desc: OH_Image_Receiver_Release 248 * @tc.type: FUNC 249 */ 250 HWTEST_F(ImageNdkTest, OH_Image_Receiver_ReleaseTest, TestSize.Level3) 251 { 252 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReleaseTest start"; 253 ImageReceiverNative *p = nullptr; 254 int32_t res = OH_Image_Receiver_Release(p); 255 ASSERT_EQ(res, IMAGE_RESULT_SUCCESS); 256 257 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_Receiver_ReleaseTest end"; 258 } 259 260 /** 261 * @tc.name: OH_Image_InitImageNativeTest 262 * @tc.desc: OH_Image_InitImageNative 263 * @tc.type: FUNC 264 */ 265 HWTEST_F(ImageNdkTest, OH_Image_InitImageNativeTest, TestSize.Level3) 266 { 267 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_InitImageNativeTest start"; 268 napi_env env = nullptr; 269 napi_value source = nullptr; 270 ImageNative* res = OH_Image_InitImageNative(env, source); 271 ASSERT_EQ(res, nullptr); 272 273 GTEST_LOG_(INFO) << "ImageNdkTest: OH_Image_InitImageNativeTest end"; 274 } 275 /** 276 * @tc.name: OH_ImageSource_CreateTest 277 * @tc.desc: OH_ImageSource_Create 278 * @tc.type: FUNC 279 */ 280 HWTEST_F(ImageNdkTest, OH_ImageSource_CreateTest, TestSize.Level3) 281 { 282 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateTest start"; 283 napi_env env = nullptr; 284 napi_value* res = nullptr; 285 OhosImageSource* src = nullptr; 286 OhosImageSourceOps* ops= nullptr; 287 int32_t ret = OH_ImageSource_Create(env, src, ops, res); 288 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 289 290 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateTest end"; 291 } 292 293 /** 294 * @tc.name: OH_ImageSource_CreateIncrementalTest 295 * @tc.desc: OH_ImageSource_CreateIncremental 296 * @tc.type: FUNC 297 */ 298 HWTEST_F(ImageNdkTest, OH_ImageSource_CreateIncrementalTest, TestSize.Level3) 299 { 300 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateIncrementalTest start"; 301 napi_env env = nullptr; 302 napi_value* res = nullptr; 303 OhosImageSource* src = nullptr; 304 OhosImageSourceOps* ops= nullptr; 305 int32_t ret = OH_ImageSource_CreateIncremental(env, src, ops, res); 306 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 307 308 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreateIncrementalTest end"; 309 } 310 311 /** 312 * @tc.name: OH_ImageSource_GetSupportedFormatsTest 313 * @tc.desc: OH_ImageSource_GetSupportedFormats 314 * @tc.type: FUNC 315 */ 316 HWTEST_F(ImageNdkTest, OH_ImageSource_GetSupportedFormatsTest, TestSize.Level3) 317 { 318 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetSupportedFormatsTest start"; 319 OhosImageSourceSupportedFormatList* res = nullptr; 320 int32_t ret = OH_ImageSource_GetSupportedFormats(res); 321 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 322 323 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetSupportedFormatsTest end"; 324 } 325 326 /** 327 * @tc.name: OH_ImageSource_CreatePixelMapTest 328 * @tc.desc: OH_ImageSource_CreatePixelMap 329 * @tc.type: FUNC 330 */ 331 HWTEST_F(ImageNdkTest, OH_ImageSource_CreatePixelMapTest, TestSize.Level3) 332 { 333 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreatePixelMapTest start"; 334 ImageSourceNative* native = nullptr; 335 OhosImageDecodingOps* ops = nullptr; 336 napi_value *res = nullptr; 337 int32_t ret = OH_ImageSource_CreatePixelMap(native, ops, res); 338 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 339 340 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreatePixelMapTest end"; 341 } 342 343 /** 344 * @tc.name: OH_ImageSource_CreatePixelMapListTest 345 * @tc.desc: OH_ImageSource_CreatePixelMapList 346 * @tc.type: FUNC 347 */ 348 HWTEST_F(ImageNdkTest, OH_ImageSource_CreatePixelMapListTest, TestSize.Level3) 349 { 350 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreatePixelMapListTest start"; 351 ImageSourceNative* native = nullptr; 352 OhosImageDecodingOps* ops = nullptr; 353 napi_value *res = nullptr; 354 int32_t ret = OH_ImageSource_CreatePixelMapList(native, ops, res); 355 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 356 357 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_CreatePixelMapListTest end"; 358 } 359 360 /** 361 * @tc.name: OH_ImageSource_GetDelayTimeTest 362 * @tc.desc: OH_ImageSource_GetDelayTime 363 * @tc.type: FUNC 364 */ 365 HWTEST_F(ImageNdkTest, OH_ImageSource_GetDelayTimeTest, TestSize.Level3) 366 { 367 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetDelayTimeTest start"; 368 ImageSourceNative* native = nullptr; 369 OhosImageSourceDelayTimeList* res = nullptr; 370 int32_t ret = OH_ImageSource_GetDelayTime(native, res); 371 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 372 373 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetDelayTimeTest end"; 374 } 375 376 /** 377 * @tc.name: OH_ImageSource_GetFrameCountTest 378 * @tc.desc: OH_ImageSource_GetFrameCount 379 * @tc.type: FUNC 380 */ 381 HWTEST_F(ImageNdkTest, OH_ImageSource_GetFrameCountTest, TestSize.Level3) 382 { 383 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetFrameCountTest start"; 384 ImageSourceNative* native = nullptr; 385 uint32_t *res = nullptr; 386 int32_t ret = OH_ImageSource_GetFrameCount(native, res); 387 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 388 389 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetFrameCountTest end"; 390 } 391 392 /** 393 * @tc.name: OH_ImageSource_GetImageInfoTest 394 * @tc.desc: OH_ImageSource_GetImageInfo 395 * @tc.type: FUNC 396 */ 397 HWTEST_F(ImageNdkTest, OH_ImageSource_GetImageInfoTest, TestSize.Level3) 398 { 399 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetImageInfoTest start"; 400 ImageSourceNative* native = nullptr; 401 int32_t index = 0; 402 OhosImageSourceInfo* info = nullptr; 403 int32_t ret = OH_ImageSource_GetImageInfo(native, index, info); 404 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 405 406 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetImageInfoTest end"; 407 } 408 409 /** 410 * @tc.name: OH_ImageSource_GetImagePropertyTest 411 * @tc.desc: OH_ImageSource_GetImageProperty 412 * @tc.type: FUNC 413 */ 414 HWTEST_F(ImageNdkTest, OH_ImageSource_GetImagePropertyTest, TestSize.Level3) 415 { 416 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetImagePropertyTest start"; 417 ImageSourceNative* native = nullptr; 418 OhosImageSourceProperty* key = nullptr; 419 OhosImageSourceProperty* value = nullptr; 420 int32_t ret = OH_ImageSource_GetImageProperty(native, key, value); 421 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 422 423 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_GetImagePropertyTest end"; 424 } 425 426 /** 427 * @tc.name: OH_ImageSource_ModifyImagePropertyTest 428 * @tc.desc: OH_ImageSource_ModifyImageProperty 429 * @tc.type: FUNC 430 */ 431 HWTEST_F(ImageNdkTest, OH_ImageSource_ModifyImagePropertyTest, TestSize.Level3) 432 { 433 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_ModifyImagePropertyTest start"; 434 ImageSourceNative* native = nullptr; 435 OhosImageSourceProperty* key = nullptr; 436 OhosImageSourceProperty* value = nullptr; 437 int32_t ret = OH_ImageSource_ModifyImageProperty(native, key, value); 438 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 439 440 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_ModifyImagePropertyTest end"; 441 } 442 443 /** 444 * @tc.name: OH_ImageSource_UpdateDataTest 445 * @tc.desc: OH_ImageSource_UpdateData 446 * @tc.type: FUNC 447 */ 448 HWTEST_F(ImageNdkTest, OH_ImageSource_UpdateDataTest, TestSize.Level3) 449 { 450 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_UpdateDataTest start"; 451 ImageSourceNative* native = nullptr; 452 OhosImageSourceUpdateData* data = nullptr; 453 int32_t ret = OH_ImageSource_UpdateData(native, data); 454 ASSERT_NE(ret, OHOS_IMAGE_RESULT_SUCCESS); 455 456 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_UpdateDataTest end"; 457 } 458 459 /** 460 * @tc.name: OH_ImageSource_ReleaseTest 461 * @tc.desc: OH_ImageSource_Release 462 * @tc.type: FUNC 463 */ 464 HWTEST_F(ImageNdkTest, OH_ImageSource_ReleaseTest, TestSize.Level3) 465 { 466 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_ReleaseTest start"; 467 ImageSourceNative* native = nullptr; 468 int32_t ret = OH_ImageSource_Release(native); 469 ASSERT_EQ(ret, OHOS_IMAGE_RESULT_SUCCESS); 470 471 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_ReleaseTest end"; 472 } 473 474 /** 475 * @tc.name: OH_ImageSource_InitNativeTest 476 * @tc.desc: OH_ImageSource_InitNative 477 * @tc.type: FUNC 478 */ 479 HWTEST_F(ImageNdkTest, OH_ImageSource_InitNativeTest, TestSize.Level3) 480 { 481 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_InitNativeTest start"; 482 napi_env env = nullptr; 483 napi_value source = nullptr; 484 ImageSourceNative* ret = OH_ImageSource_InitNative(env, source); 485 ASSERT_EQ(ret, nullptr); 486 487 GTEST_LOG_(INFO) << "ImageNdkTest: OH_ImageSource_InitNativeTest end"; 488 } 489 } 490 } 491