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 30 using namespace testing; 31 using namespace testing::ext; 32 33 namespace OHOS { 34 namespace Rosen { 35 namespace Drawing { 36 class DrawingNativeShaderEffectTest : public testing::Test { 37 protected: 38 // 在每个测试用例执行前调用 SetUp()39 void SetUp() override 40 { 41 // 设置代码 42 std::cout << "DrawingNativeShaderEffectTest Setup code called before each test case." << std::endl; 43 OH_Drawing_ErrorCodeReset(); 44 std::cout << "DrawingNativeShaderEffectTest errorCodeReset before each test case." << std::endl; 45 } TearDown()46 void TearDown() override 47 { 48 std::cout << "DrawingNativeShaderEffectTest Setup code called after each test case." << std::endl; 49 OH_Drawing_ErrorCodeReset(); 50 std::cout << "DrawingNativeShaderEffectTest errorCodeReset after each test case." << std::endl; 51 } 52 }; 53 54 /* 55 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0100 56 * @tc.name: testShaderEffectCreateColorShaderNormal 57 * @tc.desc: test for testShaderEffectCreateColorShaderNormal. 58 * @tc.size : SmallTest 59 * @tc.type : Function 60 * @tc.level : Level 0 61 */ 62 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderNormal, TestSize.Level0) { 63 // 1. OH_Drawing_ShaderEffectCreateColorShader 64 uint32_t color = 0xFFFF0000; 65 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(color); 66 // add assert 67 EXPECT_NE(colorShaderEffect, nullptr); 68 // 2. Free memory 69 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 70 } 71 72 /* 73 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0101 74 * @tc.name: testShaderEffectCreateColorShaderNull 75 * @tc.desc: test for testShaderEffectCreateColorShaderNull. 76 * @tc.size : SmallTest 77 * @tc.type : Function 78 * @tc.level : Level 3 79 */ 80 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderNull, TestSize.Level3) { 81 // 1. OH_Drawing_ShaderEffectCreateColorShader with empty parameter 82 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(0); 83 // add assert 84 EXPECT_NE(colorShaderEffect, nullptr); 85 // 2. Free memory 86 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 87 } 88 89 /* 90 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0102 91 * @tc.name: testShaderEffectCreateColorShaderAbnormal 92 * @tc.desc: test for testShaderEffectCreateColorShaderAbnormal. 93 * @tc.size : SmallTest 94 * @tc.type : Function 95 * @tc.level : Level 3 96 */ 97 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderAbnormal, TestSize.Level3) { 98 // 1. OH_Drawing_ShaderEffectCreateColorShader with a negative parameter 99 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(-0xFFFF0000); 100 // add assert 101 EXPECT_NE(colorShaderEffect, nullptr); 102 // 2. Free memory 103 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 104 } 105 106 /* 107 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0103 108 * @tc.name: testShaderEffectCreateColorShaderMaximum 109 * @tc.desc: test for testShaderEffectCreateColorShaderMaximum. 110 * @tc.size : SmallTest 111 * @tc.type : Function 112 * @tc.level : Level 3 113 */ 114 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderMaximum, TestSize.Level3) { 115 // 1. OH_Drawing_ShaderEffectCreateColorShader with maximum value as parameter 116 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(UINT32_MAX); 117 // add assert 118 EXPECT_NE(colorShaderEffect, nullptr); 119 // 2. Free memory 120 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 121 } 122 123 /* 124 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0104 125 * @tc.name: testShaderEffectCreateColorShaderMultipleCalls 126 * @tc.desc: test for testShaderEffectCreateColorShaderMultipleCalls. 127 * @tc.size : SmallTest 128 * @tc.type : Function 129 * @tc.level : Level 3 130 */ 131 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateColorShaderMultipleCalls, TestSize.Level3) { 132 // 1. Call OH_Drawing_ShaderEffectCreateColorShader 10 times with different colors 133 for (int i = 0; i < 10; i++) { 134 OH_Drawing_ShaderEffect *colorShaderEffect = OH_Drawing_ShaderEffectCreateColorShader(0xFF000000 + i); 135 // add assert 136 EXPECT_NE(colorShaderEffect, nullptr); 137 // 2. Free memory 138 OH_Drawing_ShaderEffectDestroy(colorShaderEffect); 139 } 140 } 141 142 /* 143 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0200 144 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixNormal 145 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixNormal. 146 * @tc.size : SmallTest 147 * @tc.type : Function 148 * @tc.level : Level 0 149 */ 150 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixNormal, TestSize.Level0) { 151 OH_Drawing_Point2D start = {0, 0}; 152 OH_Drawing_Point2D end = {100.f, 0}; 153 float pos[3] = {0.0f, 0.5f, 1.0f}; 154 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 155 OH_Drawing_TileMode modes[] = { 156 CLAMP, 157 REPEAT, 158 MIRROR, 159 DECAL, 160 }; 161 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 162 // add assert 163 EXPECT_NE(matrix, nullptr); 164 // 1. Enumerate OH_Drawing_TileMode values for OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix, and test 165 // with both identity and non-identity matrix 166 for (OH_Drawing_TileMode mode : modes) { 167 OH_Drawing_ShaderEffect *linearGradientEffect = 168 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, mode, matrix); 169 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 170 } 171 172 // 2. Test OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with pos set to NULL 173 OH_Drawing_ShaderEffect *linearGradientEffect = OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix( 174 &start, &end, colors, nullptr, 3, OH_Drawing_TileMode::CLAMP, matrix); 175 // add assert 176 EXPECT_NE(linearGradientEffect, nullptr); 177 // add assert 178 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 179 // 3. Test OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with matrix set to NULL 180 OH_Drawing_ShaderEffect *linearGradientEffect2 = OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix( 181 &start, &end, colors, pos, 3, OH_Drawing_TileMode::CLAMP, nullptr); 182 // add assert 183 EXPECT_NE(linearGradientEffect2, nullptr); 184 // add assert 185 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 186 187 // 4. Free memory 188 OH_Drawing_MatrixDestroy(matrix); 189 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 190 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 191 } 192 193 /* 194 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0201 195 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixNull 196 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixNull. 197 * @tc.size : SmallTest 198 * @tc.type : Function 199 * @tc.level : Level 3 200 */ 201 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixNull, TestSize.Level3) { 202 OH_Drawing_Point2D start = {0, 0}; 203 OH_Drawing_Point2D end = {100.f, 0}; 204 float pos[3] = {0.0f, 0.5f, 1.0f}; 205 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 206 OH_Drawing_TileMode modes[] = { 207 CLAMP, 208 REPEAT, 209 MIRROR, 210 DECAL, 211 }; 212 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 213 // add assert 214 EXPECT_NE(matrix, nullptr); 215 // 1. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with the first parameter set to nullptr, check the 216 // error code using OH_Drawing_ErrorCodeGet 217 OH_Drawing_ShaderEffect *effect1 = 218 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(nullptr, &end, colors, pos, 3, modes[0], matrix); 219 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 220 OH_Drawing_ErrorCodeReset(); 221 // 2. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with the second parameter set to nullptr, check the 222 // error code using OH_Drawing_ErrorCodeGet 223 OH_Drawing_ShaderEffect *effect2 = 224 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, nullptr, colors, pos, 3, modes[0], matrix); 225 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 226 OH_Drawing_ErrorCodeReset(); 227 // 3. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix with the third parameter set to nullptr, check the 228 // error code using OH_Drawing_ErrorCodeGet 229 OH_Drawing_ShaderEffect *effect3 = 230 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, nullptr, pos, 3, modes[0], matrix); 231 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 232 // 4. Free memory 233 OH_Drawing_MatrixDestroy(matrix); 234 OH_Drawing_ShaderEffectDestroy(effect1); 235 OH_Drawing_ShaderEffectDestroy(effect2); 236 OH_Drawing_ShaderEffectDestroy(effect3); 237 } 238 239 /* 240 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0202 241 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixAbnormal 242 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixAbnormal. 243 * @tc.size : SmallTest 244 * @tc.type : Function 245 * @tc.level : Level 3 246 */ 247 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixAbnormal, TestSize.Level3) { 248 OH_Drawing_Point2D start = {0, 0}; 249 OH_Drawing_Point2D end = {100.f, 0}; 250 float pos[3] = {0.0f, 0.5f, 1.0f}; 251 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 252 OH_Drawing_TileMode modes[] = { 253 CLAMP, 254 REPEAT, 255 MIRROR, 256 DECAL, 257 }; 258 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 259 // add assert 260 EXPECT_NE(matrix, nullptr); 261 // 1. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with negative values for startPt 262 start = {-1, -1}; 263 OH_Drawing_ShaderEffect *linearGradientEffect = 264 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 265 // add assert 266 EXPECT_NE(linearGradientEffect, nullptr); 267 // add assert 268 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 269 // 2. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with negative values for endPt 270 start = {0, 0}; 271 end = {-1, -1}; 272 OH_Drawing_ShaderEffect *linearGradientEffect2 = 273 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 274 // add assert 275 EXPECT_NE(linearGradientEffect2, nullptr); 276 // add assert 277 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 278 // 3. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with negative values for colors 279 colors[0] = -0xFF00FFFF; 280 OH_Drawing_ShaderEffect *linearGradientEffect3 = 281 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 282 // add assert 283 EXPECT_NE(linearGradientEffect3, nullptr); 284 // add assert 285 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 286 // 4. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with negative values for pos 287 colors[0] = 0xFF00FFFF; 288 pos[0] = -0.1f; 289 OH_Drawing_ShaderEffect *linearGradientEffect4 = 290 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 291 // add assert 292 EXPECT_NE(linearGradientEffect4, nullptr); 293 // add assert 294 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 295 // 5. Free memory 296 OH_Drawing_MatrixDestroy(matrix); 297 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 298 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 299 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 300 OH_Drawing_ShaderEffectDestroy(linearGradientEffect4); 301 } 302 303 /* 304 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0203 305 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixMaximum 306 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixMaximum. 307 * @tc.size : SmallTest 308 * @tc.type : Function 309 * @tc.level : Level 3 310 */ 311 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixMaximum, TestSize.Level3) { 312 OH_Drawing_Point2D start = {0, 0}; 313 OH_Drawing_Point2D end = {100.f, 0}; 314 float pos[3] = {0.0f, 0.5f, 1.0f}; 315 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 316 OH_Drawing_TileMode modes[] = { 317 CLAMP, 318 REPEAT, 319 MIRROR, 320 DECAL, 321 }; 322 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 323 // add assert 324 EXPECT_NE(matrix, nullptr); 325 // 1. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with startPt set to maximum value 326 start = {FLT_MAX, FLT_MAX}; 327 OH_Drawing_ShaderEffect *linearGradientEffect = 328 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 329 // add assert 330 EXPECT_NE(linearGradientEffect, nullptr); 331 // add assert 332 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 333 // 2. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with endPt set to maximum value 334 start = {0, 0}; 335 end = {FLT_MAX, FLT_MAX}; 336 OH_Drawing_ShaderEffect *linearGradientEffect2 = 337 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 338 // add assert 339 EXPECT_NE(linearGradientEffect2, nullptr); 340 // add assert 341 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 342 // 3. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with colors set to maximum value 343 colors[0] = UINT32_MAX; 344 OH_Drawing_ShaderEffect *linearGradientEffect3 = 345 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 346 // add assert 347 EXPECT_NE(linearGradientEffect3, nullptr); 348 // add assert 349 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 350 // 4. OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix interface with pos set to maximum value 351 colors[0] = 0xFF00FFFF; 352 pos[0] = FLT_MAX; 353 OH_Drawing_ShaderEffect *linearGradientEffect4 = 354 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, modes[0], matrix); 355 // add assert 356 EXPECT_NE(linearGradientEffect4, nullptr); 357 // add assert 358 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 359 // 5. Free memory 360 OH_Drawing_MatrixDestroy(matrix); 361 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 362 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 363 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 364 OH_Drawing_ShaderEffectDestroy(linearGradientEffect4); 365 } 366 367 /* 368 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0204 369 * @tc.name: testShaderEffectCreateLinearGradientWithLocalMatrixMultipleCalls 370 * @tc.desc: test for testShaderEffectCreateLinearGradientWithLocalMatrixMultipleCalls. 371 * @tc.size : SmallTest 372 * @tc.type : Function 373 * @tc.level : Level 3 374 */ 375 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradientWithLocalMatrixMultipleCalls, 376 TestSize.Level3) { 377 OH_Drawing_Point2D start = {0, 0}; 378 OH_Drawing_Point2D end = {100.f, 0}; 379 float pos[3] = {0.0f, 0.5f, 1.0f}; 380 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 381 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 382 // 1. Call OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix 10 times 383 for (int i = 0; i < 10; i++) { 384 OH_Drawing_ShaderEffect *linearGradientEffect = 385 OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(&start, &end, colors, pos, 3, CLAMP, matrix); 386 // add assert 387 EXPECT_NE(linearGradientEffect, nullptr); 388 // add assert 389 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 390 // 2. Free memory 391 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 392 } 393 } 394 395 /* 396 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0300 397 * @tc.name: testShaderEffectCreateLinearGradienNormal 398 * @tc.desc: test for testShaderEffectCreateLinearGradienNormal. 399 * @tc.size : SmallTest 400 * @tc.type : Function 401 * @tc.level : Level 0 402 */ 403 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienNormal, TestSize.Level0) { 404 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ShaderEffectCreateLinearGradient 405 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 406 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 407 float pos[3] = {0.0f, 0.5f, 1.0f}; 408 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 409 OH_Drawing_TileMode modes[] = { 410 CLAMP, 411 REPEAT, 412 MIRROR, 413 DECAL, 414 }; 415 for (OH_Drawing_TileMode mode : modes) { 416 OH_Drawing_ShaderEffect *linearGradientEffect = 417 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, mode); 418 // add assert 419 EXPECT_NE(linearGradientEffect, nullptr); 420 // add assert 421 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 422 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 423 } 424 // 2. OH_Drawing_ShaderEffectCreateLinearGradient interface with pos set to NULL 425 OH_Drawing_ShaderEffect *linearGradientEffect = 426 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, nullptr, 3, CLAMP); 427 // add assert 428 EXPECT_NE(linearGradientEffect, nullptr); 429 // add assert 430 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 431 // 3. Free memory 432 OH_Drawing_PointDestroy(startPt); 433 OH_Drawing_PointDestroy(endPt); 434 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 435 } 436 437 /* 438 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0301 439 * @tc.name: testShaderEffectCreateLinearGradienNull 440 * @tc.desc: test for testShaderEffectCreateLinearGradienNull. 441 * @tc.size : SmallTest 442 * @tc.type : Function 443 * @tc.level : Level 3 444 */ 445 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienNull, TestSize.Level3) { 446 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 447 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 448 float pos[3] = {0.0f, 0.5f, 1.0f}; 449 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 450 // 1. OH_Drawing_ShaderEffectCreateLinearGradient with the first parameter set to nullptr, check the error code 451 // using OH_Drawing_ErrorCodeGet 452 OH_Drawing_ShaderEffect *linearGradientEffect = 453 OH_Drawing_ShaderEffectCreateLinearGradient(nullptr, endPt, colors, pos, 3, CLAMP); 454 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 455 OH_Drawing_ErrorCodeReset(); 456 // 2. OH_Drawing_ShaderEffectCreateLinearGradient with the second parameter set to nullptr, check the error code 457 // using OH_Drawing_ErrorCodeGet 458 OH_Drawing_ShaderEffect *linearGradientEffect2 = 459 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, nullptr, colors, pos, 3, CLAMP); 460 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 461 OH_Drawing_ErrorCodeReset(); 462 // 3. OH_Drawing_ShaderEffectCreateLinearGradient with the third parameter set to nullptr, check the error code 463 // using OH_Drawing_ErrorCodeGet 464 OH_Drawing_ShaderEffect *linearGradientEffect3 = 465 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, nullptr, pos, 3, CLAMP); 466 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 467 // 4. Free memory 468 OH_Drawing_PointDestroy(startPt); 469 OH_Drawing_PointDestroy(endPt); 470 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 471 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 472 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 473 } 474 475 /* 476 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0302 477 * @tc.name: testShaderEffectCreateLinearGradienAbnormal 478 * @tc.desc: test for testShaderEffectCreateLinearGradienAbnormal. 479 * @tc.size : SmallTest 480 * @tc.type : Function 481 * @tc.level : Level 3 482 */ 483 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienAbnormal, TestSize.Level3) { 484 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 485 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 486 float pos[3] = {0.0f, 0.5f, 1.0f}; 487 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 488 // 1. OH_Drawing_ShaderEffectCreateLinearGradient interface with startPt set to negative values 489 OH_Drawing_Point *startPt2 = OH_Drawing_PointCreate(-1, -1); 490 OH_Drawing_ShaderEffect *linearGradientEffect = 491 OH_Drawing_ShaderEffectCreateLinearGradient(startPt2, endPt, colors, pos, 3, CLAMP); 492 // add assert 493 EXPECT_NE(linearGradientEffect, nullptr); 494 // add assert 495 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 496 // 2. OH_Drawing_ShaderEffectCreateLinearGradient interface with endPt set to negative values 497 OH_Drawing_Point *endPt2 = OH_Drawing_PointCreate(-1, -1); 498 OH_Drawing_ShaderEffect *linearGradientEffect2 = 499 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt2, colors, pos, 3, CLAMP); 500 // add assert 501 EXPECT_NE(linearGradientEffect2, nullptr); 502 // add assert 503 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 504 // 3. OH_Drawing_ShaderEffectCreateLinearGradient interface with colors set to negative values 505 colors[0] = -0xFF00FFFF; 506 OH_Drawing_ShaderEffect *linearGradientEffect3 = 507 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 508 // add assert 509 EXPECT_NE(linearGradientEffect3, nullptr); 510 // add assert 511 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 512 // 4. OH_Drawing_ShaderEffectCreateLinearGradient interface with pos set to negative values 513 colors[0] = 0xFF00FFFF; 514 pos[0] = -0.1f; 515 OH_Drawing_ShaderEffect *linearGradientEffect4 = 516 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 517 // add assert 518 EXPECT_NE(linearGradientEffect4, nullptr); 519 // add assert 520 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 521 // 5. Free memory 522 OH_Drawing_PointDestroy(startPt); 523 OH_Drawing_PointDestroy(endPt); 524 OH_Drawing_PointDestroy(startPt2); 525 OH_Drawing_PointDestroy(endPt2); 526 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 527 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 528 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 529 OH_Drawing_ShaderEffectDestroy(linearGradientEffect4); 530 } 531 532 /* 533 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0303 534 * @tc.name: testShaderEffectCreateLinearGradienMaximum 535 * @tc.desc: test for testShaderEffectCreateLinearGradienMaximum. 536 * @tc.size : SmallTest 537 * @tc.type : Function 538 * @tc.level : Level 3 539 */ 540 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienMaximum, TestSize.Level3) { 541 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 542 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 543 float pos[3] = {0.0f, 0.5f, 1.0f}; 544 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 545 // 1. Call OH_Drawing_ShaderEffectCreateLinearGradient with startPt set to maximum values 546 OH_Drawing_Point *startPt2 = OH_Drawing_PointCreate(FLT_MAX, FLT_MAX); 547 OH_Drawing_ShaderEffect *linearGradientEffect = 548 OH_Drawing_ShaderEffectCreateLinearGradient(startPt2, endPt, colors, pos, 3, CLAMP); 549 // add assert 550 EXPECT_NE(linearGradientEffect, nullptr); 551 // add assert 552 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 553 // 2. Call OH_Drawing_ShaderEffectCreateLinearGradient with endPt set to maximum values 554 OH_Drawing_Point *endPt2 = OH_Drawing_PointCreate(FLT_MAX, FLT_MAX); 555 OH_Drawing_ShaderEffect *linearGradientEffect2 = 556 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt2, colors, pos, 3, CLAMP); 557 // add assert 558 EXPECT_NE(linearGradientEffect2, nullptr); 559 // add assert 560 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 561 // 3. Call OH_Drawing_ShaderEffectCreateLinearGradient with colors set to maximum values 562 colors[0] = UINT32_MAX; 563 OH_Drawing_ShaderEffect *linearGradientEffect3 = 564 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 565 // add assert 566 EXPECT_NE(linearGradientEffect3, nullptr); 567 // add assert 568 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 569 // 4. Call OH_Drawing_ShaderEffectCreateLinearGradient with pos set to maximum values 570 colors[0] = 0xFF00FFFF; 571 pos[0] = FLT_MAX; 572 OH_Drawing_ShaderEffect *linearGradientEffect4 = 573 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 574 // add assert 575 EXPECT_NE(linearGradientEffect4, nullptr); 576 // add assert 577 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 578 // 5. Free memory 579 OH_Drawing_PointDestroy(startPt); 580 OH_Drawing_PointDestroy(endPt); 581 OH_Drawing_PointDestroy(startPt2); 582 OH_Drawing_PointDestroy(endPt2); 583 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 584 OH_Drawing_ShaderEffectDestroy(linearGradientEffect2); 585 OH_Drawing_ShaderEffectDestroy(linearGradientEffect3); 586 OH_Drawing_ShaderEffectDestroy(linearGradientEffect4); 587 } 588 589 /* 590 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0304 591 * @tc.name: testShaderEffectCreateLinearGradienMultipleCalls 592 * @tc.desc: test for testShaderEffectCreateLinearGradienMultipleCalls. 593 * @tc.size : SmallTest 594 * @tc.type : Function 595 * @tc.level : Level 3 596 */ 597 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateLinearGradienMultipleCalls, TestSize.Level3) { 598 OH_Drawing_Point *startPt = OH_Drawing_PointCreate(0, 0); 599 OH_Drawing_Point *endPt = OH_Drawing_PointCreate(100.f, 0); 600 float pos[3] = {0.0f, 0.5f, 1.0f}; 601 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 602 // 1. Call OH_Drawing_ShaderEffectCreateLinearGradient 10 times 603 for (int i = 0; i < 10; i++) { 604 OH_Drawing_ShaderEffect *linearGradientEffect = 605 OH_Drawing_ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, 3, CLAMP); 606 // add assert 607 EXPECT_NE(linearGradientEffect, nullptr); 608 // add assert 609 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 610 // 2. Free memory 611 OH_Drawing_ShaderEffectDestroy(linearGradientEffect); 612 } 613 } 614 615 /* 616 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0400 617 * @tc.name: testShaderEffectCreateRadialGradientNormal 618 * @tc.desc: test for testShaderEffectCreateRadialGradientNormal. 619 * @tc.size : SmallTest 620 * @tc.type : Function 621 * @tc.level : Level 0 622 */ 623 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientNormal, TestSize.Level0) { 624 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ShaderEffectCreateRadialGradient 625 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 626 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 627 float pos[] = {0, 0.5, 1.0}; 628 OH_Drawing_TileMode modes[] = { 629 CLAMP, 630 REPEAT, 631 MIRROR, 632 DECAL, 633 }; 634 for (OH_Drawing_TileMode mode : modes) { 635 OH_Drawing_ErrorCodeReset(); 636 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos, 3, mode); 637 // add assert 638 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 639 EXPECT_NE(effect, nullptr); 640 OH_Drawing_ShaderEffectDestroy(effect); 641 } 642 // 2. OH_Drawing_ShaderEffectCreateRadialGradient with pos set to nullptr 643 OH_Drawing_ShaderEffect *effect = 644 OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, nullptr, 3, CLAMP); 645 // add assert 646 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 647 EXPECT_NE(effect, nullptr); 648 // 3. Free memory 649 OH_Drawing_PointDestroy(point); 650 OH_Drawing_ShaderEffectDestroy(effect); 651 } 652 653 /* 654 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0401 655 * @tc.name: testShaderEffectCreateRadialGradientNull 656 * @tc.desc: test for testShaderEffectCreateRadialGradientNull. 657 * @tc.size : SmallTest 658 * @tc.type : Function 659 * @tc.level : Level 3 660 */ 661 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientNull, TestSize.Level3) { 662 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 663 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 664 float pos[] = {0, 0.5, 1.0}; 665 // 1. OH_Drawing_ShaderEffectCreateRadialGradient with the first parameter set to nullptr, check the error code 666 // using OH_Drawing_ErrorCodeGet 667 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradient(nullptr, 100, colors, pos, 3, CLAMP); 668 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 669 // 2. OH_Drawing_ShaderEffectCreateRadialGradient with the second parameter set to nullptr 670 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, nullptr, pos, 3, CLAMP); 671 EXPECT_EQ(effect2, nullptr); 672 // 3. OH_Drawing_ShaderEffectCreateRadialGradient with the third parameter set to nullptr 673 OH_Drawing_ShaderEffect *effect3 = 674 OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, nullptr, 3, CLAMP); 675 EXPECT_NE(effect3, nullptr); 676 // 4. Free memory 677 OH_Drawing_PointDestroy(point); 678 OH_Drawing_ShaderEffectDestroy(effect); 679 OH_Drawing_ShaderEffectDestroy(effect2); 680 OH_Drawing_ShaderEffectDestroy(effect3); 681 } 682 683 /* 684 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0402 685 * @tc.name: testShaderEffectCreateRadialGradientAbnormal 686 * @tc.desc: test for testShaderEffectCreateRadialGradientAbnormal. 687 * @tc.size : SmallTest 688 * @tc.type : Function 689 * @tc.level : Level 3 690 */ 691 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientAbnormal, TestSize.Level3) { 692 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 693 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 694 float pos[] = {0, 0.5, 1.0}; 695 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradient with centerPt set to negative values 696 OH_Drawing_Point *point2 = OH_Drawing_PointCreate(-100, -100); 697 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradient(point2, 100, colors, pos, 3, CLAMP); 698 // add assert 699 EXPECT_NE(effect, nullptr); 700 // add assert 701 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 702 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradient with radius set to negative values 703 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateRadialGradient(point, -100, colors, pos, 3, CLAMP); 704 // add assert 705 EXPECT_NE(effect2, nullptr); 706 // add assert 707 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 708 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradient with colors set to negative values 709 colors[0] = -0xFFFF0000; 710 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos, 3, CLAMP); 711 // add assert 712 EXPECT_NE(effect3, nullptr); 713 // add assert 714 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 715 // 4. Call OH_Drawing_ShaderEffectCreateRadialGradient with pos set to negative values 716 colors[0] = 0xFFFF0000; 717 pos[0] = -0.1f; 718 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos, 3, CLAMP); 719 // add assert 720 EXPECT_NE(effect4, nullptr); 721 // add assert 722 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 723 // 5. Free memory 724 OH_Drawing_PointDestroy(point); 725 OH_Drawing_PointDestroy(point2); 726 OH_Drawing_ShaderEffectDestroy(effect); 727 OH_Drawing_ShaderEffectDestroy(effect2); 728 OH_Drawing_ShaderEffectDestroy(effect3); 729 OH_Drawing_ShaderEffectDestroy(effect4); 730 } 731 732 /* 733 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0403 734 * @tc.name: testShaderEffectCreateRadialGradientMaximum 735 * @tc.desc: test for testShaderEffectCreateRadialGradientMaximum. 736 * @tc.size : SmallTest 737 * @tc.type : Function 738 * @tc.level : Level 3 739 */ 740 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientMaximum, TestSize.Level3) { 741 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 742 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 743 float pos[] = {0, 0.5, 1.0}; 744 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradient with centerPt set to maximum values 745 OH_Drawing_Point *point2 = OH_Drawing_PointCreate(FLT_MAX, FLT_MAX); 746 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradient(point2, 100, colors, pos, 3, CLAMP); 747 // add assert 748 EXPECT_NE(effect, nullptr); 749 // add assert 750 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 751 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradient with radius set to maximum values 752 OH_Drawing_ShaderEffect *effect2 = 753 OH_Drawing_ShaderEffectCreateRadialGradient(point, FLT_MAX, colors, pos, 3, CLAMP); 754 // add assert 755 EXPECT_NE(effect2, nullptr); 756 // add assert 757 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 758 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradient with colors set to maximum values 759 uint32_t colors2[] = {UINT32_MAX, UINT32_MAX, UINT32_MAX}; 760 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors2, pos, 3, CLAMP); 761 // add assert 762 EXPECT_NE(effect3, nullptr); 763 // add assert 764 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 765 // 4. Call OH_Drawing_ShaderEffectCreateRadialGradient with pos set to maximum values 766 float pos2[] = {FLT_MAX, FLT_MAX, FLT_MAX}; 767 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos2, 3, CLAMP); 768 // add assert 769 EXPECT_NE(effect4, nullptr); 770 // add assert 771 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 772 // 5. Free memory 773 OH_Drawing_PointDestroy(point); 774 OH_Drawing_PointDestroy(point2); 775 OH_Drawing_ShaderEffectDestroy(effect); 776 OH_Drawing_ShaderEffectDestroy(effect2); 777 OH_Drawing_ShaderEffectDestroy(effect3); 778 OH_Drawing_ShaderEffectDestroy(effect4); 779 } 780 781 /* 782 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0404 783 * @tc.name: testShaderEffectCreateRadialGradientMultipleCalls 784 * @tc.desc: test for testShaderEffectCreateRadialGradientMultipleCalls. 785 * @tc.size : SmallTest 786 * @tc.type : Function 787 * @tc.level : Level 3 788 */ 789 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientMultipleCalls, TestSize.Level3) { 790 OH_Drawing_Point *point = OH_Drawing_PointCreate(100, 100); 791 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 792 float pos[] = {0, 0.5, 1.0}; 793 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradient 10 times 794 for (int i = 0; i < 10; i++) { 795 OH_Drawing_ShaderEffect *effect = 796 OH_Drawing_ShaderEffectCreateRadialGradient(point, 100, colors, pos, 3, CLAMP); 797 // add assert 798 EXPECT_NE(effect, nullptr); 799 // add assert 800 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 801 // 2. Free memory 802 OH_Drawing_ShaderEffectDestroy(effect); 803 } 804 } 805 806 /* 807 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0500 808 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixNormal 809 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixNormal. 810 * @tc.size : SmallTest 811 * @tc.type : Function 812 * @tc.level : Level 0 813 */ 814 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixNormal, TestSize.Level0) { 815 float pos[] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 816 float radius = 5.0; // 5.0f: gradient color radius 817 OH_Drawing_Point2D start = {100.f, 0}; // 100.f: start point's x 818 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 819 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 820 // add assert 821 EXPECT_NE(matrix, nullptr); 822 OH_Drawing_TileMode modes[] = { 823 CLAMP, 824 REPEAT, 825 MIRROR, 826 DECAL, 827 }; 828 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix, covering 829 // both the identity matrix and non-identity matrices for matrix 830 for (OH_Drawing_TileMode mode : modes) { 831 OH_Drawing_ShaderEffect *effect = 832 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(&start, radius, colors, pos, 3, mode, matrix); 833 EXPECT_NE(effect, nullptr); 834 OH_Drawing_ShaderEffectDestroy(effect); 835 } 836 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with pos set to nullptr 837 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix( 838 &start, radius, colors, nullptr, 3, OH_Drawing_TileMode::CLAMP, matrix); 839 // add assert 840 EXPECT_NE(effect2, nullptr); 841 // add assert 842 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 843 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with matrix set to nullptr 844 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix( 845 &start, radius, colors, pos, 3, OH_Drawing_TileMode::CLAMP, nullptr); 846 // add assert 847 EXPECT_NE(effect3, nullptr); 848 // add assert 849 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 850 // 4. Free memory 851 OH_Drawing_MatrixDestroy(matrix); 852 OH_Drawing_ShaderEffectDestroy(effect2); 853 OH_Drawing_ShaderEffectDestroy(effect3); 854 } 855 856 /* 857 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0501 858 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixNull 859 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixNull. 860 * @tc.size : SmallTest 861 * @tc.type : Function 862 * @tc.level : Level 3 863 */ 864 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixNull, TestSize.Level3) { 865 float pos[] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 866 float radius = 5.0; // 5.0f: gradient color radius 867 OH_Drawing_Point2D start = {100.f, 0}; // 100.f: start point's x 868 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 869 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 870 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with the first parameter set to nullptr and 871 // check the error code using OH_Drawing_ErrorCodeGet 872 OH_Drawing_ShaderEffect *effect = 873 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(nullptr, radius, colors, pos, 3, CLAMP, matrix); 874 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 875 OH_Drawing_ErrorCodeReset(); 876 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with the second parameter set to nullptr 877 OH_Drawing_ShaderEffect *effect2 = 878 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(&start, radius, nullptr, pos, 3, CLAMP, matrix); 879 // add assert 880 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 881 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with the third parameter set to nullptr 882 OH_Drawing_ShaderEffect *effect3 = 883 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(&start, radius, colors, nullptr, 3, CLAMP, matrix); 884 // add assert 885 EXPECT_NE(effect3, nullptr); 886 // 4. Free memory 887 OH_Drawing_MatrixDestroy(matrix); 888 OH_Drawing_ShaderEffectDestroy(effect); 889 OH_Drawing_ShaderEffectDestroy(effect2); 890 OH_Drawing_ShaderEffectDestroy(effect3); 891 } 892 893 /* 894 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0502 895 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixAbnormal 896 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixAbnormal. 897 * @tc.size : SmallTest 898 * @tc.type : Function 899 * @tc.level : Level 3 900 */ 901 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixAbnormal, TestSize.Level3) { 902 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with centerPt set to negative values 903 OH_Drawing_Point2D centerPt = {-1, -1}; 904 float radius = 5.0; 905 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 906 float pos[] = {0.0f, 0.5f, 1.0f}; 907 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 908 OH_Drawing_ShaderEffect *effect = 909 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 910 // add assert 911 EXPECT_NE(effect, nullptr); 912 // add assert 913 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 914 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with radius set to negative values 915 centerPt = {100, 0}; 916 radius = -5.0; 917 OH_Drawing_ShaderEffect *effect2 = 918 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 919 // add assert 920 EXPECT_NE(effect2, nullptr); 921 // add assert 922 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 923 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with colors set to negative values 924 colors[0] = -0xFFFF0000; 925 OH_Drawing_ShaderEffect *effect3 = 926 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 927 // add assert 928 EXPECT_NE(effect3, nullptr); 929 // add assert 930 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 931 // 4. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with pos set to negative values 932 colors[0] = 0xFFFF0000; 933 pos[0] = -0.1f; 934 OH_Drawing_ShaderEffect *effect4 = 935 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 936 // add assert 937 EXPECT_NE(effect4, nullptr); 938 // add assert 939 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 940 // 5. Free memory 941 OH_Drawing_MatrixDestroy(matrix); 942 OH_Drawing_ShaderEffectDestroy(effect); 943 OH_Drawing_ShaderEffectDestroy(effect2); 944 OH_Drawing_ShaderEffectDestroy(effect3); 945 OH_Drawing_ShaderEffectDestroy(effect4); 946 } 947 948 /* 949 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0503 950 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixMaximum 951 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixMaximum. 952 * @tc.size : SmallTest 953 * @tc.type : Function 954 * @tc.level : Level 3 955 */ 956 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixMaximum, TestSize.Level3) { 957 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with centerPt set to a large number 958 OH_Drawing_Point2D centerPt = {FLT_MAX, FLT_MAX}; 959 float radius = 5.0; 960 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 961 float pos[] = {0.0f, 0.5f, 1.0f}; 962 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 963 OH_Drawing_ShaderEffect *effect = 964 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 965 // add assert 966 EXPECT_NE(effect, nullptr); 967 // add assert 968 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 969 // 2. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with radius set to a large number 970 centerPt = {100, 0}; 971 radius = FLT_MAX; 972 OH_Drawing_ShaderEffect *effect2 = 973 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 974 // add assert 975 EXPECT_NE(effect2, nullptr); 976 // add assert 977 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 978 // 3. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with colors set to a large number 979 colors[0] = UINT32_MAX; 980 OH_Drawing_ShaderEffect *effect3 = 981 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 982 // add assert 983 EXPECT_NE(effect3, nullptr); 984 // add assert 985 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 986 // 4. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix with pos set to a large number 987 colors[0] = 0xFFFF0000; 988 pos[0] = FLT_MAX; 989 OH_Drawing_ShaderEffect *effect4 = 990 OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix(¢erPt, radius, colors, pos, 3, CLAMP, matrix); 991 // add assert 992 EXPECT_NE(effect4, nullptr); 993 // add assert 994 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 995 // 5. Free memory 996 OH_Drawing_MatrixDestroy(matrix); 997 OH_Drawing_ShaderEffectDestroy(effect); 998 OH_Drawing_ShaderEffectDestroy(effect2); 999 OH_Drawing_ShaderEffectDestroy(effect3); 1000 OH_Drawing_ShaderEffectDestroy(effect4); 1001 } 1002 1003 /* 1004 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0504 1005 * @tc.name: testShaderEffectCreateRadialGradientWithLocalMatrixMultipleCalls 1006 * @tc.desc: test for testShaderEffectCreateRadialGradientWithLocalMatrixMultipleCalls. 1007 * @tc.size : SmallTest 1008 * @tc.type : Function 1009 * @tc.level : Level 3 1010 */ 1011 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateRadialGradientWithLocalMatrixMultipleCalls, 1012 TestSize.Level3) { 1013 OH_Drawing_Point2D centerPt = {100, 100}; 1014 float radius = 5.0; 1015 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1016 float pos[] = {0.0f, 0.5f, 1.0f}; 1017 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1018 // 1. Call OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix 10 times 1019 for (int i = 0; i < 10; i++) { 1020 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateRadialGradientWithLocalMatrix( 1021 ¢erPt, radius, colors, pos, 3, CLAMP, matrix); 1022 // add assert 1023 EXPECT_NE(effect, nullptr); 1024 // add assert 1025 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1026 // 2. Free memory 1027 OH_Drawing_ShaderEffectDestroy(effect); 1028 } 1029 } 1030 1031 /* 1032 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0600 1033 * @tc.name: testShaderEffectCreateSweepGradientNormal 1034 * @tc.desc: test for testShaderEffectCreateSweepGradientNormal. 1035 * @tc.size : SmallTest 1036 * @tc.type : Function 1037 * @tc.level : Level 0 1038 */ 1039 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientNormal, TestSize.Level0) { 1040 // 1. Enumerate OH_Drawing_TileMode values in OH_Drawing_ShaderEffectCreateSweepGradient 1041 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1042 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1043 float pos[] = {0, 0.5, 1.0}; 1044 OH_Drawing_TileMode modes[] = { 1045 CLAMP, 1046 REPEAT, 1047 MIRROR, 1048 DECAL, 1049 }; 1050 for (OH_Drawing_TileMode mode : modes) { 1051 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, mode); 1052 EXPECT_NE(effect, nullptr); 1053 // add assert 1054 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1055 OH_Drawing_ShaderEffectDestroy(effect); 1056 } 1057 // 2. Call OH_Drawing_ShaderEffectCreateSweepGradient with pos set to nullptr 1058 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, nullptr, 3, CLAMP); 1059 // add assert 1060 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1061 EXPECT_NE(effect, nullptr); 1062 // 3. Free memory 1063 OH_Drawing_PointDestroy(centerPt); 1064 OH_Drawing_ShaderEffectDestroy(effect); 1065 } 1066 1067 /* 1068 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0601 1069 * @tc.name: testShaderEffectCreateSweepGradientNull 1070 * @tc.desc: test for testShaderEffectCreateSweepGradientNull. 1071 * @tc.size : SmallTest 1072 * @tc.type : Function 1073 * @tc.level : Level 3 1074 */ 1075 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientNull, TestSize.Level3) { 1076 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1077 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1078 float pos[] = {0, 0.5, 1.0}; 1079 // 1. Call OH_Drawing_ShaderEffectCreateSweepGradient with the first parameter set to nullptr and check the error 1080 // code using OH_Drawing_ErrorCodeGet 1081 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateSweepGradient(nullptr, colors, pos, 3, CLAMP); 1082 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1083 OH_Drawing_ErrorCodeReset(); 1084 // 2. Call OH_Drawing_ShaderEffectCreateSweepGradient with the second parameter set to nullptr and check the error 1085 // code using OH_Drawing_ErrorCodeGet 1086 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, nullptr, pos, 3, CLAMP); 1087 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1088 // 3. Free memory 1089 OH_Drawing_PointDestroy(centerPt); 1090 OH_Drawing_ShaderEffectDestroy(effect); 1091 OH_Drawing_ShaderEffectDestroy(effect2); 1092 } 1093 1094 /* 1095 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0602 1096 * @tc.name: testShaderEffectCreateSweepGradientAbnormal 1097 * @tc.desc: test for testShaderEffectCreateSweepGradientAbnormal. 1098 * @tc.size : SmallTest 1099 * @tc.type : Function 1100 * @tc.level : Level 3 1101 */ 1102 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientAbnormal, TestSize.Level3) { 1103 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1104 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1105 float pos[] = {0, 0.5, 1.0}; 1106 // 1. Call OH_Drawing_ShaderEffectCreateSweepGradient with centerPt set to negative values 1107 OH_Drawing_Point *centerPt2 = OH_Drawing_PointCreate(-1, -1); 1108 OH_Drawing_ShaderEffect *sweepGradientEffect = 1109 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt2, colors, pos, 3, CLAMP); 1110 // add assert 1111 EXPECT_NE(sweepGradientEffect, nullptr); 1112 // add assert 1113 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1114 // 2. Call OH_Drawing_ShaderEffectCreateSweepGradient with colors set to negative values 1115 colors[0] = -0xFFFF0000; 1116 OH_Drawing_ShaderEffect *sweepGradientEffect2 = 1117 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1118 // add assert 1119 EXPECT_NE(sweepGradientEffect2, nullptr); 1120 // add assert 1121 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1122 // 3. Call OH_Drawing_ShaderEffectCreateSweepGradient with pos set to negative values 1123 colors[0] = 0xFFFF0000; 1124 pos[0] = -0.1f; 1125 OH_Drawing_ShaderEffect *sweepGradientEffect3 = 1126 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1127 // add assert 1128 EXPECT_NE(sweepGradientEffect3, nullptr); 1129 // add assert 1130 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1131 // 4. Free memory 1132 OH_Drawing_PointDestroy(centerPt); 1133 OH_Drawing_PointDestroy(centerPt2); 1134 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect); 1135 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect2); 1136 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect3); 1137 } 1138 1139 /* 1140 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0603 1141 * @tc.name: testShaderEffectCreateSweepGradientMaximum 1142 * @tc.desc: test for testShaderEffectCreateSweepGradientMaximum. 1143 * @tc.size : SmallTest 1144 * @tc.type : Function 1145 * @tc.level : Level 3 1146 */ 1147 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientMaximum, TestSize.Level3) { 1148 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1149 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1150 float pos[] = {0, 0.5, 1.0}; 1151 // 1. Call OH_Drawing_ShaderEffectCreateSweepGradient with centerPt set to a large number 1152 OH_Drawing_Point *centerPt2 = OH_Drawing_PointCreate(FLT_MAX, FLT_MAX); 1153 OH_Drawing_ShaderEffect *sweepGradientEffect = 1154 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt2, colors, pos, 3, CLAMP); 1155 // add assert 1156 EXPECT_NE(sweepGradientEffect, nullptr); 1157 // add assert 1158 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1159 // 2. Call OH_Drawing_ShaderEffectCreateSweepGradient with colors set to a large number 1160 colors[0] = UINT32_MAX; 1161 OH_Drawing_ShaderEffect *sweepGradientEffect2 = 1162 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1163 // add assert 1164 EXPECT_NE(sweepGradientEffect2, nullptr); 1165 // add assert 1166 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1167 // 3. Call OH_Drawing_ShaderEffectCreateSweepGradient with pos set to a large number 1168 colors[0] = 0xFFFF0000; 1169 pos[0] = FLT_MAX; 1170 OH_Drawing_ShaderEffect *sweepGradientEffect3 = 1171 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1172 // add assert 1173 EXPECT_NE(sweepGradientEffect3, nullptr); 1174 // add assert 1175 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1176 // 4. Free memory 1177 OH_Drawing_PointDestroy(centerPt); 1178 OH_Drawing_PointDestroy(centerPt2); 1179 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect); 1180 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect2); 1181 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect3); 1182 } 1183 1184 /* 1185 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0604 1186 * @tc.name: testShaderEffectCreateSweepGradientMultipleCalls 1187 * @tc.desc: test for testShaderEffectCreateSweepGradientMultipleCalls. 1188 * @tc.size : SmallTest 1189 * @tc.type : Function 1190 * @tc.level : Level 3 1191 */ 1192 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateSweepGradientMultipleCalls, TestSize.Level3) { 1193 OH_Drawing_Point *centerPt = OH_Drawing_PointCreate(100, 100); 1194 uint32_t colors[] = {0xFFFF0000, 0xFF00FF00, 0xFF0000FF}; 1195 float pos[] = {0, 0.5, 1.0}; 1196 // 1. Call OH_Drawing_ShaderEffectCreateSweepGradient 10 times 1197 for (int i = 0; i < 10; i++) { 1198 OH_Drawing_ShaderEffect *sweepGradientEffect = 1199 OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, 3, CLAMP); 1200 // add assert 1201 EXPECT_NE(sweepGradientEffect, nullptr); 1202 // add assert 1203 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1204 // 2. Free memory 1205 OH_Drawing_ShaderEffectDestroy(sweepGradientEffect); 1206 } 1207 } 1208 1209 /* 1210 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0700 1211 * @tc.name: testShaderEffectCreateImageShaderNormal 1212 * @tc.desc: test for testShaderEffectCreateImageShaderNormal. 1213 * @tc.size : SmallTest 1214 * @tc.type : Function 1215 * @tc.level : Level 0 1216 */ 1217 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateImageShaderNormal, TestSize.Level0) { 1218 // 1. Call OH_Drawing_ImageCreate 1219 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1220 // add assert 1221 EXPECT_NE(image, nullptr); 1222 // 2. Call OH_Drawing_SamplingOptionsCreate 1223 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR); 1224 // add assert 1225 EXPECT_NE(options, nullptr); 1226 // 3. Call OH_Drawing_ShaderEffectCreateImageShader with different OH_Drawing_TileMode values for tileX and tileY 1227 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1228 // add assert 1229 EXPECT_NE(matrix, nullptr); 1230 OH_Drawing_TileMode modes[] = { 1231 CLAMP, 1232 REPEAT, 1233 MIRROR, 1234 DECAL, 1235 }; 1236 for (OH_Drawing_TileMode tileX : modes) { 1237 for (OH_Drawing_TileMode tileY : modes) { 1238 OH_Drawing_ErrorCodeReset(); 1239 OH_Drawing_ShaderEffect *effect = 1240 OH_Drawing_ShaderEffectCreateImageShader(image, tileX, tileY, options, matrix); 1241 // add assert 1242 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1243 EXPECT_NE(effect, nullptr); 1244 OH_Drawing_ShaderEffectDestroy(effect); 1245 } 1246 } 1247 // 4. Call OH_Drawing_ShaderEffectCreateImageShader with null matrix 1248 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, options, nullptr); 1249 // add assert 1250 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1251 EXPECT_NE(effect, nullptr); 1252 // 5. Free memory 1253 OH_Drawing_ImageDestroy(image); 1254 OH_Drawing_SamplingOptionsDestroy(options); 1255 OH_Drawing_ShaderEffectDestroy(effect); 1256 } 1257 1258 /* 1259 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0701 1260 * @tc.name: testShaderEffectCreateImageShaderNull 1261 * @tc.desc: test for testShaderEffectCreateImageShaderNull. 1262 * @tc.size : SmallTest 1263 * @tc.type : Function 1264 * @tc.level : Level 3 1265 */ 1266 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateImageShaderNull, TestSize.Level3) { 1267 // 1. Call OH_Drawing_ShaderEffectCreateImageShader with the first parameter set to nullptr and check the error 1268 // code using OH_Drawing_ErrorCodeGet 1269 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR); 1270 // add assert 1271 EXPECT_NE(options, nullptr); 1272 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1273 // add assert 1274 EXPECT_NE(matrix, nullptr); 1275 OH_Drawing_ShaderEffectCreateImageShader(nullptr, CLAMP, CLAMP, options, matrix); 1276 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1277 OH_Drawing_ErrorCodeReset(); 1278 // 2. Call OH_Drawing_ShaderEffectCreateImageShader with the fourth parameter set to nullptr and check the error 1279 // code using OH_Drawing_ErrorCodeGet 1280 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1281 OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, nullptr, matrix); 1282 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1283 // 3. Free memory 1284 OH_Drawing_ImageDestroy(image); 1285 OH_Drawing_SamplingOptionsDestroy(options); 1286 OH_Drawing_MatrixDestroy(matrix); 1287 } 1288 1289 /* 1290 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0704 1291 * @tc.name: testShaderEffectCreateImageShaderMultipleCalls 1292 * @tc.desc: test for testShaderEffectCreateImageShaderMultipleCalls. 1293 * @tc.size : SmallTest 1294 * @tc.type : Function 1295 * @tc.level : Level 3 1296 */ 1297 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateImageShaderMultipleCalls, TestSize.Level3) { 1298 OH_Drawing_SamplingOptions *options = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR); 1299 // add assert 1300 EXPECT_NE(options, nullptr); 1301 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1302 // add assert 1303 EXPECT_NE(matrix, nullptr); 1304 OH_Drawing_Image *image = OH_Drawing_ImageCreate(); 1305 // add assert 1306 EXPECT_NE(image, nullptr); 1307 // 1. Call OH_Drawing_ShaderEffectCreateImageShader 10 times 1308 for (int i = 0; i < 10; i++) { 1309 OH_Drawing_ShaderEffect *effect = 1310 OH_Drawing_ShaderEffectCreateImageShader(image, CLAMP, CLAMP, options, matrix); 1311 EXPECT_NE(effect, nullptr); 1312 OH_Drawing_ShaderEffectDestroy(effect); 1313 } 1314 // 2. Free memory 1315 OH_Drawing_ImageDestroy(image); 1316 OH_Drawing_SamplingOptionsDestroy(options); 1317 OH_Drawing_MatrixDestroy(matrix); 1318 } 1319 1320 /* 1321 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0800 1322 * @tc.name: testShaderEffectCreateTwoPointConicalGradientNormal 1323 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientNormal. 1324 * @tc.size : SmallTest 1325 * @tc.type : Function 1326 * @tc.level : Level 0 1327 */ 1328 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientNormal, TestSize.Level0) { 1329 OH_Drawing_Point2D startPt = {0, 0}; 1330 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1331 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1332 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1333 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1334 OH_Drawing_TileMode modes[] = { 1335 CLAMP, 1336 REPEAT, 1337 MIRROR, 1338 DECAL, 1339 }; 1340 // 1. Enumerate OH_Drawing_TileMode values for OH_Drawing_ShaderEffectCreateTwoPointConicalGradient, and cover both 1341 // the identity matrix and non-identity matrix for the matrix parameter 1342 for (OH_Drawing_TileMode mode : modes) { 1343 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1344 OH_Drawing_ShaderEffect *effect1 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1345 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, mode, matrix); 1346 EXPECT_NE(effect1, nullptr); 1347 OH_Drawing_ShaderEffectDestroy(effect1); 1348 1349 OH_Drawing_MatrixSetMatrix(matrix, 1, 0, 0, 1, 0, 0, 0, 0, 0); 1350 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1351 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, mode, matrix); 1352 EXPECT_NE(effect2, nullptr); 1353 OH_Drawing_ShaderEffectDestroy(effect2); 1354 OH_Drawing_MatrixDestroy(matrix); 1355 } 1356 // 2. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with pos set to nullptr 1357 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1358 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1359 &startPt, startRadius, &endPt, endRadius, colors, nullptr, 3, CLAMP, matrix); 1360 EXPECT_NE(effect, nullptr); 1361 // add assert 1362 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1363 // 3. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with matrix set to nullptr 1364 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1365 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, nullptr); 1366 EXPECT_NE(effect2, nullptr); 1367 // add assert 1368 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1369 // 4. Free memory 1370 OH_Drawing_MatrixDestroy(matrix); 1371 OH_Drawing_ShaderEffectDestroy(effect); 1372 OH_Drawing_ShaderEffectDestroy(effect2); 1373 } 1374 1375 /* 1376 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0801 1377 * @tc.name: testShaderEffectCreateTwoPointConicalGradientNull 1378 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientNull. 1379 * @tc.size : SmallTest 1380 * @tc.type : Function 1381 * @tc.level : Level 3 1382 */ 1383 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientNull, TestSize.Level3) { 1384 OH_Drawing_Point2D startPt = {0, 0}; 1385 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1386 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1387 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1388 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1389 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1390 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the first parameter set to nullptr and check 1391 // the error code using OH_Drawing_ErrorCodeGet 1392 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1393 nullptr, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1394 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1395 OH_Drawing_ErrorCodeReset(); 1396 // 2. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the second parameter set to nullptr 1397 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1398 &startPt, 0, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1399 // 3. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the third parameter set to nullptr and check 1400 // the error code using OH_Drawing_ErrorCodeGet 1401 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1402 &startPt, startRadius, nullptr, endRadius, colors, pos, 3, CLAMP, matrix); 1403 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1404 OH_Drawing_ErrorCodeReset(); 1405 // 4. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the fourth parameter set to nullptr 1406 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1407 &startPt, startRadius, &endPt, 0, colors, pos, 3, CLAMP, matrix); 1408 // 5. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the fifth parameter set to nullptr and check 1409 // the error code using OH_Drawing_ErrorCodeGet 1410 OH_Drawing_ShaderEffect *effect5 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1411 &startPt, startRadius, &endPt, endRadius, nullptr, pos, 3, CLAMP, matrix); 1412 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_ERROR_INVALID_PARAMETER); 1413 // 6. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with the sixth parameter set to nullptr 1414 OH_Drawing_ShaderEffect *effect6 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1415 &startPt, startRadius, &endPt, endRadius, colors, nullptr, 3, CLAMP, matrix); 1416 // 7. Free memory 1417 OH_Drawing_MatrixDestroy(matrix); 1418 OH_Drawing_ShaderEffectDestroy(effect); 1419 OH_Drawing_ShaderEffectDestroy(effect2); 1420 OH_Drawing_ShaderEffectDestroy(effect3); 1421 OH_Drawing_ShaderEffectDestroy(effect4); 1422 OH_Drawing_ShaderEffectDestroy(effect5); 1423 OH_Drawing_ShaderEffectDestroy(effect6); 1424 } 1425 1426 /* 1427 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0802 1428 * @tc.name: testShaderEffectCreateTwoPointConicalGradientAbnormal 1429 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientAbnormal. 1430 * @tc.size : SmallTest 1431 * @tc.type : Function 1432 * @tc.level : Level 3 1433 */ 1434 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientAbnormal, TestSize.Level3) { 1435 OH_Drawing_Point2D startPt = {0, 0}; 1436 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1437 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1438 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1439 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1440 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1441 // add assert 1442 EXPECT_NE(matrix, nullptr); 1443 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with startPt set to a negative value 1444 OH_Drawing_Point2D startPt2 = {-1, -1}; 1445 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1446 &startPt2, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1447 // add assert 1448 EXPECT_NE(effect, nullptr); 1449 // add assert 1450 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1451 // 2. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with startRadius set to a negative value 1452 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1453 &startPt, -5.0f, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1454 // add assert 1455 EXPECT_NE(effect2, nullptr); 1456 // add assert 1457 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1458 // 3. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with endPt set to a negative value 1459 OH_Drawing_Point2D endPt2 = {-1, -1}; 1460 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1461 &startPt, startRadius, &endPt2, endRadius, colors, pos, 3, CLAMP, matrix); 1462 // add assert 1463 EXPECT_NE(effect3, nullptr); 1464 // add assert 1465 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1466 // 4. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with endRadius set to a negative value 1467 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1468 &startPt, startRadius, &endPt, -10.0f, colors, pos, 3, CLAMP, matrix); 1469 // add assert 1470 EXPECT_NE(effect4, nullptr); 1471 // add assert 1472 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1473 // 5. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with colors set to a negative value 1474 colors[0] = -0xFF00FFFF; 1475 OH_Drawing_ShaderEffect *effect5 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1476 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1477 // add assert 1478 EXPECT_NE(effect5, nullptr); 1479 // add assert 1480 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1481 // 6. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with pos set to a negative value 1482 colors[0] = 0xFF00FFFF; 1483 pos[0] = -0.1f; 1484 OH_Drawing_ShaderEffect *effect6 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1485 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1486 // add assert 1487 EXPECT_NE(effect6, nullptr); 1488 // add assert 1489 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1490 // 7. Free memory 1491 OH_Drawing_MatrixDestroy(matrix); 1492 OH_Drawing_ShaderEffectDestroy(effect); 1493 OH_Drawing_ShaderEffectDestroy(effect2); 1494 OH_Drawing_ShaderEffectDestroy(effect3); 1495 OH_Drawing_ShaderEffectDestroy(effect4); 1496 OH_Drawing_ShaderEffectDestroy(effect5); 1497 OH_Drawing_ShaderEffectDestroy(effect6); 1498 } 1499 1500 /* 1501 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0803 1502 * @tc.name: testShaderEffectCreateTwoPointConicalGradientMaximum 1503 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientMaximum. 1504 * @tc.size : SmallTest 1505 * @tc.type : Function 1506 * @tc.level : Level 3 1507 */ 1508 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientMaximum, TestSize.Level3) { 1509 OH_Drawing_Point2D startPt = {0, 0}; 1510 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1511 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1512 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1513 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1514 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1515 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with startPt set to a maximum value 1516 OH_Drawing_Point2D startPt2 = {FLT_MAX, FLT_MAX}; 1517 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1518 &startPt2, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1519 // add assert 1520 EXPECT_NE(effect, nullptr); 1521 // add assert 1522 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1523 // 2. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with startRadius set to a maximum value 1524 OH_Drawing_ShaderEffect *effect2 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1525 &startPt, FLT_MAX, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1526 // add assert 1527 EXPECT_NE(effect2, nullptr); 1528 // add assert 1529 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1530 // 3. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with endPt set to a maximum value 1531 OH_Drawing_Point2D endPt2 = {FLT_MAX, FLT_MAX}; 1532 OH_Drawing_ShaderEffect *effect3 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1533 &startPt, startRadius, &endPt2, endRadius, colors, pos, 3, CLAMP, matrix); 1534 // add assert 1535 EXPECT_NE(effect3, nullptr); 1536 // add assert 1537 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1538 // 4. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with endRadius set to a maximum value 1539 OH_Drawing_ShaderEffect *effect4 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1540 &startPt, startRadius, &endPt, FLT_MAX, colors, pos, 3, CLAMP, matrix); 1541 // add assert 1542 EXPECT_NE(effect4, nullptr); 1543 // add assert 1544 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1545 // 5. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with colors set to a maximum value 1546 colors[0] = UINT32_MAX; 1547 OH_Drawing_ShaderEffect *effect5 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1548 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1549 // add assert 1550 EXPECT_NE(effect5, nullptr); 1551 // add assert 1552 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1553 // 6. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient with pos set to a maximum value 1554 colors[0] = 0xFF00FFFF; 1555 pos[0] = FLT_MAX; 1556 OH_Drawing_ShaderEffect *effect6 = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1557 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1558 // add assert 1559 EXPECT_NE(effect6, nullptr); 1560 // add assert 1561 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1562 // 7. Free memory 1563 OH_Drawing_MatrixDestroy(matrix); 1564 OH_Drawing_ShaderEffectDestroy(effect); 1565 OH_Drawing_ShaderEffectDestroy(effect2); 1566 OH_Drawing_ShaderEffectDestroy(effect3); 1567 OH_Drawing_ShaderEffectDestroy(effect4); 1568 OH_Drawing_ShaderEffectDestroy(effect5); 1569 OH_Drawing_ShaderEffectDestroy(effect6); 1570 } 1571 1572 /* 1573 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0804 1574 * @tc.name: testShaderEffectCreateTwoPointConicalGradientMultipleCalls 1575 * @tc.desc: test for testShaderEffectCreateTwoPointConicalGradientMultipleCalls. 1576 * @tc.size : SmallTest 1577 * @tc.type : Function 1578 * @tc.level : Level 3 1579 */ 1580 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectCreateTwoPointConicalGradientMultipleCalls, TestSize.Level3) { 1581 OH_Drawing_Point2D startPt = {0, 0}; 1582 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1583 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1584 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1585 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1586 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1587 // add assert 1588 EXPECT_NE(matrix, nullptr); 1589 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient 10 times 1590 for (int i = 0; i < 10; i++) { 1591 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1592 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1593 // add assert 1594 EXPECT_NE(effect, nullptr); 1595 // add assert 1596 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1597 // 2. Free memory 1598 OH_Drawing_ShaderEffectDestroy(effect); 1599 } 1600 } 1601 1602 /* 1603 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0900 1604 * @tc.name: testShaderEffectDestroyNormal 1605 * @tc.desc: test for testShaderEffectDestroyNormal. 1606 * @tc.size : SmallTest 1607 * @tc.type : Function 1608 * @tc.level : Level 0 1609 */ 1610 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectDestroyNormal, TestSize.Level0) { 1611 OH_Drawing_Point2D startPt = {0, 0}; 1612 OH_Drawing_Point2D endPt = {100.f, 0}; // 100.f: end point's x 1613 uint32_t colors[3] = {0xFF00FFFF, 0xFFFF00FF, 0xFFFFFF00}; 1614 float pos[3] = {0.0f, 0.5f, 1.0f}; // 0.5f: gradient color points, 1.0f: gradient color points 1615 float startRadius = 5.0f, endRadius = 10.0f; // 5.0f: gradient color radius, 10.0f: gradient color radius 1616 OH_Drawing_Matrix *matrix = OH_Drawing_MatrixCreate(); 1617 // add assert 1618 EXPECT_NE(matrix, nullptr); 1619 // 1. Call OH_Drawing_ShaderEffectCreateTwoPointConicalGradient 1620 OH_Drawing_ShaderEffect *effect = OH_Drawing_ShaderEffectCreateTwoPointConicalGradient( 1621 &startPt, startRadius, &endPt, endRadius, colors, pos, 3, CLAMP, matrix); 1622 // add assert 1623 EXPECT_EQ(OH_Drawing_ErrorCodeGet(), OH_Drawing_ErrorCode::OH_DRAWING_SUCCESS); 1624 EXPECT_NE(effect, nullptr); 1625 // 2. Call OH_Drawing_ShaderEffectDestroy 1626 OH_Drawing_ShaderEffectDestroy(effect); 1627 } 1628 1629 /* 1630 * @tc.number: SUB_BASIC_GRAPHICS_SPECIAL_API_C_DRAWING_SHADOW_EFFECT_0901 1631 * @tc.name: testShaderEffectDestroyNull 1632 * @tc.desc: test for testShaderEffectDestroyNull. 1633 * @tc.size : SmallTest 1634 * @tc.type : Function 1635 * @tc.level : Level 3 1636 */ 1637 HWTEST_F(DrawingNativeShaderEffectTest, testShaderEffectDestroyNull, TestSize.Level3) { 1638 // 1. OH_Drawing_ShaderEffectDestroy parameter is null 1639 OH_Drawing_ShaderEffectDestroy(nullptr); 1640 // add assert 1641 EXPECT_TRUE(true); 1642 } 1643 1644 } // namespace Drawing 1645 } // namespace Rosen 1646 } // namespace OHOS