1 /*
2 * Copyright (c) 2024 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 "ge_double_ripple_shader_mask.h"
19 #include "ge_radial_gradient_shader_mask.h"
20 #include "ge_ripple_shader_mask.h"
21 #include "ge_visual_effect_impl.h"
22 #include "ge_wave_gradient_shader_mask.h"
23 #include "utils/rect.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace GraphicsEffectEngine {
30
31 using namespace Rosen;
32
33 class GEVisualEffectImplTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 };
40
SetUpTestCase(void)41 void GEVisualEffectImplTest::SetUpTestCase(void) {}
42
TearDownTestCase(void)43 void GEVisualEffectImplTest::TearDownTestCase(void) {}
44
SetUp()45 void GEVisualEffectImplTest::SetUp() {}
46
TearDown()47 void GEVisualEffectImplTest::TearDown() {}
48
49 /**
50 * @tc.name: GetFilterType_001
51 * @tc.desc: Verify function GetFilterType
52 * @tc.type:FUNC
53 */
54 HWTEST_F(GEVisualEffectImplTest, GetFilterType_001, TestSize.Level2)
55 {
56 Drawing::GEVisualEffectImpl geVisualEffectImpl1(Drawing::GE_FILTER_KAWASE_BLUR);
57 EXPECT_EQ(geVisualEffectImpl1.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::KAWASE_BLUR);
58
59 Drawing::GEVisualEffectImpl geVisualEffectImpl2(Drawing::GE_FILTER_GREY);
60 EXPECT_EQ(geVisualEffectImpl2.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::GREY);
61
62 Drawing::GEVisualEffectImpl geVisualEffectImpl3(Drawing::GE_FILTER_AI_BAR);
63 EXPECT_EQ(geVisualEffectImpl3.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::AIBAR);
64
65 Drawing::GEVisualEffectImpl geVisualEffectImpl4(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR);
66 EXPECT_EQ(geVisualEffectImpl4.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::LINEAR_GRADIENT_BLUR);
67
68 Drawing::GEVisualEffectImpl geVisualEffectImplMESA(Drawing::GE_FILTER_MESA_BLUR);
69 EXPECT_EQ(geVisualEffectImplMESA.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::MESA_BLUR);
70
71 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_WATER_RIPPLE);
72 EXPECT_EQ(geVisualEffectImpl.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::WATER_RIPPLE);
73
74 Drawing::GEVisualEffectImpl geVisualEffectImplSound(Drawing::GE_FILTER_SOUND_WAVE);
75 EXPECT_EQ(geVisualEffectImplSound.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::SOUND_WAVE);
76
77 Drawing::GEVisualEffectImpl geVisualEffectImplEdgeLight(Drawing::GE_FILTER_EDGE_LIGHT);
78 EXPECT_EQ(geVisualEffectImplEdgeLight.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::EDGE_LIGHT);
79
80 Drawing::GEVisualEffectImpl geVisualEffectImplDispersion(Drawing::GE_FILTER_DISPERSION);
81 EXPECT_EQ(geVisualEffectImplDispersion.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::DISPERSION);
82
83 Drawing::GEVisualEffectImpl geVisualEffectImplLightCave(Drawing::GEX_SHADER_LIGHT_CAVE);
84 EXPECT_EQ(geVisualEffectImplLightCave.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::LIGHT_CAVE);
85 }
86
87 /**
88 * @tc.name: SetParam_001
89 * @tc.desc: Verify function SetParam
90 * @tc.type:FUNC
91 */
92 HWTEST_F(GEVisualEffectImplTest, SetParam_001, TestSize.Level2)
93 {
94 Drawing::GEVisualEffectImpl geVisualEffectImpl1(Drawing::GE_FILTER_KAWASE_BLUR);
95
96 // 1 set for Kawase blur RADIUS, linear gradient blur DIRECTION
97 int32_t paramInt32 { 1 };
98 geVisualEffectImpl1.SetParam(Drawing::GE_FILTER_KAWASE_BLUR_RADIUS, paramInt32);
99 ASSERT_NE(geVisualEffectImpl1.GetKawaseParams(), nullptr);
100 EXPECT_EQ(geVisualEffectImpl1.GetKawaseParams()->radius, paramInt32);
101
102 Drawing::GEVisualEffectImpl geVisualEffectImpl2(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR);
103 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_DIRECTION, paramInt32);
104 ASSERT_NE(geVisualEffectImpl2.GetLinearGradientBlurParams(), nullptr);
105 EXPECT_EQ(geVisualEffectImpl2.GetLinearGradientBlurParams()->direction, paramInt32);
106
107 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_IS_OFF_SCREEN, true);
108 EXPECT_EQ(geVisualEffectImpl2.GetLinearGradientBlurParams()->isOffscreenCanvas, true);
109
110 // 1.f is linear gradient blur params：blurRadius,geoWidth,geoHeight,tranX,tranY
111 float paramfloat { 1.f };
112 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_RADIUS, paramfloat);
113 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_GEO_WIDTH, paramfloat);
114 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_GEO_HEIGHT, paramfloat);
115 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_TRAN_X, paramfloat);
116 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_TRAN_Y, paramfloat);
117 EXPECT_EQ(geVisualEffectImpl2.GetLinearGradientBlurParams()->blurRadius, paramfloat);
118 EXPECT_EQ(geVisualEffectImpl2.GetLinearGradientBlurParams()->geoWidth, paramfloat);
119 EXPECT_EQ(geVisualEffectImpl2.GetLinearGradientBlurParams()->geoHeight, paramfloat);
120 EXPECT_EQ(geVisualEffectImpl2.GetLinearGradientBlurParams()->tranX, paramfloat);
121 EXPECT_EQ(geVisualEffectImpl2.GetLinearGradientBlurParams()->tranY, paramfloat);
122
123 auto image = std::make_shared<Drawing::Image>();
124 auto colorFilter = std::make_shared<Drawing::ColorFilter>(Drawing::ColorFilter::FilterType::NO_TYPE);
125 Drawing::Matrix mat;
126 int64_t paramInt64 { 1 }; // 1 is linear gradient blur params：CANVAS_MAT
127 geVisualEffectImpl1.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_CANVAS_MAT, paramInt64);
128 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR, image);
129 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR, colorFilter);
130
131 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_CANVAS_MAT, mat);
132 EXPECT_EQ(geVisualEffectImpl2.GetLinearGradientBlurParams()->mat, mat);
133
134 // 0.1f, 0.1f is linear gradient blur params: FRACTION_STOPS
135 std::vector<std::pair<float, float>> expectFraStops { { 0.1f, 0.1f } };
136 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_FRACTION_STOPS, expectFraStops);
137 EXPECT_EQ(geVisualEffectImpl2.GetLinearGradientBlurParams()->fractionStops, expectFraStops);
138 }
139
140 /**
141 * @tc.name: SetParam_002
142 * @tc.desc: Verify function SetParam
143 * @tc.type:FUNC
144 */
145 HWTEST_F(GEVisualEffectImplTest, SetParam_002, TestSize.Level1)
146 {
147 // 1.0f is params of AI Bar blur, Grey blur
148 float paramfloat { 1.0f };
149 Drawing::GEVisualEffectImpl geVisualEffectImpl1(Drawing::GE_FILTER_AI_BAR);
150 geVisualEffectImpl1.SetParam(Drawing::GE_FILTER_AI_BAR_LOW, paramfloat);
151 geVisualEffectImpl1.SetParam(Drawing::GE_FILTER_AI_BAR_HIGH, paramfloat);
152 geVisualEffectImpl1.SetParam(Drawing::GE_FILTER_AI_BAR_THRESHOLD, paramfloat);
153 geVisualEffectImpl1.SetParam(Drawing::GE_FILTER_AI_BAR_OPACITY, paramfloat);
154 geVisualEffectImpl1.SetParam(Drawing::GE_FILTER_AI_BAR_SATURATION, paramfloat);
155 ASSERT_NE(geVisualEffectImpl1.GetAIBarParams(), nullptr);
156 EXPECT_EQ(geVisualEffectImpl1.GetAIBarParams()->aiBarLow, paramfloat);
157 EXPECT_EQ(geVisualEffectImpl1.GetAIBarParams()->aiBarHigh, paramfloat);
158 EXPECT_EQ(geVisualEffectImpl1.GetAIBarParams()->aiBarThreshold, paramfloat);
159 EXPECT_EQ(geVisualEffectImpl1.GetAIBarParams()->aiBarOpacity, paramfloat);
160 EXPECT_EQ(geVisualEffectImpl1.GetAIBarParams()->aiBarSaturation, paramfloat);
161
162 Drawing::GEVisualEffectImpl geVisualEffectImpl2(Drawing::GE_FILTER_GREY);
163 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_GREY_COEF_1, paramfloat);
164 geVisualEffectImpl2.SetParam(Drawing::GE_FILTER_GREY_COEF_2, paramfloat);
165 ASSERT_NE(geVisualEffectImpl2.GetGreyParams(), nullptr);
166 EXPECT_EQ(geVisualEffectImpl2.GetGreyParams()->greyCoef1, paramfloat);
167 EXPECT_EQ(geVisualEffectImpl2.GetGreyParams()->greyCoef2, paramfloat);
168 }
169
170 /**
171 * @tc.name: SetParam_003
172 * @tc.desc: Verify function SetParam no filter type
173 * @tc.type:FUNC
174 */
175 HWTEST_F(GEVisualEffectImplTest, SetParam_003, TestSize.Level1)
176 {
177 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
178 geVisualEffectImpl.SetParam("", 0); // 0 invalid params
179 geVisualEffectImpl.SetParam("", false);
180 geVisualEffectImpl.SetParam("", 1.0f); // 1.0f invalid params
181 geVisualEffectImpl.SetParam("", 1.0f); // 1.0f invalid params
182 Drawing::Matrix blurMat;
183 geVisualEffectImpl.SetParam("", blurMat);
184 std::vector<std::pair<float, float>> blurFractionStops;
185 geVisualEffectImpl.SetParam("", blurFractionStops);
186 geVisualEffectImpl.SetAIBarParams("", 1.0f); // 1.0f invalid params
187 geVisualEffectImpl.SetGreyParams("", 1.0f); // 1.0f invalid params
188 geVisualEffectImpl.SetLinearGradientBlurParams("", 1.0f); // 1.0f invalid params
189 EXPECT_EQ(geVisualEffectImpl.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::NONE);
190 }
191
192 /**
193 * @tc.name: SetParam_004
194 * @tc.desc: Verify function SetParam for param is nullptr when filtertype is NONE
195 * @tc.type:FUNC
196 */
197 HWTEST_F(GEVisualEffectImplTest, SetParam_004, TestSize.Level1)
198 {
199 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
200 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::KAWASE_BLUR);
201 geVisualEffectImpl.SetParam("", 0); // 0 invalid params
202
203 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::LINEAR_GRADIENT_BLUR);
204 geVisualEffectImpl.SetParam("", 0); // 0 invalid params
205 geVisualEffectImpl.SetParam("", false);
206 Drawing::Matrix blurMat;
207 geVisualEffectImpl.SetParam("", blurMat);
208 std::vector<std::pair<float, float>> blurFractionStops;
209 geVisualEffectImpl.SetParam("", blurFractionStops);
210
211 EXPECT_EQ(geVisualEffectImpl.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::LINEAR_GRADIENT_BLUR);
212 }
213
214 /**
215 * @tc.name: SetParam_005
216 * @tc.desc: Verify function SetParam for tag is invalid
217 * @tc.type:FUNC
218 */
219 HWTEST_F(GEVisualEffectImplTest, SetParam_005, TestSize.Level1)
220 {
221 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_KAWASE_BLUR);
222 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_KAWASE_BLUR_RADIUS, 2); // 2 blur radius
223 EXPECT_EQ(geVisualEffectImpl.GetKawaseParams()->radius, 2);
224 geVisualEffectImpl.SetParam("", 3); // 3 blur radius, but invalid
225 EXPECT_NE(geVisualEffectImpl.GetKawaseParams()->radius, 3);
226 }
227
228 /**
229 * @tc.name: SetParam_006
230 * @tc.desc: Verify function SetParam for tag is invalid
231 * @tc.type:FUNC
232 */
233 HWTEST_F(GEVisualEffectImplTest, SetParam_006, TestSize.Level1)
234 {
235 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR);
236 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_DIRECTION, 2); // 2 blur direction
237 EXPECT_EQ(geVisualEffectImpl.GetLinearGradientBlurParams()->direction, 2);
238 geVisualEffectImpl.SetParam("", 3); // 3 blur direction, but invalid
239 EXPECT_NE(geVisualEffectImpl.GetLinearGradientBlurParams()->direction, 3);
240
241 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_IS_OFF_SCREEN, true);
242 EXPECT_TRUE(geVisualEffectImpl.GetLinearGradientBlurParams()->isOffscreenCanvas);
243 geVisualEffectImpl.SetParam("", false);
244 EXPECT_TRUE(geVisualEffectImpl.GetLinearGradientBlurParams()->isOffscreenCanvas);
245
246 Drawing::Matrix blurMat;
247 blurMat.Set(Drawing::Matrix::SKEW_X, 0.002f); // 0.002f skew x
248 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_CANVAS_MAT, blurMat);
249 EXPECT_EQ(geVisualEffectImpl.GetLinearGradientBlurParams()->mat, blurMat);
250 Drawing::Matrix mat;
251 mat.Set(Drawing::Matrix::SKEW_X, 0.005f); // 0.005f skew x
252 geVisualEffectImpl.SetParam("", mat);
253 EXPECT_EQ(geVisualEffectImpl.GetLinearGradientBlurParams()->mat, blurMat);
254
255 std::vector<std::pair<float, float>> blurFractionStops { { 0.1f, 0.1f } };
256 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_FRACTION_STOPS, blurFractionStops);
257 EXPECT_EQ(geVisualEffectImpl.GetLinearGradientBlurParams()->fractionStops, blurFractionStops);
258 std::vector<std::pair<float, float>> expectFractionStops { { 0.2f, 0.2f } };
259 geVisualEffectImpl.SetParam("", expectFractionStops);
260 EXPECT_EQ(geVisualEffectImpl.GetLinearGradientBlurParams()->fractionStops, blurFractionStops);
261 }
262
263 /**
264 * @tc.name: SetParam_007
265 * @tc.desc: Verify function SetParam for action is invalid
266 * @tc.type:FUNC
267 */
268 HWTEST_F(GEVisualEffectImplTest, SetParam_007, TestSize.Level1)
269 {
270 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_AI_BAR);
271 geVisualEffectImpl.SetAIBarParams(Drawing::GE_FILTER_AI_BAR_LOW, 1.0f);
272 EXPECT_EQ(geVisualEffectImpl.GetAIBarParams()->aiBarLow, 1.0f);
273 geVisualEffectImpl.SetAIBarParams("", 2.0f);
274 EXPECT_NE(geVisualEffectImpl.GetAIBarParams()->aiBarLow, 2.0f);
275 }
276
277 /**
278 * @tc.name: SetParam_008
279 * @tc.desc: Verify function SetParam for action is invalid
280 * @tc.type:FUNC
281 */
282 HWTEST_F(GEVisualEffectImplTest, SetParam_008, TestSize.Level1)
283 {
284 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_GREY);
285 geVisualEffectImpl.SetGreyParams(Drawing::GE_FILTER_GREY_COEF_1, 1.0f);
286 EXPECT_EQ(geVisualEffectImpl.GetGreyParams()->greyCoef1, 1.0f);
287 geVisualEffectImpl.SetGreyParams("", 2.0f);
288 EXPECT_NE(geVisualEffectImpl.GetGreyParams()->greyCoef1, 2.0f);
289 }
290
291 /**
292 * @tc.name: SetParam_009
293 * @tc.desc: Verify function SetParam for action is invalid
294 * @tc.type:FUNC
295 */
296 HWTEST_F(GEVisualEffectImplTest, SetParam_009, TestSize.Level1)
297 {
298 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR);
299 geVisualEffectImpl.SetLinearGradientBlurParams(Drawing::GE_FILTER_LINEAR_GRADIENT_BLUR_RADIUS, 1.0f);
300 EXPECT_EQ(geVisualEffectImpl.GetLinearGradientBlurParams()->blurRadius, 1.0f);
301 geVisualEffectImpl.SetLinearGradientBlurParams("", 2.0f);
302 EXPECT_NE(geVisualEffectImpl.GetLinearGradientBlurParams()->blurRadius, 2.0f);
303 }
304
305 /**
306 * @tc.name: SetParam_010
307 * @tc.desc: Verify function SetParam for action is invalid
308 * @tc.type:FUNC
309 */
310 HWTEST_F(GEVisualEffectImplTest, SetParam_010, TestSize.Level1)
311 {
312 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_WATER_RIPPLE);
313 geVisualEffectImpl.SetWaterRippleParams(Drawing::GE_FILTER_WATER_RIPPLE_PROGRESS, 0.5f);
314 EXPECT_EQ(geVisualEffectImpl.GetWaterRippleParams()->progress, 0.5f);
315 geVisualEffectImpl.SetWaterRippleParams(Drawing::GE_FILTER_WATER_RIPPLE_RIPPLE_CENTER_X, 0.5f);
316 EXPECT_EQ(geVisualEffectImpl.GetWaterRippleParams()->rippleCenterX, 0.5f);
317 geVisualEffectImpl.SetWaterRippleParams(Drawing::GE_FILTER_WATER_RIPPLE_RIPPLE_CENTER_Y, 0.5f);
318 EXPECT_EQ(geVisualEffectImpl.GetWaterRippleParams()->rippleCenterY, 0.5f);
319 geVisualEffectImpl.SetWaterRippleParams(Drawing::GE_FILTER_WATER_RIPPLE_RIPPLE_MODE, 1.0f);
320 EXPECT_EQ(geVisualEffectImpl.GetWaterRippleParams()->rippleMode, 1.0f);
321 }
322
323 /**
324 * @tc.name: SetParam_011
325 * @tc.desc: Verify function SetParam for action is invalid
326 * @tc.type:FUNC
327 */
328 HWTEST_F(GEVisualEffectImplTest, SetParam_011, TestSize.Level1)
329 {
330 Drawing::GEVisualEffectImpl geVisualEffectImplWaterRipple(Drawing::GE_FILTER_WATER_RIPPLE);
331 Drawing::GEVisualEffectImpl geVisualEffectImplKawaseBulr(Drawing::GE_FILTER_KAWASE_BLUR);
332
333 // test invalid params setting
334 geVisualEffectImplWaterRipple.SetParam(Drawing::GE_FILTER_WATER_RIPPLE_PROGRESS, 0.5);
335 EXPECT_NE(geVisualEffectImplWaterRipple.GetWaterRippleParams()->progress, 0.5);
336
337 // test invalid params setting
338 uint32_t paramUint32 { 1 };
339 geVisualEffectImplKawaseBulr.SetParam("GE_FILTER_KAWASE_BLUR_RADIUS", paramUint32);
340 ASSERT_NE(geVisualEffectImplKawaseBulr.GetKawaseParams(), nullptr);
341 EXPECT_NE(geVisualEffectImplKawaseBulr.GetKawaseParams()->radius, paramUint32);
342
343 geVisualEffectImplKawaseBulr.SetParam("GE_FILTER_KAWASE_BLUR_RADIUS", "1");
344 ASSERT_NE(geVisualEffectImplKawaseBulr.GetKawaseParams(), nullptr);
345 EXPECT_NE(geVisualEffectImplKawaseBulr.GetKawaseParams()->radius, paramUint32);
346 }
347
348 /**
349 * @tc.name: SetParam_026
350 * @tc.desc: Verify function SetParam for action is invalid
351 * @tc.type: FUNC
352 */
353 HWTEST_F(GEVisualEffectImplTest, SetParam_026, TestSize.Level1)
354 {
355 float paramFloat = 1.0f;
356 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GEX_SHADER_COLOR_GRADIENT_EFFECT);
357 geVisualEffectImpl.SetParam(Drawing::GEX_SHADER_COLOR_GRADIENT_EFFECT_COLOR_NUMBER, paramFloat);
358
359 Vector4f c4 = {0.0f, 0.0f, 0.0f, 0.0f};
360 geVisualEffectImpl.SetParam(Drawing::GEX_SHADER_COLOR_GRADIENT_EFFECT_COLOR0, c4);
361
362 std::pair<float, float> p2 = {0.0f, 0.0f};
363 geVisualEffectImpl.SetParam(Drawing::GEX_SHADER_COLOR_GRADIENT_EFFECT_POS0, p2);
364
365 ASSERT_NE(geVisualEffectImpl.GetColorGradientEffectParams(), nullptr);
366 EXPECT_EQ(geVisualEffectImpl.GetColorGradientEffectParams()->colorNum_, paramFloat);
367 EXPECT_EQ(geVisualEffectImpl.GetColorGradientEffectParams()->colors_[0].redF_, c4[0]);
368 EXPECT_EQ(geVisualEffectImpl.GetColorGradientEffectParams()->colors_[0].greenF_, c4[1]);
369 EXPECT_EQ(geVisualEffectImpl.GetColorGradientEffectParams()->colors_[0].blueF_, c4[2]);
370 EXPECT_EQ(geVisualEffectImpl.GetColorGradientEffectParams()->colors_[0].alphaF_, c4[3]);
371
372 EXPECT_EQ(geVisualEffectImpl.GetColorGradientEffectParams()->positions_[0].GetX(), p2.first);
373 EXPECT_EQ(geVisualEffectImpl.GetColorGradientEffectParams()->positions_[0].GetY(), p2.second);
374 }
375
376 /**
377 * @tc.name: SetSoundWaveParams001
378 * @tc.desc: Verify function SetSoundWaveParams for float
379 * @tc.type:FUNC
380 */
381 HWTEST_F(GEVisualEffectImplTest, SetSoundWaveParams001, TestSize.Level1)
382 {
383 Drawing::GEVisualEffectImpl geVisualEffectImplSoundWave(Drawing::GE_FILTER_SOUND_WAVE);
384 float colorProgress = 0.5f;
385 geVisualEffectImplSoundWave.SetParam(Drawing::GE_FILTER_SOUND_WAVE_COLORPROGRESS, colorProgress);
386 EXPECT_NE(geVisualEffectImplSoundWave.GetSoundWaveParams(), nullptr);
387
388 // test valid sound wave params setting
389 geVisualEffectImplSoundWave.SetSoundWaveParams(Drawing::GE_FILTER_SOUND_WAVE_COLORPROGRESS, 0.5f);
390 EXPECT_EQ(geVisualEffectImplSoundWave.GetSoundWaveParams()->colorProgress, 0.5f);
391 geVisualEffectImplSoundWave.SetSoundWaveParams(Drawing::GE_FILTER_SOUND_WAVE_SOUNDINTENSITY, 1.0f);
392 EXPECT_EQ(geVisualEffectImplSoundWave.GetSoundWaveParams()->soundIntensity, 1.0f);
393 geVisualEffectImplSoundWave.SetSoundWaveParams(Drawing::GE_FILTER_SOUND_WAVE_SHOCKWAVEALPHA_A, 0.6f);
394 EXPECT_EQ(geVisualEffectImplSoundWave.GetSoundWaveParams()->shockWaveAlphaA, 0.6f);
395 geVisualEffectImplSoundWave.SetSoundWaveParams(Drawing::GE_FILTER_SOUND_WAVE_SHOCKWAVEALPHA_B, 1.0f);
396 EXPECT_EQ(geVisualEffectImplSoundWave.GetSoundWaveParams()->shockWaveAlphaB, 1.0f);
397 geVisualEffectImplSoundWave.SetSoundWaveParams(Drawing::GE_FILTER_SOUND_WAVE_SHOCKWAVEPROGRESS_A, 1.0f);
398 EXPECT_EQ(geVisualEffectImplSoundWave.GetSoundWaveParams()->shockWaveProgressA, 1.0f);
399 geVisualEffectImplSoundWave.SetSoundWaveParams(Drawing::GE_FILTER_SOUND_WAVE_SHOCKWAVEPROGRESS_B, 1.0f);
400 EXPECT_EQ(geVisualEffectImplSoundWave.GetSoundWaveParams()->shockWaveProgressB, 1.0f);
401 geVisualEffectImplSoundWave.SetSoundWaveParams(Drawing::GE_FILTER_SOUND_WAVE_TOTAL_ALPHA, 0.5f);
402 EXPECT_EQ(geVisualEffectImplSoundWave.GetSoundWaveParams()->shockWaveTotalAlpha, 0.5f);
403 }
404
405 /**
406 * @tc.name: SetSoundWaveParam002
407 * @tc.desc: Verify function SetSoundWaveParams
408 * @tc.type:FUNC
409 */
410 HWTEST_F(GEVisualEffectImplTest, SetSoundWaveParam002, TestSize.Level1)
411 {
412 Drawing::GEVisualEffectImpl geVisualEffectImplSoundWave("");
413 float param = 1.2f;
414
415 // test invalid params setting
416 geVisualEffectImplSoundWave.SetSoundWaveParams(Drawing::GE_FILTER_SOUND_WAVE_COLORPROGRESS, param);
417 EXPECT_EQ(geVisualEffectImplSoundWave.GetSoundWaveParams(), nullptr);
418
419 Drawing::GEVisualEffectImpl geVisualEffectImplSoundWave1(Drawing::GE_FILTER_SOUND_WAVE);
420 EXPECT_NE(geVisualEffectImplSoundWave1.GetSoundWaveParams(), nullptr);
421
422 geVisualEffectImplSoundWave1.SetSoundWaveParams("", param);
423 EXPECT_NE(geVisualEffectImplSoundWave1.GetSoundWaveParams()->shockWaveProgressB, param);
424 }
425
426 /**
427 * @tc.name: SetParam_013
428 * @tc.desc: Verify function SetParam for action is invalid
429 * @tc.type:FUNC
430 */
431 HWTEST_F(GEVisualEffectImplTest, SetParam_013, TestSize.Level1)
432 {
433 Drawing::GEVisualEffectImpl geVisualEffectImplRippleMask(Drawing::GE_MASK_RIPPLE);
434 geVisualEffectImplRippleMask.filterType_ = Drawing::GEVisualEffectImpl::FilterType::RIPPLE_MASK;
435 geVisualEffectImplRippleMask.rippleMaskParams_ = std::make_shared<Drawing::GERippleShaderMaskParams>();
436
437 // test invalid params setting
438 float rippleRadius = 0.5f;
439 geVisualEffectImplRippleMask.SetParam("RippleMask_Radius", rippleRadius);
440 EXPECT_EQ(geVisualEffectImplRippleMask.rippleMaskParams_->radius_, rippleRadius);
441
442 float rippleWidth = 0.6f;
443 geVisualEffectImplRippleMask.SetParam("RippleMask_Width", rippleWidth);
444 EXPECT_EQ(geVisualEffectImplRippleMask.rippleMaskParams_->width_, rippleWidth);
445
446 float centerOffset = 0.7f;
447 geVisualEffectImplRippleMask.SetParam("RippleMask_Offset", centerOffset);
448 EXPECT_EQ(geVisualEffectImplRippleMask.rippleMaskParams_->widthCenterOffset_, centerOffset);
449 }
450
451 /**
452 * @tc.name: SetParam_014
453 * @tc.desc: Verify function SetParam for action is invalid
454 * @tc.type:FUNC
455 */
456 HWTEST_F(GEVisualEffectImplTest, SetParam_014, TestSize.Level1)
457 {
458 Drawing::GEVisualEffectImpl geVisualEffectImplRippleMask(Drawing::GE_MASK_RIPPLE);
459 geVisualEffectImplRippleMask.filterType_ = Drawing::GEVisualEffectImpl::FilterType::RIPPLE_MASK;
460 geVisualEffectImplRippleMask.rippleMaskParams_ = std::make_shared<Drawing::GERippleShaderMaskParams>();
461
462 std::pair<float, float> center = {0.5f, 0.5f};
463 geVisualEffectImplRippleMask.SetParam("RippleMask_Center", center);
464 EXPECT_EQ(geVisualEffectImplRippleMask.rippleMaskParams_->center_, center);
465
466
467 std::pair<float, float> factor = {0.5f, 0.5f};
468 Drawing::GEVisualEffectImpl geVisualEffectImplDisplaceDistort(Drawing::GE_FILTER_DISPLACEMENT_DISTORT);
469 geVisualEffectImplDisplaceDistort.filterType_ =
470 Drawing::GEVisualEffectImpl::FilterType::DISPLACEMENT_DISTORT_FILTER;
471 geVisualEffectImplDisplaceDistort.displacementDistortParams_ =
472 std::make_shared<Drawing::GEDisplacementDistortFilterParams>();
473 geVisualEffectImplDisplaceDistort.SetParam("DispDistort_Factor", factor);
474 EXPECT_EQ(geVisualEffectImplDisplaceDistort.displacementDistortParams_->factor_, factor);
475 }
476
477 /**
478 * @tc.name: SetParam_015
479 * @tc.desc: Verify function SetParam for action is invalid
480 * @tc.type:FUNC
481 */
482 HWTEST_F(GEVisualEffectImplTest, SetParam_015, TestSize.Level1)
483 {
484 Drawing::GERippleShaderMaskParams param;
485 auto geRippleShaderMask = std::make_shared<Drawing::GERippleShaderMask>(param);
486 auto shaderMask = std::static_pointer_cast<Drawing::GEShaderMask>(geRippleShaderMask);
487 Drawing::GEVisualEffectImpl geVisualEffectImplDisplaceDistort(Drawing::GE_FILTER_DISPLACEMENT_DISTORT);
488 geVisualEffectImplDisplaceDistort.filterType_ =
489 Drawing::GEVisualEffectImpl::FilterType::DISPLACEMENT_DISTORT_FILTER;
490 geVisualEffectImplDisplaceDistort.displacementDistortParams_ =
491 std::make_shared<Drawing::GEDisplacementDistortFilterParams>();
492 geVisualEffectImplDisplaceDistort.SetParam("DispDistort_Mask", shaderMask);
493 EXPECT_EQ(geVisualEffectImplDisplaceDistort.displacementDistortParams_->mask_, shaderMask);
494 }
495
496 /**
497 * @tc.name: SetParam_016
498 * @tc.desc: Verify function SetParam for action is invalid
499 * @tc.type:FUNC
500 */
501 HWTEST_F(GEVisualEffectImplTest, SetParam_016, TestSize.Level1)
502 {
503 constexpr size_t BEZIER_WARP_POINT_NUM = 12; // 12 anchor points of a patch
504 std::array<Drawing::Point, BEZIER_WARP_POINT_NUM> points = {{
505 {1.0f, 2.0f},
506 {3.0f, 4.0f},
507 {5.0f, 6.0f},
508 {7.0f, 8.0f},
509 {9.0f, 10.0f},
510 {11.0f, 12.0f},
511 {13.0f, 14.0f},
512 {15.0f, 16.0f},
513 {17.0f, 18.0f},
514 {19.0f, 20.0f},
515 {21.0f, 22.0f},
516 {23.0f, 24.0f}
517 }};
518 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_BEZIER_WARP);
519 geVisualEffectImpl.MakeBezierWarpParams();
520 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_BEZIER_WARP_DESTINATION_PATCH, points);
521 EXPECT_EQ(geVisualEffectImpl.bezierWarpParams_->destinationPatch, points);
522 }
523
524 /**
525 * @tc.name: SetParamEdgelight_001
526 * @tc.desc: Verify function SetParam for action is invalid
527 * @tc.type:FUNC
528 */
529 HWTEST_F(GEVisualEffectImplTest, SetParamEdgelight_001, TestSize.Level1)
530 {
531 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_EDGE_LIGHT);
532
533 geVisualEffectImpl.SetEdgeLightParams(Drawing::GE_FILTER_EDGE_LIGHT_ALPHA, 0.5f);
534 EXPECT_EQ(geVisualEffectImpl.GetEdgeLightParams()->alpha, 0.5f);
535
536 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_EDGE_LIGHT_BLOOM, true);
537 EXPECT_EQ(geVisualEffectImpl.GetEdgeLightParams()->bloom, true);
538
539 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_EDGE_LIGHT_BLOOM, false);
540 EXPECT_EQ(geVisualEffectImpl.GetEdgeLightParams()->bloom, false);
541
542 Vector4f color = Vector4f{0.2f, 0.7f, 0.1f, 0.0f};
543 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_EDGE_LIGHT_COLOR, color);
544 EXPECT_EQ(geVisualEffectImpl.GetEdgeLightParams()->color, color);
545
546 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_EDGE_LIGHT_USE_RAW_COLOR, true);
547 EXPECT_EQ(geVisualEffectImpl.GetEdgeLightParams()->useRawColor, true);
548
549 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_EDGE_LIGHT_USE_RAW_COLOR, false);
550 EXPECT_EQ(geVisualEffectImpl.GetEdgeLightParams()->useRawColor, false);
551
552 Drawing::GERadialGradientShaderMaskParams param;
553 auto geRadialGradientShaderMask = std::make_shared<Drawing::GERadialGradientShaderMask>(param);
554 auto shaderMask = std::static_pointer_cast<Drawing::GEShaderMask>(geRadialGradientShaderMask);
555 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_EDGE_LIGHT_MASK, shaderMask);
556 EXPECT_EQ(geVisualEffectImpl.GetEdgeLightParams()->mask, shaderMask);
557 }
558
559 /**
560 * @tc.name: SetParamBezierWarpTest_001
561 * @tc.desc: Verify function SetParam for action is valid, bezier filter adapt ng filter
562 * @tc.type:FUNC
563 */
564 HWTEST_F(GEVisualEffectImplTest, SetParamBezierWarpTest_001, TestSize.Level1)
565 {
566 constexpr size_t BEZIER_WARP_POINT_NUM = 12; // 12 anchor points of a patch
567 std::array<Drawing::Point, BEZIER_WARP_POINT_NUM> points = {{
568 {0.0f, 0.0f},
569 {0.0f, 0.0f},
570 {0.0f, 0.0f},
571 {0.0f, 0.0f},
572 {0.0f, 0.0f},
573 {0.0f, 0.0f},
574 {0.0f, 0.0f},
575 {0.0f, 0.0f},
576 {0.0f, 0.0f},
577 {0.0f, 0.0f},
578 {0.0f, 0.0f},
579 {0.0f, 0.0f}
580 }};
581 Drawing::GEVisualEffectImpl geVisualEffectImplTest(Drawing::GE_FILTER_EDGE_LIGHT);
582 EXPECT_EQ(geVisualEffectImplTest.bezierWarpParams_, nullptr);
583
584 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_BEZIER_WARP);
585 geVisualEffectImpl.MakeBezierWarpParams();
586 EXPECT_NE(geVisualEffectImpl.bezierWarpParams_, nullptr);
587
588 geVisualEffectImpl.SetBezierWarpParams(Drawing::GE_FILTER_BEZIER_WARP_CONTROL_POINT0, std::make_pair(0.5f, 0.5f));
589 EXPECT_FLOAT_EQ(geVisualEffectImpl.GetBezierWarpParams()->destinationPatch[0].GetX(), 0.5f);
590
591 geVisualEffectImpl.SetBezierWarpParams(Drawing::GE_FILTER_BEZIER_WARP_CONTROL_POINT11, std::make_pair(1.f, 1.f));
592 EXPECT_FLOAT_EQ(geVisualEffectImpl.GetBezierWarpParams()->destinationPatch[11].GetY(), 1.f);
593 }
594
595 /**
596 * @tc.name: SetParamDispersion_001
597 * @tc.desc: Verify function SetParam for action is invalid
598 * @tc.type:FUNC
599 */
600 HWTEST_F(GEVisualEffectImplTest, SetParamDispersion_001, TestSize.Level1)
601 {
602 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_DISPERSION);
603 geVisualEffectImpl.SetDispersionParams(Drawing::GE_FILTER_DISPERSION_OPACITY, 0.5f);
604 EXPECT_EQ(geVisualEffectImpl.GetDispersionParams()->opacity, 0.5f);
605 geVisualEffectImpl.SetDispersionParams(Drawing::GE_FILTER_DISPERSION_RED_OFFSET, std::make_pair(0.5f, 0.5f));
606 EXPECT_EQ(geVisualEffectImpl.GetDispersionParams()->redOffset, std::make_pair(0.5f, 0.5f));
607 geVisualEffectImpl.SetDispersionParams(Drawing::GE_FILTER_DISPERSION_GREEN_OFFSET, std::make_pair(0.5f, 0.5f));
608 EXPECT_EQ(geVisualEffectImpl.GetDispersionParams()->greenOffset, std::make_pair(0.5f, 0.5f));
609 geVisualEffectImpl.SetDispersionParams(Drawing::GE_FILTER_DISPERSION_BLUE_OFFSET, std::make_pair(0.5f, 0.5f));
610 EXPECT_EQ(geVisualEffectImpl.GetDispersionParams()->blueOffset, std::make_pair(0.5f, 0.5f));
611 }
612
613 /**
614 * @tc.name: SetWaterRippleParams_001
615 * @tc.desc: Verify function SetWaterRippleParams is invalid
616 * @tc.type:FUNC
617 */
618 HWTEST_F(GEVisualEffectImplTest, SetWaterRippleParams_001, TestSize.Level1)
619 {
620 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_WATER_RIPPLE);
621 ASSERT_NE(geVisualEffectImpl.waterRippleParams_, nullptr);
622 geVisualEffectImpl.SetWaterRippleParams(Drawing::GE_FILTER_WATER_RIPPLE_PROGRESS, 0.5f);
623 EXPECT_EQ(geVisualEffectImpl.GetWaterRippleParams()->progress, 0.5f);
624 geVisualEffectImpl.SetWaterRippleParams(Drawing::GE_FILTER_WATER_RIPPLE_RIPPLE_CENTER_X, 0.5f);
625 EXPECT_EQ(geVisualEffectImpl.GetWaterRippleParams()->rippleCenterX, 0.5f);
626 geVisualEffectImpl.SetWaterRippleParams(Drawing::GE_FILTER_WATER_RIPPLE_RIPPLE_CENTER_Y, 0.5f);
627 EXPECT_EQ(geVisualEffectImpl.GetWaterRippleParams()->rippleCenterY, 0.5f);
628 geVisualEffectImpl.SetWaterRippleParams(Drawing::GE_FILTER_WATER_RIPPLE_RIPPLE_MODE, 1.0f);
629 EXPECT_EQ(geVisualEffectImpl.GetWaterRippleParams()->rippleMode, 1.0f);
630 }
631
632 /**
633 * @tc.name: SetWaterRippleParams_002
634 * @tc.desc: Verify function SetWaterRippleParams
635 * @tc.type:FUNC
636 */
637 HWTEST_F(GEVisualEffectImplTest, SetWaterRippleParams_002, TestSize.Level1)
638 {
639 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_WATER_RIPPLE);
640
641 // test invalid params setting
642 geVisualEffectImpl.SetWaterRippleParams("GE_FILTER_WATER_RIPPLE_PROGRESS", 0.5f);
643 EXPECT_NE(geVisualEffectImpl.GetWaterRippleParams()->progress, 0.5f);
644 }
645
646 /**
647 * @tc.name: MakeWaterRippleParams_001
648 * @tc.desc: Verify function MakeWaterRippleParams is invalid
649 * @tc.type:FUNC
650 */
651 HWTEST_F(GEVisualEffectImplTest, MakeWaterRippleParams_001, TestSize.Level1)
652 {
653 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
654 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::WATER_RIPPLE);
655 ASSERT_EQ(geVisualEffectImpl.GetWaterRippleParams(), nullptr);
656 geVisualEffectImpl.MakeWaterRippleParams();
657 ASSERT_NE(geVisualEffectImpl.GetWaterRippleParams(), nullptr);
658 }
659
660 /**
661 * @tc.name: GetMESAParams_001
662 * @tc.desc: Verify function GetMESAParams
663 * @tc.type:FUNC
664 */
665 HWTEST_F(GEVisualEffectImplTest, GetMESAParams_001, TestSize.Level1)
666 {
667 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_MESA_BLUR);
668 // 0.0f, 1, 1.0f: mesa blur params
669 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_RADIUS, 1);
670 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_GREY_COEF_1, 1.0f);
671 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_GREY_COEF_2, 1.0f);
672 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_OFFSET_X, 0.0f);
673 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_OFFSET_Y, 0.0f);
674 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_OFFSET_Z, 0.0f);
675 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_OFFSET_W, 0.0f);
676 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_TILE_MODE, 0);
677 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_WIDTH, 0.0f);
678 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_MESA_BLUR_STRETCH_HEIGHT, 0.0f);
679 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->radius, 1);
680 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->greyCoef1, 1.0f);
681 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->greyCoef1, 1.0f);
682 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->offsetX, 0.0f);
683 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->offsetY, 0.0f);
684 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->offsetZ, 0.0f);
685 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->offsetW, 0.0f);
686 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->tileMode, 0);
687 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->width, 0.0f);
688 EXPECT_EQ(geVisualEffectImpl.GetMESAParams()->height, 0.0f);
689 }
690
691 /**
692 * @tc.name: SetParam_012
693 * @tc.desc: Verify function SetParam for param is nullptr
694 * @tc.type:FUNC
695 */
696 HWTEST_F(GEVisualEffectImplTest, SetParam_012, TestSize.Level1)
697 {
698 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
699 int32_t paramInt32 { 0 }; // 0 invalid params
700 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::KAWASE_BLUR);
701 geVisualEffectImpl.SetParam("", paramInt32);
702
703 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::MESA_BLUR);
704 geVisualEffectImpl.SetParam("", paramInt32);
705
706 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::MAGNIFIER);
707 geVisualEffectImpl.SetParam("", paramInt32);
708
709 uint32_t paramUint32 { 0 }; // 0 invalid params
710 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::WATER_RIPPLE);
711 geVisualEffectImpl.SetParam("", paramUint32);
712
713 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::LINEAR_GRADIENT_BLUR);
714 geVisualEffectImpl.SetParam("", paramInt32);
715
716 EXPECT_EQ(geVisualEffectImpl.GetFilterType(), Drawing::GEVisualEffectImpl::FilterType::LINEAR_GRADIENT_BLUR);
717 }
718
719 /**
720 * @tc.name: SetParam_017
721 * @tc.desc: Verify function SetParam for param is nullptr
722 * @tc.type:FUNC
723 */
724 HWTEST_F(GEVisualEffectImplTest, SetParam_017, TestSize.Level1)
725 {
726 Drawing::GEVisualEffectImpl geVisualEffectImplTest("");
727 Drawing::Color4f colorTestA = {0.0, 1.0, 1.0, 1.0};
728 Drawing::Color4f colorTestB = {1.0, 0.0, 1.0, 1.0};
729 Drawing::Color4f colorTestC = {1.0, 1.0, 0.0, 1.0};
730 geVisualEffectImplTest.SetParam(Drawing::GE_FILTER_SOUND_WAVE_COLOR_A, colorTestA);
731 EXPECT_EQ(geVisualEffectImplTest.GetSoundWaveParams(), nullptr);
732
733 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_SOUND_WAVE);
734 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::SOUND_WAVE);
735 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_SOUND_WAVE_COLOR_A, colorTestA);
736 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_SOUND_WAVE_COLOR_B, colorTestB);
737 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_SOUND_WAVE_COLOR_C, colorTestC);
738 EXPECT_EQ(geVisualEffectImpl.GetSoundWaveParams()->colorA.redF_, 0.0f);
739 EXPECT_EQ(geVisualEffectImpl.GetSoundWaveParams()->colorB.greenF_, 0.0f);
740 EXPECT_EQ(geVisualEffectImpl.GetSoundWaveParams()->colorC.blueF_, 0.0f);
741 }
742
743 /**
744 * @tc.name: SetParam_020
745 * @tc.desc: Verify function SetParam for param is content light
746 * @tc.type: FUNC
747 */
748 HWTEST_F(GEVisualEffectImplTest, SetParam_020, TestSize.Level1)
749 {
750 Drawing::GEVisualEffectImpl geVisualEffectImplTest("");
751 float lightIntensity = 0.5f;
752 geVisualEffectImplTest.SetParam(Drawing::GE_FILTER_CONTENT_LIGHT_INTENSITY, lightIntensity);
753 EXPECT_EQ(geVisualEffectImplTest.GetContentLightParams(), nullptr);
754
755 Drawing::GEVisualEffectImpl geVisualEffectImpl(Drawing::GE_FILTER_CONTENT_LIGHT);
756 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::CONTENT_LIGHT);
757
758 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_CONTENT_LIGHT_INTENSITY, lightIntensity);
759 EXPECT_EQ(geVisualEffectImpl.GetContentLightParams()->intensity, lightIntensity);
760
761 Vector3f lightPosition = Vector3f(0.0f, 0.0f, 0.0f);
762 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_CONTENT_LIGHT_POSITION, lightPosition);
763 EXPECT_EQ(geVisualEffectImpl.GetContentLightParams()->position, lightPosition);
764
765 Vector4f lightColor = Vector4f(0.3f, 0.6f, 0.9f, 0.0f);
766 geVisualEffectImpl.SetParam(Drawing::GE_FILTER_CONTENT_LIGHT_COLOR, lightColor);
767 EXPECT_EQ(geVisualEffectImpl.GetContentLightParams()->color, lightColor);
768 }
769
770 /**
771 * @tc.name: SetParam_021
772 * @tc.desc: Verify function SetParam for pixelMapMask params
773 * @tc.type: FUNC
774 */
775 HWTEST_F(GEVisualEffectImplTest, SetParam_021, TestSize.Level1)
776 {
777 Drawing::GEVisualEffectImpl geVisualEffectImplPixelMapMask(Drawing::GE_MASK_PIXEL_MAP);
778 geVisualEffectImplPixelMapMask.filterType_ = Drawing::GEVisualEffectImpl::FilterType::PIXEL_MAP_MASK;
779 geVisualEffectImplPixelMapMask.pixelMapMaskParams_ = std::make_shared<Drawing::GEPixelMapMaskParams>();
780
781 Drawing::RectF srcRect = Drawing::RectF(0.0f, 0.0f, 100.0f, 100.0f);
782 geVisualEffectImplPixelMapMask.SetParam("PixelMapMask_Src", srcRect);
783 EXPECT_EQ(geVisualEffectImplPixelMapMask.pixelMapMaskParams_->src, srcRect);
784
785 Drawing::RectF dstRect = Drawing::RectF(0.0f, 0.0f, 200.0f, 200.0f);
786 geVisualEffectImplPixelMapMask.SetParam("PixelMapMask_Dst", dstRect);
787 EXPECT_EQ(geVisualEffectImplPixelMapMask.pixelMapMaskParams_->dst, dstRect);
788
789 Vector4f fillColor = Vector4f(1.0f, 0.5f, 0.2f, 0.8f);
790 geVisualEffectImplPixelMapMask.SetParam("PixelMapMask_FillColor", fillColor);
791 EXPECT_EQ(geVisualEffectImplPixelMapMask.pixelMapMaskParams_->fillColor, fillColor);
792
793 auto testImage = std::make_shared<Drawing::Image>();
794 geVisualEffectImplPixelMapMask.SetParam("PixelMapMask_Image", testImage);
795 EXPECT_EQ(geVisualEffectImplPixelMapMask.pixelMapMaskParams_->image, testImage);
796 }
797
798 /**
799 * @tc.name: SetParam_022
800 * @tc.desc: Verify function SetParam for action is invalid
801 * @tc.type: FUNC
802 */
803 HWTEST_F(GEVisualEffectImplTest, SetParam_022, TestSize.Level1)
804 {
805 Drawing::GEVisualEffectImpl geVisualEffectImplWaveGradientMask(Drawing::GE_MASK_WAVE_GRADIENT);
806 geVisualEffectImplWaveGradientMask.filterType_ = Drawing::GEVisualEffectImpl::FilterType::WAVE_GRADIENT_MASK;
807 geVisualEffectImplWaveGradientMask.waveGradientMaskParams_ =
808 std::make_shared<Drawing::GEWaveGradientShaderMaskParams>();
809
810 // test invalid params setting
811 float width = 0.5f;
812 geVisualEffectImplWaveGradientMask.SetParam("WaveGradientMask_WaveWidth", width);
813 EXPECT_EQ(geVisualEffectImplWaveGradientMask.waveGradientMaskParams_->width_, width);
814
815 float turbulenceStrength = 0.5f;
816 geVisualEffectImplWaveGradientMask.SetParam("WaveGradientMask_TurbulenceStrength", turbulenceStrength);
817 EXPECT_EQ(geVisualEffectImplWaveGradientMask.waveGradientMaskParams_->turbulenceStrength_, turbulenceStrength);
818
819 float blurRadius = 0.5f;
820 geVisualEffectImplWaveGradientMask.SetParam("WaveGradientMask_BlurRadius", blurRadius);
821 EXPECT_EQ(geVisualEffectImplWaveGradientMask.waveGradientMaskParams_->blurRadius_, blurRadius);
822
823 float propagationRadius = 0.5f;
824 geVisualEffectImplWaveGradientMask.SetParam("WaveGradientMask_PropagationRadius", propagationRadius);
825 EXPECT_EQ(geVisualEffectImplWaveGradientMask.waveGradientMaskParams_->propagationRadius_, propagationRadius);
826
827 std::pair<float, float> center = {-2.5f, -2.5f};
828 geVisualEffectImplWaveGradientMask.SetParam("WaveGradientMask_WaveCenter", center);
829 EXPECT_EQ(geVisualEffectImplWaveGradientMask.waveGradientMaskParams_->center_, center);
830 }
831
832 /**
833 * @tc.name: SetParam_023
834 * @tc.desc: Verify function SetParam for action is invalid
835 * @tc.type: FUNC
836 */
837 HWTEST_F(GEVisualEffectImplTest, SetParam_023, TestSize.Level1)
838 {
839 Drawing::GEWaveGradientShaderMaskParams param;
840 auto geWaveGradientShaderMask = std::make_shared<Drawing::GEWaveGradientShaderMask>(param);
841 auto shaderMask = std::static_pointer_cast<Drawing::GEShaderMask>(geWaveGradientShaderMask);
842
843 Drawing::GEVisualEffectImpl geVisualEffectImplDisplaceDistort(Drawing::GE_FILTER_DISPLACEMENT_DISTORT);
844 geVisualEffectImplDisplaceDistort.filterType_ =
845 Drawing::GEVisualEffectImpl::FilterType::DISPLACEMENT_DISTORT_FILTER;
846 geVisualEffectImplDisplaceDistort.displacementDistortParams_ =
847 std::make_shared<Drawing::GEDisplacementDistortFilterParams>();
848 geVisualEffectImplDisplaceDistort.SetParam("DispDistort_Mask", shaderMask);
849 EXPECT_EQ(geVisualEffectImplDisplaceDistort.displacementDistortParams_->mask_, shaderMask);
850 }
851
852 /**
853 * @tc.name: SetParam_024
854 * @tc.desc: Verify function SetParam for DoubleRippleMask is invalid
855 * @tc.type: FUNC
856 */
857 HWTEST_F(GEVisualEffectImplTest, SetParam_024, TestSize.Level1)
858 {
859 Drawing::GEVisualEffectImpl geVisualEffectImplDoubleRippleMask(Drawing::GE_MASK_DOUBLE_RIPPLE);
860 geVisualEffectImplDoubleRippleMask.filterType_ = Drawing::GEVisualEffectImpl::FilterType::DOUBLE_RIPPLE_MASK;
861 geVisualEffectImplDoubleRippleMask.doubleRippleMaskParams_ =
862 std::make_shared<Drawing::GEDoubleRippleShaderMaskParams>();
863
864 // test invalid params setting
865 std::pair<float, float> center1 = {-2.5f, -2.5f};
866 geVisualEffectImplDoubleRippleMask.SetParam("DoubleRippleMask_Center1", center1);
867 EXPECT_EQ(geVisualEffectImplDoubleRippleMask.doubleRippleMaskParams_->center1_, center1);
868
869 std::pair<float, float> center2 = {2.5f, 2.5f};
870 geVisualEffectImplDoubleRippleMask.SetParam("DoubleRippleMask_Center2", center2);
871 EXPECT_EQ(geVisualEffectImplDoubleRippleMask.doubleRippleMaskParams_->center2_, center2);
872
873 float radius = 0.5f;
874 geVisualEffectImplDoubleRippleMask.SetParam("DoubleRippleMask_Radius", radius);
875 EXPECT_EQ(geVisualEffectImplDoubleRippleMask.doubleRippleMaskParams_->radius_, radius);
876
877 float width = 0.5f;
878 geVisualEffectImplDoubleRippleMask.SetParam("DoubleRippleMask_Width", width);
879 EXPECT_EQ(geVisualEffectImplDoubleRippleMask.doubleRippleMaskParams_->width_, width);
880
881 float turbulence = 0.5f;
882 geVisualEffectImplDoubleRippleMask.SetParam("DoubleRippleMask_Turbulence", turbulence);
883 EXPECT_EQ(geVisualEffectImplDoubleRippleMask.doubleRippleMaskParams_->turbulence_, turbulence);
884 }
885
886 /**
887 * @tc.name: SetParam_025
888 * @tc.desc: Verify function SetParam for DoubleRippleMask is invalid
889 * @tc.type: FUNC
890 */
891 HWTEST_F(GEVisualEffectImplTest, SetParam_025, TestSize.Level1)
892 {
893 Drawing::GEDoubleRippleShaderMaskParams param;
894 auto geDoubleRippleShaderMask = std::make_shared<Drawing::GEDoubleRippleShaderMask>(param);
895 auto shaderMask = std::static_pointer_cast<Drawing::GEShaderMask>(geDoubleRippleShaderMask);
896
897 Drawing::GEVisualEffectImpl geVisualEffectImplDisplaceDistort(Drawing::GE_FILTER_DISPLACEMENT_DISTORT);
898 geVisualEffectImplDisplaceDistort.filterType_ =
899 Drawing::GEVisualEffectImpl::FilterType::DISPLACEMENT_DISTORT_FILTER;
900 geVisualEffectImplDisplaceDistort.displacementDistortParams_ =
901 std::make_shared<Drawing::GEDisplacementDistortFilterParams>();
902 geVisualEffectImplDisplaceDistort.SetParam("DispDistort_Mask", shaderMask);
903 EXPECT_EQ(geVisualEffectImplDisplaceDistort.displacementDistortParams_->mask_, shaderMask);
904 }
905
906 /**
907 * @tc.name: MakeDoubleRippleMaskParams_001
908 * @tc.desc: Verify function DoubleRippleMaskParams
909 * @tc.type: FUNC
910 */
911 HWTEST_F(GEVisualEffectImplTest, DoubleRippleMaskParams_001, TestSize.Level1)
912 {
913 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
914 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::DOUBLE_RIPPLE_MASK);
915 EXPECT_EQ(geVisualEffectImpl.GetDoubleRippleMaskParams(), nullptr);
916
917 geVisualEffectImpl.MakeDoubleRippleMaskParams();
918 EXPECT_NE(geVisualEffectImpl.GetDoubleRippleMaskParams(), nullptr);
919 }
920
921 /**
922 * @tc.name: MakeWaveGradientMaskParams_001
923 * @tc.desc: Verify function WaveGradientMaskParams
924 * @tc.type: FUNC
925 */
926 HWTEST_F(GEVisualEffectImplTest, WaveGradientMaskParams_001, TestSize.Level1)
927 {
928 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
929 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::WAVE_GRADIENT_MASK);
930 EXPECT_EQ(geVisualEffectImpl.GetWaveGradientMaskParams(), nullptr);
931
932 geVisualEffectImpl.MakeWaveGradientMaskParams();
933 EXPECT_NE(geVisualEffectImpl.GetWaveGradientMaskParams(), nullptr);
934 }
935
936 /**
937 * @tc.name: MakePixelMapMaskParams_001
938 * @tc.desc: Verify function MakePixelMapMaskParams is invalid
939 * @tc.type: FUNC
940 */
941 HWTEST_F(GEVisualEffectImplTest, MakePixelMapMaskParams_001, TestSize.Level1)
942 {
943 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
944 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::PIXEL_MAP_MASK);
945 ASSERT_EQ(geVisualEffectImpl.GetPixelMapMaskParams(), nullptr);
946
947 geVisualEffectImpl.MakePixelMapMaskParams();
948 ASSERT_NE(geVisualEffectImpl.GetPixelMapMaskParams(), nullptr);
949 }
950
951 /**
952 * @tc.name: SetAllParam_001
953 * @tc.desc: Verify function Set All Param for param is nullptr
954 * @tc.type: FUNC
955 */
956 HWTEST_F(GEVisualEffectImplTest, SetAllParam_001, TestSize.Level1)
957 {
958 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
959 uint32_t paramUint32 { 0 };
960 float paramFloat { 1.0f };
961 EXPECT_EQ(geVisualEffectImpl.GetMESAParams(), nullptr);
962
963 geVisualEffectImpl.SetMESABlurParams("", paramFloat);
964 geVisualEffectImpl.SetMagnifierParamsFloat("", paramFloat);
965 geVisualEffectImpl.SetMagnifierParamsUint32("", paramUint32);
966 geVisualEffectImpl.SetWaterRippleParams("", paramFloat);
967 geVisualEffectImpl.SetRippleMaskParamsFloat("", paramFloat);
968 geVisualEffectImpl.SetWaveGradientMaskParamsFloat("", paramFloat);
969 geVisualEffectImpl.SetDoubleRippleMaskParamsFloat("", paramFloat);
970 }
971
972 /**
973 * @tc.name: SetAllParam_002
974 * @tc.desc: Verify function Set XXX Param for param is not nullptr and tag is invalid
975 * @tc.type:FUNC
976 */
977 HWTEST_F(GEVisualEffectImplTest, SetAllParam_002, TestSize.Level1)
978 {
979 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
980 uint32_t paramUint32 { 0 };
981 float paramFloat { 1.0f };
982
983 geVisualEffectImpl.MakeMESAParams();
984 EXPECT_NE(geVisualEffectImpl.GetMESAParams(), nullptr);
985 geVisualEffectImpl.SetMESABlurParams("", paramFloat);
986
987 geVisualEffectImpl.MakeMagnifierParams();
988 EXPECT_NE(geVisualEffectImpl.GetMagnifierParams(), nullptr);
989 geVisualEffectImpl.SetMagnifierParamsFloat("", paramFloat);
990 geVisualEffectImpl.SetMagnifierParamsUint32("", paramUint32);
991
992 int32_t paramInt32 { 0 };
993 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::MAGNIFIER);
994 geVisualEffectImpl.SetParam("", paramInt32);
995 }
996
997 /**
998 * @tc.name: SetColorGradientParam_001
999 * @tc.desc: Verify function Set ColorGradient Param
1000 * @tc.type:FUNC
1001 */
1002 HWTEST_F(GEVisualEffectImplTest, SetColorGradientParam_001, TestSize.Level1)
1003 {
1004 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
1005
1006 geVisualEffectImpl.SetParam("", nullptr);
1007 EXPECT_EQ(geVisualEffectImpl.GetColorGradientParams(), nullptr);
1008
1009 Drawing::GEVisualEffectImpl geVisualEffectImpl1(Drawing::GE_FILTER_DISPLACEMENT_DISTORT);
1010 geVisualEffectImpl.SetParam("", nullptr);
1011 EXPECT_EQ(geVisualEffectImpl1.GetColorGradientParams(), nullptr);
1012 }
1013
1014 /**
1015 * @tc.name: SetColorGradientParam_002
1016 * @tc.desc: Verify function Set ColorGradient Param
1017 * @tc.type:FUNC
1018 */
1019 HWTEST_F(GEVisualEffectImplTest, SetColorGradientParam_002, TestSize.Level1)
1020 {
1021 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
1022 std::vector<float> param;
1023 geVisualEffectImpl.SetParam("", param);
1024 EXPECT_EQ(geVisualEffectImpl.GetColorGradientParams(), nullptr);
1025
1026 Drawing::GEVisualEffectImpl geVisualEffectImpl1(Drawing::GE_FILTER_DISPLACEMENT_DISTORT);
1027 geVisualEffectImpl.SetParam("", param);
1028 EXPECT_EQ(geVisualEffectImpl1.GetColorGradientParams(), nullptr);
1029
1030 geVisualEffectImpl1.MakeColorGradientParams();
1031 param = {0.1f, 0.5f}; // 0.1f, 0.5f is param of ColorGradient
1032 geVisualEffectImpl.SetParam("", param);
1033 EXPECT_NE(geVisualEffectImpl1.GetColorGradientParams(), nullptr);
1034 EXPECT_TRUE(geVisualEffectImpl1.GetColorGradientParams()->colors.empty());
1035 }
1036
1037 /**
1038 * @tc.name: SetContentLightParams_001
1039 * @tc.desc: Verify function Set ContentLight Param
1040 * @tc.type:FUNC
1041 */
1042 HWTEST_F(GEVisualEffectImplTest, SetContentLightParams_001, TestSize.Level1)
1043 {
1044 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
1045 float param = 0.5f;
1046 geVisualEffectImpl.SetParam("", param);
1047 EXPECT_EQ(geVisualEffectImpl.GetContentLightParams(), nullptr);
1048
1049 Drawing::GEVisualEffectImpl geVisualEffectImpl1(Drawing::GE_FILTER_DISPLACEMENT_DISTORT);
1050 geVisualEffectImpl.SetParam("", param);
1051 EXPECT_EQ(geVisualEffectImpl1.GetContentLightParams(), nullptr);
1052
1053 geVisualEffectImpl1.MakeContentLightParams();
1054 geVisualEffectImpl.SetParam("", param);
1055 EXPECT_NE(geVisualEffectImpl1.GetContentLightParams(), nullptr);
1056 }
1057
1058 /**
1059 * @tc.name: SetLightCaveParamsTest
1060 * @tc.desc: Verify function Set LightCave Param
1061 * @tc.type:FUNC
1062 */
1063 HWTEST_F(GEVisualEffectImplTest, SetLightCaveParamsTest, TestSize.Level1)
1064 {
1065 Drawing::GEVisualEffectImpl geVisualEffectImpl("");
1066 geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::LIGHT_CAVE);
1067 EXPECT_EQ(geVisualEffectImpl.GetLightCaveParams(), nullptr);
1068
1069 // init param data
1070 Vector4f color = Vector4f(0.5f, 0.5f, 0.5f, 1.0f); // 0.5f, 0.5f, 0.5f, 1.0f is RGBA
1071 std::pair<float, float> position = {0.5f, 0.5f}; // 0.5f, 0.5f is random number
1072 std::pair<float, float> randerXY = {0.6f, 0.7f}; // 0.6f, 0.7f is random number
1073 float progress = 0.5f; // 0.5f is random number
1074
1075 geVisualEffectImpl.SetLightCaveParams("", color);
1076 geVisualEffectImpl.SetLightCaveParams("", position);
1077 geVisualEffectImpl.SetLightCaveParams("", progress);
1078 EXPECT_EQ(geVisualEffectImpl.lightCaveShaderParams_, nullptr);
1079
1080 geVisualEffectImpl.MakeLightCaveParams();
1081 ASSERT_NE(geVisualEffectImpl.GetLightCaveParams(), nullptr);
1082
1083 geVisualEffectImpl.SetParam("", color);
1084 EXPECT_NE(geVisualEffectImpl.lightCaveShaderParams_->colorA, color);
1085
1086 geVisualEffectImpl.SetParam(Drawing::GEX_SHADER_LIGHT_CAVE_COLORA, color);
1087 EXPECT_EQ(geVisualEffectImpl.lightCaveShaderParams_->colorA, color);
1088
1089 geVisualEffectImpl.SetParam(Drawing::GEX_SHADER_LIGHT_CAVE_COLORB, color);
1090 EXPECT_EQ(geVisualEffectImpl.lightCaveShaderParams_->colorB, color);
1091
1092 geVisualEffectImpl.SetParam(Drawing::GEX_SHADER_LIGHT_CAVE_COLORC, color);
1093 EXPECT_EQ(geVisualEffectImpl.lightCaveShaderParams_->colorC, color);
1094
1095 geVisualEffectImpl.SetParam("", position);
1096 EXPECT_NE(geVisualEffectImpl.lightCaveShaderParams_->position, Vector2f(position.first, position.second));
1097
1098 geVisualEffectImpl.SetParam(Drawing::GEX_SHADER_LIGHT_CAVE_POSITION, position);
1099 EXPECT_EQ(geVisualEffectImpl.lightCaveShaderParams_->position, Vector2f(position.first, position.second));
1100
1101 geVisualEffectImpl.SetParam(Drawing::GEX_SHADER_LIGHT_CAVE_RADIUSXY, randerXY);
1102 EXPECT_EQ(geVisualEffectImpl.lightCaveShaderParams_->radiusXY, Vector2f(randerXY.first, randerXY.second));
1103
1104 geVisualEffectImpl.SetParam("", progress);
1105 EXPECT_NE(geVisualEffectImpl.lightCaveShaderParams_->progress, progress);
1106
1107 geVisualEffectImpl.SetParam(Drawing::GEX_SHADER_LIGHT_CAVE_PROGRESS, progress);
1108 EXPECT_EQ(geVisualEffectImpl.lightCaveShaderParams_->progress, progress);
1109 }
1110 } // namespace GraphicsEffectEngine
1111 } // namespace OHOS
1112