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