1 /*
2 * Copyright (c) 2025 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_radial_gradient_shader_mask.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Rosen {
25 namespace Drawing {
26
27 class GERadialGradientShaderMaskTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 void SetUp() override;
32 void TearDown() override;
33 };
34
SetUpTestCase(void)35 void GERadialGradientShaderMaskTest::SetUpTestCase(void) {}
TearDownTestCase(void)36 void GERadialGradientShaderMaskTest::TearDownTestCase(void) {}
37
SetUp()38 void GERadialGradientShaderMaskTest::SetUp() {}
TearDown()39 void GERadialGradientShaderMaskTest::TearDown() {}
40
41 /**
42 * @tc.name: GenerateDrawingShader_001
43 * @tc.desc: Verify the GenerateDrawingShader function
44 * @tc.type: FUNC
45 */
46 HWTEST_F(GERadialGradientShaderMaskTest, GenerateDrawingShader_001, TestSize.Level1)
47 {
48 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShader_001 start";
49 GERadialGradientShaderMaskParams param;
50 param.center_ = {0.5f, 0.5f};
51 param.radiusX_ = 1.0f;
52 param.radiusY_ = 1.0f;
53 param.colors_ = {0.0f, 1.0f};
54 param.positions_ = {0.0f, 1.0f};
55
56 GERadialGradientShaderMask mask(param);
57 auto shader = mask.GenerateDrawingShader(0.5f, 0.5f);
58 EXPECT_NE(shader, nullptr);
59 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShader_001 end";
60 }
61
62 /**
63 * @tc.name: GenerateDrawingShader_002
64 * @tc.desc: Verify GenerateDrawingShader returns null when radius is too small
65 * @tc.type: FUNC
66 */
67 HWTEST_F(GERadialGradientShaderMaskTest, GenerateDrawingShader_002, TestSize.Level1)
68 {
69 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShader_002 start";
70 GERadialGradientShaderMaskParams param;
71 param.radiusX_ = 0.0f;
72 param.radiusY_ = 0.0f;
73 GERadialGradientShaderMask mask(param);
74 auto shader = mask.GenerateDrawingShader(100.0f, 100.0f);
75 EXPECT_EQ(shader, nullptr);
76
77 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShader_002 end";
78 }
79
80 /**
81 * @tc.name: GenerateDrawingShader_003
82 * @tc.desc: Verify GenerateDrawingShader handles invalid colors and positions
83 * @tc.type: FUNC
84 */
85 HWTEST_F(GERadialGradientShaderMaskTest, GenerateDrawingShader_003, TestSize.Level1)
86 {
87 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShader_003 start";
88 GERadialGradientShaderMaskParams param;
89 param.colors_.clear();
90 param.positions_.clear();
91 GERadialGradientShaderMask mask(param);
92 auto shader = mask.GenerateDrawingShader(100.0f, 100.0f);
93 EXPECT_EQ(shader, nullptr);
94 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShader_003 end";
95 }
96
97 /**
98 * @tc.name: GenerateDrawingShaderHasNormal_001
99 * @tc.desc: Verify GenerateDrawingShaderHasNormal returns non-null shader with valid parameters
100 * @tc.type: FUNC
101 */
102 HWTEST_F(GERadialGradientShaderMaskTest, GenerateDrawingShaderHasNormal_001, TestSize.Level1)
103 {
104 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShaderHasNormal_001 start";
105 GERadialGradientShaderMaskParams param;
106 param.center_ = {0.5f, 0.5f};
107 param.radiusX_ = 1.0f;
108 param.radiusY_ = 1.0f;
109 param.colors_.push_back(0.0f);
110 param.colors_.push_back(1.0f);
111 param.positions_.push_back(0.0f);
112 param.positions_.push_back(1.0f);
113
114 GERadialGradientShaderMask mask(param);
115 auto shader = mask.GenerateDrawingShaderHasNormal(100.0f, 100.0f);
116 EXPECT_NE(shader, nullptr);
117
118 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShaderHasNormal_001 end";
119 }
120
121 /**
122 * @tc.name: GenerateDrawingShaderHasNormal_002
123 * @tc.desc: Verify GenerateDrawingShaderHasNormal returns null when parameters are invalid
124 * @tc.type: FUNC
125 */
126 HWTEST_F(GERadialGradientShaderMaskTest, GenerateDrawingShaderHasNormal_002, TestSize.Level1)
127 {
128 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShaderHasNormal_002 start";
129 GERadialGradientShaderMaskParams param;
130 param.radiusX_ = 0.0f;
131 param.radiusY_ = 0.0f;
132 GERadialGradientShaderMask mask(param);
133 auto shader = mask.GenerateDrawingShaderHasNormal(100.0f, 100.0f);
134 EXPECT_EQ(shader, nullptr);
135
136 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateDrawingShaderHasNormal_002 end";
137 }
138
139 /**
140 * @tc.name: GenerateShaderEffect_001
141 * @tc.desc: Verify GenerateShaderEffect sets uniforms correctly
142 * @tc.type: FUNC
143 */
144 HWTEST_F(GERadialGradientShaderMaskTest, GenerateShaderEffect_001, TestSize.Level1)
145 {
146 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateShaderEffect_001 start";
147 GERadialGradientShaderMaskParams param;
148 param.center_ = {0.5f, 0.5f};
149 param.radiusX_ = 1.0f;
150 param.radiusY_ = 1.0f;
151 param.colors_ = {0.0f, 1.0f};
152 param.positions_ = {0.0f, 1.0f};
153
154 GERadialGradientShaderMask mask(param);
155 auto shader = mask.GenerateDrawingShader(100.0f, 100.0f);
156 EXPECT_NE(shader, nullptr);
157
158 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateShaderEffect_001 end";
159 }
160
161 /**
162 * @tc.name: GenerateShaderEffect_002
163 * @tc.desc: Verify GenerateShaderEffect returns null for invalid parameters
164 * @tc.type: FUNC
165 */
166 HWTEST_F(GERadialGradientShaderMaskTest, GenerateShaderEffect_002, TestSize.Level1)
167 {
168 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateShaderEffect_002 start";
169 // colorSize <= 0
170 GERadialGradientShaderMaskParams param;
171 param.colors_.clear();
172 param.positions_.clear();
173 GERadialGradientShaderMask mask(param);
174 auto shader = mask.GenerateDrawingShader(100.0f, 100.0f);
175 EXPECT_EQ(shader, nullptr);
176
177 // colorSize != positionSize
178 GERadialGradientShaderMaskParams param2;
179 param2.center_ = {0.5f, 0.5f};
180 param2.radiusX_ = 1.0f;
181 param2.radiusY_ = 1.0f;
182 param2.colors_.assign(12, 1.0f);
183 param2.positions_ = {0.0f, 1.0f};
184 GERadialGradientShaderMask mask2(param2);
185 auto shader2 = mask2.GenerateDrawingShader(100.0f, 100.0f);
186 EXPECT_EQ(shader2, nullptr);
187
188 // colorSize > SIZE_ARRAY
189 param2.colors_.assign(15, 1.0f);
190 GERadialGradientShaderMask mask3(param2);
191 auto shader3 = mask3.GenerateDrawingShader(100.0f, 100.0f);
192 EXPECT_EQ(shader3, nullptr);
193
194 // width < 0.01f || height < 0.01f
195 param2.colors_ = {0.0f, 1.0f};
196 param2.positions_ = {0.0f, 1.0f};
197 GERadialGradientShaderMask mask4(param2);
198 auto shader4 = mask4.GenerateDrawingShader(0.0f, 100.0f);
199 EXPECT_EQ(shader4, nullptr);
200 GERadialGradientShaderMask mask5(param2);
201 auto shader5 = mask5.GenerateDrawingShader(100.0f, 0.0f);
202 EXPECT_EQ(shader5, nullptr);
203
204 // param_.radiusX_ < 0.001f || param_.radiusY_ < 0.001f
205 param2.radiusX_ = 0.0f;
206 GERadialGradientShaderMask mask6(param2);
207 auto shader6 = mask6.GenerateDrawingShader(100.0f, 100.0f);
208 EXPECT_EQ(shader6, nullptr);
209 param2.radiusX_ = 1.0f;
210 param2.radiusY_ = 0.0f;
211 GERadialGradientShaderMask mask7(param2);
212 auto shader7 = mask7.GenerateDrawingShader(100.0f, 100.0f);
213 EXPECT_EQ(shader7, nullptr);
214
215 // position[i] < position[i - 1]
216 param2.radiusY_ = 1.0f;
217 param2.positions_ = {1.0f, 0.0f};
218 GERadialGradientShaderMask mask8(param2);
219 auto shader8 = mask8.GenerateDrawingShader(100.0f, 100.0f);
220 EXPECT_EQ(shader8, nullptr);
221
222 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GenerateShaderEffect_002 end";
223 }
224
225 /**
226 * @tc.name: GetRadialGradientShaderMaskBuilder_001
227 * @tc.desc: Verify GetRadialGradientShaderMaskBuilder returns a valid builder
228 * @tc.type: FUNC
229 */
230 HWTEST_F(GERadialGradientShaderMaskTest, GetRadialGradientShaderMaskBuilder_001, TestSize.Level1)
231 {
232 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GetRadialGradientShaderMaskBuilder_001 start";
233 GERadialGradientShaderMaskParams param;
234 param.center_ = {0.5f, 0.5f};
235 param.radiusX_ = 1.0f;
236 param.radiusY_ = 1.0f;
237 param.colors_.push_back(0.0f);
238 param.colors_.push_back(1.0f);
239 param.positions_.push_back(0.0f);
240 param.positions_.push_back(1.0f);
241
242 GERadialGradientShaderMask mask(param);
243 auto builder = mask.GetRadialGradientShaderMaskBuilder();
244 EXPECT_NE(builder, nullptr);
245
246 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GetRadialGradientShaderMaskBuilder_001 end";
247 }
248
249 /**
250 * @tc.name: GetRadialGradientNormalMaskBuilder_001
251 * @tc.desc: Verify GetRadialGradientNormalMaskBuilder returns a valid builder
252 * @tc.type: FUNC
253 */
254 HWTEST_F(GERadialGradientShaderMaskTest, GetRadialGradientNormalMaskBuilder_001, TestSize.Level1)
255 {
256 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GetRadialGradientNormalMaskBuilder_001 start";
257 GERadialGradientShaderMaskParams param;
258 param.center_ = {0.5f, 0.5f};
259 param.radiusX_ = 1.0f;
260 param.radiusY_ = 1.0f;
261 param.colors_.push_back(0.0f);
262 param.colors_.push_back(1.0f);
263 param.positions_.push_back(0.0f);
264 param.positions_.push_back(1.0f);
265
266 GERadialGradientShaderMask mask(param);
267 auto builder = mask.GetRadialGradientNormalMaskBuilder();
268 EXPECT_NE(builder, nullptr);
269
270 GTEST_LOG_(INFO) << "GERadialGradientShaderMaskTest GetRadialGradientNormalMaskBuilder_001 end";
271 }
272 } // namespace Drawing
273 } // namespace Rosen
274 } // namespace OHOS