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 "base/geometry/transform_util.h"
19 
20 using namespace testing;
21 using namespace testing::ext;
22 
23 namespace OHOS::Ace {
24 namespace {
25 const double NUM_D1 = 1.0;
26 const double NUM_D2 = 0.0;
27 const float PROGRESS = 0.5f;
28 } // namespace
29 
30 class TransformUtilTest : public testing::Test {};
31 
32 /**
33  * @tc.name: TransformUtilTest001
34  * @tc.desc: Test the functions of the class TranslateOperation.
35  * @tc.type: FUNC
36  */
HWTEST_F(TransformUtilTest, TransformUtilTest001, TestSize.Level1)37 HWTEST_F(TransformUtilTest, TransformUtilTest001, TestSize.Level1)
38 {
39     Dimension dimension(NUM_D1);
40     TranslateOperation to(dimension, dimension, dimension);
41     TranslateOperation from(dimension, dimension, dimension);
42     TranslateOperation result = TranslateOperation::Blend(to, from, PROGRESS);
43     EXPECT_EQ(result, to);
44 }
45 
46 /**
47  * @tc.name: TransformUtilTest002
48  * @tc.desc: Test the functions of the class ScaleOperation.
49  * @tc.type: FUNC
50  */
HWTEST_F(TransformUtilTest, TransformUtilTest002, TestSize.Level1)51 HWTEST_F(TransformUtilTest, TransformUtilTest002, TestSize.Level1)
52 {
53     ScaleOperation to(NUM_D1, NUM_D1, NUM_D1);
54     ScaleOperation from(NUM_D1, NUM_D1, NUM_D1);
55     ScaleOperation result = ScaleOperation::Blend(to, from, PROGRESS);
56     EXPECT_EQ(result, to);
57 }
58 
59 /**
60  * @tc.name: TransformUtilTest003
61  * @tc.desc: Test the functions of the class SkewOperation.
62  * @tc.type: FUNC
63  */
HWTEST_F(TransformUtilTest, TransformUtilTest003, TestSize.Level1)64 HWTEST_F(TransformUtilTest, TransformUtilTest003, TestSize.Level1)
65 {
66     SkewOperation to(NUM_D1, NUM_D1);
67     SkewOperation from(NUM_D1, NUM_D1);
68     SkewOperation result = SkewOperation::Blend(to, from, PROGRESS);
69     EXPECT_EQ(result, to);
70 }
71 
72 /**
73  * @tc.name: TransformUtilTest004
74  * @tc.desc: Test the functions of the class RotateOperation.
75  * @tc.type: FUNC
76  */
HWTEST_F(TransformUtilTest, TransformUtilTest004, TestSize.Level1)77 HWTEST_F(TransformUtilTest, TransformUtilTest004, TestSize.Level1)
78 {
79     RotateOperation to(NUM_D1, NUM_D1, NUM_D1, NUM_D1);
80     RotateOperation from(NUM_D1, NUM_D1, NUM_D1, NUM_D1);
81     RotateOperation result = RotateOperation::Blend(to, from, PROGRESS);
82     EXPECT_EQ(result, to);
83 
84     to = RotateOperation(NUM_D2, NUM_D2, NUM_D2, NUM_D1);
85     from = RotateOperation(NUM_D1, NUM_D1, NUM_D1, NUM_D1);
86     result = RotateOperation::Blend(to, from, PROGRESS);
87     EXPECT_EQ(result, from);
88 }
89 
90 /**
91  * @tc.name: TransformUtilTest005
92  * @tc.desc: Test the functions of the class PerspectiveOperation.
93  * @tc.type: FUNC
94  */
HWTEST_F(TransformUtilTest, TransformUtilTest005, TestSize.Level1)95 HWTEST_F(TransformUtilTest, TransformUtilTest005, TestSize.Level1)
96 {
97     Dimension dimension(NUM_D1);
98     PerspectiveOperation to(dimension);
99     PerspectiveOperation from(dimension);
100     PerspectiveOperation result = PerspectiveOperation::Blend(to, from, PROGRESS);
101     EXPECT_EQ(result, to);
102 }
103 
104 /**
105  * @tc.name: TransformUtilTest006
106  * @tc.desc: Test the functions of the class TransformOperation.
107  * @tc.type: FUNC
108  */
HWTEST_F(TransformUtilTest, TransformUtilTest006, TestSize.Level1)109 HWTEST_F(TransformUtilTest, TransformUtilTest006, TestSize.Level1)
110 {
111     TransformOperation result;
112     TransformOperation to = TransformOperation::Create(TransformOperationType::UNDEFINED);
113     TransformOperation from = TransformOperation::Create(TransformOperationType::UNDEFINED);
114     result = TransformOperation::Blend(to, from, PROGRESS);
115     EXPECT_EQ(result.matrix4_, Matrix4::CreateIdentity());
116     from = TransformOperation::Create(TransformOperationType::TRANSLATE);
117     result = TransformOperation::Blend(to, from, PROGRESS);
118     EXPECT_EQ(result.type_, TransformOperationType::TRANSLATE);
119     EXPECT_EQ(result.translateOperation_, TranslateOperation());
120     result = TransformOperation::Blend(from, to, PROGRESS);
121     EXPECT_EQ(result.type_, TransformOperationType::TRANSLATE);
122     EXPECT_EQ(result.translateOperation_, TranslateOperation());
123     result = TransformOperation::Blend(from, from, PROGRESS);
124     EXPECT_EQ(result.type_, TransformOperationType::TRANSLATE);
125     EXPECT_EQ(result.translateOperation_, TranslateOperation());
126 
127     from = TransformOperation::Create(TransformOperationType::SCALE);
128     result = TransformOperation::Blend(to, from, PROGRESS);
129     EXPECT_EQ(result.type_, TransformOperationType::SCALE);
130     EXPECT_EQ(result.scaleOperation_, ScaleOperation());
131 
132     from = TransformOperation::Create(TransformOperationType::SKEW);
133     result = TransformOperation::Blend(to, from, PROGRESS);
134     EXPECT_EQ(result.type_, TransformOperationType::SKEW);
135     EXPECT_EQ(result.skewOperation_, SkewOperation());
136 
137     from = TransformOperation::Create(TransformOperationType::ROTATE);
138     result = TransformOperation::Blend(to, from, PROGRESS);
139     EXPECT_EQ(result.type_, TransformOperationType::ROTATE);
140     EXPECT_EQ(result.rotateOperation_, RotateOperation());
141 
142     from = TransformOperation::Create(TransformOperationType::MATRIX);
143     result = TransformOperation::Blend(to, from, PROGRESS);
144     EXPECT_EQ(result.type_, TransformOperationType::MATRIX);
145     EXPECT_EQ(result.matrix4_, Matrix4::CreateIdentity());
146 
147     from = TransformOperation::Create(TransformOperationType::PERSPECTIVE);
148     result = TransformOperation::Blend(to, from, PROGRESS);
149     EXPECT_EQ(result.type_, TransformOperationType::PERSPECTIVE);
150     EXPECT_EQ(result.perspectiveOperation_, PerspectiveOperation());
151 }
152 
153 /**
154  * @tc.name: TransformUtilTest007
155  * @tc.desc: Test the function ToString of the class DecomposedTransform.
156  * @tc.type: FUNC
157  */
HWTEST_F(TransformUtilTest, TransformUtilTest007, TestSize.Level1)158 HWTEST_F(TransformUtilTest, TransformUtilTest007, TestSize.Level1)
159 {
160     DecomposedTransform decomposedTransform;
161     std::string resStr;
162     resStr.append("translate: ")
163         .append(std::to_string(0.0f))
164         .append(" ")
165         .append(std::to_string(0.0f))
166         .append(" ")
167         .append(std::to_string(0.0f))
168         .append("\n")
169         .append("scale: ")
170         .append(std::to_string(1.0f))
171         .append(" ")
172         .append(std::to_string(1.0f))
173         .append(" ")
174         .append(std::to_string(1.0f))
175         .append("\n")
176         .append("skew: ")
177         .append(std::to_string(0.0f))
178         .append(" ")
179         .append(std::to_string(0.0f))
180         .append(" ")
181         .append(std::to_string(0.0f))
182         .append("\n")
183         .append("perspective: ")
184         .append(std::to_string(0.0f))
185         .append(" ")
186         .append(std::to_string(0.0f))
187         .append(" ")
188         .append(std::to_string(0.0f))
189         .append(" ")
190         .append(std::to_string(1.0f))
191         .append("\n")
192         .append("quaternion: ")
193         .append(std::to_string(0.0))
194         .append(" ")
195         .append(std::to_string(0.0))
196         .append(" ")
197         .append(std::to_string(0.0))
198         .append(" ")
199         .append(std::to_string(0.0))
200         .append("\n");
201     EXPECT_EQ(decomposedTransform.ToString(), resStr);
202 }
203 
204 /**
205  * @tc.name: TransformUtilTest008
206  * @tc.desc: Test the functions of the class TransformOperations.
207  * @tc.type: FUNC
208  */
HWTEST_F(TransformUtilTest, TransformUtilTest008, TestSize.Level1)209 HWTEST_F(TransformUtilTest, TransformUtilTest008, TestSize.Level1)
210 {
211     std::vector<TransformOperation> operations;
212     operations.push_back(TransformOperation::Create(TransformOperationType::TRANSLATE));
213     operations.push_back(TransformOperation::Create(TransformOperationType::SCALE));
214     operations.push_back(TransformOperation::Create(TransformOperationType::SKEW));
215     operations.push_back(TransformOperation::Create(TransformOperationType::ROTATE));
216     operations.push_back(TransformOperation::Create(TransformOperationType::PERSPECTIVE));
217     operations.push_back(TransformOperation::Create(TransformOperationType::MATRIX));
218     operations.push_back(TransformOperation::Create(TransformOperationType::UNDEFINED));
219 
220     TransformOperations::ParseOperationsToMatrix(operations);
221     EXPECT_EQ(operations[0].type_, TransformOperationType::TRANSLATE);
222     EXPECT_EQ(operations[0].translateOperation_, TranslateOperation());
223     EXPECT_EQ(operations[0].matrix4_, Matrix4::CreateTranslate(NUM_D2, NUM_D2, NUM_D2));
224     EXPECT_EQ(operations[1].type_, TransformOperationType::SCALE);
225     EXPECT_EQ(operations[1].scaleOperation_, ScaleOperation());
226     EXPECT_EQ(operations[1].matrix4_, Matrix4::CreateScale(NUM_D1, NUM_D1, NUM_D1));
227     EXPECT_EQ(operations[2].type_, TransformOperationType::SKEW);
228     EXPECT_EQ(operations[2].skewOperation_, SkewOperation());
229     EXPECT_EQ(operations[2].matrix4_, Matrix4::CreateSkew(NUM_D2, NUM_D2));
230     EXPECT_EQ(operations[3].type_, TransformOperationType::ROTATE);
231     EXPECT_EQ(operations[3].rotateOperation_, RotateOperation());
232     EXPECT_EQ(operations[3].matrix4_, Matrix4::CreateRotate(NUM_D2, NUM_D2, NUM_D2, NUM_D2));
233     EXPECT_EQ(operations[4].type_, TransformOperationType::PERSPECTIVE);
234     EXPECT_EQ(operations[4].perspectiveOperation_, PerspectiveOperation());
235     EXPECT_EQ(operations[4].matrix4_, Matrix4::CreatePerspective(NUM_D2));
236     EXPECT_EQ(operations[5].type_, TransformOperationType::MATRIX);
237     EXPECT_EQ(operations[5].matrix4_, Matrix4::CreateIdentity());
238     EXPECT_EQ(operations[6].type_, TransformOperationType::UNDEFINED);
239     EXPECT_EQ(operations[6].matrix4_, Matrix4::CreateIdentity());
240 
241     TransformOperations to(operations);
242     TransformOperations from(operations);
243     TransformOperations result = TransformOperations::Blend(to, from, PROGRESS);
244     ASSERT_EQ(result.GetOperations().size(), operations.size());
245     EXPECT_EQ(result.GetOperations()[0].translateOperation_, TranslateOperation());
246     EXPECT_EQ(result.GetOperations()[1].scaleOperation_, ScaleOperation());
247     EXPECT_EQ(result.GetOperations()[2].skewOperation_, SkewOperation());
248     EXPECT_EQ(result.GetOperations()[3].rotateOperation_, RotateOperation());
249     EXPECT_EQ(result.GetOperations()[4].perspectiveOperation_, PerspectiveOperation());
250 }
251 
252 /**
253  * @tc.name: TransformUtilTest009
254  * @tc.desc: Test the functions of the class ComposeTransform.
255  * @tc.type: FUNC
256  */
HWTEST_F(TransformUtilTest, TransformUtilTest009, TestSize.Level1)257 HWTEST_F(TransformUtilTest, TransformUtilTest009, TestSize.Level1)
258 {
259     DecomposedTransform decomposedTransform;
260     decomposedTransform.skew[0] = 1.0f;
261     decomposedTransform.skew[1] = 1.0f;
262     decomposedTransform.skew[2] = 1.0f;
263     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0);
264     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0);
265 }
266 
267 /**
268  * @tc.name: TransformUtilTest010
269  * @tc.desc: Test the functions of  BuildTranslationMatrix.
270  * @tc.type: FUNC
271  */
HWTEST_F(TransformUtilTest, TransformUtilTest010, TestSize.Level1)272 HWTEST_F(TransformUtilTest, TransformUtilTest010, TestSize.Level1)
273 {
274     DecomposedTransform decomposedTransform;
275     // 0.000001 true false false
276     decomposedTransform.translate[0] = 0.000001f;
277     decomposedTransform.translate[1] = 1.0f;
278     decomposedTransform.translate[2] = 1.0f;
279     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0);
280     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0);
281     // 0.000001 true true false
282     decomposedTransform.translate[0] = 0.000001f;
283     decomposedTransform.translate[1] = 0.000001f;
284     decomposedTransform.translate[2] = 1.0f;
285     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0);
286     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0);
287     // 0.000001 true true true
288     decomposedTransform.translate[0] = 0.000001f;
289     decomposedTransform.translate[1] = 0.000001f;
290     decomposedTransform.translate[2] = 0.000001f;
291     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0);
292     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0);
293     // 0.000001 false true true
294     decomposedTransform.translate[0] = 1.0f;
295     decomposedTransform.translate[1] = 0.000001f;
296     decomposedTransform.translate[2] = 0.000001f;
297     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0);
298     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0);
299     // 0.000001 true false true
300     decomposedTransform.translate[0] = 0.000001f;
301     decomposedTransform.translate[1] = 1.0f;
302     decomposedTransform.translate[2] = 0.000001f;
303     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0);
304     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0);
305 }
306 
307 /**
308  * @tc.name: TransformUtilTest011
309  * @tc.desc: Test the functions of the BuildSkewMatrix
310  * @tc.type: FUNC
311  */
HWTEST_F(TransformUtilTest, TransformUtilTest011, TestSize.Level1)312 HWTEST_F(TransformUtilTest, TransformUtilTest011, TestSize.Level1)
313 {
314     DecomposedTransform decomposedTransform;
315     decomposedTransform.skew[0] = 0.0f;
316     decomposedTransform.skew[1] = 0.0f;
317     decomposedTransform.skew[2] = 0.0f;
318     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0);
319     EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0);
320 }
321 
322 /**
323  * @tc.name: TransformUtilTest012
324  * @tc.desc: Test the functions of the DecomposeTransform
325  * @tc.type: FUNC
326  */
HWTEST_F(TransformUtilTest, TransformUtilTest012, TestSize.Level1)327 HWTEST_F(TransformUtilTest, TransformUtilTest012, TestSize.Level1)
328 {
329     // Normalize is false
330     DecomposedTransform out;
331     Matrix4 transform = Matrix4::CreateIdentity();
332     transform.Set(3, 3, 0.000001f);
333     TransformUtil::DecomposeTransform(out, transform);
334     EXPECT_EQ(transform.Get(3, 3) == 0.000001f, true);
335     // Normalize is true
336     transform.Set(3, 3, 1.0f);
337     // NearZero false false false
338     transform.Set(3, 0, 1.0f);
339     transform.Set(3, 1, 1.0f);
340     transform.Set(3, 2, 1.0f);
341     TransformUtil::DecomposeTransform(out, transform);
342     EXPECT_EQ(out.perspective[0] == 1.0f, true);
343     // NearZero true false false
344     transform.Set(3, 0, 0.000001f);
345     transform.Set(3, 1, 1.0f);
346     transform.Set(3, 2, 1.0f);
347     TransformUtil::DecomposeTransform(out, transform);
348     EXPECT_EQ(out.perspective[0] == 0.000001f, true);
349     // NearZero true true false
350     transform.Set(3, 0, 0.000001f);
351     transform.Set(3, 1, 1.0f);
352     transform.Set(3, 2, 1.0f);
353     TransformUtil::DecomposeTransform(out, transform);
354     EXPECT_EQ(out.perspective[0] == 0.000001f, true);
355     // CreateScale 0.0f
356     Matrix4 transform2 = Matrix4::CreateScale(0.0f, 0.0f, 0.0f);
357     TransformUtil::DecomposeTransform(out, transform2);
358     EXPECT_EQ(out.scale[0] == 0.0f, true);
359 }
360 } // namespace OHOS::Ace
361