1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #include "effect/shader_effect.h"
19 #include "image/image.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace Rosen {
26 namespace Drawing {
27 class ShaderEffectTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 void SetUp() override;
32 void TearDown() override;
33 };
34
SetUpTestCase()35 void ShaderEffectTest::SetUpTestCase() {}
TearDownTestCase()36 void ShaderEffectTest::TearDownTestCase() {}
SetUp()37 void ShaderEffectTest::SetUp() {}
TearDown()38 void ShaderEffectTest::TearDown() {}
39
40 /*
41 * @tc.name: CreateColorShader001
42 * @tc.desc:
43 * @tc.type: FUNC
44 * @tc.require: AR000GGNV3
45 * @tc.author:
46 */
47 HWTEST_F(ShaderEffectTest, CreateColorShader001, TestSize.Level1)
48 {
49 ColorQuad color = 13;
50 auto newShaderEffect = ShaderEffect::CreateColorShader(color);
51 EXPECT_TRUE(newShaderEffect != nullptr);
52 }
53
54 /*
55 * @tc.name: CreateColorShader002
56 * @tc.desc:
57 * @tc.type: FUNC
58 * @tc.require: AR000GGNV3
59 * @tc.author:
60 */
61 HWTEST_F(ShaderEffectTest, CreateColorShader002, TestSize.Level1)
62 {
63 ColorQuad color = 24;
64 auto newShaderEffect = ShaderEffect::CreateColorShader(color);
65 EXPECT_TRUE(newShaderEffect != nullptr);
66 }
67
68 /*
69 * @tc.name: CreateBlendShader001
70 * @tc.desc:
71 * @tc.type: FUNC
72 * @tc.require: AR000GGNV3
73 * @tc.author:
74 */
75 HWTEST_F(ShaderEffectTest, CreateBlendShader001, TestSize.Level1)
76 {
77 ShaderEffect shaderEffect1(ShaderEffect::ShaderEffectType::BLEND, 20);
78 ShaderEffect shaderEffect2(ShaderEffect::ShaderEffectType::LINEAR_GRADIENT, 10);
79 auto newShaderEffect = ShaderEffect::CreateBlendShader(shaderEffect1, shaderEffect2, BlendMode::CLEAR);
80 EXPECT_TRUE(newShaderEffect != nullptr);
81 }
82
83 /*
84 * @tc.name: CreateBlendShader002
85 * @tc.desc:
86 * @tc.type: FUNC
87 * @tc.require: AR000GGNV3
88 * @tc.author:
89 */
90 HWTEST_F(ShaderEffectTest, CreateBlendShader002, TestSize.Level1)
91 {
92 ShaderEffect shaderEffect3(ShaderEffect::ShaderEffectType::LINEAR_GRADIENT, 60);
93 ShaderEffect shaderEffect4(ShaderEffect::ShaderEffectType::CONICAL_GRADIENT, 4);
94 auto newShaderEffect = ShaderEffect::CreateBlendShader(shaderEffect3, shaderEffect4, BlendMode::DST);
95 EXPECT_TRUE(newShaderEffect != nullptr);
96 }
97
98 /*
99 * @tc.name: CreateImageShader001
100 * @tc.desc:
101 * @tc.type: FUNC
102 * @tc.require: AR000GGNV3
103 * @tc.author:
104 */
105 HWTEST_F(ShaderEffectTest, CreateImageShader001, TestSize.Level1)
106 {
107 Image image;
108 SamplingOptions sampling;
109 Matrix matrix;
110 auto newShaderEffect = ShaderEffect::CreateImageShader(image, TileMode::CLAMP, TileMode::REPEAT, sampling, matrix);
111 EXPECT_TRUE(newShaderEffect != nullptr);
112 }
113
114 /*
115 * @tc.name: CreateImageShader002
116 * @tc.desc:
117 * @tc.type: FUNC
118 * @tc.require: AR000GGNV3
119 * @tc.author:
120 */
121 HWTEST_F(ShaderEffectTest, CreateImageShader002, TestSize.Level1)
122 {
123 Image image;
124 SamplingOptions sampling;
125 Matrix matrix;
126 auto newShaderEffect = ShaderEffect::CreateImageShader(image, TileMode::REPEAT, TileMode::MIRROR, sampling, matrix);
127 EXPECT_TRUE(newShaderEffect != nullptr);
128 }
129
130 /*
131 * @tc.name: CreatePictureShader001
132 * @tc.desc:
133 * @tc.type: FUNC
134 * @tc.require: AR000GGNV3
135 * @tc.author:
136 */
137 HWTEST_F(ShaderEffectTest, CreatePictureShader001, TestSize.Level1)
138 {
139 Picture picture;
140 Matrix matrix;
141 Rect rect;
142 auto newShaderEffect = ShaderEffect::CreatePictureShader(
143 picture, TileMode::MIRROR, TileMode::REPEAT, FilterMode::LINEAR, matrix, rect);
144 EXPECT_TRUE(newShaderEffect != nullptr);
145 }
146
147 /*
148 * @tc.name: CreatePictureShader002
149 * @tc.desc:
150 * @tc.type: FUNC
151 * @tc.require: AR000GGNV3
152 * @tc.author:
153 */
154 HWTEST_F(ShaderEffectTest, CreatePictureShader002, TestSize.Level1)
155 {
156 Picture picture;
157 Matrix matrix;
158 Rect rect;
159 auto newShaderEffect =
160 ShaderEffect::CreatePictureShader(picture, TileMode::CLAMP, TileMode::REPEAT, FilterMode::LINEAR, matrix, rect);
161 EXPECT_TRUE(newShaderEffect != nullptr);
162 }
163
164 /*
165 * @tc.name: CreateLinearGradient001
166 * @tc.desc:
167 * @tc.type: FUNC
168 * @tc.require: AR000GGNV3
169 * @tc.author:
170 */
171 HWTEST_F(ShaderEffectTest, CreateLinearGradient001, TestSize.Level1)
172 {
173 Point startPoint;
174 Point endPoint;
175 std::vector<ColorQuad> colors;
176 std::vector<scalar> position;
177 auto newShaderEffect = ShaderEffect::CreateLinearGradient(startPoint, endPoint, colors, position, TileMode::CLAMP);
178 EXPECT_TRUE(newShaderEffect != nullptr);
179 }
180
181 /*
182 * @tc.name: CreateLinearGradient002
183 * @tc.desc:
184 * @tc.type: FUNC
185 * @tc.require: AR000GGNV3
186 * @tc.author:
187 */
188 HWTEST_F(ShaderEffectTest, CreateLinearGradient002, TestSize.Level1)
189 {
190 Point startPoint;
191 Point endPoint;
192 std::vector<ColorQuad> colors;
193 std::vector<scalar> position;
194 auto newShaderEffect = ShaderEffect::CreateLinearGradient(startPoint, endPoint, colors, position, TileMode::REPEAT);
195 EXPECT_TRUE(newShaderEffect != nullptr);
196 }
197
198 /*
199 * @tc.name: CreateRadialGradient001
200 * @tc.desc:
201 * @tc.type: FUNC
202 * @tc.require: AR000GGNV3
203 * @tc.author:
204 */
205 HWTEST_F(ShaderEffectTest, CreateRadialGradient001, TestSize.Level1)
206 {
207 Point centerPoint;
208 scalar radius = 0.5f;
209 std::vector<ColorQuad> colors;
210 std::vector<scalar> position;
211 TileMode tileMode = TileMode::MIRROR;
212 auto newShaderEffect = ShaderEffect::CreateRadialGradient(centerPoint, radius, colors, position, tileMode);
213 EXPECT_TRUE(newShaderEffect != nullptr);
214 }
215
216 /*
217 * @tc.name: CreateRadialGradient002
218 * @tc.desc:
219 * @tc.type: FUNC
220 * @tc.require: AR000GGNV3
221 * @tc.author:
222 */
223 HWTEST_F(ShaderEffectTest, CreateRadialGradient002, TestSize.Level1)
224 {
225 Point centerPoint;
226 scalar radius = 2.5f;
227 std::vector<ColorQuad> colors;
228 std::vector<scalar> position;
229 TileMode tileMode = TileMode::REPEAT;
230 auto newShaderEffect = ShaderEffect::CreateRadialGradient(centerPoint, radius, colors, position, tileMode);
231 EXPECT_TRUE(newShaderEffect != nullptr);
232 }
233
234 /*
235 * @tc.name: CreateTwoPointConical001
236 * @tc.desc:
237 * @tc.type: FUNC
238 * @tc.require: AR000GGNV3
239 * @tc.author:
240 */
241 HWTEST_F(ShaderEffectTest, CreateTwoPointConical001, TestSize.Level1)
242 {
243 Point startPoint;
244 scalar startRadius = 0.2f;
245 Point endPoint;
246 scalar endRadius = 0.5f;
247 std::vector<ColorQuad> colors;
248 std::vector<scalar> position;
249 TileMode tileMode = TileMode::MIRROR;
250 auto newShaderEffect =
251 ShaderEffect::CreateTwoPointConical(startPoint, startRadius, endPoint, endRadius, colors, position, tileMode);
252 EXPECT_TRUE(newShaderEffect != nullptr);
253 }
254
255 /*
256 * @tc.name: CreateTwoPointConical002
257 * @tc.desc:
258 * @tc.type: FUNC
259 * @tc.require: AR000GGNV3
260 * @tc.author:
261 */
262 HWTEST_F(ShaderEffectTest, CreateTwoPointConical002, TestSize.Level1)
263 {
264 Point startPoint;
265 scalar startRadius = 0.1f;
266 Point endPoint;
267 scalar endRadius = 0.7f;
268 std::vector<ColorQuad> colors;
269 std::vector<scalar> position;
270 TileMode tileMode = TileMode::REPEAT;
271 auto newShaderEffect =
272 ShaderEffect::CreateTwoPointConical(startPoint, startRadius, endPoint, endRadius, colors, position, tileMode);
273 EXPECT_TRUE(newShaderEffect != nullptr);
274 }
275
276 /*
277 * @tc.name: CreateSweepGradient001
278 * @tc.desc:
279 * @tc.type: FUNC
280 * @tc.require: AR000GGNV3
281 * @tc.author:
282 */
283 HWTEST_F(ShaderEffectTest, CreateSweepGradient001, TestSize.Level1)
284 {
285 Point centerPoint;
286 std::vector<ColorQuad> colors;
287 std::vector<scalar> position;
288 TileMode tileMode = TileMode::MIRROR;
289 scalar startAngle = 0.2f;
290 scalar endAngle = 0.5f;
291 auto newShaderEffect =
292 ShaderEffect::CreateSweepGradient(centerPoint, colors, position, tileMode, startAngle, endAngle);
293 EXPECT_TRUE(newShaderEffect != nullptr);
294 }
295
296 /*
297 * @tc.name: CreateSweepGradient002
298 * @tc.desc:
299 * @tc.type: FUNC
300 * @tc.require: AR000GGNV3
301 * @tc.author:
302 */
303 HWTEST_F(ShaderEffectTest, CreateSweepGradient002, TestSize.Level1)
304 {
305 Point centerPoint;
306 std::vector<ColorQuad> colors;
307 std::vector<scalar> position;
308 TileMode tileMode = TileMode::REPEAT;
309 scalar startAngle = 10.2f;
310 scalar endAngle = 10.5f;
311 auto newShaderEffect =
312 ShaderEffect::CreateSweepGradient(centerPoint, colors, position, tileMode, startAngle, endAngle);
313 EXPECT_TRUE(newShaderEffect != nullptr);
314 }
315
316 /*
317 * @tc.name: ArgsContructor001
318 * @tc.desc:
319 * @tc.type: FUNC
320 * @tc.require: AR000GGNV3
321 * @tc.author:
322 */
323 HWTEST_F(ShaderEffectTest, ArgsContructor001, TestSize.Level1)
324 {
325 auto newShaderEffect = std::make_unique<ShaderEffect>(ShaderEffect::ShaderEffectType::COLOR, 230);
326 ASSERT_TRUE(newShaderEffect != nullptr);
327 }
328
329 /*
330 * @tc.name: ArgsContructor002
331 * @tc.desc:
332 * @tc.type: FUNC
333 * @tc.require: AR000GGNV3
334 * @tc.author:
335 */
336 HWTEST_F(ShaderEffectTest, ArgsContructor002, TestSize.Level1)
337 {
338 auto newShaderEffect = std::make_unique<ShaderEffect>(ShaderEffect::ShaderEffectType::PICTURE, 100);
339 ASSERT_TRUE(newShaderEffect != nullptr);
340 }
341
342 /*
343 * @tc.name: ArgsContructor003
344 * @tc.desc:
345 * @tc.type: FUNC
346 * @tc.require: AR000GGNV3
347 * @tc.author:
348 */
349 HWTEST_F(ShaderEffectTest, ArgsContructor003, TestSize.Level1)
350 {
351 ShaderEffect shaderEffect3(ShaderEffect::ShaderEffectType::IMAGE, 55);
352 ShaderEffect shaderEffect4(ShaderEffect::ShaderEffectType::IMAGE, 100);
353 auto newShaderEffect = std::make_unique<ShaderEffect>(
354 ShaderEffect::ShaderEffectType::RADIAL_GRADIENT, shaderEffect3, shaderEffect4, BlendMode::SRC);
355 ASSERT_TRUE(newShaderEffect != nullptr);
356 }
357
358 /*
359 * @tc.name: ArgsContructor004
360 * @tc.desc:
361 * @tc.type: FUNC
362 * @tc.require: AR000GGNV3
363 * @tc.author:
364 */
365 HWTEST_F(ShaderEffectTest, ArgsContructor004, TestSize.Level1)
366 {
367 ShaderEffect shaderEffect3(ShaderEffect::ShaderEffectType::SWEEP_GRADIENT, 60);
368 ShaderEffect shaderEffect4(ShaderEffect::ShaderEffectType::IMAGE, 10);
369 auto newShaderEffect = std::make_unique<ShaderEffect>(
370 ShaderEffect::ShaderEffectType::SWEEP_GRADIENT, shaderEffect3, shaderEffect4, BlendMode::SRC);
371 ASSERT_TRUE(newShaderEffect != nullptr);
372 }
373
374 /*
375 * @tc.name: ArgsContructor005
376 * @tc.desc:
377 * @tc.type: FUNC
378 * @tc.require: AR000GGNV3
379 * @tc.author:
380 */
381 HWTEST_F(ShaderEffectTest, ArgsContructor005, TestSize.Level1)
382 {
383 Image image;
384 TileMode tileX = TileMode::REPEAT;
385 TileMode tileY = TileMode::MIRROR;
386 SamplingOptions sampling;
387 Matrix matrix;
388 auto newShaderEffect = std::make_unique<ShaderEffect>(
389 ShaderEffect::ShaderEffectType::CONICAL_GRADIENT, image, tileX, tileY, sampling, matrix);
390 ASSERT_TRUE(newShaderEffect != nullptr);
391 }
392
393 /*
394 * @tc.name: ArgsContructor006
395 * @tc.desc:
396 * @tc.type: FUNC
397 * @tc.require: AR000GGNV3
398 * @tc.author:
399 */
400 HWTEST_F(ShaderEffectTest, ArgsContructor006, TestSize.Level1)
401 {
402 Image image;
403 TileMode tileX = TileMode::REPEAT;
404 TileMode tileY = TileMode::CLAMP;
405 SamplingOptions sampling;
406 Matrix matrix;
407 auto newShaderEffect =
408 std::make_unique<ShaderEffect>(ShaderEffect::ShaderEffectType::PICTURE, image, tileX, tileY, sampling, matrix);
409 ASSERT_TRUE(newShaderEffect != nullptr);
410 }
411
412 /*
413 * @tc.name: ArgsContructor007
414 * @tc.desc:
415 * @tc.type: FUNC
416 * @tc.require: AR000GGNV3
417 * @tc.author:
418 */
419 HWTEST_F(ShaderEffectTest, ArgsContructor007, TestSize.Level1)
420 {
421 Image image;
422 SamplingOptions sampling;
423 Matrix matrix;
424 auto newShaderEffect = std::make_unique<ShaderEffect>(
425 ShaderEffect::ShaderEffectType::NO_TYPE, image, TileMode::CLAMP, TileMode::REPEAT, sampling, matrix);
426 ASSERT_TRUE(newShaderEffect != nullptr);
427 }
428
429 /*
430 * @tc.name: ArgsContructor008
431 * @tc.desc:
432 * @tc.type: FUNC
433 * @tc.require: AR000GGNV3
434 * @tc.author:
435 */
436 HWTEST_F(ShaderEffectTest, ArgsContructor008, TestSize.Level1)
437 {
438 Image image;
439 SamplingOptions sampling;
440 Matrix matrix;
441 auto newShaderEffect = std::make_unique<ShaderEffect>(
442 ShaderEffect::ShaderEffectType::CONICAL_GRADIENT, image, TileMode::REPEAT, TileMode::CLAMP, sampling, matrix);
443 ASSERT_TRUE(newShaderEffect != nullptr);
444 }
445
446 /*
447 * @tc.name: ArgsContructor009
448 * @tc.desc:
449 * @tc.type: FUNC
450 * @tc.require: AR000GGNV3
451 * @tc.author:
452 */
453 HWTEST_F(ShaderEffectTest, ArgsContructor009, TestSize.Level1)
454 {
455 Picture picture;
456 Rect rect;
457 Matrix matrix;
458 auto newShaderEffect = std::make_unique<ShaderEffect>(ShaderEffect::ShaderEffectType::PICTURE, picture,
459 TileMode::REPEAT, TileMode::MIRROR, FilterMode::LINEAR, matrix, rect);
460 ASSERT_TRUE(newShaderEffect != nullptr);
461 }
462
463 /*
464 * @tc.name: ArgsContructor010
465 * @tc.desc:
466 * @tc.type: FUNC
467 * @tc.require: AR000GGNV3
468 * @tc.author:
469 */
470 HWTEST_F(ShaderEffectTest, ArgsContructor010, TestSize.Level1)
471 {
472 Picture picture;
473 Rect rect;
474 Matrix matrix;
475 auto newShaderEffect = std::make_unique<ShaderEffect>(ShaderEffect::ShaderEffectType::CONICAL_GRADIENT, picture,
476 TileMode::MIRROR, TileMode::REPEAT, FilterMode::LINEAR, matrix, rect);
477 ASSERT_TRUE(newShaderEffect != nullptr);
478 }
479
480 /*
481 * @tc.name: ArgsContructor011
482 * @tc.desc:
483 * @tc.type: FUNC
484 * @tc.require: AR000GGNV3
485 * @tc.author:
486 */
487 HWTEST_F(ShaderEffectTest, ArgsContructor011, TestSize.Level1)
488 {
489 Point startPoint;
490 Point endPoint;
491 std::vector<ColorQuad> colors;
492 std::vector<scalar> position;
493 auto newShaderEffect = std::make_unique<ShaderEffect>(
494 ShaderEffect::ShaderEffectType::NO_TYPE, startPoint, endPoint, colors, position, TileMode::REPEAT);
495 ASSERT_TRUE(newShaderEffect != nullptr);
496 }
497
498 /*
499 * @tc.name: ArgsContructor012
500 * @tc.desc:
501 * @tc.type: FUNC
502 * @tc.require: AR000GGNV3
503 * @tc.author:
504 */
505 HWTEST_F(ShaderEffectTest, ArgsContructor012, TestSize.Level1)
506 {
507 Point startPoint;
508 Point endPoint;
509 std::vector<ColorQuad> colors;
510 std::vector<scalar> position;
511 auto newShaderEffect = std::make_unique<ShaderEffect>(
512 ShaderEffect::ShaderEffectType::COLOR, startPoint, endPoint, colors, position, TileMode::REPEAT);
513 ASSERT_TRUE(newShaderEffect != nullptr);
514 auto type = newShaderEffect->GetType();
515 EXPECT_EQ(type, ShaderEffect::ShaderEffectType::COLOR);
516 }
517
518 /*
519 * @tc.name: ArgsContructor013
520 * @tc.desc:
521 * @tc.type: FUNC
522 * @tc.require: AR000GGNV3
523 * @tc.author:
524 */
525 HWTEST_F(ShaderEffectTest, ArgsContructor013, TestSize.Level1)
526 {
527 Point centerPoint;
528 scalar radius = 0.5f;
529 std::vector<ColorQuad> colors;
530 std::vector<scalar> position;
531 auto newShaderEffect = std::make_unique<ShaderEffect>(
532 ShaderEffect::ShaderEffectType::SWEEP_GRADIENT, centerPoint, radius, colors, position, TileMode::REPEAT);
533 ASSERT_TRUE(newShaderEffect != nullptr);
534 auto type = newShaderEffect->GetType();
535 EXPECT_EQ(type, ShaderEffect::ShaderEffectType::SWEEP_GRADIENT);
536 }
537
538 /*
539 * @tc.name: ArgsContructor014
540 * @tc.desc:
541 * @tc.type: FUNC
542 * @tc.require: AR000GGNV3
543 * @tc.author:
544 */
545 HWTEST_F(ShaderEffectTest, ArgsContructor014, TestSize.Level1)
546 {
547 Point centerPoint;
548 scalar radius = 0.5f;
549 std::vector<ColorQuad> colors;
550 std::vector<scalar> position;
551 auto newShaderEffect = std::make_unique<ShaderEffect>(
552 ShaderEffect::ShaderEffectType::IMAGE, centerPoint, radius, colors, position, TileMode::REPEAT);
553 ASSERT_TRUE(newShaderEffect != nullptr);
554 }
555
556 /*
557 * @tc.name: ArgsContructor015
558 * @tc.desc:
559 * @tc.type: FUNC
560 * @tc.require: AR000GGNV3
561 * @tc.author:
562 */
563 HWTEST_F(ShaderEffectTest, ArgsContructor015, TestSize.Level1)
564 {
565 Point startPoint;
566 scalar startRadius = 0.1f;
567 Point endPoint;
568 scalar endRadius = 0.7f;
569 std::vector<ColorQuad> colors;
570 std::vector<scalar> position;
571 auto newShaderEffect = std::make_unique<ShaderEffect>(ShaderEffect::ShaderEffectType::COLOR, startPoint,
572 startRadius, endPoint, endRadius, colors, position, TileMode::REPEAT);
573 ASSERT_TRUE(newShaderEffect != nullptr);
574 }
575
576 /*
577 * @tc.name: ArgsContructor016
578 * @tc.desc:
579 * @tc.type: FUNC
580 * @tc.require: AR000GGNV3
581 * @tc.author:
582 */
583 HWTEST_F(ShaderEffectTest, ArgsContructor016, TestSize.Level1)
584 {
585 Point startPoint;
586 scalar startRadius = 55.1f;
587 Point endPoint;
588 scalar endRadius = 10.7f;
589 std::vector<ColorQuad> colors;
590 std::vector<scalar> position;
591 auto newShaderEffect = std::make_unique<ShaderEffect>(ShaderEffect::ShaderEffectType::LINEAR_GRADIENT, startPoint,
592 startRadius, endPoint, endRadius, colors, position, TileMode::REPEAT);
593 ASSERT_TRUE(newShaderEffect != nullptr);
594 }
595
596 /*
597 * @tc.name: ArgsContructor017
598 * @tc.desc:
599 * @tc.type: FUNC
600 * @tc.require: AR000GGNV3
601 * @tc.author:
602 */
603 HWTEST_F(ShaderEffectTest, ArgsContructor017, TestSize.Level1)
604 {
605 Point centerPoint;
606 scalar startAngle = 42.2f;
607 scalar endAngle = 55.7f;
608 std::vector<ColorQuad> colors;
609 std::vector<scalar> position;
610 auto newShaderEffect = std::make_unique<ShaderEffect>(
611 ShaderEffect::ShaderEffectType::BLEND, centerPoint, colors, position, TileMode::REPEAT, startAngle, endAngle);
612 ASSERT_TRUE(newShaderEffect != nullptr);
613 }
614
615 /*
616 * @tc.name: ArgsContructor017
617 * @tc.desc:
618 * @tc.type: FUNC
619 * @tc.require: AR000GGNV3
620 * @tc.author:
621 */
622 HWTEST_F(ShaderEffectTest, ArgsContructor018, TestSize.Level1)
623 {
624 Point centerPoint;
625 scalar startAngle = 3.55f;
626 scalar endAngle = 4.65f;
627 std::vector<ColorQuad> colors;
628 std::vector<scalar> position;
629 auto newShaderEffect = std::make_unique<ShaderEffect>(
630 ShaderEffect::ShaderEffectType::COLOR, centerPoint, colors, position, TileMode::REPEAT, startAngle, endAngle);
631 ASSERT_TRUE(newShaderEffect != nullptr);
632 }
633 } // namespace Drawing
634 } // namespace Rosen
635 } // namespace OHOS