1 /*
2  * Copyright (c) 2023 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 #define private public
19 #define protected public
20 #include "frameworks/core/components_ng/property/gradient_property.h"
21 
22 using namespace testing;
23 using namespace testing::ext;
24 
25 namespace OHOS::Ace::NG {
26 namespace {
27 const Dimension TEST_LENGTH1 = 10.0_vp;
28 const Dimension TEST_LENGTH2 = 15.0_vp;
29 const Dimension TEST_LENGTH3 = 20.0_vp;
30 const Dimension TEST_LENGTH4 = 25.0_vp;
31 const Dimension TEST_LENGTH5 = 30.0_vp;
32 const Dimension TEST_LENGTH6 = 35.0_vp;
33 
Result(const GradientDirection x,const GradientDirection y,const Gradient gradient)34 void Result(const GradientDirection x, const GradientDirection y, const Gradient gradient)
35 {
36     std::string str = "";
37     if (x == GradientDirection::LEFT) {
38         if (y == GradientDirection::TOP) {
39             str = gradient.LinearGradientToJson()->GetString("direction");
40             EXPECT_EQ(str, "GradientDirection.LeftTop");
41         } else if (y == GradientDirection::BOTTOM) {
42             str = gradient.LinearGradientToJson()->GetString("direction");
43             EXPECT_EQ(str, "GradientDirection.LeftBottom");
44         } else {
45             str = gradient.LinearGradientToJson()->GetString("direction");
46             EXPECT_EQ(str, "GradientDirection.Left");
47         }
48     } else if (x == GradientDirection::RIGHT) {
49         if (y == GradientDirection::TOP) {
50             str = gradient.LinearGradientToJson()->GetString("direction");
51             EXPECT_EQ(str, "GradientDirection.RightTop");
52         } else if (y == GradientDirection::BOTTOM) {
53             str = gradient.LinearGradientToJson()->GetString("direction");
54             EXPECT_EQ(str, "GradientDirection.RightBottom");
55         } else {
56             str = gradient.LinearGradientToJson()->GetString("direction");
57             EXPECT_EQ(str, "GradientDirection.Right");
58         }
59     } else {
60         if (y == GradientDirection::TOP) {
61             str = gradient.LinearGradientToJson()->GetString("direction");
62             EXPECT_EQ(str, "GradientDirection.Top");
63         } else if (y == GradientDirection::BOTTOM) {
64             str = gradient.LinearGradientToJson()->GetString("direction");
65             EXPECT_EQ(str, "GradientDirection.Bottom");
66         } else {
67             str = gradient.LinearGradientToJson()->GetString("direction");
68             EXPECT_EQ(str, "GradientDirection.None");
69         }
70     }
71 }
72 } // namespace
73 
74 class GradientPropertyTestNg : public testing::Test {
75 public:
SetUpTestCase()76     static void SetUpTestCase() {};
TearDownTestCase()77     static void TearDownTestCase() {};
78 };
79 
80 /**
81  * @tc.name: AccessibilityPropertyTest001
82  * @tc.desc: LinearGradientToJson
83  * @tc.type: FUNC
84  */
85 HWTEST_F(GradientPropertyTestNg, gradientPropertyTest001, TestSize.Level1)
86 {
87     Gradient gradient = Gradient();
88     gradient.type_ = GradientType::RADIAL;
89     auto linearJson = gradient.LinearGradientToJson();
90     EXPECT_TRUE(linearJson);
91 
92     gradient.type_ = GradientType::LINEAR;
93     linearJson = gradient.LinearGradientToJson();
94     auto str = linearJson->GetString("angle");
95     EXPECT_EQ(str, "");
96 
97     LinearGradient linearGradient;
98     linearGradient.angle = std::make_optional(2.00_vp);
99     linearGradient.linearX = std::make_optional(GradientDirection::TOP);
100     linearGradient.linearY = std::make_optional(GradientDirection::LEFT);
101     linearGradient.x1 = std::make_optional(TEST_LENGTH1);
102     linearGradient.y1 = std::make_optional(TEST_LENGTH2);
103     linearGradient.x2 = std::make_optional(TEST_LENGTH3);
104     linearGradient.y2 = std::make_optional(TEST_LENGTH4);
105     gradient.SetLinearGradient(linearGradient);
106 
107     std::vector<GradientDirection> linearX;
108     linearX.push_back(GradientDirection::LEFT);
109     linearX.push_back(GradientDirection::RIGHT);
110     linearX.push_back(GradientDirection::TOP);
111     std::vector<GradientDirection> linearY;
112     linearY.push_back(GradientDirection::TOP);
113     linearY.push_back(GradientDirection::BOTTOM);
114     linearY.push_back(GradientDirection::LEFT);
115     for (auto x : linearX) {
116         gradient.linearGradient_->linearX = x;
117         for (auto y : linearY) {
118             gradient.linearGradient_->linearY = y;
119             Result(x, y, gradient);
120         }
121     }
122 }
123 
124 HWTEST_F(GradientPropertyTestNg, gradientPropertyTest002, TestSize.Level1)
125 {
126     Gradient gradient = Gradient();
127     gradient.type_ = GradientType::RADIAL;
128     auto sweepJson = gradient.SweepGradientToJson();
129     EXPECT_TRUE(sweepJson);
130 
131     gradient.type_ = GradientType::SWEEP;
132     sweepJson = gradient.SweepGradientToJson();
133     auto str = sweepJson->GetString("start");
134     EXPECT_EQ(str, "");
135 
136     SweepGradient sweepGradient;
137     sweepGradient.centerX = std::make_optional(TEST_LENGTH1);
138     sweepGradient.centerY = std::make_optional(TEST_LENGTH2);
139     sweepGradient.startAngle = std::make_optional(TEST_LENGTH3);
140     sweepGradient.endAngle = std::make_optional(TEST_LENGTH4);
141     sweepGradient.rotation = std::make_optional(TEST_LENGTH5);
142     gradient.SetSweepGradient(sweepGradient);
143     sweepJson = gradient.SweepGradientToJson();
144     str = sweepJson->GetString("start");
145     EXPECT_EQ(str, TEST_LENGTH3.ToString());
146     str = sweepJson->GetString("end");
147     EXPECT_EQ(str, TEST_LENGTH4.ToString());
148 }
149 
150 HWTEST_F(GradientPropertyTestNg, gradientPropertyTest003, TestSize.Level1)
151 {
152     Gradient gradient = Gradient();
153     gradient.type_ = GradientType::SWEEP;
154     auto radialJson = gradient.RadialGradientToJson();
155     EXPECT_TRUE(radialJson);
156 
157     gradient.type_ = GradientType::RADIAL;
158     radialJson = gradient.RadialGradientToJson();
159     auto str = radialJson->GetString("radius");
160     EXPECT_EQ(str, "");
161 
162     GradientColor color(Color::BLACK);
163     gradient.AddColor(color);
164     RadialGradient radialGradient;
165     radialGradient.radialSizeType = std::make_optional(RadialSizeType::CLOSEST_CORNER);
166     radialGradient.radialShape = std::make_optional(RadialShapeType::CIRCLE);
167     radialGradient.radialHorizontalSize = std::make_optional(TEST_LENGTH1);
168     radialGradient.radialVerticalSize = std::make_optional(TEST_LENGTH2);
169     radialGradient.radialCenterX = std::make_optional(TEST_LENGTH3);
170     radialGradient.radialCenterY = std::make_optional(TEST_LENGTH4);
171     radialGradient.fRadialCenterX = std::make_optional(TEST_LENGTH5);
172     radialGradient.fRadialCenterY = std::make_optional(TEST_LENGTH6);
173     gradient.SetRadialGradient(radialGradient);
174     radialJson = gradient.RadialGradientToJson();
175     str = radialJson->GetString("radius");
176     EXPECT_EQ(str, TEST_LENGTH2.ToString());
177     EXPECT_EQ(gradient.colors_.size(), 1);
178     gradient.ClearColors();
179 }
180 
181 /**
182  * @tc.name: gradientPropertyTest004
183  * @tc.desc: LinearGradientToJson
184  * @tc.type: FUNC
185  */
186 HWTEST_F(GradientPropertyTestNg, gradientPropertyTest004, TestSize.Level1)
187 {
188     Gradient gradient = Gradient();
189     gradient.type_ = GradientType::RADIAL;
190     auto linearJson = gradient.LinearGradientToJson();
191     EXPECT_TRUE(linearJson);
192 
193     gradient.type_ = GradientType::LINEAR;
194     linearJson = gradient.LinearGradientToJson();
195     auto str = linearJson->GetString("angle");
196     EXPECT_EQ(str, "");
197 
198     LinearGradient linearGradient;
199     gradient.SetLinearGradient(linearGradient);
200     linearJson = gradient.LinearGradientToJson();
201     str = linearJson->GetString("angle");
202     EXPECT_EQ(str, "");
203     str = linearJson->GetString("direction");
204     EXPECT_EQ(str, "GradientDirection.None");
205 }
206 
207 /**
208  * @tc.name: gradientPropertyTest005
209  * @tc.desc: LinearGradientToJson
210  * @tc.type: FUNC
211  */
212 HWTEST_F(GradientPropertyTestNg, gradientPropertyTest005, TestSize.Level1)
213 {
214     /**
215      * @tc.steps: step1. Create Gradient and set type != SWEEP.
216      */
217     Gradient gradient = Gradient();
218     gradient.type_ = GradientType::RADIAL;
219     auto sweepJson = gradient.SweepGradientToJson();
220     EXPECT_TRUE(sweepJson);
221 
222     /**
223      * @tc.steps: step1. set type == SWEEP.
224      */
225     gradient.type_ = GradientType::SWEEP;
226     sweepJson = gradient.SweepGradientToJson();
227     auto str = sweepJson->GetString("start");
228     EXPECT_EQ(str, "");
229 
230     /**
231      * @tc.steps: step3. set radialCenterX  false and radialCenterY false.
232      */
233     SweepGradient sweepGradient;
234     gradient.SetSweepGradient(sweepGradient);
235     sweepJson = gradient.SweepGradientToJson();
236     auto jsonTemp = sweepJson->GetValue("center");
237     str = jsonTemp->GetString("0");
238     EXPECT_EQ(str, "");
239     str = jsonTemp->GetString("1");
240     EXPECT_EQ(str, "");
241 
242     /**
243      * @tc.steps: step4. set radialCenterX  false and radialCenterY true.
244      */
245     SweepGradient sweepGradient1;
246     sweepGradient1.centerY = std::make_optional(TEST_LENGTH2);
247     gradient.SetSweepGradient(sweepGradient1);
248     sweepJson = gradient.SweepGradientToJson();
249     jsonTemp = sweepJson->GetValue("center");
250     str = jsonTemp->GetString("0");
251     EXPECT_EQ(str, "");
252     str = jsonTemp->GetString("1");
253     EXPECT_EQ(str, "");
254 
255     /**
256      * @tc.steps: step5. set radialCenterX  true and radialCenterY false.
257      */
258     SweepGradient sweepGradient2;
259     sweepGradient2.centerX = std::make_optional(TEST_LENGTH1);
260     gradient.SetSweepGradient(sweepGradient2);
261     sweepJson = gradient.SweepGradientToJson();
262     jsonTemp = sweepJson->GetValue("center");
263     str = jsonTemp->GetString("0");
264     EXPECT_EQ(str, "");
265     str = jsonTemp->GetString("1");
266     EXPECT_EQ(str, "");
267 
268     /**
269      * @tc.steps: step6. set radialCenterX  true and radialCenterY true.
270      */
271     sweepGradient.centerX = std::make_optional(TEST_LENGTH1);
272     sweepGradient.centerY = std::make_optional(TEST_LENGTH2);
273     gradient.SetSweepGradient(sweepGradient);
274     sweepJson = gradient.SweepGradientToJson();
275     jsonTemp = sweepJson->GetValue("center");
276     str = jsonTemp->GetString("0");
277     EXPECT_EQ(str, TEST_LENGTH1.ToString());
278     str = jsonTemp->GetString("1");
279     EXPECT_EQ(str, TEST_LENGTH2.ToString());
280     str = sweepJson->GetString("start");
281     EXPECT_EQ(str, "");
282     str = sweepJson->GetString("end");
283     EXPECT_EQ(str, "");
284 }
285 
286 /**
287  * @tc.name: gradientPropertyTest006
288  * @tc.desc: LinearGradientToJson
289  * @tc.type: FUNC
290  */
291 HWTEST_F(GradientPropertyTestNg, gradientPropertyTest006, TestSize.Level1)
292 {
293     /**
294      * @tc.steps: step1. Create Gradient and set type != RADIAL.
295      */
296     Gradient gradient = Gradient();
297     gradient.type_ = GradientType::SWEEP;
298     auto radialJson = gradient.RadialGradientToJson();
299     EXPECT_TRUE(radialJson);
300 
301     /**
302      * @tc.steps: step1. Set type == RADIAL.
303      */
304     gradient.type_ = GradientType::RADIAL;
305     radialJson = gradient.RadialGradientToJson();
306     auto str = radialJson->GetString("radius");
307     EXPECT_EQ(str, "");
308 
309     /**
310      * @tc.steps: step3. set radialCenterX false and radialCenterY false.
311      */
312     GradientColor color(Color::BLACK);
313     gradient.AddColor(color);
314     RadialGradient radialGradient;
315     gradient.SetRadialGradient(radialGradient);
316     radialJson = gradient.RadialGradientToJson();
317     auto jsonTemp = radialJson->GetValue("center");
318     str = jsonTemp->GetString("0");
319     EXPECT_EQ(str, "");
320     str = jsonTemp->GetString("1");
321     EXPECT_EQ(str, "");
322 
323     /**
324      * @tc.steps: step4. set radialCenterX true and radialCenterY false.
325      */
326     RadialGradient radialGradient1;
327     radialGradient1.radialCenterX = std::make_optional(TEST_LENGTH3);
328     gradient.SetRadialGradient(radialGradient1);
329     radialJson = gradient.RadialGradientToJson();
330     jsonTemp = radialJson->GetValue("center");
331     str = jsonTemp->GetString("0");
332     EXPECT_EQ(str, "");
333     str = jsonTemp->GetString("1");
334     EXPECT_EQ(str, "");
335 
336     /**
337      * @tc.steps: step5. set radialCenterX false and radialCenterY true.
338      */
339     RadialGradient radialGradient2;
340     radialGradient2.radialCenterY = std::make_optional(TEST_LENGTH4);
341     gradient.SetRadialGradient(radialGradient2);
342     radialJson = gradient.RadialGradientToJson();
343     jsonTemp = radialJson->GetValue("center");
344     str = jsonTemp->GetString("0");
345     EXPECT_EQ(str, "");
346     str = jsonTemp->GetString("1");
347     EXPECT_EQ(str, "");
348 
349     /**
350      * @tc.steps: step6. set radialCenterX true and radialCenterY true.
351      */
352     radialGradient.radialCenterX = std::make_optional(TEST_LENGTH3);
353     radialGradient.radialCenterY = std::make_optional(TEST_LENGTH4);
354     gradient.SetRadialGradient(radialGradient);
355     radialJson = gradient.RadialGradientToJson();
356     jsonTemp = radialJson->GetValue("center");
357     str = jsonTemp->GetString("0");
358     EXPECT_EQ(str, TEST_LENGTH3.ToString());
359     str = jsonTemp->GetString("1");
360     EXPECT_EQ(str, TEST_LENGTH4.ToString());
361     str = radialJson->GetString("radius");
362     EXPECT_EQ(str, "");
363 }
364 } // namespace OHOS::Ace::NG
365