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 "gtest/gtest.h" 17 18 #include "drawing_color.h" 19 #include "drawing_error_code.h" 20 #include "drawing_filter.h" 21 #include "drawing_image.h" 22 #include "drawing_mask_filter.h" 23 #include "drawing_matrix.h" 24 #include "drawing_point.h" 25 #include "drawing_rect.h" 26 #include "drawing_round_rect.h" 27 #include "drawing_sampling_options.h" 28 #include "drawing_shader_effect.h" 29 #include "drawing_pixel_map.h" 30 #include "image/pixelmap_native.h" 31 32 using namespace testing; 33 using namespace testing::ext; 34 35 namespace OHOS { 36 namespace Rosen { 37 namespace Drawing { 38 class DrawingNativeShaderEffectTest : public testing::Test { 39 protected: 40 // 在每个测试用例执行前调用 SetUp()41 void SetUp() override 42 { 43 // 设置代码 44 std::cout << "DrawingNativeShaderEffectTest Setup code called before each test case." << std::endl; 45 OH_Drawing_ErrorCodeReset(); 46 std::cout << "DrawingNativeShaderEffectTest errorCodeReset before each test case." << std::endl; 47 } TearDown()48 void TearDown() override 49 { 50 std::cout << "DrawingNativeShaderEffectTest Setup code called after each test case." << std::endl; 51 OH_Drawing_ErrorCodeReset(); 52 std::cout << "DrawingNativeShaderEffectTest errorCodeReset after each test case." << std::endl; 53 } 54 }; 55 56 /* 57 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0100 58 * @tc.name: testShaderEffectCreateColorShaderNormal 59 * @tc.desc: test for testShaderEffectCreateColorShaderNormal. 60 * @tc.size : SmallTest 61 * @tc.type : Function 62 * @tc.level : Level 0 63 */ 64 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderNormal, Function | SmallTest | Level0) { 65 // 1. OH_Drawing_ShaderEffectCreateColorShader 66 uint32_t color = 0xFFFF0000; 67 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(color); 68 // add assert 69 EXPECT_NE(colorShaderEffect, nullptr); 70 // 2. Free memory 71 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 72 } 73 74 /* 75 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0101 76 * @tc.name: testShaderEffectCreateColorShaderNull 77 * @tc.desc: test for testShaderEffectCreateColorShaderNull. 78 * @tc.size : SmallTest 79 * @tc.type : Function 80 * @tc.level : Level 3 81 */ 82 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderNull, Function | SmallTest | Level3) { 83 // 1. OH_Drawing_ShaderEffectCreateColorShader with empty parameter 84 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(0); 85 // add assert 86 EXPECT_NE(colorShaderEffect, nullptr); 87 // 2. Free memory 88 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 89 } 90 91 /* 92 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0102 93 * @tc.name: testShaderEffectCreateColorShaderAbnormal 94 * @tc.desc: test for testShaderEffectCreateColorShaderAbnormal. 95 * @tc.size : SmallTest 96 * @tc.type : Function 97 * @tc.level : Level 3 98 */ 99 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderAbnormal, Function | SmallTest | Level3) { 100 // 1. OH_Drawing_ShaderEffectCreateColorShader with a negative parameter 101 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(-0xFFFF0000); 102 // add assert 103 EXPECT_NE(colorShaderEffect, nullptr); 104 // 2. Free memory 105 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 106 } 107 108 /* 109 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0103 110 * @tc.name: testShaderEffectCreateColorShaderMaximum 111 * @tc.desc: test for testShaderEffectCreateColorShaderMaximum. 112 * @tc.size : SmallTest 113 * @tc.type : Function 114 * @tc.level : Level 3 115 */ 116 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderMaximum, Function | SmallTest | Level3) { 117 // 1. OH_Drawing_ShaderEffectCreateColorShader with maximum value as parameter 118 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(UINT32_MAX); 119 // add assert 120 EXPECT_NE(colorShaderEffect, nullptr); 121 // 2. Free memory 122 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 123 } 124 125 /* 126 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0104 127 * @tc.name: testShaderEffectCreateColorShaderMultipleCalls 128 * @tc.desc: test for testShaderEffectCreateColorShaderMultipleCalls. 129 * @tc.size : SmallTest 130 * @tc.type : Function 131 * @tc.level : Level 3 132 */ 133 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderMultipleCalls, Function | SmallTest | Level3) { 134 // 1. Call OH_Drawing_ShaderEffectCreateColorShader 10 times with different colors 135 for (int i = 0; i < 10; i++) { 136 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(0xFF000000 + i); 137 // add assert 138 EXPECT_NE(colorShaderEffect, nullptr); 139 // 2. Free memory 140 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 141 } 142 } 143 144 /* 145 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0200 146 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixNormal 147 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixNormal. 148 * @tc.size : SmallTest 149 * @tc.type : Function 150 * @tc.level : Level 0 151 */ 152 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixNormal, Function | SmallTest | Level0) { 153 OH_Drawing_Point2D start = {0, 0}; 154 OH_Drawing_Point2D end = {100.f, 0}; 155 float pos[3] = {0.0f, 0.5f, 1.0f}; 156 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 157 OH_Drawing_TileMode modes[] = { 158 CLAMP, 159 REPEAT, 160 MIRROR, 161 DECAL, 162 }; 163 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 164 // add assert 165 EXPECT_NE(matrix, nullptr); 166 // 1. Enumerate OH_Drawing_TileMode values for OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix, and test 167 // with both identity and non-identity matrix 168 for (OH_Drawing_TileMode mode : modes) { 169 OH_Drawing_ShaderEffect *linearGradientEffect = 170 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, mode, matrix); 171 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 172 } 173 174 // 2. Test OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with pos set to NULL 175 OH_Drawing_ShaderEffect *linearGradientEffect = OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix( 176 &start, &end, colors, nullptr, 3, OH_Drawing_TileMode::CLAMP, matrix); 177 // add assert 178 EXPECT_NE(linearGradientEffect, nullptr); 179 // add assert 180 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 181 // 3. Test OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with matrix set to NULL 182 OH_Drawing_ShaderEffect *linearGradientEffect2 = OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix( 183 &start, &end, colors, pos, 3, OH_Drawing_TileMode::CLAMP, nullptr); 184 // add assert 185 EXPECT_NE(linearGradientEffect2, nullptr); 186 // add assert 187 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 188 189 // 4. Free memory 190 OH_Drawing_MatrixDestroy(matrix); 191 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 192 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 193 } 194 195 /* 196 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0201 197 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixNull 198 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixNull. 199 * @tc.size : SmallTest 200 * @tc.type : Function 201 * @tc.level : Level 3 202 */ 203 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixNull, Function | SmallTest | Level3) { 204 OH_Drawing_Point2D start = {0, 0}; 205 OH_Drawing_Point2D end = {100.f, 0}; 206 float pos[3] = {0.0f, 0.5f, 1.0f}; 207 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 208 OH_Drawing_TileMode modes[] = { 209 CLAMP, 210 REPEAT, 211 MIRROR, 212 DECAL, 213 }; 214 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 215 // add assert 216 EXPECT_NE(matrix, nullptr); 217 // 1. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with the first parameter set to nullptr, check the 218 // error code using OH_Drawing_ErrorCodeGet 219 OH_Drawing_ShaderEffect *effect1 = 220 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(nullptr, &end, colors, pos, 3, modes[0], matrix); 221 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 222 OH_Drawing_ErrorCodeReset(); 223 // 2. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with the second parameter set to nullptr, check the 224 // error code using OH_Drawing_ErrorCodeGet 225 OH_Drawing_ShaderEffect *effect2 = 226 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, nullptr, colors, pos, 3, modes[0], matrix); 227 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 228 OH_Drawing_ErrorCodeReset(); 229 // 3. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with the third parameter set to nullptr, check the 230 // error code using OH_Drawing_ErrorCodeGet 231 OH_Drawing_ShaderEffect *effect3 = 232 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, nullptr, pos, 3, modes[0], matrix); 233 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 234 // 4. Free memory 235 OH_Drawing_MatrixDestroy(matrix); 236 OH_Drawing_ShaderEffectDestroy(effect1); 237 OH_Drawing_ShaderEffectDestroy(effect2); 238 OH_Drawing_ShaderEffectDestroy(effect3); 239 } 240 241 /* 242 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0202 243 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixAbnormal 244 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixAbnormal. 245 * @tc.size : SmallTest 246 * @tc.type : Function 247 * @tc.level : Level 3 248 */ 249 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixAbnormal, Function | SmallTest | Level3) { 250 OH_Drawing_Point2D start = {0, 0}; 251 OH_Drawing_Point2D end = {100.f, 0}; 252 float pos[3] = {0.0f, 0.5f, 1.0f}; 253 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 254 OH_Drawing_TileMode modes[] = { 255 CLAMP, 256 REPEAT, 257 MIRROR, 258 DECAL, 259 }; 260 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 261 // add assert 262 EXPECT_NE(matrix, nullptr); 263 // 1. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with negative values for startPt 264 start = {-1, -1}; 265 OH_Drawing_ShaderEffect *linearGradientEffect = 266 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 267 // add assert 268 EXPECT_NE(linearGradientEffect, nullptr); 269 // add assert 270 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 271 // 2. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with negative values for endPt 272 start = {0, 0}; 273 end = {-1, -1}; 274 OH_Drawing_ShaderEffect *linearGradientEffect2 = 275 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 276 // add assert 277 EXPECT_NE(linearGradientEffect2, nullptr); 278 // add assert 279 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 280 // 3. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with negative values for colors 281 colors[0] = -0xFF00FFFF; 282 OH_Drawing_ShaderEffect *linearGradientEffect3 = 283 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 284 // add assert 285 EXPECT_NE(linearGradientEffect3, nullptr); 286 // add assert 287 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 288 // 4. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with negative values for pos 289 colors[0] = 0xFF00FFFF; 290 pos[0] = -0.1f; 291 OH_Drawing_ShaderEffect *linearGradientEffect4 = 292 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 293 // add assert 294 EXPECT_NE(linearGradientEffect4, nullptr); 295 // add assert 296 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 297 // 5. Free memory 298 OH_Drawing_MatrixDestroy(matrix); 299 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 300 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 301 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 302 OH_Drawing_ShaderEffectDestroy(linearGradientEffect4); 303 } 304 305 /* 306 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0203 307 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixMaximum 308 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixMaximum. 309 * @tc.size : SmallTest 310 * @tc.type : Function 311 * @tc.level : Level 3 312 */ 313 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixMaximum, Function | SmallTest | Level3) { 314 OH_Drawing_Point2D start = {0, 0}; 315 OH_Drawing_Point2D end = {100.f, 0}; 316 float pos[3] = {0.0f, 0.5f, 1.0f}; 317 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 318 OH_Drawing_TileMode modes[] = { 319 CLAMP, 320 REPEAT, 321 MIRROR, 322 DECAL, 323 }; 324 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 325 // add assert 326 EXPECT_NE(matrix, nullptr); 327 // 1. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with startPt set to maximum value 328 start = {FLT_MAX, FLT_MAX}; 329 OH_Drawing_ShaderEffect *linearGradientEffect = 330 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 331 // add assert 332 EXPECT_NE(linearGradientEffect, nullptr); 333 // add assert 334 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 335 // 2. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with endPt set to maximum value 336 start = {0, 0}; 337 end = {FLT_MAX, FLT_MAX}; 338 OH_Drawing_ShaderEffect *linearGradientEffect2 = 339 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 340 // add assert 341 EXPECT_NE(linearGradientEffect2, nullptr); 342 // add assert 343 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 344 // 3. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with colors set to maximum value 345 colors[0] = UINT32_MAX; 346 OH_Drawing_ShaderEffect *linearGradientEffect3 = 347 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 348 // add assert 349 EXPECT_NE(linearGradientEffect3, nullptr); 350 // add assert 351 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 352 // 4. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with pos set to maximum value 353 colors[0] = 0xFF00FFFF; 354 pos[0] = FLT_MAX; 355 OH_Drawing_ShaderEffect *linearGradientEffect4 = 356 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 357 // add assert 358 EXPECT_NE(linearGradientEffect4, nullptr); 359 // add assert 360 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 361 // 5. Free memory 362 OH_Drawing_MatrixDestroy(matrix); 363 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 364 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 365 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 366 OH_Drawing_ShaderEffectDestroy(linearGradientEffect4); 367 } 368 369 /* 370 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0204 371 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixMultipleCalls 372 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixMultipleCalls. 373 * @tc.size : SmallTest 374 * @tc.type : Function 375 * @tc.level : Level 3 376 */ 377 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixMultipleCalls, 378 Function | SmallTest | Level3) { 379 OH_Drawing_Point2D start = {0, 0}; 380 OH_Drawing_Point2D end = {100.f, 0}; 381 float pos[3] = {0.0f, 0.5f, 1.0f}; 382 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 383 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 384 // 1. Call OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix 10 times 385 for (int i = 0; i < 10; i++) { 386 OH_Drawing_ShaderEffect *linearGradientEffect = 387 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, CLAMP, matrix); 388 // add assert 389 EXPECT_NE(linearGradientEffect, nullptr); 390 // add assert 391 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 392 // 2. Free memory 393 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 394 } 395 } 396 397 /* 398 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0300 399 * @tc.name: testShaderEffectCreateLinearGradienNormal 400 * @tc.desc: test for testShaderEffectCreateLinearGradienNormal. 401 * @tc.size : SmallTest 402 * @tc.type : Function 403 * @tc.level : Level 0 404 */ 405 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienNormal, Function | SmallTest | Level0) { 406 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ShaderEffectCreateLinearGradient 407 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 408 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 409 float pos[3] = {0.0f, 0.5f, 1.0f}; 410 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 411 OH_Drawing_TileMode modes[] = { 412 CLAMP, 413 REPEAT, 414 MIRROR, 415 DECAL, 416 }; 417 for (OH_Drawing_TileMode mode : modes) { 418 OH_Drawing_ShaderEffect *linearGradientEffect = 419 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, mode); 420 // add assert 421 EXPECT_NE(linearGradientEffect, nullptr); 422 // add assert 423 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 424 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 425 } 426 // 2. OH_Drawing_ShaderEffectCreateLinearGradient interface with pos set to NULL 427 OH_Drawing_ShaderEffect *linearGradientEffect = 428 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, nullptr, 3, CLAMP); 429 // add assert 430 EXPECT_NE(linearGradientEffect, nullptr); 431 // add assert 432 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 433 // 3. Free memory 434 OH_Drawing_PointDestroy(startPt); 435 OH_Drawing_PointDestroy(endPt); 436 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 437 } 438 439 /* 440 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0301 441 * @tc.name: testShaderEffectCreateLinearGradienNull 442 * @tc.desc: test for testShaderEffectCreateLinearGradienNull. 443 * @tc.size : SmallTest 444 * @tc.type : Function 445 * @tc.level : Level 3 446 */ 447 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienNull, Function | SmallTest | Level3) { 448 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 449 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 450 float pos[3] = {0.0f, 0.5f, 1.0f}; 451 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 452 // 1. OH_Drawing_ShaderEffectCreateLinearGradient with the first parameter set to nullptr, check the error code 453 // using OH_Drawing_ErrorCodeGet 454 OH_Drawing_ShaderEffect *linearGradientEffect = 455 OH_Drawing_ShaderEffectCreateLinearGradient(nullptr, endPt, colors, pos, 3, CLAMP); 456 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 457 OH_Drawing_ErrorCodeReset(); 458 // 2. OH_Drawing_ShaderEffectCreateLinearGradient with the second parameter set to nullptr, check the error code 459 // using OH_Drawing_ErrorCodeGet 460 OH_Drawing_ShaderEffect *linearGradientEffect2 = 461 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, nullptr, colors, pos, 3, CLAMP); 462 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 463 OH_Drawing_ErrorCodeReset(); 464 // 3. OH_Drawing_ShaderEffectCreateLinearGradient with the third parameter set to nullptr, check the error code 465 // using OH_Drawing_ErrorCodeGet 466 OH_Drawing_ShaderEffect *linearGradientEffect3 = 467 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, nullptr, pos, 3, CLAMP); 468 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 469 // 4. Free memory 470 OH_Drawing_PointDestroy(startPt); 471 OH_Drawing_PointDestroy(endPt); 472 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 473 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 474 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 475 } 476 477 /* 478 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0302 479 * @tc.name: testShaderEffectCreateLinearGradienAbnormal 480 * @tc.desc: test for testShaderEffectCreateLinearGradienAbnormal. 481 * @tc.size : SmallTest 482 * @tc.type : Function 483 * @tc.level : Level 3 484 */ 485 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienAbnormal, Function | SmallTest | Level3) { 486 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 487 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 488 float pos[3] = {0.0f, 0.5f, 1.0f}; 489 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 490 // 1. OH_Drawing_ShaderEffectCreateLinearGradient interface with startPt set to negative values 491 OH_Drawing_Point *startPt2 = OH_Drawing_PointCreate(-1, -1); 492 OH_Drawing_ShaderEffect *linearGradientEffect = 493 OH_Drawing_ShaderEffectCreateLinearGradient(startPt2, endPt, colors, pos, 3, CLAMP); 494 // add assert 495 EXPECT_NE(linearGradientEffect, nullptr); 496 // add assert 497 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 498 // 2. OH_Drawing_ShaderEffectCreateLinearGradient interface with endPt set to negative values 499 OH_Drawing_Point *endPt2 = OH_Drawing_PointCreate(-1, -1); 500 OH_Drawing_ShaderEffect *linearGradientEffect2 = 501 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt2, colors, pos, 3, CLAMP); 502 // add assert 503 EXPECT_NE(linearGradientEffect2, nullptr); 504 // add assert 505 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 506 // 3. OH_Drawing_ShaderEffectCreateLinearGradient interface with colors set to negative values 507 colors[0] = -0xFF00FFFF; 508 OH_Drawing_ShaderEffect *linearGradientEffect3 = 509 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 510 // add assert 511 EXPECT_NE(linearGradientEffect3, nullptr); 512 // add assert 513 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 514 // 4. OH_Drawing_ShaderEffectCreateLinearGradient interface with pos set to negative values 515 colors[0] = 0xFF00FFFF; 516 pos[0] = -0.1f; 517 OH_Drawing_ShaderEffect *linearGradientEffect4 = 518 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 519 // add assert 520 EXPECT_NE(linearGradientEffect4, nullptr); 521 // add assert 522 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 523 // 5. Free memory 524 OH_Drawing_PointDestroy(startPt); 525 OH_Drawing_PointDestroy(endPt); 526 OH_Drawing_PointDestroy(startPt2); 527 OH_Drawing_PointDestroy(endPt2); 528 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 529 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 530 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 531 OH_Drawing_ShaderEffectDestroy(linearGradientEffect4); 532 } 533 534 /* 535 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0303 536 * @tc.name: testShaderEffectCreateLinearGradienMaximum 537 * @tc.desc: test for testShaderEffectCreateLinearGradienMaximum. 538 * @tc.size : SmallTest 539 * @tc.type : Function 540 * @tc.level : Level 3 541 */ 542 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienMaximum, Function | SmallTest | Level3) { 543 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 544 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 545 float pos[3] = {0.0f, 0.5f, 1.0f}; 546 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 547 // 1. Call OH_Drawing_ShaderEffectCreateLinearGradient with startPt set to maximum values 548 OH_Drawing_Point *startPt2 = OH_Drawing_PointCreate(FLT_MAX, FLT_MAX); 549 OH_Drawing_ShaderEffect *linearGradientEffect = 550 OH_Drawing_ShaderEffectCreateLinearGradient(startPt2, endPt, colors, pos, 3, CLAMP); 551 // add assert 552 EXPECT_NE(linearGradientEffect, nullptr); 553 // add assert 554 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 555 // 2. Call OH_Drawing_ShaderEffectCreateLinearGradient with endPt set to maximum values 556 OH_Drawing_Point *endPt2 = OH_Drawing_PointCreate(FLT_MAX, FLT_MAX); 557 OH_Drawing_ShaderEffect *linearGradientEffect2 = 558 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt2, colors, pos, 3, CLAMP); 559 // add assert 560 EXPECT_NE(linearGradientEffect2, nullptr); 561 // add assert 562 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 563 // 3. Call OH_Drawing_ShaderEffectCreateLinearGradient with colors set to maximum values 564 colors[0] = UINT32_MAX; 565 OH_Drawing_ShaderEffect *linearGradientEffect3 = 566 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 567 // add assert 568 EXPECT_NE(linearGradientEffect3, nullptr); 569 // add assert 570 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 571 // 4. Call OH_Drawing_ShaderEffectCreateLinearGradient with pos set to maximum values 572 colors[0] = 0xFF00FFFF; 573 pos[0] = FLT_MAX; 574 OH_Drawing_ShaderEffect *linearGradientEffect4 = 575 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 576 // add assert 577 EXPECT_NE(linearGradientEffect4, nullptr); 578 // add assert 579 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 580 // 5. Free memory 581 OH_Drawing_PointDestroy(startPt); 582 OH_Drawing_PointDestroy(endPt); 583 OH_Drawing_PointDestroy(startPt2); 584 OH_Drawing_PointDestroy(endPt2); 585 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 586 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 587 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 588 OH_Drawing_ShaderEffectDestroy(linearGradientEffect4); 589 } 590 591 /* 592 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0304 593 * @tc.name: testShaderEffectCreateLinearGradienMultipleCalls 594 * @tc.desc: test for testShaderEffectCreateLinearGradienMultipleCalls. 595 * @tc.size : SmallTest 596 * @tc.type : Function 597 * @tc.level : Level 3 598 */ 599 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienMultipleCalls, Function | SmallTest | Level3) { 600 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 601 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 602 float pos[3] = {0.0f, 0.5f, 1.0f}; 603 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 604 // 1. Call OH_Drawing_ShaderEffectCreateLinearGradient 10 times 605 for (int i = 0; i < 10; i++) { 606 OH_Drawing_ShaderEffect *linearGradientEffect = 607 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 608 // add assert 609 EXPECT_NE(linearGradientEffect, nullptr); 610 // add assert 611 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 612 // 2. Free memory 613 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 614 } 615 } 616 617 /* 618 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0400 619 * @tc.name: testShaderEffectCreateRadialGradientNormal 620 * @tc.desc: test for testShaderEffectCreateRadialGradientNormal. 621 * @tc.size : SmallTest 622 * @tc.type : Function 623 * @tc.level : Level 0 624 */ 625 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientNormal, Function | SmallTest | Level0) { 626 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ShaderEffectCreateRadialGradient 627 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 628 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 629 float pos[] = {0, 0.5, 1.0}; 630 OH_Drawing_TileMode modes[] = { 631 CLAMP, 632 REPEAT, 633 MIRROR, 634 DECAL, 635 }; 636 for (OH_Drawing_TileMode mode : modes) { 637 OH_Drawing_ErrorCodeReset(); 638 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos, 3, mode); 639 // add assert 640 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 641 EXPECT_NE(effect, nullptr); 642 OH_Drawing_ShaderEffectDestroy(effect); 643 } 644 // 2. OH_Drawing_ShaderEffectCreateRadialGradient with pos set to nullptr 645 OH_Drawing_ShaderEffect *effect = 646 OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, nullptr, 3, CLAMP); 647 // add assert 648 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 649 EXPECT_NE(effect, nullptr); 650 // 3. Free memory 651 OH_Drawing_PointDestroy(point); 652 OH_Drawing_ShaderEffectDestroy(effect); 653 } 654 655 /* 656 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0401 657 * @tc.name: testShaderEffectCreateRadialGradientNull 658 * @tc.desc: test for testShaderEffectCreateRadialGradientNull. 659 * @tc.size : SmallTest 660 * @tc.type : Function 661 * @tc.level : Level 3 662 */ 663 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientNull, Function | SmallTest | Level3) { 664 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 665 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 666 float pos[] = {0, 0.5, 1.0}; 667 // 1. OH_Drawing_ShaderEffectCreateRadialGradient with the first parameter set to nullptr, check the error code 668 // using OH_Drawing_ErrorCodeGet 669 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradient(nullptr, 100, colors, pos, 3, CLAMP); 670 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 671 // 2. OH_Drawing_ShaderEffectCreateRadialGradient with the second parameter set to nullptr 672 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, nullptr, pos, 3, CLAMP); 673 EXPECT_EQ(effect2, nullptr); 674 // 3. OH_Drawing_ShaderEffectCreateRadialGradient with the third parameter set to nullptr 675 OH_Drawing_ShaderEffect *effect3 = 676 OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, nullptr, 3, CLAMP); 677 EXPECT_NE(effect3, nullptr); 678 // 4. Free memory 679 OH_Drawing_PointDestroy(point); 680 OH_Drawing_ShaderEffectDestroy(effect); 681 OH_Drawing_ShaderEffectDestroy(effect2); 682 OH_Drawing_ShaderEffectDestroy(effect3); 683 } 684 685 /* 686 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0402 687 * @tc.name: testShaderEffectCreateRadialGradientAbnormal 688 * @tc.desc: test for testShaderEffectCreateRadialGradientAbnormal. 689 * @tc.size : SmallTest 690 * @tc.type : Function 691 * @tc.level : Level 3 692 */ 693 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientAbnormal, Function | SmallTest | Level3) { 694 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 695 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 696 float pos[] = {0, 0.5, 1.0}; 697 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradient with centerPt set to negative values 698 OH_Drawing_Point *point2 = OH_Drawing_PointCreate(-100, -100); 699 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradient(point2, 100, colors, pos, 3, CLAMP); 700 // add assert 701 EXPECT_NE(effect, nullptr); 702 // add assert 703 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 704 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradient with radius set to negative values 705 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateRadialGradient(point, -100, colors, pos, 3, CLAMP); 706 // add assert 707 EXPECT_NE(effect2, nullptr); 708 // add assert 709 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 710 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradient with colors set to negative values 711 colors[0] = -0xFFFF0000; 712 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos, 3, CLAMP); 713 // add assert 714 EXPECT_NE(effect3, nullptr); 715 // add assert 716 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 717 // 4. Call OH_Drawing_ShaderEffectCreateRadialGradient with pos set to negative values 718 colors[0] = 0xFFFF0000; 719 pos[0] = -0.1f; 720 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos, 3, CLAMP); 721 // add assert 722 EXPECT_NE(effect4, nullptr); 723 // add assert 724 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 725 // 5. Free memory 726 OH_Drawing_PointDestroy(point); 727 OH_Drawing_PointDestroy(point2); 728 OH_Drawing_ShaderEffectDestroy(effect); 729 OH_Drawing_ShaderEffectDestroy(effect2); 730 OH_Drawing_ShaderEffectDestroy(effect3); 731 OH_Drawing_ShaderEffectDestroy(effect4); 732 } 733 734 /* 735 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0403 736 * @tc.name: testShaderEffectCreateRadialGradientMaximum 737 * @tc.desc: test for testShaderEffectCreateRadialGradientMaximum. 738 * @tc.size : SmallTest 739 * @tc.type : Function 740 * @tc.level : Level 3 741 */ 742 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientMaximum, Function | SmallTest | Level3) { 743 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 744 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 745 float pos[] = {0, 0.5, 1.0}; 746 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradient with centerPt set to maximum values 747 OH_Drawing_Point *point2 = OH_Drawing_PointCreate(FLT_MAX, FLT_MAX); 748 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradient(point2, 100, colors, pos, 3, CLAMP); 749 // add assert 750 EXPECT_NE(effect, nullptr); 751 // add assert 752 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 753 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradient with radius set to maximum values 754 OH_Drawing_ShaderEffect *effect2 = 755 OH_Drawing_ShaderEffectCreateRadialGradient(point, FLT_MAX, colors, pos, 3, CLAMP); 756 // add assert 757 EXPECT_NE(effect2, nullptr); 758 // add assert 759 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 760 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradient with colors set to maximum values 761 uint32_t colors2[] = {UINT32_MAX, UINT32_MAX, UINT32_MAX}; 762 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors2, pos, 3, CLAMP); 763 // add assert 764 EXPECT_NE(effect3, nullptr); 765 // add assert 766 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 767 // 4. Call OH_Drawing_ShaderEffectCreateRadialGradient with pos set to maximum values 768 float pos2[] = {FLT_MAX, FLT_MAX, FLT_MAX}; 769 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos2, 3, CLAMP); 770 // add assert 771 EXPECT_NE(effect4, nullptr); 772 // add assert 773 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 774 // 5. Free memory 775 OH_Drawing_PointDestroy(point); 776 OH_Drawing_PointDestroy(point2); 777 OH_Drawing_ShaderEffectDestroy(effect); 778 OH_Drawing_ShaderEffectDestroy(effect2); 779 OH_Drawing_ShaderEffectDestroy(effect3); 780 OH_Drawing_ShaderEffectDestroy(effect4); 781 } 782 783 /* 784 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0404 785 * @tc.name: testShaderEffectCreateRadialGradientMultipleCalls 786 * @tc.desc: test for testShaderEffectCreateRadialGradientMultipleCalls. 787 * @tc.size : SmallTest 788 * @tc.type : Function 789 * @tc.level : Level 3 790 */ 791 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientMultipleCalls, Function | SmallTest | Level3) { 792 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 793 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 794 float pos[] = {0, 0.5, 1.0}; 795 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradient 10 times 796 for (int i = 0; i < 10; i++) { 797 OH_Drawing_ShaderEffect *effect = 798 OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos, 3, CLAMP); 799 // add assert 800 EXPECT_NE(effect, nullptr); 801 // add assert 802 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 803 // 2. Free memory 804 OH_Drawing_ShaderEffectDestroy(effect); 805 } 806 } 807 808 /* 809 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0500 810 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixNormal 811 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixNormal. 812 * @tc.size : SmallTest 813 * @tc.type : Function 814 * @tc.level : Level 0 815 */ 816 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixNormal, Function | SmallTest | Level0) { 817 float pos[] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 818 float radius = 5.0; // 5.0f: gradient color radius 819 OH_Drawing_Point2D start = {100.f, 0}; // 100.f: start point's x 820 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 821 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 822 // add assert 823 EXPECT_NE(matrix, nullptr); 824 OH_Drawing_TileMode modes[] = { 825 CLAMP, 826 REPEAT, 827 MIRROR, 828 DECAL, 829 }; 830 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix, covering 831 // both the identity matrix and non-identity matrices for matrix 832 for (OH_Drawing_TileMode mode : modes) { 833 OH_Drawing_ShaderEffect *effect = 834 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(&start, radius, colors, pos, 3, mode, matrix); 835 EXPECT_NE(effect, nullptr); 836 OH_Drawing_ShaderEffectDestroy(effect); 837 } 838 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with pos set to nullptr 839 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix( 840 &start, radius, colors, nullptr, 3, OH_Drawing_TileMode::CLAMP, matrix); 841 // add assert 842 EXPECT_NE(effect2, nullptr); 843 // add assert 844 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 845 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with matrix set to nullptr 846 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix( 847 &start, radius, colors, pos, 3, OH_Drawing_TileMode::CLAMP, nullptr); 848 // add assert 849 EXPECT_NE(effect3, nullptr); 850 // add assert 851 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 852 // 4. Free memory 853 OH_Drawing_MatrixDestroy(matrix); 854 OH_Drawing_ShaderEffectDestroy(effect2); 855 OH_Drawing_ShaderEffectDestroy(effect3); 856 } 857 858 /* 859 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0501 860 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixNull 861 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixNull. 862 * @tc.size : SmallTest 863 * @tc.type : Function 864 * @tc.level : Level 3 865 */ 866 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixNull, Function | SmallTest | Level3) { 867 float pos[] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 868 float radius = 5.0; // 5.0f: gradient color radius 869 OH_Drawing_Point2D start = {100.f, 0}; // 100.f: start point's x 870 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 871 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 872 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with the first parameter set to nullptr and 873 // check the error code using OH_Drawing_ErrorCodeGet 874 OH_Drawing_ShaderEffect *effect = 875 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(nullptr, radius, colors, pos, 3, CLAMP, matrix); 876 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 877 OH_Drawing_ErrorCodeReset(); 878 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with the second parameter set to nullptr 879 OH_Drawing_ShaderEffect *effect2 = 880 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(&start, radius, nullptr, pos, 3, CLAMP, matrix); 881 // add assert 882 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 883 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with the third parameter set to nullptr 884 OH_Drawing_ShaderEffect *effect3 = 885 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(&start, radius, colors, nullptr, 3, CLAMP, matrix); 886 // add assert 887 EXPECT_NE(effect3, nullptr); 888 // 4. Free memory 889 OH_Drawing_MatrixDestroy(matrix); 890 OH_Drawing_ShaderEffectDestroy(effect); 891 OH_Drawing_ShaderEffectDestroy(effect2); 892 OH_Drawing_ShaderEffectDestroy(effect3); 893 } 894 895 /* 896 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0502 897 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixAbnormal 898 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixAbnormal. 899 * @tc.size : SmallTest 900 * @tc.type : Function 901 * @tc.level : Level 3 902 */ 903 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixAbnormal, Function | SmallTest | Level3) { 904 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with centerPt set to negative values 905 OH_Drawing_Point2D centerPt = {-1, -1}; 906 float radius = 5.0; 907 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 908 float pos[] = {0.0f, 0.5f, 1.0f}; 909 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 910 OH_Drawing_ShaderEffect *effect = 911 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 912 // add assert 913 EXPECT_NE(effect, nullptr); 914 // add assert 915 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 916 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with radius set to negative values 917 centerPt = {100, 0}; 918 radius = -5.0; 919 OH_Drawing_ShaderEffect *effect2 = 920 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 921 // add assert 922 EXPECT_NE(effect2, nullptr); 923 // add assert 924 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 925 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with colors set to negative values 926 colors[0] = -0xFFFF0000; 927 OH_Drawing_ShaderEffect *effect3 = 928 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 929 // add assert 930 EXPECT_NE(effect3, nullptr); 931 // add assert 932 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 933 // 4. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with pos set to negative values 934 colors[0] = 0xFFFF0000; 935 pos[0] = -0.1f; 936 OH_Drawing_ShaderEffect *effect4 = 937 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 938 // add assert 939 EXPECT_NE(effect4, nullptr); 940 // add assert 941 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 942 // 5. Free memory 943 OH_Drawing_MatrixDestroy(matrix); 944 OH_Drawing_ShaderEffectDestroy(effect); 945 OH_Drawing_ShaderEffectDestroy(effect2); 946 OH_Drawing_ShaderEffectDestroy(effect3); 947 OH_Drawing_ShaderEffectDestroy(effect4); 948 } 949 950 /* 951 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0503 952 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixMaximum 953 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixMaximum. 954 * @tc.size : SmallTest 955 * @tc.type : Function 956 * @tc.level : Level 3 957 */ 958 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixMaximum, Function | SmallTest | Level3) { 959 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with centerPt set to a large number 960 OH_Drawing_Point2D centerPt = {FLT_MAX, FLT_MAX}; 961 float radius = 5.0; 962 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 963 float pos[] = {0.0f, 0.5f, 1.0f}; 964 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 965 OH_Drawing_ShaderEffect *effect = 966 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 967 // add assert 968 EXPECT_NE(effect, nullptr); 969 // add assert 970 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 971 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with radius set to a large number 972 centerPt = {100, 0}; 973 radius = FLT_MAX; 974 OH_Drawing_ShaderEffect *effect2 = 975 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 976 // add assert 977 EXPECT_NE(effect2, nullptr); 978 // add assert 979 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 980 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with colors set to a large number 981 colors[0] = UINT32_MAX; 982 OH_Drawing_ShaderEffect *effect3 = 983 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 984 // add assert 985 EXPECT_NE(effect3, nullptr); 986 // add assert 987 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 988 // 4. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with pos set to a large number 989 colors[0] = 0xFFFF0000; 990 pos[0] = FLT_MAX; 991 OH_Drawing_ShaderEffect *effect4 = 992 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 993 // add assert 994 EXPECT_NE(effect4, nullptr); 995 // add assert 996 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 997 // 5. Free memory 998 OH_Drawing_MatrixDestroy(matrix); 999 OH_Drawing_ShaderEffectDestroy(effect); 1000 OH_Drawing_ShaderEffectDestroy(effect2); 1001 OH_Drawing_ShaderEffectDestroy(effect3); 1002 OH_Drawing_ShaderEffectDestroy(effect4); 1003 } 1004 1005 /* 1006 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0504 1007 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixMultipleCalls 1008 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixMultipleCalls. 1009 * @tc.size : SmallTest 1010 * @tc.type : Function 1011 * @tc.level : Level 3 1012 */ 1013 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixMultipleCalls, 1014 Function | SmallTest | Level3) { 1015 OH_Drawing_Point2D centerPt = {100, 100}; 1016 float radius = 5.0; 1017 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1018 float pos[] = {0.0f, 0.5f, 1.0f}; 1019 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1020 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix 10 times 1021 for (int i = 0; i < 10; i++) { 1022 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix( 1023 ¢erPt, radius, colors, pos, 3, CLAMP, matrix); 1024 // add assert 1025 EXPECT_NE(effect, nullptr); 1026 // add assert 1027 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1028 // 2. Free memory 1029 OH_Drawing_ShaderEffectDestroy(effect); 1030 } 1031 } 1032 1033 /* 1034 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0600 1035 * @tc.name: testShaderEffectCreateSweepGradientNormal 1036 * @tc.desc: test for testShaderEffectCreateSweepGradientNormal. 1037 * @tc.size : SmallTest 1038 * @tc.type : Function 1039 * @tc.level : Level 0 1040 */ 1041 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientNormal, Function | SmallTest | Level0) { 1042 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ShaderEffectCreateSweepGradient 1043 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1044 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1045 float pos[] = {0, 0.5, 1.0}; 1046 OH_Drawing_TileMode modes[] = { 1047 CLAMP, 1048 REPEAT, 1049 MIRROR, 1050 DECAL, 1051 }; 1052 for (OH_Drawing_TileMode mode : modes) { 1053 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, mode); 1054 EXPECT_NE(effect, nullptr); 1055 // add assert 1056 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1057 OH_Drawing_ShaderEffectDestroy(effect); 1058 } 1059 // 2. Call OH_Drawing_ShaderEffectCreateSweepGradient with pos set to nullptr 1060 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, nullptr, 3, CLAMP); 1061 // add assert 1062 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1063 EXPECT_NE(effect, nullptr); 1064 // 3. Free memory 1065 OH_Drawing_PointDestroy(centerPt); 1066 OH_Drawing_ShaderEffectDestroy(effect); 1067 } 1068 1069 /* 1070 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0601 1071 * @tc.name: testShaderEffectCreateSweepGradientNull 1072 * @tc.desc: test for testShaderEffectCreateSweepGradientNull. 1073 * @tc.size : SmallTest 1074 * @tc.type : Function 1075 * @tc.level : Level 3 1076 */ 1077 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientNull, Function | SmallTest | Level3) { 1078 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1079 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1080 float pos[] = {0, 0.5, 1.0}; 1081 // 1. Call OH_Drawing_ShaderEffectCreateSweepGradient with the first parameter set to nullptr and check the error 1082 // code using OH_Drawing_ErrorCodeGet 1083 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateSweepGradient(nullptr, colors, pos, 3, CLAMP); 1084 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1085 OH_Drawing_ErrorCodeReset(); 1086 // 2. Call OH_Drawing_ShaderEffectCreateSweepGradient with the second parameter set to nullptr and check the error 1087 // code using OH_Drawing_ErrorCodeGet 1088 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, nullptr, pos, 3, CLAMP); 1089 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1090 // 3. Free memory 1091 OH_Drawing_PointDestroy(centerPt); 1092 OH_Drawing_ShaderEffectDestroy(effect); 1093 OH_Drawing_ShaderEffectDestroy(effect2); 1094 } 1095 1096 /* 1097 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0602 1098 * @tc.name: testShaderEffectCreateSweepGradientAbnormal 1099 * @tc.desc: test for testShaderEffectCreateSweepGradientAbnormal. 1100 * @tc.size : SmallTest 1101 * @tc.type : Function 1102 * @tc.level : Level 3 1103 */ 1104 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientAbnormal, Function | SmallTest | Level3) { 1105 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1106 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1107 float pos[] = {0, 0.5, 1.0}; 1108 // 1. Call OH_Drawing_ShaderEffectCreateSweepGradient with centerPt set to negative values 1109 OH_Drawing_Point *centerPt2 = OH_Drawing_PointCreate(-1, -1); 1110 OH_Drawing_ShaderEffect *sweepGradientEffect = 1111 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt2, colors, pos, 3, CLAMP); 1112 // add assert 1113 EXPECT_NE(sweepGradientEffect, nullptr); 1114 // add assert 1115 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1116 // 2. Call OH_Drawing_ShaderEffectCreateSweepGradient with colors set to negative values 1117 colors[0] = -0xFFFF0000; 1118 OH_Drawing_ShaderEffect *sweepGradientEffect2 = 1119 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1120 // add assert 1121 EXPECT_NE(sweepGradientEffect2, nullptr); 1122 // add assert 1123 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1124 // 3. Call OH_Drawing_ShaderEffectCreateSweepGradient with pos set to negative values 1125 colors[0] = 0xFFFF0000; 1126 pos[0] = -0.1f; 1127 OH_Drawing_ShaderEffect *sweepGradientEffect3 = 1128 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1129 // add assert 1130 EXPECT_NE(sweepGradientEffect3, nullptr); 1131 // add assert 1132 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1133 // 4. Free memory 1134 OH_Drawing_PointDestroy(centerPt); 1135 OH_Drawing_PointDestroy(centerPt2); 1136 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect); 1137 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect2); 1138 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect3); 1139 } 1140 1141 /* 1142 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0603 1143 * @tc.name: testShaderEffectCreateSweepGradientMaximum 1144 * @tc.desc: test for testShaderEffectCreateSweepGradientMaximum. 1145 * @tc.size : SmallTest 1146 * @tc.type : Function 1147 * @tc.level : Level 3 1148 */ 1149 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientMaximum, Function | SmallTest | Level3) { 1150 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1151 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1152 float pos[] = {0, 0.5, 1.0}; 1153 // 1. Call OH_Drawing_ShaderEffectCreateSweepGradient with centerPt set to a large number 1154 OH_Drawing_Point *centerPt2 = OH_Drawing_PointCreate(FLT_MAX, FLT_MAX); 1155 OH_Drawing_ShaderEffect *sweepGradientEffect = 1156 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt2, colors, pos, 3, CLAMP); 1157 // add assert 1158 EXPECT_NE(sweepGradientEffect, nullptr); 1159 // add assert 1160 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1161 // 2. Call OH_Drawing_ShaderEffectCreateSweepGradient with colors set to a large number 1162 colors[0] = UINT32_MAX; 1163 OH_Drawing_ShaderEffect *sweepGradientEffect2 = 1164 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1165 // add assert 1166 EXPECT_NE(sweepGradientEffect2, nullptr); 1167 // add assert 1168 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1169 // 3. Call OH_Drawing_ShaderEffectCreateSweepGradient with pos set to a large number 1170 colors[0] = 0xFFFF0000; 1171 pos[0] = FLT_MAX; 1172 OH_Drawing_ShaderEffect *sweepGradientEffect3 = 1173 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1174 // add assert 1175 EXPECT_NE(sweepGradientEffect3, nullptr); 1176 // add assert 1177 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1178 // 4. Free memory 1179 OH_Drawing_PointDestroy(centerPt); 1180 OH_Drawing_PointDestroy(centerPt2); 1181 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect); 1182 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect2); 1183 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect3); 1184 } 1185 1186 /* 1187 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0604 1188 * @tc.name: testShaderEffectCreateSweepGradientMultipleCalls 1189 * @tc.desc: test for testShaderEffectCreateSweepGradientMultipleCalls. 1190 * @tc.size : SmallTest 1191 * @tc.type : Function 1192 * @tc.level : Level 3 1193 */ 1194 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientMultipleCalls, Function | SmallTest | Level3) { 1195 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1196 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1197 float pos[] = {0, 0.5, 1.0}; 1198 // 1. Call OH_Drawing_ShaderEffectCreateSweepGradient 10 times 1199 for (int i = 0; i < 10; i++) { 1200 OH_Drawing_ShaderEffect *sweepGradientEffect = 1201 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1202 // add assert 1203 EXPECT_NE(sweepGradientEffect, nullptr); 1204 // add assert 1205 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1206 // 2. Free memory 1207 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect); 1208 } 1209 } 1210 1211 /* 1212 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0700 1213 * @tc.name: testShaderEffectCreateImageShaderNormal 1214 * @tc.desc: test for testShaderEffectCreateImageShaderNormal. 1215 * @tc.size : SmallTest 1216 * @tc.type : Function 1217 * @tc.level : Level 0 1218 */ 1219 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateImageShaderNormal, Function | SmallTest | Level0) { 1220 // 1. Call OH_Drawing_ImageCreate 1221 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1222 // add assert 1223 EXPECT_NE(image, nullptr); 1224 // 2. Call OH_Drawing_SamplingOptionsCreate 1225 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR); 1226 // add assert 1227 EXPECT_NE(options, nullptr); 1228 // 3. Call OH_Drawing_ShaderEffectCreateImageShader with different OH_Drawing_TileMode values for tileX and tileY 1229 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1230 // add assert 1231 EXPECT_NE(matrix, nullptr); 1232 OH_Drawing_TileMode modes[] = { 1233 CLAMP, 1234 REPEAT, 1235 MIRROR, 1236 DECAL, 1237 }; 1238 for (OH_Drawing_TileMode tileX : modes) { 1239 for (OH_Drawing_TileMode tileY : modes) { 1240 OH_Drawing_ErrorCodeReset(); 1241 OH_Drawing_ShaderEffect *effect = 1242 OH_Drawing_ShaderEffectCreateImageShader(image, tileX, tileY, options, matrix); 1243 // add assert 1244 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1245 EXPECT_NE(effect, nullptr); 1246 OH_Drawing_ShaderEffectDestroy(effect); 1247 } 1248 } 1249 // 4. Call OH_Drawing_ShaderEffectCreateImageShader with null matrix 1250 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, options, nullptr); 1251 // add assert 1252 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1253 EXPECT_NE(effect, nullptr); 1254 // 5. Free memory 1255 OH_Drawing_ImageDestroy(image); 1256 OH_Drawing_SamplingOptionsDestroy(options); 1257 OH_Drawing_ShaderEffectDestroy(effect); 1258 } 1259 1260 /* 1261 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0701 1262 * @tc.name: testShaderEffectCreateImageShaderNull 1263 * @tc.desc: test for testShaderEffectCreateImageShaderNull. 1264 * @tc.size : SmallTest 1265 * @tc.type : Function 1266 * @tc.level : Level 3 1267 */ 1268 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateImageShaderNull, Function | SmallTest | Level3) { 1269 // 1. Call OH_Drawing_ShaderEffectCreateImageShader with the first parameter set to nullptr and check the error 1270 // code using OH_Drawing_ErrorCodeGet 1271 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR); 1272 // add assert 1273 EXPECT_NE(options, nullptr); 1274 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1275 // add assert 1276 EXPECT_NE(matrix, nullptr); 1277 OH_Drawing_ShaderEffectCreateImageShader(nullptr, CLAMP, CLAMP, options, matrix); 1278 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1279 OH_Drawing_ErrorCodeReset(); 1280 // 2. Call OH_Drawing_ShaderEffectCreateImageShader with the fourth parameter set to nullptr and check the error 1281 // code using OH_Drawing_ErrorCodeGet 1282 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1283 OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, nullptr, matrix); 1284 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1285 // 3. Free memory 1286 OH_Drawing_ImageDestroy(image); 1287 OH_Drawing_SamplingOptionsDestroy(options); 1288 OH_Drawing_MatrixDestroy(matrix); 1289 } 1290 1291 /* 1292 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0704 1293 * @tc.name: testShaderEffectCreateImageShaderMultipleCalls 1294 * @tc.desc: test for testShaderEffectCreateImageShaderMultipleCalls. 1295 * @tc.size : SmallTest 1296 * @tc.type : Function 1297 * @tc.level : Level 3 1298 */ 1299 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateImageShaderMultipleCalls, Function | SmallTest | Level3) { 1300 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR); 1301 // add assert 1302 EXPECT_NE(options, nullptr); 1303 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1304 // add assert 1305 EXPECT_NE(matrix, nullptr); 1306 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1307 // add assert 1308 EXPECT_NE(image, nullptr); 1309 // 1. Call OH_Drawing_ShaderEffectCreateImageShader 10 times 1310 for (int i = 0; i < 10; i++) { 1311 OH_Drawing_ShaderEffect *effect = 1312 OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, options, matrix); 1313 EXPECT_NE(effect, nullptr); 1314 OH_Drawing_ShaderEffectDestroy(effect); 1315 } 1316 // 2. Free memory 1317 OH_Drawing_ImageDestroy(image); 1318 OH_Drawing_SamplingOptionsDestroy(options); 1319 OH_Drawing_MatrixDestroy(matrix); 1320 } 1321 1322 /* 1323 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0800 1324 * @tc.name: testShaderEffectCreateTwoPointConicalGradientNormal 1325 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientNormal. 1326 * @tc.size : SmallTest 1327 * @tc.type : Function 1328 * @tc.level : Level 0 1329 */ 1330 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientNormal, Function | SmallTest | Level0) { 1331 OH_Drawing_Point2D startPt = {0, 0}; 1332 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1333 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1334 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1335 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1336 OH_Drawing_TileMode modes[] = { 1337 CLAMP, 1338 REPEAT, 1339 MIRROR, 1340 DECAL, 1341 }; 1342 // 1. Enumerate OH_Drawing_TileMode values for OH_Drawing_ShaderEffectCreateTwoPointConicalGradient, and cover both 1343 // the identity matrix and non-identity matrix for the matrix parameter 1344 for (OH_Drawing_TileMode mode : modes) { 1345 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1346 OH_Drawing_ShaderEffect *effect1 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1347 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, mode, matrix); 1348 EXPECT_NE(effect1, nullptr); 1349 OH_Drawing_ShaderEffectDestroy(effect1); 1350 1351 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 1, 0, 0, 0, 0, 0); 1352 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1353 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, mode, matrix); 1354 EXPECT_NE(effect2, nullptr); 1355 OH_Drawing_ShaderEffectDestroy(effect2); 1356 OH_Drawing_MatrixDestroy(matrix); 1357 } 1358 // 2. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with pos set to nullptr 1359 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1360 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1361 &startPt, startRadius, &endPt, endRadius, colors, nullptr, 3, CLAMP, matrix); 1362 EXPECT_NE(effect, nullptr); 1363 // add assert 1364 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1365 // 3. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with matrix set to nullptr 1366 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1367 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, nullptr); 1368 EXPECT_NE(effect2, nullptr); 1369 // add assert 1370 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1371 // 4. Free memory 1372 OH_Drawing_MatrixDestroy(matrix); 1373 OH_Drawing_ShaderEffectDestroy(effect); 1374 OH_Drawing_ShaderEffectDestroy(effect2); 1375 } 1376 1377 /* 1378 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0801 1379 * @tc.name: testShaderEffectCreateTwoPointConicalGradientNull 1380 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientNull. 1381 * @tc.size : SmallTest 1382 * @tc.type : Function 1383 * @tc.level : Level 3 1384 */ 1385 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientNull, Function | SmallTest | Level3) { 1386 OH_Drawing_Point2D startPt = {0, 0}; 1387 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1388 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1389 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1390 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1391 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1392 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the first parameter set to nullptr and check 1393 // the error code using OH_Drawing_ErrorCodeGet 1394 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1395 nullptr, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1396 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1397 OH_Drawing_ErrorCodeReset(); 1398 // 2. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the second parameter set to nullptr 1399 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1400 &startPt, 0, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1401 // 3. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the third parameter set to nullptr and check 1402 // the error code using OH_Drawing_ErrorCodeGet 1403 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1404 &startPt, startRadius, nullptr, endRadius, colors, pos, 3, CLAMP, matrix); 1405 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1406 OH_Drawing_ErrorCodeReset(); 1407 // 4. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the fourth parameter set to nullptr 1408 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1409 &startPt, startRadius, &endPt, 0, colors, pos, 3, CLAMP, matrix); 1410 // 5. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the fifth parameter set to nullptr and check 1411 // the error code using OH_Drawing_ErrorCodeGet 1412 OH_Drawing_ShaderEffect *effect5 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1413 &startPt, startRadius, &endPt, endRadius, nullptr, pos, 3, CLAMP, matrix); 1414 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1415 // 6. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the sixth parameter set to nullptr 1416 OH_Drawing_ShaderEffect *effect6 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1417 &startPt, startRadius, &endPt, endRadius, colors, nullptr, 3, CLAMP, matrix); 1418 // 7. Free memory 1419 OH_Drawing_MatrixDestroy(matrix); 1420 OH_Drawing_ShaderEffectDestroy(effect); 1421 OH_Drawing_ShaderEffectDestroy(effect2); 1422 OH_Drawing_ShaderEffectDestroy(effect3); 1423 OH_Drawing_ShaderEffectDestroy(effect4); 1424 OH_Drawing_ShaderEffectDestroy(effect5); 1425 OH_Drawing_ShaderEffectDestroy(effect6); 1426 } 1427 1428 /* 1429 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0802 1430 * @tc.name: testShaderEffectCreateTwoPointConicalGradientAbnormal 1431 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientAbnormal. 1432 * @tc.size : SmallTest 1433 * @tc.type : Function 1434 * @tc.level : Level 3 1435 */ 1436 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientAbnormal, Function | SmallTest | Level3) { 1437 OH_Drawing_Point2D startPt = {0, 0}; 1438 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1439 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1440 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1441 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1442 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1443 // add assert 1444 EXPECT_NE(matrix, nullptr); 1445 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with startPt set to a negative value 1446 OH_Drawing_Point2D startPt2 = {-1, -1}; 1447 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1448 &startPt2, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1449 // add assert 1450 EXPECT_NE(effect, nullptr); 1451 // add assert 1452 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1453 // 2. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with startRadius set to a negative value 1454 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1455 &startPt, -5.0f, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1456 // add assert 1457 EXPECT_NE(effect2, nullptr); 1458 // add assert 1459 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1460 // 3. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with endPt set to a negative value 1461 OH_Drawing_Point2D endPt2 = {-1, -1}; 1462 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1463 &startPt, startRadius, &endPt2, endRadius, colors, pos, 3, CLAMP, matrix); 1464 // add assert 1465 EXPECT_NE(effect3, nullptr); 1466 // add assert 1467 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1468 // 4. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with endRadius set to a negative value 1469 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1470 &startPt, startRadius, &endPt, -10.0f, colors, pos, 3, CLAMP, matrix); 1471 // add assert 1472 EXPECT_NE(effect4, nullptr); 1473 // add assert 1474 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1475 // 5. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with colors set to a negative value 1476 colors[0] = -0xFF00FFFF; 1477 OH_Drawing_ShaderEffect *effect5 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1478 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1479 // add assert 1480 EXPECT_NE(effect5, nullptr); 1481 // add assert 1482 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1483 // 6. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with pos set to a negative value 1484 colors[0] = 0xFF00FFFF; 1485 pos[0] = -0.1f; 1486 OH_Drawing_ShaderEffect *effect6 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1487 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1488 // add assert 1489 EXPECT_NE(effect6, nullptr); 1490 // add assert 1491 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1492 // 7. Free memory 1493 OH_Drawing_MatrixDestroy(matrix); 1494 OH_Drawing_ShaderEffectDestroy(effect); 1495 OH_Drawing_ShaderEffectDestroy(effect2); 1496 OH_Drawing_ShaderEffectDestroy(effect3); 1497 OH_Drawing_ShaderEffectDestroy(effect4); 1498 OH_Drawing_ShaderEffectDestroy(effect5); 1499 OH_Drawing_ShaderEffectDestroy(effect6); 1500 } 1501 1502 /* 1503 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0803 1504 * @tc.name: testShaderEffectCreateTwoPointConicalGradientMaximum 1505 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientMaximum. 1506 * @tc.size : SmallTest 1507 * @tc.type : Function 1508 * @tc.level : Level 3 1509 */ 1510 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientMaximum, Function | SmallTest | Level3) { 1511 OH_Drawing_Point2D startPt = {0, 0}; 1512 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1513 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1514 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1515 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1516 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1517 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with startPt set to a maximum value 1518 OH_Drawing_Point2D startPt2 = {FLT_MAX, FLT_MAX}; 1519 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1520 &startPt2, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1521 // add assert 1522 EXPECT_NE(effect, nullptr); 1523 // add assert 1524 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1525 // 2. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with startRadius set to a maximum value 1526 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1527 &startPt, FLT_MAX, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1528 // add assert 1529 EXPECT_NE(effect2, nullptr); 1530 // add assert 1531 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1532 // 3. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with endPt set to a maximum value 1533 OH_Drawing_Point2D endPt2 = {FLT_MAX, FLT_MAX}; 1534 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1535 &startPt, startRadius, &endPt2, endRadius, colors, pos, 3, CLAMP, matrix); 1536 // add assert 1537 EXPECT_NE(effect3, nullptr); 1538 // add assert 1539 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1540 // 4. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with endRadius set to a maximum value 1541 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1542 &startPt, startRadius, &endPt, FLT_MAX, colors, pos, 3, CLAMP, matrix); 1543 // add assert 1544 EXPECT_NE(effect4, nullptr); 1545 // add assert 1546 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1547 // 5. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with colors set to a maximum value 1548 colors[0] = UINT32_MAX; 1549 OH_Drawing_ShaderEffect *effect5 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1550 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1551 // add assert 1552 EXPECT_NE(effect5, nullptr); 1553 // add assert 1554 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1555 // 6. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with pos set to a maximum value 1556 colors[0] = 0xFF00FFFF; 1557 pos[0] = FLT_MAX; 1558 OH_Drawing_ShaderEffect *effect6 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1559 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1560 // add assert 1561 EXPECT_NE(effect6, nullptr); 1562 // add assert 1563 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1564 // 7. Free memory 1565 OH_Drawing_MatrixDestroy(matrix); 1566 OH_Drawing_ShaderEffectDestroy(effect); 1567 OH_Drawing_ShaderEffectDestroy(effect2); 1568 OH_Drawing_ShaderEffectDestroy(effect3); 1569 OH_Drawing_ShaderEffectDestroy(effect4); 1570 OH_Drawing_ShaderEffectDestroy(effect5); 1571 OH_Drawing_ShaderEffectDestroy(effect6); 1572 } 1573 1574 /* 1575 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0804 1576 * @tc.name: testShaderEffectCreateTwoPointConicalGradientMultipleCalls 1577 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientMultipleCalls. 1578 * @tc.size : SmallTest 1579 * @tc.type : Function 1580 * @tc.level : Level 3 1581 */ 1582 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientMultipleCalls, Function | SmallTest | Level3) { 1583 OH_Drawing_Point2D startPt = {0, 0}; 1584 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1585 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1586 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1587 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1588 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1589 // add assert 1590 EXPECT_NE(matrix, nullptr); 1591 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient 10 times 1592 for (int i = 0; i < 10; i++) { 1593 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1594 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1595 // add assert 1596 EXPECT_NE(effect, nullptr); 1597 // add assert 1598 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1599 // 2. Free memory 1600 OH_Drawing_ShaderEffectDestroy(effect); 1601 } 1602 } 1603 1604 /* 1605 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0900 1606 * @tc.name: testShaderEffectDestroyNormal 1607 * @tc.desc: test for testShaderEffectDestroyNormal. 1608 * @tc.size : SmallTest 1609 * @tc.type : Function 1610 * @tc.level : Level 0 1611 */ 1612 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectDestroyNormal, Function | SmallTest | Level0) { 1613 OH_Drawing_Point2D startPt = {0, 0}; 1614 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1615 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1616 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1617 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1618 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1619 // add assert 1620 EXPECT_NE(matrix, nullptr); 1621 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient 1622 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1623 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1624 // add assert 1625 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1626 EXPECT_NE(effect, nullptr); 1627 // 2. Call OH_Drawing_ShaderEffectDestroy 1628 OH_Drawing_ShaderEffectDestroy(effect); 1629 } 1630 1631 /* 1632 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0901 1633 * @tc.name: testShaderEffectDestroyNull 1634 * @tc.desc: test for testShaderEffectDestroyNull. 1635 * @tc.size : SmallTest 1636 * @tc.type : Function 1637 * @tc.level : Level 3 1638 */ 1639 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectDestroyNull, Function | SmallTest | Level3) { 1640 // 1. OH_Drawing_ShaderEffectDestroy parameter is null 1641 OH_Drawing_ShaderEffectDestroy(nullptr); 1642 // add assert 1643 EXPECT_TRUE(true); 1644 } 1645 1646 /* 1647 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1000 1648 * @tc.name: testShaderEffectCreateSweepGradientWithLocalMatrixNormal 1649 * @tc.desc: test for testShaderEffectCreateSweepGradientWithLocalMatrixNormal. 1650 * @tc.size : SmallTest 1651 * @tc.type : Function 1652 * @tc.level : Level 0 1653 */ 1654 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientWithLocalMatrixNormal, 1655 Function | SmallTest | Level0) { 1656 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(200, 200); 1657 uint32_t colors[] = {0xFF00FFFF, 0xFFFFFF00}; 1658 float pos[] = {0.0f, 1.0f}; // 1.0f: gradient color points 1659 uint32_t size = 2; // colors' number 1660 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1661 EXPECT_NE(matrix, nullptr); 1662 OH_Drawing_MatrixSetMatrix(matrix, 1, 1, 1, 1, 1, 1, 1, 1, 1); 1663 // 1. OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix enumeration traversal and sets the unit matrix. 1664 OH_Drawing_ShaderEffect *shaderEffect1 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1665 centerPt, colors, pos, size, OH_Drawing_TileMode::CLAMP, matrix); 1666 EXPECT_NE(shaderEffect1, nullptr); 1667 OH_Drawing_ShaderEffect *shaderEffect2 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1668 centerPt, colors, pos, size, OH_Drawing_TileMode::REPEAT, matrix); 1669 EXPECT_NE(shaderEffect2, nullptr); 1670 OH_Drawing_ShaderEffect *shaderEffect3 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1671 centerPt, colors, pos, size, OH_Drawing_TileMode::MIRROR, matrix); 1672 EXPECT_NE(shaderEffect3, nullptr); 1673 OH_Drawing_ShaderEffect *shaderEffect4 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1674 centerPt, colors, pos, size, OH_Drawing_TileMode::DECAL, matrix); 1675 EXPECT_NE(shaderEffect4, nullptr); 1676 // 2. OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix sets the non-identity matrix. 1677 OH_Drawing_MatrixSetMatrix(matrix, 1, 2, 3, 4, 5, 6, 7, 8, 9); 1678 OH_Drawing_ShaderEffect *shaderEffect5 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1679 centerPt, colors, pos, size, OH_Drawing_TileMode::CLAMP, matrix); 1680 EXPECT_NE(shaderEffect5, nullptr); 1681 // 3.The last parameter of the interface passes to nullptr. 1682 OH_Drawing_ShaderEffect *shaderEffect6 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1683 centerPt, colors, pos, size, OH_Drawing_TileMode::CLAMP, nullptr); 1684 EXPECT_NE(shaderEffect6, nullptr); 1685 // 4. Destroy objects. 1686 OH_Drawing_PointDestroy(centerPt); 1687 OH_Drawing_MatrixDestroy(matrix); 1688 OH_Drawing_ShaderEffectDestroy(shaderEffect1); 1689 OH_Drawing_ShaderEffectDestroy(shaderEffect2); 1690 OH_Drawing_ShaderEffectDestroy(shaderEffect3); 1691 OH_Drawing_ShaderEffectDestroy(shaderEffect4); 1692 OH_Drawing_ShaderEffectDestroy(shaderEffect5); 1693 OH_Drawing_ShaderEffectDestroy(shaderEffect6); 1694 } 1695 1696 /* 1697 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1001 1698 * @tc.name: testShaderEffectCreateSweepGradientWithLocalMatrixNull 1699 * @tc.desc: test for testShaderEffectCreateSweepGradientWithLocalMatrixNull. 1700 * @tc.size : SmallTest 1701 * @tc.type : Function 1702 * @tc.level : Level 3 1703 */ 1704 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientWithLocalMatrixNull, 1705 Function | SmallTest | Level3) { 1706 OH_Drawing_Point *centerPt1 = OH_Drawing_PointCreate(0, 0); 1707 OH_Drawing_Point *centerPt2 = OH_Drawing_PointCreate(200, 200); 1708 uint32_t colors[] = {0xFF00FFFF, 0xFFFFFF00}; 1709 float pos[] = {0.0f, 1.0f}; // 1.0f: gradient color points 1710 uint32_t size = 2; // colors' number 1711 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1712 EXPECT_NE(matrix, nullptr); 1713 OH_Drawing_MatrixSetMatrix(matrix, 1, 1, 1, 1, 1, 1, 1, 1, 1); 1714 // 1.The first parameter of the interface passes to nullptr. 1715 OH_Drawing_ShaderEffect *shaderEffect1 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1716 nullptr, colors, pos, size, OH_Drawing_TileMode::CLAMP, matrix); 1717 EXPECT_EQ(shaderEffect1, nullptr); 1718 // 2.The first parameter of the interface passes to 0. 1719 OH_Drawing_ShaderEffect *shaderEffect2 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1720 centerPt1, colors, pos, size, OH_Drawing_TileMode::REPEAT, matrix); 1721 EXPECT_NE(shaderEffect2, nullptr); 1722 // 3.The second parameter of the interface passes to nullptr. 1723 OH_Drawing_ShaderEffect *shaderEffect3 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1724 centerPt2, nullptr, pos, size, OH_Drawing_TileMode::MIRROR, matrix); 1725 EXPECT_EQ(shaderEffect3, nullptr); 1726 // 4.The third parameter of the interface passes to nullptr. 1727 OH_Drawing_ShaderEffect *shaderEffect4 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1728 centerPt2, colors, nullptr, size, OH_Drawing_TileMode::DECAL, matrix); 1729 EXPECT_NE(shaderEffect4, nullptr); 1730 // 5.The forth parameter of the interface passes to nullptr. 1731 OH_Drawing_ShaderEffect *shaderEffect5 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1732 centerPt2, colors, pos, 0, OH_Drawing_TileMode::CLAMP, matrix); 1733 EXPECT_NE(shaderEffect5, nullptr); 1734 // 6.The last parameter of the interface passes to nullptr. 1735 OH_Drawing_ShaderEffect *shaderEffect6 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1736 centerPt2, colors, pos, size, OH_Drawing_TileMode::CLAMP, nullptr); 1737 EXPECT_NE(shaderEffect6, nullptr); 1738 // 7. Destroy objects. 1739 OH_Drawing_PointDestroy(centerPt1); 1740 OH_Drawing_PointDestroy(centerPt2); 1741 OH_Drawing_MatrixDestroy(matrix); 1742 OH_Drawing_ShaderEffectDestroy(shaderEffect1); 1743 OH_Drawing_ShaderEffectDestroy(shaderEffect2); 1744 OH_Drawing_ShaderEffectDestroy(shaderEffect3); 1745 OH_Drawing_ShaderEffectDestroy(shaderEffect4); 1746 OH_Drawing_ShaderEffectDestroy(shaderEffect5); 1747 OH_Drawing_ShaderEffectDestroy(shaderEffect6); 1748 } 1749 1750 /* 1751 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1002 1752 * @tc.name: testShaderEffectCreateSweepGradientWithLocalMatrixAbnormal 1753 * @tc.desc: test for testShaderEffectCreateSweepGradientWithLocalMatrixAbnormal. 1754 * @tc.size : SmallTest 1755 * @tc.type : Function 1756 * @tc.level : Level 3 1757 */ 1758 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientWithLocalMatrixAbnormal, 1759 Function | SmallTest | Level3) { 1760 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(200, 200); 1761 uint32_t colors1[] = {0xFF00FFFF, 0xFFFFFF00}; 1762 uint32_t colors2[] = {0xFFFFFFFF}; 1763 float pos1[] = {0.0f, 1.0f}; // 1.0f: gradient color points 1764 float pos2[] = {-1.0f}; // -1.0f: gradient color points 1765 float pos3[] = {0xFFFFFFFF}; 1766 uint32_t size = 2; // colors' number 1767 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1768 EXPECT_NE(matrix, nullptr); 1769 OH_Drawing_MatrixSetMatrix(matrix, 1, 1, 1, 1, 1, 1, 1, 1, 1); 1770 // 1.The second parameter of the interface passes to maximum value. 1771 OH_Drawing_ShaderEffect *shaderEffect1 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1772 centerPt, colors2, pos1, size, OH_Drawing_TileMode::CLAMP, matrix); 1773 EXPECT_NE(shaderEffect1, nullptr); 1774 // 2.The third parameter of the interface passes to negative value. 1775 OH_Drawing_ShaderEffect *shaderEffect2 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1776 centerPt, colors1, pos2, size, OH_Drawing_TileMode::REPEAT, matrix); 1777 EXPECT_NE(shaderEffect2, nullptr); 1778 // 3.The third parameter of the interface passes to maximum value. 1779 OH_Drawing_ShaderEffect *shaderEffect3 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1780 centerPt, colors1, pos3, size, OH_Drawing_TileMode::MIRROR, matrix); 1781 EXPECT_NE(shaderEffect3, nullptr); 1782 // 4.The fourth parameter of the interface does not match the second parameter. 1783 OH_Drawing_ShaderEffect *shaderEffect4 = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1784 centerPt, colors1, pos1, 3, OH_Drawing_TileMode::CLAMP, matrix); 1785 EXPECT_NE(shaderEffect4, nullptr); 1786 // 5. Destroy objects. 1787 OH_Drawing_PointDestroy(centerPt); 1788 OH_Drawing_MatrixDestroy(matrix); 1789 OH_Drawing_ShaderEffectDestroy(shaderEffect1); 1790 OH_Drawing_ShaderEffectDestroy(shaderEffect2); 1791 OH_Drawing_ShaderEffectDestroy(shaderEffect3); 1792 OH_Drawing_ShaderEffectDestroy(shaderEffect4); 1793 } 1794 1795 /* 1796 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1003 1797 * @tc.name: testShaderEffectCreateSweepGradientWithLocalMatrixMultipleCalls 1798 * @tc.desc: test for testShaderEffectCreateSweepGradientWithLocalMatrixMultipleCalls. 1799 * @tc.size : SmallTest 1800 * @tc.type : Function 1801 * @tc.level : Level 3 1802 */ 1803 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientWithLocalMatrixMultipleCalls, 1804 Function | SmallTest | Level3) { 1805 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(200, 200); 1806 uint32_t colors[] = {0xFF00FFFF, 0xFFFFFF00}; 1807 float pos[] = {0.0f, 1.0f}; // 1.0f: gradient color points 1808 uint32_t size = 2; // colors' number 1809 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1810 EXPECT_NE(matrix, nullptr); 1811 OH_Drawing_MatrixSetMatrix(matrix, 1, 1, 1, 1, 1, 1, 1, 1, 1); 1812 // 1.OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix is called multiple times. 1813 for (int i = 0; i < 10; i++) { 1814 OH_Drawing_ShaderEffect *shaderEffect = OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix( 1815 centerPt, colors, pos, size, OH_Drawing_TileMode::CLAMP, matrix); 1816 EXPECT_NE(shaderEffect, nullptr); 1817 OH_Drawing_ShaderEffectDestroy(shaderEffect); 1818 } 1819 // 2. Destroy objects. 1820 OH_Drawing_PointDestroy(centerPt); 1821 OH_Drawing_MatrixDestroy(matrix); 1822 } 1823 1824 /* 1825 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1100 1826 * @tc.name: testShaderEffectCreateComposeEnumTraversal 1827 * @tc.desc: test for testShaderEffectCreateComposeEnumTraversal. 1828 * @tc.size : SmallTest 1829 * @tc.type : Function 1830 * @tc.level : Level 0 1831 */ 1832 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateComposeEnumTraversal, 1833 Function | SmallTest | Level0) { 1834 std::vector<OH_Drawing_BlendMode > blendMode = { 1835 BLEND_MODE_CLEAR, 1836 BLEND_MODE_SRC, 1837 BLEND_MODE_DST, 1838 BLEND_MODE_SRC_OVER, 1839 BLEND_MODE_DST_OVER, 1840 BLEND_MODE_SRC_IN, 1841 BLEND_MODE_DST_IN, 1842 BLEND_MODE_SRC_OUT, 1843 BLEND_MODE_DST_OUT, 1844 BLEND_MODE_SRC_ATOP, 1845 BLEND_MODE_DST_ATOP, 1846 BLEND_MODE_XOR, 1847 BLEND_MODE_PLUS, 1848 BLEND_MODE_MODULATE, 1849 BLEND_MODE_SCREEN, 1850 BLEND_MODE_OVERLAY, 1851 BLEND_MODE_DARKEN, 1852 BLEND_MODE_LIGHTEN, 1853 BLEND_MODE_COLOR_DODGE, 1854 BLEND_MODE_COLOR_BURN, 1855 BLEND_MODE_HARD_LIGHT, 1856 BLEND_MODE_SOFT_LIGHT, 1857 BLEND_MODE_DIFFERENCE, 1858 BLEND_MODE_EXCLUSION, 1859 BLEND_MODE_MULTIPLY, 1860 BLEND_MODE_HUE, 1861 BLEND_MODE_SATURATION, 1862 BLEND_MODE_COLOR, 1863 BLEND_MODE_LUMINOSITY 1864 }; 1865 OH_Drawing_ShaderEffect *src = OH_Drawing_ShaderEffectCreateColorShader(0xFF00FF00); 1866 OH_Drawing_ShaderEffect *dst = OH_Drawing_ShaderEffectCreateColorShader(0xFF0000FF); 1867 // 1.OH_Drawing_ShaderEffectCreateCompose passes parameters normally and traversals enumeration. 1868 for (int i = 0; i < blendMode.size(); i++) { 1869 OH_Drawing_ShaderEffect *shaderEffect = OH_Drawing_ShaderEffectCreateCompose(dst, src, blendMode[i]); 1870 EXPECT_NE(shaderEffect, nullptr); 1871 OH_Drawing_ShaderEffectDestroy(shaderEffect); 1872 } 1873 // 2. Destroy objects. 1874 OH_Drawing_ShaderEffectDestroy(src); 1875 OH_Drawing_ShaderEffectDestroy(dst); 1876 } 1877 1878 /* 1879 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1101 1880 * @tc.name: testShaderEffectCreateComposeNull 1881 * @tc.desc: test for testShaderEffectCreateComposeNull. 1882 * @tc.size : SmallTest 1883 * @tc.type : Function 1884 * @tc.level : Level 3 1885 */ 1886 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateComposeNull, 1887 Function | SmallTest | Level3) { 1888 OH_Drawing_ShaderEffect *src = OH_Drawing_ShaderEffectCreateColorShader(0xFF00FF00); 1889 OH_Drawing_ShaderEffect *dst = OH_Drawing_ShaderEffectCreateColorShader(0xFF0000FF); 1890 // 1. The first parameter of the interface passes to nullptr. 1891 OH_Drawing_ShaderEffect *shaderEffect1 = 1892 OH_Drawing_ShaderEffectCreateCompose(nullptr, src, OH_Drawing_BlendMode::BLEND_MODE_SRC); 1893 EXPECT_EQ(shaderEffect1, nullptr); 1894 // 2. The second parameter of the interface passes to nullptr. 1895 OH_Drawing_ShaderEffect *shaderEffect2 = 1896 OH_Drawing_ShaderEffectCreateCompose(dst, nullptr, OH_Drawing_BlendMode::BLEND_MODE_SRC); 1897 EXPECT_EQ(shaderEffect2, nullptr); 1898 // 3. Destroy objects. 1899 OH_Drawing_ShaderEffectDestroy(src); 1900 OH_Drawing_ShaderEffectDestroy(dst); 1901 OH_Drawing_ShaderEffectDestroy(shaderEffect1); 1902 OH_Drawing_ShaderEffectDestroy(shaderEffect2); 1903 } 1904 1905 /* 1906 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1102 1907 * @tc.name: testShaderEffectCreateComposeMultipleCalls 1908 * @tc.desc: test for testShaderEffectCreateComposeMultipleCalls. 1909 * @tc.size : SmallTest 1910 * @tc.type : Function 1911 * @tc.level : Level 3 1912 */ 1913 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateComposeMultipleCalls, 1914 Function | SmallTest | Level3) { 1915 OH_Drawing_ShaderEffect *src = OH_Drawing_ShaderEffectCreateColorShader(0xFF00FF00); 1916 OH_Drawing_ShaderEffect *dst = OH_Drawing_ShaderEffectCreateColorShader(0xFF0000FF); 1917 // 1. The interface is called multiple times. 1918 for (int i = 0; i < 10; i++) { 1919 OH_Drawing_ShaderEffect *shaderEffect = 1920 OH_Drawing_ShaderEffectCreateCompose(dst, src, OH_Drawing_BlendMode::BLEND_MODE_SRC); 1921 EXPECT_NE(shaderEffect, nullptr); 1922 OH_Drawing_ShaderEffectDestroy(shaderEffect); 1923 } 1924 // 2. Destroy objects. 1925 OH_Drawing_ShaderEffectDestroy(src); 1926 OH_Drawing_ShaderEffectDestroy(dst); 1927 } 1928 1929 /* 1930 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1200 1931 * @tc.name: testShaderEffectCreatePixelMapShaderNormal 1932 * @tc.desc: test for testShaderEffectCreatePixelMapShaderNormal 1933 * @tc.size : SmallTest 1934 * @tc.type : Function 1935 * @tc.level : Level 0 1936 */ 1937 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreatePixelMapShaderNormal, Function | SmallTest | Level0) { 1938 uint32_t imageWidth = 200; 1939 uint32_t imageHeight = 200; 1940 OH_Pixelmap_InitializationOptions* createOps = nullptr; 1941 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 1942 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 1943 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 1944 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 1945 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 1946 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 1947 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 1948 void* buffer = malloc(bufferSize); 1949 if (buffer == nullptr) { 1950 return; 1951 } 1952 for (int i = 0; i < imageWidth * imageHeight; i++) { 1953 ((uint32_t*)buffer)[i] = 0xFFFF00FF; 1954 } 1955 OH_PixelmapNative* pixelMapNative = nullptr; 1956 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)buffer, bufferSize, createOps, &pixelMapNative); 1957 OH_Drawing_SamplingOptions* samplingOptions = 1958 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 1959 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 1960 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1961 // 1. The interface of OH_Drawing_ShaderEffectCreatePixelMapShader is called normally. 1962 OH_Drawing_ShaderEffect *shaderEffect = OH_Drawing_ShaderEffectCreatePixelMapShader( 1963 pixelMap, OH_Drawing_TileMode::CLAMP, OH_Drawing_TileMode::CLAMP, samplingOptions, matrix); 1964 EXPECT_NE(shaderEffect, nullptr); 1965 // 2. Destroy objects. 1966 OH_Drawing_MatrixDestroy(matrix); 1967 OH_Drawing_ShaderEffectDestroy(shaderEffect); 1968 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 1969 OH_Drawing_PixelMapDissolve(pixelMap); 1970 OH_PixelmapNative_Release(pixelMapNative); 1971 OH_PixelmapInitializationOptions_Release(createOps); 1972 free(buffer); 1973 } 1974 1975 /* 1976 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1201 1977 * @tc.name: testShaderEffectCreatePixelMapShaderNull 1978 * @tc.desc: test for testShaderEffectCreatePixelMapShaderNull 1979 * @tc.size : SmallTest 1980 * @tc.type : Function 1981 * @tc.level : Level 3 1982 */ 1983 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreatePixelMapShaderNull, Function | SmallTest | Level3) { 1984 uint32_t imageWidth = 200; 1985 uint32_t imageHeight = 200; 1986 OH_Pixelmap_InitializationOptions* createOps = nullptr; 1987 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 1988 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 1989 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 1990 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 1991 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 1992 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 1993 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 1994 void* buffer = malloc(bufferSize); 1995 if (buffer == nullptr) { 1996 return; 1997 } 1998 for (int i = 0; i < imageWidth * imageHeight; i++) { 1999 ((uint32_t*)buffer)[i] = 0xFFFF00FF; 2000 } 2001 OH_PixelmapNative* pixelMapNative = nullptr; 2002 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)buffer, bufferSize, createOps, &pixelMapNative); 2003 OH_Drawing_SamplingOptions* samplingOptions = 2004 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 2005 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 2006 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 2007 // 1. Pass each interface parameter nullptr for verification one by one. 2008 OH_Drawing_ShaderEffect *shaderEffect = OH_Drawing_ShaderEffectCreatePixelMapShader( 2009 nullptr, OH_Drawing_TileMode::CLAMP, OH_Drawing_TileMode::CLAMP, samplingOptions, matrix); 2010 EXPECT_EQ(shaderEffect, nullptr); 2011 shaderEffect = OH_Drawing_ShaderEffectCreatePixelMapShader( 2012 pixelMap, OH_Drawing_TileMode::CLAMP, OH_Drawing_TileMode::CLAMP, nullptr, matrix); 2013 EXPECT_EQ(shaderEffect, nullptr); 2014 shaderEffect = OH_Drawing_ShaderEffectCreatePixelMapShader( 2015 pixelMap, OH_Drawing_TileMode::CLAMP, OH_Drawing_TileMode::CLAMP, samplingOptions, nullptr); 2016 EXPECT_NE(shaderEffect, nullptr); 2017 // 2. Destroy objects. 2018 OH_Drawing_MatrixDestroy(matrix); 2019 OH_Drawing_ShaderEffectDestroy(shaderEffect); 2020 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 2021 OH_Drawing_PixelMapDissolve(pixelMap); 2022 OH_PixelmapNative_Release(pixelMapNative); 2023 OH_PixelmapInitializationOptions_Release(createOps); 2024 free(buffer); 2025 } 2026 2027 /* 2028 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_1202 2029 * @tc.name: testShaderEffectCreatePixelMapShaderMultiCalls 2030 * @tc.desc: test for testShaderEffectCreatePixelMapShaderMultiCalls 2031 * @tc.size : SmallTest 2032 * @tc.type : Function 2033 * @tc.level : Level 3 2034 */ 2035 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreatePixelMapShaderMultiCalls, Function | SmallTest | Level3) { 2036 uint32_t imageWidth = 200; 2037 uint32_t imageHeight = 200; 2038 OH_Pixelmap_InitializationOptions* createOps = nullptr; 2039 auto ret = OH_PixelmapInitializationOptions_Create(&createOps); 2040 OH_PixelmapInitializationOptions_SetWidth(createOps, imageWidth); 2041 OH_PixelmapInitializationOptions_SetHeight(createOps, imageHeight); 2042 OH_PixelmapInitializationOptions_SetPixelFormat(createOps, 3); // 3 is RGBA fromat 2043 OH_PixelmapInitializationOptions_SetSrcPixelFormat(createOps, 3); // 3 is RGBA fromat 2044 OH_PixelmapInitializationOptions_SetAlphaType(createOps, 2); // 2 is ALPHA_FORMAT_PREMUL 2045 size_t bufferSize = imageWidth * imageHeight * 4; // 4 for test 2046 void* buffer = malloc(bufferSize); 2047 if (buffer == nullptr) { 2048 return; 2049 } 2050 for (int i = 0; i < imageWidth * imageHeight; i++) { 2051 ((uint32_t*)buffer)[i] = 0xFFFF00FF; 2052 } 2053 OH_PixelmapNative* pixelMapNative = nullptr; 2054 ret = OH_PixelmapNative_CreatePixelmap((uint8_t*)buffer, bufferSize, createOps, &pixelMapNative); 2055 OH_Drawing_SamplingOptions* samplingOptions = 2056 OH_Drawing_SamplingOptionsCreate(FILTER_MODE_NEAREST, MIPMAP_MODE_NEAREST); 2057 OH_Drawing_PixelMap* pixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(pixelMapNative); 2058 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 2059 // 1. The interface of OH_Drawing_ShaderEffectCreatePixelMapShader is called 10 times. 2060 OH_Drawing_ShaderEffect *shaderEffect = nullptr; 2061 for (int i = 0; i < 10; i++) { 2062 shaderEffect = OH_Drawing_ShaderEffectCreatePixelMapShader( 2063 pixelMap, OH_Drawing_TileMode::CLAMP, OH_Drawing_TileMode::CLAMP, samplingOptions, matrix); 2064 EXPECT_NE(shaderEffect, nullptr); 2065 } 2066 // 2. Destroy objects. 2067 OH_Drawing_MatrixDestroy(matrix); 2068 OH_Drawing_ShaderEffectDestroy(shaderEffect); 2069 OH_Drawing_SamplingOptionsDestroy(samplingOptions); 2070 OH_Drawing_PixelMapDissolve(pixelMap); 2071 OH_PixelmapNative_Release(pixelMapNative); 2072 OH_PixelmapInitializationOptions_Release(createOps); 2073 free(buffer); 2074 } 2075 } // namespace Drawing 2076 } // namespace Rosen 2077 } // namespace OHOS