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 <memory>
17 
18 #include "gtest/gtest.h"
19 #include "test/mock/core/pipeline/mock_pipeline_context.h"
20 
21 #include "base/geometry/dimension.h"
22 
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS::Ace {
27 namespace {
28 const double DEFAULT_DOUBLE = 1.0;
29 const double ZERO_DOUBLE = 0.0;
30 
31 const Dimension DIMENSION_PX(DEFAULT_DOUBLE, DimensionUnit::PX);
32 const Dimension DIMENSION_VP(DEFAULT_DOUBLE, DimensionUnit::VP);
33 const Dimension DIMENSION_FP(DEFAULT_DOUBLE, DimensionUnit::FP);
34 const Dimension DIMENSION_LPX(DEFAULT_DOUBLE, DimensionUnit::LPX);
35 const Dimension DIMENSION_PCT(DEFAULT_DOUBLE, DimensionUnit::PERCENT);
36 const Dimension DIMENSION_AUTO(DEFAULT_DOUBLE, DimensionUnit::AUTO);
37 const Dimension DIMENSION_CALC(DEFAULT_DOUBLE, DimensionUnit::CALC);
38 const Dimension DIMENSION_NONE(DEFAULT_DOUBLE, DimensionUnit::NONE);
39 
40 const std::string DIMENSION_PX_STR = StringUtils::DoubleToString(DEFAULT_DOUBLE).append("px");
41 const std::string DIMENSION_VP_STR = StringUtils::DoubleToString(DEFAULT_DOUBLE).append("vp");
42 const std::string DIMENSION_FP_STR = StringUtils::DoubleToString(DEFAULT_DOUBLE).append("fp");
43 const std::string DIMENSION_LPX_STR = StringUtils::DoubleToString(DEFAULT_DOUBLE).append("lpx");
44 const std::string DIMENSION_PCT_STR = StringUtils::DoubleToString(DEFAULT_DOUBLE * 100).append("%");
45 const std::string DIMENSION_AUTO_STR = StringUtils::DoubleToString(DEFAULT_DOUBLE).append("auto");
46 const std::string DIMENSION_NONE_STR = StringUtils::DoubleToString(DEFAULT_DOUBLE).append("none");
47 } // namespace
48 
49 class DimensionTest : public testing::Test {
50 public:
SetUpTestSuite()51     static void SetUpTestSuite()
52     {
53         NG::MockPipelineContext::SetUp();
54     }
TearDownTestSuite()55     static void TearDownTestSuite()
56     {
57         NG::MockPipelineContext::TearDown();
58     }
59 };
60 
61 /**
62  * @tc.name: DimensionTest001
63  * @tc.desc: Test the function ConvertToVp of the class Dimension.
64  * @tc.type: FUNC
65  */
66 HWTEST_F(DimensionTest, DimensionTest001, TestSize.Level1)
67 {
68     /**
69      * @tc.steps1: Test the function ConvertToVp of the class Dimension.
70      * @tc.expected: The return values are equal to DEFAULT_DOUBLE or ZERO_DOUBLE
71      */
72     EXPECT_DOUBLE_EQ(DIMENSION_PX.ConvertToVp(), DEFAULT_DOUBLE);
73     EXPECT_DOUBLE_EQ(DIMENSION_VP.ConvertToVp(), DEFAULT_DOUBLE);
74     EXPECT_DOUBLE_EQ(DIMENSION_FP.ConvertToVp(), DEFAULT_DOUBLE);
75     EXPECT_DOUBLE_EQ(DIMENSION_LPX.ConvertToVp(), DEFAULT_DOUBLE);
76     EXPECT_DOUBLE_EQ(DIMENSION_PCT.ConvertToVp(), ZERO_DOUBLE);
77     EXPECT_DOUBLE_EQ(DIMENSION_AUTO.ConvertToVp(), ZERO_DOUBLE);
78     EXPECT_DOUBLE_EQ(DIMENSION_CALC.ConvertToVp(), ZERO_DOUBLE);
79     EXPECT_DOUBLE_EQ(DIMENSION_NONE.ConvertToVp(), DEFAULT_DOUBLE);
80 }
81 
82 /**
83  * @tc.name: DimensionTest002
84  * @tc.desc: Test the function ConvertToPx of the class Dimension.
85  * @tc.type: FUNC
86  */
87 HWTEST_F(DimensionTest, DimensionTest002, TestSize.Level1)
88 {
89     /**
90      * @tc.steps1: Test the function ConvertToPx of the class Dimension.
91      * @tc.expected: The return values are equal to DEFAULT_DOUBLE or ZERO_DOUBLE.
92      */
93     EXPECT_DOUBLE_EQ(DIMENSION_PX.ConvertToPx(), DEFAULT_DOUBLE);
94     EXPECT_DOUBLE_EQ(DIMENSION_VP.ConvertToPx(), DEFAULT_DOUBLE);
95     EXPECT_DOUBLE_EQ(DIMENSION_FP.ConvertToPx(), DEFAULT_DOUBLE);
96     EXPECT_DOUBLE_EQ(DIMENSION_LPX.ConvertToPx(), DEFAULT_DOUBLE);
97     EXPECT_DOUBLE_EQ(DIMENSION_PCT.ConvertToPx(), ZERO_DOUBLE);
98     EXPECT_DOUBLE_EQ(DIMENSION_AUTO.ConvertToPx(), ZERO_DOUBLE);
99     EXPECT_DOUBLE_EQ(DIMENSION_CALC.ConvertToPx(), ZERO_DOUBLE);
100     EXPECT_DOUBLE_EQ(DIMENSION_NONE.ConvertToPx(), DEFAULT_DOUBLE);
101 }
102 
103 /**
104  * @tc.name: DimensionTest003
105  * @tc.desc: Test the function ToString of the class Dimension.
106  * @tc.type: FUNC
107  */
108 HWTEST_F(DimensionTest, DimensionTest003, TestSize.Level1)
109 {
110     /**
111      * @tc.steps1: Test the function ToString of the class Dimension.
112      * @tc.expected: The return values are equal to DIMENSION_STR of PX, VP, FP, LPX, PCT and AUTO.
113      */
114     EXPECT_EQ(DIMENSION_PX.ToString(), DIMENSION_PX_STR);
115     EXPECT_EQ(DIMENSION_VP.ToString(), DIMENSION_VP_STR);
116     EXPECT_EQ(DIMENSION_FP.ToString(), DIMENSION_FP_STR);
117     EXPECT_EQ(DIMENSION_LPX.ToString(), DIMENSION_LPX_STR);
118     EXPECT_EQ(DIMENSION_PCT.ToString(), DIMENSION_PCT_STR);
119     EXPECT_EQ(DIMENSION_AUTO.ToString(), DIMENSION_AUTO_STR);
120     Dimension dimension(DEFAULT_DOUBLE);
121     dimension.SetUnit(static_cast<DimensionUnit>(7));
122     EXPECT_EQ(dimension.ToString(), DIMENSION_PX_STR);
123     dimension.SetUnit(DimensionUnit::NONE);
124     EXPECT_EQ(dimension.ToString(), DIMENSION_NONE_STR);
125 }
126 
127 /**
128  * @tc.name: DimensionTest004
129  * @tc.desc: Test the function NormalizeToPx of the class Dimension with -DEFAULT_DOUBLE.
130  * @tc.type: FUNC
131  */
132 HWTEST_F(DimensionTest, DimensionTest004, TestSize.Level1)
133 {
134     /**
135      * @tc.steps1: Test the function NormalizeToPx of the class Dimension with DIMENSION_PX.
136      * @tc.expected: The return values are equal to DEFAULT_DOUBLE.
137      */
138     double result = 0;
139     EXPECT_TRUE(DIMENSION_PX.NormalizeToPx(-DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, result));
140     EXPECT_DOUBLE_EQ(result, DEFAULT_DOUBLE);
141 
142     /**
143      * @tc.steps2: Test the function NormalizeToPx of the class Dimension with DIMENSION_VP.
144      * @tc.expected: The return values are equal to ZERO_DOUBLE.
145      */
146     result = 0;
147     EXPECT_FALSE(
148         DIMENSION_VP.NormalizeToPx(-DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, result));
149     EXPECT_DOUBLE_EQ(result, ZERO_DOUBLE);
150 
151     /**
152      * @tc.steps3: Test the function NormalizeToPx of the class Dimension with DIMENSION_FP.
153      * @tc.expected: The return values are equal to ZERO_DOUBLE.
154      */
155     result = 0;
156     EXPECT_FALSE(
157         DIMENSION_FP.NormalizeToPx(-DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, result));
158     EXPECT_DOUBLE_EQ(result, ZERO_DOUBLE);
159 
160     /**
161      * @tc.steps4: Test the function NormalizeToPx of the class Dimension with DIMENSION_LPX.
162      * @tc.expected: The return values are equal to ZERO_DOUBLE.
163      */
164     result = 0;
165     EXPECT_FALSE(
166         DIMENSION_LPX.NormalizeToPx(-DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, result));
167     EXPECT_DOUBLE_EQ(result, ZERO_DOUBLE);
168 
169     /**
170      * @tc.steps5: Test the function NormalizeToPx of the class Dimension with DIMENSION_PCT.
171      * @tc.expected: The return values are equal to ZERO_DOUBLE.
172      */
173     result = 0;
174     EXPECT_FALSE(
175         DIMENSION_PCT.NormalizeToPx(-DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, result));
176     EXPECT_DOUBLE_EQ(result, ZERO_DOUBLE);
177 
178     /**
179      * @tc.steps6: Test the function NormalizeToPx of the class Dimension with DIMENSION_AUTO.
180      * @tc.expected: The return values are equal to ZERO_DOUBLE.
181      */
182     result = 0;
183     EXPECT_FALSE(
184         DIMENSION_AUTO.NormalizeToPx(-DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, result));
185     EXPECT_DOUBLE_EQ(result, ZERO_DOUBLE);
186 
187     /**
188      * @tc.steps7: Test the function NormalizeToPx of the class Dimension with DIMENSION_CALC.
189      * @tc.expected: The return values are equal to ZERO_DOUBLE.
190      */
191     result = 0;
192     EXPECT_FALSE(
193         DIMENSION_CALC.NormalizeToPx(-DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, -DEFAULT_DOUBLE, result));
194     EXPECT_DOUBLE_EQ(result, ZERO_DOUBLE);
195 }
196 
197 /**
198  * @tc.name: DimensionTest005
199  * @tc.desc: Test the function NormalizeToPx of the class Dimension with DEFAULT_DOUBLE.
200  * @tc.type: FUNC
201  */
202 HWTEST_F(DimensionTest, DimensionTest005, TestSize.Level1)
203 {
204     /**
205      * @tc.steps1: Test the function NormalizeToPx of the class Dimension with DIMENSION_PX.
206      * @tc.expected: The return values are equal to DEFAULT_DOUBLE.
207      */
208     double result = 0;
209     EXPECT_TRUE(DIMENSION_PX.NormalizeToPx(DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, result));
210     EXPECT_DOUBLE_EQ(result, DEFAULT_DOUBLE);
211 
212     /**
213      * @tc.steps2: Test the function NormalizeToPx of the class Dimension with DIMENSION_VP.
214      * @tc.expected: The return values are equal to DEFAULT_DOUBLE.
215      */
216     result = 0;
217     EXPECT_TRUE(DIMENSION_VP.NormalizeToPx(DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, result));
218     EXPECT_DOUBLE_EQ(result, DEFAULT_DOUBLE);
219 
220     /**
221      * @tc.steps3: Test the function NormalizeToPx of the class Dimension with DIMENSION_FP.
222      * @tc.expected: The return values are equal to DEFAULT_DOUBLE.
223      */
224     result = 0;
225     EXPECT_TRUE(DIMENSION_FP.NormalizeToPx(DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, result));
226     EXPECT_DOUBLE_EQ(result, DEFAULT_DOUBLE);
227 
228     /**
229      * @tc.steps4: Test the function NormalizeToPx of the class Dimension with DIMENSION_LPX.
230      * @tc.expected: The return values are equal to DEFAULT_DOUBLE.
231      */
232     result = 0;
233     EXPECT_TRUE(DIMENSION_LPX.NormalizeToPx(DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, result));
234     EXPECT_DOUBLE_EQ(result, DEFAULT_DOUBLE);
235 
236     /**
237      * @tc.steps5: Test the function NormalizeToPx of the class Dimension with DIMENSION_PCT.
238      * @tc.expected: The return values are equal to DEFAULT_DOUBLE.
239      */
240     result = 0;
241     EXPECT_TRUE(DIMENSION_PCT.NormalizeToPx(DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, result));
242     EXPECT_DOUBLE_EQ(result, DEFAULT_DOUBLE);
243 
244     /**
245      * @tc.steps6: Test the function NormalizeToPx of the class Dimension with DIMENSION_AUTO.
246      * @tc.expected: The return values are equal to ZERO_DOUBLE.
247      */
248     result = 0;
249     EXPECT_FALSE(DIMENSION_AUTO.NormalizeToPx(DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, result));
250     EXPECT_DOUBLE_EQ(result, ZERO_DOUBLE);
251 
252     /**
253      * @tc.steps7: Test the function NormalizeToPx of the class Dimension with DIMENSION_CALC.
254      * @tc.expected: The return values are equal to ZERO_DOUBLE.
255      */
256     result = 0;
257     EXPECT_FALSE(DIMENSION_CALC.NormalizeToPx(DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, DEFAULT_DOUBLE, result));
258     EXPECT_DOUBLE_EQ(result, ZERO_DOUBLE);
259 }
260 
261 /**
262  * @tc.name: DimensionTest006
263  * @tc.desc: ConvertToFp().
264  * @tc.type: FUNC
265  */
266 HWTEST_F(DimensionTest, DimensionTest006, TestSize.Level1)
267 {
268     /**
269      * @tc.steps1: Test the function ConvertToFp of the class Dimension.
270      * @tc.expected: The return values are equal to DEFAULT_DOUBLE or ZERO_DOUBLE
271      */
272     EXPECT_DOUBLE_EQ(DIMENSION_PX.ConvertToFp(), DEFAULT_DOUBLE);
273     EXPECT_DOUBLE_EQ(DIMENSION_VP.ConvertToFp(), DEFAULT_DOUBLE);
274     EXPECT_DOUBLE_EQ(DIMENSION_FP.ConvertToFp(), DEFAULT_DOUBLE);
275     EXPECT_DOUBLE_EQ(DIMENSION_LPX.ConvertToFp(), DEFAULT_DOUBLE);
276     EXPECT_DOUBLE_EQ(DIMENSION_PCT.ConvertToFp(), ZERO_DOUBLE);
277     EXPECT_DOUBLE_EQ(DIMENSION_AUTO.ConvertToFp(), ZERO_DOUBLE);
278     EXPECT_DOUBLE_EQ(DIMENSION_CALC.ConvertToFp(), ZERO_DOUBLE);
279     EXPECT_DOUBLE_EQ(DIMENSION_NONE.ConvertToFp(), DEFAULT_DOUBLE);
280 }
281 
282 /**
283  * @tc.name: DimensionTest007
284  * @tc.desc: FromString().
285  * @tc.type: FUNC
286  */
287 HWTEST_F(DimensionTest, DimensionTest007, TestSize.Level1)
288 {
289     /**
290      * @tc.steps1: Test the function FromString of the class Dimension.
291      * @tc.expected: The return values are equal to DEFAULT_DOUBLE or ZERO_DOUBLE
292      */
293     EXPECT_DOUBLE_EQ(Dimension::FromString(DIMENSION_PX_STR).Value(), DEFAULT_DOUBLE);
294     EXPECT_DOUBLE_EQ(Dimension::FromString(DIMENSION_VP_STR).Value(), DEFAULT_DOUBLE);
295     EXPECT_DOUBLE_EQ(Dimension::FromString(DIMENSION_FP_STR).Value(), DEFAULT_DOUBLE);
296     EXPECT_DOUBLE_EQ(Dimension::FromString(DIMENSION_LPX_STR).Value(), DEFAULT_DOUBLE);
297     EXPECT_DOUBLE_EQ(Dimension::FromString(DIMENSION_PCT_STR).Value(), DEFAULT_DOUBLE);
298     EXPECT_DOUBLE_EQ(Dimension::FromString(DIMENSION_AUTO_STR).Value(), DEFAULT_DOUBLE);
299     EXPECT_DOUBLE_EQ(Dimension::FromString("").Value(), ZERO_DOUBLE);
300 }
301 
302 /**
303  * @tc.name: DimensionTest008
304  * @tc.desc: ConvertToPxWithSize().
305  * @tc.type: FUNC
306  */
307 HWTEST_F(DimensionTest, DimensionTest008, TestSize.Level1)
308 {
309     /**
310      * @tc.steps1: Test the function ConvertToPxWithSize of the class Dimension.
311      * @tc.expected: The return values are equal to DEFAULT_DOUBLE * size.
312      */
313     Dimension dimension(DEFAULT_DOUBLE, DimensionUnit::PERCENT);
314     EXPECT_DOUBLE_EQ(dimension.ConvertToPxWithSize(5.0), DEFAULT_DOUBLE * 5.0);
315     dimension.SetUnit(DimensionUnit::PX);
316     EXPECT_DOUBLE_EQ(dimension.ConvertToPxWithSize(5.0), DEFAULT_DOUBLE);
317 }
318 } // namespace OHOS::Ace
319