1 /* 2 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development 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 "drawing_bitmap.h" 17 #include "drawing_rect.h" 18 #include "drawing_color.h" 19 #include "drawing_color_filter.h" 20 #include "drawing_error_code.h" 21 #include "drawing_image.h" 22 #include "drawing_image_filter.h" 23 #include "gtest/gtest.h" 24 #include <iostream> 25 #include <random> 26 27 using namespace testing; 28 using namespace testing::ext; 29 30 namespace OHOS { 31 namespace Rosen { 32 namespace Drawing { 33 class DrawingNativeImageFilterTest : public testing::Test { 34 protected: 35 // 在每个测试用例执行前调用 SetUp()36 void SetUp() override 37 { 38 // 设置代码 39 std::cout << "DrawingNativeImageFilterTest Setup code called before each test case." << std::endl; 40 OH_Drawing_ErrorCodeReset(); 41 std::cout << "DrawingNativeImageFilterTest errorCodeReset before each test case." << std::endl; 42 } TearDown()43 void TearDown() override 44 { 45 std::cout << "DrawingNativeImageFilterTest Setup code called after each test case." << std::endl; 46 OH_Drawing_ErrorCodeReset(); 47 std::cout << "DrawingNativeImageFilterTest errorCodeReset after each test case." << std::endl; 48 } 49 }; 50 51 /* 52 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0100 53 * @tc.name: testImageFilterCreateBlurNormal 54 * @tc.desc: Test for creating a blur image filter with normal parameters. 55 * @tc.size : SmallTest 56 * @tc.type : Function 57 * @tc.level : Level 0 58 */ 59 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurNormal, Function | SmallTest | Level0) { 60 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ImageFilterCreateBlur 61 OH_Drawing_TileMode modes[] = {CLAMP, REPEAT, MIRROR, DECAL}; 62 for (OH_Drawing_TileMode mode : modes) { 63 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 1.0f, mode, nullptr); 64 EXPECT_NE(filter, nullptr); 65 OH_Drawing_ImageFilterDestroy(filter); 66 } 67 // 2. Pass decimal values for sigmaX and sigmaY in OH_Drawing_ImageFilterCreateBlur 68 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 1.0f, OH_Drawing_TileMode::MIRROR, nullptr); 69 // add assert 70 EXPECT_NE(filter, nullptr); 71 // 3. Pass integer values for sigmaX and sigmaY in OH_Drawing_ImageFilterCreateBlur 72 filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 73 // add assert 74 EXPECT_NE(filter, nullptr); 75 // 4. Pass NULL for input parameter in OH_Drawing_ImageFilterCreateBlur 76 filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 1.0f, OH_Drawing_TileMode::MIRROR, nullptr); 77 // add assert 78 EXPECT_NE(filter, nullptr); 79 // 5. Pass non-NULL for input parameter in OH_Drawing_ImageFilterCreateBlur 80 filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 1.0f, OH_Drawing_TileMode::MIRROR, filter); 81 // add assert 82 EXPECT_NE(filter, nullptr); 83 // 6. Destroy the filter object 84 OH_Drawing_ImageFilterDestroy(filter); 85 } 86 87 /* 88 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0101 89 * @tc.name: testImageFilterCreateBlurNULL 90 * @tc.desc: Test for creating a blur image filter with NULL parameters. 91 * @tc.size : SmallTest 92 * @tc.type : Function 93 * @tc.level : Level 3 94 */ 95 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurNULL, Function | SmallTest | Level3) { 96 // 1. OH_Drawing_ImageFilterCreateBlur with the first parameter being null 97 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(0, 1.0f, OH_Drawing_TileMode::MIRROR, nullptr); 98 // add assert 99 EXPECT_NE(filter, nullptr); 100 // 2. OH_Drawing_ImageFilterCreateBlur with the second parameter being null 101 filter = OH_Drawing_ImageFilterCreateBlur(1.0f, 0, OH_Drawing_TileMode::MIRROR, nullptr); 102 // add assert 103 EXPECT_NE(filter, nullptr); 104 // 3. Destroy the filter object 105 OH_Drawing_ImageFilterDestroy(filter); 106 } 107 108 /* 109 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0102 110 * @tc.name: testImageFilterCreateBlurMultipleCalls 111 * @tc.desc: Test for multiple calls of creating a blur image filter. 112 * @tc.size : SmallTest 113 * @tc.type : Function 114 * @tc.level : Level 3 115 */ 116 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurMultipleCalls, Function | SmallTest | Level3) { 117 // 1. OH_Drawing_ImageFilterCreateBlur (pass random values for sigmaX and sigmaY, random enum value for 118 // OH_Drawing_TileMode), call 10 times 119 for (int i = 0; i < 10; i++) { 120 std::random_device rd; 121 std::mt19937 gen(rd()); 122 std::uniform_real_distribution<float> dis(0, 10); 123 std::uniform_int_distribution<int> enum_dis(0, 3); 124 OH_Drawing_TileMode tileMode = static_cast<OH_Drawing_TileMode>(enum_dis(gen)); 125 OH_Drawing_ImageFilter *filter = 126 OH_Drawing_ImageFilterCreateBlur(dis(gen), dis(gen), tileMode, nullptr); 127 EXPECT_NE(filter, nullptr); 128 OH_Drawing_ImageFilterDestroy(filter); 129 } 130 } 131 132 /* 133 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0103 134 * @tc.name: testImageFilterCreateBlurAbnormal 135 * @tc.desc: Test for creating a blur image filter with abnormal parameters. 136 * @tc.size : SmallTest 137 * @tc.type : Function 138 * @tc.level : Level 3 139 */ 140 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurAbnormal, Function | SmallTest | Level3) { 141 // 1. Pass negative values for sigmaX and sigmaY in OH_Drawing_ImageFilterCreateBlur 142 OH_Drawing_ImageFilter *filter = 143 OH_Drawing_ImageFilterCreateBlur(-1.0f, -1.0f, OH_Drawing_TileMode::MIRROR, nullptr); 144 // add assert 145 EXPECT_NE(filter, nullptr); 146 // 2. Destroy the filter object 147 OH_Drawing_ImageFilterDestroy(filter); 148 } 149 150 /* 151 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0104 152 * @tc.name: testImageFilterCreateBlurMaximum 153 * @tc.desc: Test for creating a blur image filter with maximum values. 154 * @tc.size : SmallTest 155 * @tc.type : Function 156 * @tc.level : Level 3 157 */ 158 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurMaximum, Function | SmallTest | Level3) { 159 // 1. Create a blur image filter with maximum values for sigmaX and sigmaY in OH_Drawing_ImageFilterCreateBlur 160 OH_Drawing_ImageFilter *filter = 161 OH_Drawing_ImageFilterCreateBlur(FLT_MAX, FLT_MAX, OH_Drawing_TileMode::MIRROR, nullptr); 162 // add assert 163 EXPECT_NE(filter, nullptr); 164 // 2. Destroy the filter object 165 OH_Drawing_ImageFilterDestroy(filter); 166 } 167 168 /* 169 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0200 170 * @tc.name: testImageFilterCreateFromColorFilterNormal 171 * @tc.desc: Test for creating an image filter from a color filter with normal parameters. 172 * @tc.size : SmallTest 173 * @tc.type : Function 174 * @tc.level : Level 0 175 */ 176 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateFromColorFilterNormal, Function | SmallTest | Level0) { 177 // 1. OH_Drawing_ImageFilterCreateBlur 178 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 179 // add assert 180 EXPECT_NE(filter, nullptr); 181 // 2. OH_Drawing_ColorFilterCreateLinearToSrgbGamma 182 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateLinearToSrgbGamma(); 183 // add assert 184 EXPECT_NE(colorFilter, nullptr); 185 // 3. OH_Drawing_ImageFilterCreateFromColorFilter with null input parameter 186 OH_Drawing_ImageFilter *imageFilter = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilter, nullptr); 187 // add assert 188 EXPECT_NE(imageFilter, nullptr); 189 // add assert 190 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 191 // 4. OH_Drawing_ImageFilterCreateFromColorFilter with non-null input parameter 192 imageFilter = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilter, filter); 193 // add assert 194 EXPECT_NE(imageFilter, nullptr); 195 // add assert 196 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 197 // 5. Free memory 198 OH_Drawing_ImageFilterDestroy(imageFilter); 199 OH_Drawing_ColorFilterDestroy(colorFilter); 200 OH_Drawing_ImageFilterDestroy(filter); 201 } 202 203 /* 204 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0201 205 * @tc.name: testImageFilterCreateFromColorFilterNULL 206 * @tc.desc: Test for creating an image filter from a color filter with NULL parameters. 207 * @tc.size : SmallTest 208 * @tc.type : Function 209 * @tc.level : Level 3 210 */ 211 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateFromColorFilterNULL, Function | SmallTest | Level3) { 212 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 213 // add assert 214 EXPECT_NE(filter, nullptr); 215 // 1. OH_Drawing_ImageFilterCreateFromColorFilter with the first parameter being null, check the error code using 216 // OH_Drawing_ErrorCodeGet 217 OH_Drawing_ImageFilterCreateFromColorFilter(nullptr, filter); 218 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 219 // 2. Free memory 220 OH_Drawing_ImageFilterDestroy(filter); 221 } 222 223 /* 224 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0202 225 * @tc.name: testImageFilterCreateFromColorFilterMultipleCalls 226 * @tc.desc: Test for multiple calls of creating an image filter from a color filter. 227 * @tc.size : SmallTest 228 * @tc.type : Function 229 * @tc.level : Level 3 230 */ 231 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateFromColorFilterMultipleCalls, Function | SmallTest | Level3) { 232 for (int i = 0; i < 10; i++) { 233 OH_Drawing_ColorFilter *colorFilter = OH_Drawing_ColorFilterCreateLinearToSrgbGamma(); 234 // add assert 235 EXPECT_NE(colorFilter, nullptr); 236 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilter, nullptr); 237 EXPECT_NE(filter, nullptr); 238 // add assert 239 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 240 OH_Drawing_ImageFilterDestroy(filter); 241 OH_Drawing_ColorFilterDestroy(colorFilter); 242 } 243 } 244 245 /* 246 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0300 247 * @tc.name: testImageFilterDestroyNormal 248 * @tc.desc: Test for destroying an image filter with normal parameters. 249 * @tc.size : SmallTest 250 * @tc.type : Function 251 * @tc.level : Level 0 252 */ 253 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterDestroyNormal, Function | SmallTest | Level0) { 254 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 255 // add assert 256 EXPECT_NE(filter, nullptr); 257 OH_Drawing_ImageFilterDestroy(filter); 258 } 259 260 /* 261 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0301 262 * @tc.name: testImageFilterDestroyNULL 263 * @tc.desc: Test for destroying an image filter with NULL parameters. 264 * @tc.size : SmallTest 265 * @tc.type : Function 266 * @tc.level : Level 3 267 */ 268 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterDestroyNULL, Function | SmallTest | Level3) { 269 OH_Drawing_ImageFilterDestroy(nullptr); 270 // add assert 271 EXPECT_TRUE(true); 272 } 273 274 /* 275 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0302 276 * @tc.name: testImageFilterDestroyMultipleCalls 277 * @tc.desc: Test for multiple calls of destroying an image filter. 278 * @tc.size : SmallTest 279 * @tc.type : Function 280 * @tc.level : Level 3 281 */ 282 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterDestroyMultipleCalls, Function | SmallTest | Level3) { 283 // 1. Call OH_Drawing_ImageFilterCreateFromColorFilter 10 times 284 OH_Drawing_ColorFilter *colorFilters[10]; 285 OH_Drawing_ImageFilter *filters[10]; 286 for (int i = 0; i < 10; i++) { 287 colorFilters[i] = OH_Drawing_ColorFilterCreateLinearToSrgbGamma(); 288 // add assert 289 EXPECT_NE(colorFilters[i], nullptr); 290 filters[i] = OH_Drawing_ImageFilterCreateFromColorFilter(colorFilters[i], nullptr); 291 // add assert 292 EXPECT_NE(filters[i], nullptr); 293 } 294 // 2. Call OH_Drawing_ImageFilterDestroy 10 times 295 for (int i = 0; i < 10; i++) { 296 OH_Drawing_ImageFilterDestroy(filters[i]); 297 OH_Drawing_ColorFilterDestroy(colorFilters[i]); 298 } 299 // 3. Call OH_Drawing_ImageFilterCreateBlur and OH_Drawing_ImageFilterDestroy alternately 10 times 300 for (int i = 0; i < 10; i++) { 301 OH_Drawing_ImageFilter *filter = OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 302 // add assert 303 EXPECT_NE(filter, nullptr); 304 OH_Drawing_ImageFilterDestroy(filter); 305 } 306 } 307 308 /* 309 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0400 310 * @tc.name: testImageFilterCreateOffsetNormal 311 * @tc.desc: test for testImageFilterCreateOffsetNormal. 312 * @tc.size : SmallTest 313 * @tc.type : Function 314 * @tc.level : Level 0 315 */ 316 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateOffsetNormal, Function | SmallTest | Level0) { 317 // 1. Create an instance object through the interface OH_Drawing_ImageFilterCreateBlur. 318 OH_Drawing_ImageFilter *imageFilter1 = 319 OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 320 EXPECT_NE(imageFilter1, nullptr); 321 // 2. Create an instance object through the interface OH_Drawing_ImageFilterCreateOffset. 322 OH_Drawing_ImageFilter *imageFilter2 = 323 OH_Drawing_ImageFilterCreateOffset(10, 10, imageFilter1); 324 EXPECT_NE(imageFilter2, nullptr); 325 // 3. Destroy objects. 326 OH_Drawing_ImageFilterDestroy(imageFilter1); 327 OH_Drawing_ImageFilterDestroy(imageFilter2); 328 } 329 330 /* 331 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0401 332 * @tc.name: testImageFilterCreateOffsetNULL 333 * @tc.desc: test for testImageFilterCreateOffsetNULL. 334 * @tc.size : SmallTest 335 * @tc.type : Function 336 * @tc.level : Level 3 337 */ 338 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateOffsetNULL, Function | SmallTest | Level3) { 339 // 1. Create an instance object through the interface OH_Drawing_ImageFilterCreateBlur. 340 OH_Drawing_ImageFilter *imageFilter1 = 341 OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 342 EXPECT_NE(imageFilter1, nullptr); 343 // 2. The first parameter of the interface OH_Drawing_ImageFilterCreateOffset passes to 0. 344 OH_Drawing_ImageFilter *imageFilter2 = 345 OH_Drawing_ImageFilterCreateOffset(0, 10, imageFilter1); 346 EXPECT_NE(imageFilter2, nullptr); 347 // 3. The second parameter of the interface OH_Drawing_ImageFilterCreateOffset passes to 0. 348 OH_Drawing_ImageFilter *imageFilter3 = 349 OH_Drawing_ImageFilterCreateOffset(10, 0, imageFilter1); 350 EXPECT_NE(imageFilter3, nullptr); 351 // 4. The third parameter of the interface OH_Drawing_ImageFilterCreateOffset passes to nullptr. 352 OH_Drawing_ImageFilter *imageFilter4 = 353 OH_Drawing_ImageFilterCreateOffset(10, 10, nullptr); 354 EXPECT_NE(imageFilter4, nullptr); 355 // 5. Destroy objects. 356 OH_Drawing_ImageFilterDestroy(imageFilter1); 357 OH_Drawing_ImageFilterDestroy(imageFilter2); 358 OH_Drawing_ImageFilterDestroy(imageFilter3); 359 OH_Drawing_ImageFilterDestroy(imageFilter4); 360 } 361 362 /* 363 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0402 364 * @tc.name: testImageFilterCreateOffsetAbnormal 365 * @tc.desc: test for testImageFilterCreateOffsetAbnormal. 366 * @tc.size : SmallTest 367 * @tc.type : Function 368 * @tc.level : Level 3 369 */ 370 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateOffsetAbnormal, Function | SmallTest | Level3) { 371 // 1. Create an instance object through the interface OH_Drawing_ImageFilterCreateBlur. 372 OH_Drawing_ImageFilter *imageFilter1 = 373 OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 374 EXPECT_NE(imageFilter1, nullptr); 375 // 2. The first parameter of the interface OH_Drawing_ImageFilterCreateOffset passes to maximum value. 376 OH_Drawing_ImageFilter *imageFilter2 = 377 OH_Drawing_ImageFilterCreateOffset(0xFFFFFFFF, 10, imageFilter1); 378 EXPECT_NE(imageFilter2, nullptr); 379 // 3. The second parameter of the interface OH_Drawing_ImageFilterCreateOffset passes to maximum value. 380 OH_Drawing_ImageFilter *imageFilter3 = 381 OH_Drawing_ImageFilterCreateOffset(10, 0xFFFFFFFF, imageFilter1); 382 EXPECT_NE(imageFilter3, nullptr); 383 // 4. Destroy objects. 384 OH_Drawing_ImageFilterDestroy(imageFilter1); 385 OH_Drawing_ImageFilterDestroy(imageFilter2); 386 OH_Drawing_ImageFilterDestroy(imageFilter3); 387 } 388 389 /* 390 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0403 391 * @tc.name: testImageFilterCreateOffsetMultipleCalls 392 * @tc.desc: test for testImageFilterCreateOffsetMultipleCalls. 393 * @tc.size : SmallTest 394 * @tc.type : Function 395 * @tc.level : Level 3 396 */ 397 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateOffsetMultipleCalls, Function | SmallTest | Level3) { 398 // 1. Create an instance object through the interface OH_Drawing_ImageFilterCreateBlur. 399 OH_Drawing_ImageFilter *imageFilter1 = 400 OH_Drawing_ImageFilterCreateBlur(1, 1, OH_Drawing_TileMode::MIRROR, nullptr); 401 EXPECT_NE(imageFilter1, nullptr); 402 // 2. OH_Drawing_ImageFilterCreateOffset is called multiple times. 403 for (int i = 0; i < 10; i++) { 404 OH_Drawing_ImageFilter *imageFilter2 = 405 OH_Drawing_ImageFilterCreateOffset(0xFFFFFFFF, 10, imageFilter1); 406 EXPECT_NE(imageFilter2, nullptr); 407 OH_Drawing_ImageFilterDestroy(imageFilter2); 408 } 409 // 3. Destroy objects. 410 OH_Drawing_ImageFilterDestroy(imageFilter1); 411 } 412 413 /* 414 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0500 415 * @tc.name: testImageFilterCreateFromShderEffectNormal 416 * @tc.desc: test for testImageFilterCreateFromShderEffectNormal. 417 * @tc.size : SmallTest 418 * @tc.type : Function 419 * @tc.level : Level 0 420 */ 421 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateFromShderEffectNormal, Function | SmallTest | Level0) { 422 // 1. Create an instance object through the interface OH_Drawing_ShaderEffectCreateColorShder. 423 OH_Drawing_ShaderEffect *shaderEffect = OH_Drawing_ShaderEffectCreateColorShader(0xFF00FF00); 424 EXPECT_NE(shaderEffect, nullptr); 425 // 2. Create an instance object through the interface OH_Drawing_ImageFilterCreateFromShaderEffect. 426 OH_Drawing_ImageFilter *imageFilter = OH_Drawing_ImageFilterCreateFromShaderEffect(shaderEffect); 427 EXPECT_NE(imageFilter, nullptr); 428 // 3. Destroy objects. 429 OH_Drawing_ShaderEffectDestroy(shaderEffect); 430 OH_Drawing_ImageFilterDestroy(imageFilter); 431 } 432 433 /* 434 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0501 435 * @tc.name: testImageFilterCreateFromShderEffectNULL 436 * @tc.desc: test for testImageFilterCreateFromShderEffectNULL. 437 * @tc.size : SmallTest 438 * @tc.type : Function 439 * @tc.level : Level 3 440 */ 441 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateFromShderEffectNULL, Function | SmallTest | Level3) { 442 // 1. Create an instance object through the interface OH_Drawing_ImageFilterCreateFromShaderEffect. 443 OH_Drawing_ImageFilter *imageFilter = OH_Drawing_ImageFilterCreateFromShaderEffect(nullptr); 444 EXPECT_EQ(imageFilter, nullptr); 445 // 2. Destroy objects. 446 OH_Drawing_ImageFilterDestroy(imageFilter); 447 } 448 449 /* 450 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0502 451 * @tc.name: testImageFilterCreateFromShderEffectMultipleCalls 452 * @tc.desc: test for testImageFilterCreateFromShderEffectMultipleCalls. 453 * @tc.size : SmallTest 454 * @tc.type : Function 455 * @tc.level : Level 3 456 */ 457 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateFromShderEffectMultipleCalls, 458 Function | SmallTest | Level3) { 459 // 1. Create an instance object through the interface OH_Drawing_ShaderEffectCreateColorShder. 460 OH_Drawing_ShaderEffect *shaderEffect = OH_Drawing_ShaderEffectCreateColorShader(0xFF00FF00); 461 EXPECT_NE(shaderEffect, nullptr); 462 // 2. Create an instance object through the interface OH_Drawing_ImageFilterCreateFromShaderEffect. 463 for (int i = 0; i < 10; i++) { 464 OH_Drawing_ImageFilter *imageFilter = OH_Drawing_ImageFilterCreateFromShaderEffect(shaderEffect); 465 EXPECT_NE(imageFilter, nullptr); 466 OH_Drawing_ImageFilterDestroy(imageFilter); 467 } 468 // 3. Destroy objects. 469 OH_Drawing_ShaderEffectDestroy(shaderEffect); 470 } 471 472 /* 473 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0600 474 * @tc.name: testImageFilterCreateBlurWithCropNormal 475 * @tc.desc: test for testImageFilterCreateBlurWithCropNormal 476 * @tc.size : SmallTest 477 * @tc.type : Function 478 * @tc.level : Level 0 479 */ 480 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurWithCropNormal, Function | SmallTest | Level0) { 481 OH_Drawing_Rect *cropRect = OH_Drawing_RectCreate(0, 0, 200, 200); 482 OH_Drawing_ImageFilter *imageFilter1 = 483 OH_Drawing_ImageFilterCreateBlurWithCrop(10, 10, OH_Drawing_TileMode::CLAMP, nullptr, nullptr); 484 // 1. The interface of OH_Drawing_ImageFilterCreateBlurWithCrop is called normally. 485 OH_Drawing_ImageFilter *imageFilter2 = 486 OH_Drawing_ImageFilterCreateBlurWithCrop(10, 10, OH_Drawing_TileMode::CLAMP, imageFilter1, cropRect); 487 EXPECT_NE(imageFilter2, nullptr); 488 // 2. Destroy objects. 489 OH_Drawing_RectDestroy(cropRect); 490 OH_Drawing_ImageFilterDestroy(imageFilter1); 491 OH_Drawing_ImageFilterDestroy(imageFilter2); 492 } 493 494 /* 495 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0601 496 * @tc.name: testImageFilterCreateBlurWithCropNull 497 * @tc.desc: test for testImageFilterCreateBlurWithCropNull 498 * @tc.size : SmallTest 499 * @tc.type : Function 500 * @tc.level : Level 3 501 */ 502 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurWithCropNull, Function | SmallTest | Level3) { 503 OH_Drawing_Rect *cropRect = OH_Drawing_RectCreate(0, 0, 200, 200); 504 OH_Drawing_ImageFilter *imageFilter1 = 505 OH_Drawing_ImageFilterCreateBlurWithCrop(10, 10, OH_Drawing_TileMode::CLAMP, nullptr, nullptr); 506 // 1. The first parameter of the verification interface is passed null. 507 OH_Drawing_ImageFilter *imageFilter2 = 508 OH_Drawing_ImageFilterCreateBlurWithCrop(0, 10, OH_Drawing_TileMode::CLAMP, imageFilter1, cropRect); 509 EXPECT_NE(imageFilter2, nullptr); 510 // 2. The second parameter of the verification interface is passed null. 511 imageFilter2 = OH_Drawing_ImageFilterCreateBlurWithCrop(10, 0, OH_Drawing_TileMode::CLAMP, imageFilter1, cropRect); 512 EXPECT_NE(imageFilter2, nullptr); 513 // 3. The forth parameter of the verification interface is passed null. 514 imageFilter2 = OH_Drawing_ImageFilterCreateBlurWithCrop(10, 10, OH_Drawing_TileMode::CLAMP, nullptr, cropRect); 515 EXPECT_NE(imageFilter2, nullptr); 516 // 4. The fifth parameter of the verification interface is passed null. 517 imageFilter2 = OH_Drawing_ImageFilterCreateBlurWithCrop(10, 10, OH_Drawing_TileMode::CLAMP, imageFilter1, nullptr); 518 EXPECT_NE(imageFilter2, nullptr); 519 // 5. Destroy objects. 520 OH_Drawing_RectDestroy(cropRect); 521 OH_Drawing_ImageFilterDestroy(imageFilter1); 522 OH_Drawing_ImageFilterDestroy(imageFilter2); 523 } 524 525 /* 526 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_IMAGE_FILTER_0602 527 * @tc.name: testImageFilterCreateBlurWithCropMultiCalls 528 * @tc.desc: test for testImageFilterCreateBlurWithCropMultiCalls 529 * @tc.size : SmallTest 530 * @tc.type : Function 531 * @tc.level : Level 3 532 */ 533 HWTEST_F(DrawingNativeImageFilterTest, testImageFilterCreateBlurWithCropMultiCalls, Function | SmallTest | Level3) { 534 OH_Drawing_Rect *cropRect = OH_Drawing_RectCreate(0, 0, 200, 200); 535 OH_Drawing_ImageFilter *imageFilter1 = 536 OH_Drawing_ImageFilterCreateBlurWithCrop(10, 10, OH_Drawing_TileMode::CLAMP, nullptr, nullptr); 537 OH_Drawing_ImageFilter *imageFilter2 = nullptr; 538 // 1. The interface of OH_Drawing_ImageFilterCreateBlurWithCrop is called 10 times. 539 for (int i = 0; i < 10; i++) { 540 imageFilter2 = OH_Drawing_ImageFilterCreateBlurWithCrop( 541 10, 10, OH_Drawing_TileMode::CLAMP, imageFilter1, cropRect); 542 EXPECT_NE(imageFilter2, nullptr); 543 } 544 // 2. Destroy objects. 545 OH_Drawing_RectDestroy(cropRect); 546 OH_Drawing_ImageFilterDestroy(imageFilter1); 547 OH_Drawing_ImageFilterDestroy(imageFilter2); 548 } 549 } // namespace Drawing 550 } // namespace Rosen 551 } // namespace OHOS