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 <cmath>
17 
18 #include "gtest/gtest.h"
19 
20 #include "base/geometry/matrix4.h"
21 
22 using namespace testing;
23 using namespace testing::ext;
24 
25 namespace OHOS::Ace {
26 namespace {
27 const double DEFAULT_DOUBLE0 = 0.0;
28 const double DEFAULT_DOUBLE1 = 1.0;
29 const double DEFAULT_DOUBLE2 = 2.0;
30 const double DEFAULT_DOUBLE6 = 6.0;
31 const double DEFAULT_DOUBLE7 = 7.0;
32 
33 constexpr double ANGLE_UNIT = 0.017453f;
34 const int32_t MATRIXS_LENGTH = 16;
35 
36 const int32_t VALID_ROW0 = 0;
37 const int32_t VALID_COL0 = 0;
38 const int32_t VALID_ROW1 = 1;
39 const int32_t VALID_COL1 = 1;
40 const int32_t VALID_ROW2 = 2;
41 const int32_t VALID_COL2 = 2;
42 const int32_t VALID_ROW3 = 3;
43 const int32_t VALID_COL3 = 3;
44 const int32_t VALID_ROW4 = 4;
45 const int32_t VALID_DIMENSION = 4;
46 
47 const int32_t INVALID_ROW_NEG = -1;
48 const int32_t INVALID_COL_NEG = -1;
49 const int32_t INVALID_ROW_POS = 6;
50 const int32_t INVALID_COL_POS = 6;
51 
52 const uint32_t ROW_NUM = 5;
53 const uint32_t COLUMN_NUM = 5;
54 } // namespace
55 
56 class Matrix4Test : public testing::Test {};
57 
58 /**
59  * @tc.name: Matrix4Test001
60  * @tc.desc: Test functions beginning with Create of the class Matrix4.
61  * @tc.type: FUNC
62  */
63 HWTEST_F(Matrix4Test, Matrix4Test001, TestSize.Level1)
64 {
65     /**
66      * @tc.steps: Test the function CreateIdentity of the class Matrix4.
67      */
68     Matrix4 matrix4Obj1 = Matrix4::CreateIdentity();
69     EXPECT_TRUE(matrix4Obj1.IsIdentityMatrix());
70     EXPECT_EQ(matrix4Obj1.Count(), MATRIXS_LENGTH);
71     EXPECT_DOUBLE_EQ(matrix4Obj1.Get(VALID_ROW0, VALID_COL0), DEFAULT_DOUBLE1);
72     EXPECT_DOUBLE_EQ(matrix4Obj1.Get(VALID_ROW1, VALID_COL1), DEFAULT_DOUBLE1);
73     EXPECT_DOUBLE_EQ(matrix4Obj1.Get(VALID_ROW2, VALID_COL2), DEFAULT_DOUBLE1);
74     EXPECT_DOUBLE_EQ(matrix4Obj1.Get(VALID_ROW3, VALID_COL3), DEFAULT_DOUBLE1);
75 
76     /**
77      * @tc.steps: Test the function CreateTranslate of the class Matrix4.
78      */
79     Matrix4 matrix4Obj2 = Matrix4::CreateTranslate(DEFAULT_DOUBLE0, DEFAULT_DOUBLE1, DEFAULT_DOUBLE2);
80     EXPECT_FALSE(matrix4Obj2.IsIdentityMatrix());
81     EXPECT_DOUBLE_EQ(matrix4Obj2.Get(VALID_ROW0, VALID_COL3), DEFAULT_DOUBLE0);
82     EXPECT_DOUBLE_EQ(matrix4Obj2.Get(VALID_ROW1, VALID_COL3), DEFAULT_DOUBLE1);
83     EXPECT_DOUBLE_EQ(matrix4Obj2.Get(VALID_ROW2, VALID_COL3), DEFAULT_DOUBLE2);
84 
85     /**
86      * @tc.steps: Test the function CreateScale of the class Matrix4.
87      */
88     Matrix4 matrix4Obj3 = Matrix4::CreateScale(DEFAULT_DOUBLE0, DEFAULT_DOUBLE1, DEFAULT_DOUBLE2);
89     EXPECT_DOUBLE_EQ(matrix4Obj3.Get(VALID_ROW0, VALID_COL0), DEFAULT_DOUBLE0);
90     EXPECT_DOUBLE_EQ(matrix4Obj3.Get(VALID_ROW1, VALID_COL1), DEFAULT_DOUBLE1);
91     EXPECT_DOUBLE_EQ(matrix4Obj3.Get(VALID_ROW2, VALID_COL2), DEFAULT_DOUBLE2);
92     EXPECT_DOUBLE_EQ(matrix4Obj3.Get(VALID_ROW3, VALID_COL3), DEFAULT_DOUBLE1);
93 
94     /**
95      * @tc.steps: Test functions CreateRotate and Rotate of the class Matrix4.
96      */
97     Matrix4 matrix4Obj4 = Matrix4::CreateRotate(DEFAULT_DOUBLE1, DEFAULT_DOUBLE0, DEFAULT_DOUBLE0, DEFAULT_DOUBLE0);
98     EXPECT_EQ(matrix4Obj1, matrix4Obj4);
99     Matrix4 matrix4Obj5 = Matrix4::CreateRotate(DEFAULT_DOUBLE0, DEFAULT_DOUBLE1, DEFAULT_DOUBLE1, DEFAULT_DOUBLE1);
100     Matrix4 matrix4Obj6 = Matrix4::CreateIdentity();
101     matrix4Obj6.Rotate(DEFAULT_DOUBLE0, DEFAULT_DOUBLE1, DEFAULT_DOUBLE1, DEFAULT_DOUBLE1);
102     EXPECT_EQ(matrix4Obj6, matrix4Obj5);
103 
104     /**
105      * @tc.steps: Test the function CreateMatrix2D of the class Matrix4.
106      */
107     Matrix4 matrix4Obj7 = Matrix4::CreateMatrix2D(
108         DEFAULT_DOUBLE0, DEFAULT_DOUBLE1, DEFAULT_DOUBLE2, DEFAULT_DOUBLE0, DEFAULT_DOUBLE1, DEFAULT_DOUBLE2);
109     EXPECT_DOUBLE_EQ(matrix4Obj7.Get(VALID_ROW0, VALID_COL0), DEFAULT_DOUBLE0);
110     EXPECT_DOUBLE_EQ(matrix4Obj7.Get(VALID_ROW1, VALID_COL0), DEFAULT_DOUBLE1);
111     EXPECT_DOUBLE_EQ(matrix4Obj7.Get(VALID_ROW0, VALID_COL1), DEFAULT_DOUBLE2);
112     EXPECT_DOUBLE_EQ(matrix4Obj7.Get(VALID_ROW1, VALID_COL1), DEFAULT_DOUBLE0);
113     EXPECT_DOUBLE_EQ(matrix4Obj7.Get(VALID_ROW0, VALID_COL3), DEFAULT_DOUBLE1);
114     EXPECT_DOUBLE_EQ(matrix4Obj7.Get(VALID_ROW1, VALID_COL3), DEFAULT_DOUBLE2);
115 
116     /**
117      * @tc.steps: Test the function CreateSkew of the class Matrix4.
118      */
119     Matrix4 matrix4Obj8 = Matrix4::CreateSkew(DEFAULT_DOUBLE1, DEFAULT_DOUBLE1);
120     EXPECT_DOUBLE_EQ(matrix4Obj8.Get(VALID_ROW1, VALID_COL0), std::tan(DEFAULT_DOUBLE1 * ANGLE_UNIT));
121     EXPECT_DOUBLE_EQ(matrix4Obj8.Get(VALID_ROW0, VALID_COL1), std::tan(DEFAULT_DOUBLE1 * ANGLE_UNIT));
122 
123     /**
124      * @tc.steps: Test the function CreatePerspective of the class Matrix4.
125      */
126     Matrix4 matrix4Obj9 = Matrix4::CreatePerspective(DEFAULT_DOUBLE0);
127     EXPECT_EQ(matrix4Obj1, matrix4Obj9);
128     Matrix4 matrix4Obj10 = Matrix4::CreatePerspective(DEFAULT_DOUBLE2);
129     EXPECT_EQ(matrix4Obj10.Get(VALID_ROW3, VALID_COL2), -DEFAULT_DOUBLE1 / DEFAULT_DOUBLE2);
130 }
131 
132 /**
133  * @tc.name: Matrix4Test002
134  * @tc.desc: Test the function SetEntry of the classes Matrix4, Matrix4N and MatrixN4.
135  * @tc.type: FUNC
136  */
137 HWTEST_F(Matrix4Test, Matrix4Test002, TestSize.Level1)
138 {
139     /**
140      * @tc.steps: Test the function SetEntry of the class Matrix4.
141      */
142     Matrix4 matrix4Obj1 = Matrix4::CreateIdentity();
143     std::string initStr4Obj1 = matrix4Obj1.ToString();
144     matrix4Obj1.SetEntry(INVALID_ROW_NEG, INVALID_COL_NEG, DEFAULT_DOUBLE2);
145     EXPECT_EQ(matrix4Obj1.ToString(), initStr4Obj1);
146     matrix4Obj1.SetEntry(INVALID_ROW_POS, INVALID_COL_POS, DEFAULT_DOUBLE2);
147     EXPECT_EQ(matrix4Obj1.ToString(), initStr4Obj1);
148     matrix4Obj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE2);
149     EXPECT_DOUBLE_EQ(matrix4Obj1.Get(VALID_ROW0, VALID_COL0), DEFAULT_DOUBLE2);
150 
151     /**
152      * @tc.steps: Test the function SetEntry of the class Matrix4N.
153      */
154     Matrix4N matrix4NObj1(COLUMN_NUM);
155     EXPECT_FALSE(matrix4NObj1.SetEntry(INVALID_ROW_NEG, INVALID_COL_NEG, DEFAULT_DOUBLE2));
156     EXPECT_FALSE(matrix4NObj1.SetEntry(INVALID_ROW_POS, INVALID_COL_POS, DEFAULT_DOUBLE2));
157     matrix4NObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE2);
158     EXPECT_DOUBLE_EQ(matrix4NObj1[VALID_ROW0][VALID_COL0], DEFAULT_DOUBLE2);
159 
160     /**
161      * @tc.steps: Test the function SetEntry of the class MatrixN4.
162      */
163     MatrixN4 matrixN4Obj1(ROW_NUM);
164     EXPECT_FALSE(matrixN4Obj1.SetEntry(INVALID_ROW_NEG, INVALID_COL_NEG, DEFAULT_DOUBLE2));
165     EXPECT_FALSE(matrixN4Obj1.SetEntry(INVALID_ROW_POS, INVALID_COL_POS, DEFAULT_DOUBLE2));
166     matrixN4Obj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE2);
167     EXPECT_DOUBLE_EQ(matrixN4Obj1[VALID_ROW0][VALID_COL0], DEFAULT_DOUBLE2);
168 }
169 
170 /**
171  * @tc.name: Matrix4Test003
172  * @tc.desc: Test the function Transpose of the classes Matrix4, Matrix4N and MatrixN4.
173  * @tc.type: FUNC
174  */
175 HWTEST_F(Matrix4Test, Matrix4Test003, TestSize.Level1)
176 {
177     /**
178      * @tc.steps: Test the function Transpose of the class Matrix4.
179      */
180     Matrix4 matrix4Obj1 = Matrix4::CreateIdentity();
181     matrix4Obj1.SetEntry(VALID_ROW3, VALID_COL0, DEFAULT_DOUBLE2);
182     Matrix4 matrix4Obj2 = Matrix4::CreateIdentity();
183     matrix4Obj2.SetEntry(VALID_ROW0, VALID_COL3, DEFAULT_DOUBLE2);
184     matrix4Obj1.Transpose();
185     EXPECT_EQ(matrix4Obj1, matrix4Obj2);
186 
187     /**
188      * @tc.steps: Test the function Transpose of the class Matrix4N.
189      */
190     Matrix4N matrix4NObj1(COLUMN_NUM);
191     matrix4NObj1.SetEntry(VALID_ROW2, VALID_COL0, DEFAULT_DOUBLE2);
192     EXPECT_DOUBLE_EQ(matrix4NObj1.Transpose()[VALID_ROW0][VALID_COL2], DEFAULT_DOUBLE2);
193 
194     /**
195      * @tc.steps: Test the function Transpose of the class MatrixN4.
196      */
197     MatrixN4 matrixN4Obj1(ROW_NUM);
198     matrixN4Obj1.SetEntry(VALID_ROW0, VALID_COL2, DEFAULT_DOUBLE2);
199     EXPECT_DOUBLE_EQ(matrixN4Obj1.Transpose()[VALID_ROW2][VALID_COL0], DEFAULT_DOUBLE2);
200 }
201 
202 /**
203  * @tc.name: Matrix4Test004
204  * @tc.desc: Test the function MapScalars of the classes Matrix4.
205  * @tc.type: FUNC
206  */
207 HWTEST_F(Matrix4Test, Matrix4Test004, TestSize.Level1)
208 {
209     /**
210      * @tc.steps: initialize the input parameters of the function MapScalars.
211      */
212     double srcVec[VALID_DIMENSION] = { DEFAULT_DOUBLE1, DEFAULT_DOUBLE1, DEFAULT_DOUBLE1, DEFAULT_DOUBLE1 };
213     double dstVec[VALID_DIMENSION] = { DEFAULT_DOUBLE0 };
214     Matrix4 matrix4Obj1 = Matrix4::CreateIdentity();
215     matrix4Obj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE2);
216     matrix4Obj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE2);
217 
218     /**
219      * @tc.steps: Test with given vectors srcVec and dstVec as the input and output parameters.
220      */
221     matrix4Obj1.MapScalars(srcVec, dstVec);
222     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW0], DEFAULT_DOUBLE1);
223     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW1], DEFAULT_DOUBLE2);
224     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW2], DEFAULT_DOUBLE2);
225     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW3], DEFAULT_DOUBLE1);
226 
227     /**
228      * @tc.steps: Test with the single vector srcVec as the input and output parameters.
229      */
230     matrix4Obj1.MapScalars(srcVec, srcVec);
231     EXPECT_DOUBLE_EQ(srcVec[VALID_ROW0], DEFAULT_DOUBLE1);
232     EXPECT_DOUBLE_EQ(srcVec[VALID_ROW1], DEFAULT_DOUBLE2);
233     EXPECT_DOUBLE_EQ(srcVec[VALID_ROW2], DEFAULT_DOUBLE2);
234     EXPECT_DOUBLE_EQ(srcVec[VALID_ROW3], DEFAULT_DOUBLE1);
235 }
236 
237 /**
238  * @tc.name: Matrix4Test005
239  * @tc.desc: Test the function MapScalars of the classes Matrix4N.
240  * @tc.type: FUNC
241  */
242 HWTEST_F(Matrix4Test, Matrix4Test005, TestSize.Level1)
243 {
244     /**
245      * @tc.steps: initialize the input parameters of the function MapScalars.
246      */
247     Matrix4N matrix4NObj1(COLUMN_NUM);
248     matrix4NObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE0);
249     matrix4NObj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE1);
250     matrix4NObj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE2);
251     matrix4NObj1.SetEntry(VALID_ROW3, VALID_COL3, DEFAULT_DOUBLE2);
252 
253     /**
254      * @tc.steps: Given the vector srcVec whose size is invalid, test the
255      *            function MapScalars with single parameter.
256      */
257     std::vector<double> srcVec = { DEFAULT_DOUBLE1, DEFAULT_DOUBLE1, DEFAULT_DOUBLE1, DEFAULT_DOUBLE1 };
258     std::vector<double> dstVec = matrix4NObj1.MapScalars(srcVec);
259     EXPECT_EQ(dstVec.size(), VALID_DIMENSION);
260     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW0], DEFAULT_DOUBLE0);
261     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW1], DEFAULT_DOUBLE0);
262     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW2], DEFAULT_DOUBLE0);
263     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW3], DEFAULT_DOUBLE0);
264 
265     /**
266      * @tc.steps: Given the vector srcVec whose size is valid, test the
267      *            function MapScalars with single parameter.
268      */
269     srcVec.push_back(DEFAULT_DOUBLE1);
270     dstVec = matrix4NObj1.MapScalars(srcVec);
271     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW0], DEFAULT_DOUBLE0);
272     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW1], DEFAULT_DOUBLE1);
273     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW2], DEFAULT_DOUBLE2);
274     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW3], DEFAULT_DOUBLE2);
275 
276     /**
277      * @tc.steps: Given the vector srcVec whose size is invalid, test the
278      *            function MapScalars with two parameters.
279      */
280     srcVec.pop_back();
281     dstVec.clear();
282     EXPECT_FALSE(matrix4NObj1.MapScalars(srcVec, dstVec));
283     EXPECT_TRUE(dstVec.empty());
284 
285     /**
286      * @tc.steps: Given the vector srcVec whose size is valid, test the
287      *            function MapScalars with two parameters.
288      */
289     srcVec.push_back(DEFAULT_DOUBLE1);
290     EXPECT_TRUE(matrix4NObj1.MapScalars(srcVec, dstVec));
291     EXPECT_EQ(dstVec.size(), VALID_DIMENSION);
292     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW0], DEFAULT_DOUBLE0);
293     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW1], DEFAULT_DOUBLE1);
294     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW2], DEFAULT_DOUBLE2);
295     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW3], DEFAULT_DOUBLE2);
296 }
297 
298 /**
299  * @tc.name: Matrix4Test006
300  * @tc.desc: Test the function MapScalars of the classes MatrixN4.
301  * @tc.type: FUNC
302  */
303 HWTEST_F(Matrix4Test, Matrix4Test006, TestSize.Level1)
304 {
305     /**
306      * @tc.steps: initialize the input parameters of the function MapScalars.
307      */
308     MatrixN4 matrixN4Obj1(ROW_NUM);
309     matrixN4Obj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE0);
310     matrixN4Obj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE1);
311     matrixN4Obj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE2);
312     matrixN4Obj1.SetEntry(VALID_ROW3, VALID_COL3, DEFAULT_DOUBLE2);
313 
314     /**
315      * @tc.steps: Test the function MapScalars with given the vector srcVec whose size is invalid.
316      */
317     std::vector<double> srcVec = { DEFAULT_DOUBLE1, DEFAULT_DOUBLE1, DEFAULT_DOUBLE1 };
318     std::vector<double> dstVec = matrixN4Obj1.MapScalars(srcVec);
319     EXPECT_EQ(dstVec.size(), ROW_NUM);
320     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW0], DEFAULT_DOUBLE0);
321     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW1], DEFAULT_DOUBLE0);
322     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW2], DEFAULT_DOUBLE0);
323     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW3], DEFAULT_DOUBLE0);
324     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW4], DEFAULT_DOUBLE0);
325 
326     /**
327      * @tc.steps: Test the function MapScalars with given the vector srcVec whose size is valid.
328      */
329     srcVec.push_back(DEFAULT_DOUBLE1);
330     dstVec = matrixN4Obj1.MapScalars(srcVec);
331     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW0], DEFAULT_DOUBLE0);
332     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW1], DEFAULT_DOUBLE1);
333     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW2], DEFAULT_DOUBLE2);
334     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW3], DEFAULT_DOUBLE2);
335     EXPECT_DOUBLE_EQ(dstVec[VALID_ROW4], DEFAULT_DOUBLE0);
336 }
337 
338 /**
339  * @tc.name: Matrix4Test007
340  * @tc.desc: Test the function operator* of classes Matrix4 and Matrix4N.
341  * @tc.type: FUNC
342  */
343 HWTEST_F(Matrix4Test, Matrix4Test007, TestSize.Level1)
344 {
345     /**
346      * @tc.steps: initialize parameters.
347      */
348     Matrix4 matrix4Obj1 = Matrix4::CreateIdentity();
349     matrix4Obj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
350     matrix4Obj1.SetEntry(VALID_ROW1, VALID_COL0, DEFAULT_DOUBLE2);
351     matrix4Obj1.SetEntry(VALID_ROW3, VALID_COL0, DEFAULT_DOUBLE2);
352     matrix4Obj1.SetEntry(VALID_ROW0, VALID_COL1, DEFAULT_DOUBLE0);
353     matrix4Obj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE2);
354     matrix4Obj1.SetEntry(VALID_ROW3, VALID_COL1, DEFAULT_DOUBLE2);
355 
356     /**
357      * @tc.steps: Test the function operator* of the class Matrix4 whose parameter is Point.
358      */
359     Point point(DEFAULT_DOUBLE1, DEFAULT_DOUBLE2);
360     Point result = matrix4Obj1 * point;
361     EXPECT_EQ(result.GetX(), DEFAULT_DOUBLE7);
362     EXPECT_EQ(result.GetY(), DEFAULT_DOUBLE6);
363 
364     /**
365      * @tc.steps: Test the function operator* of the class Matrix4 whose parameter is Matrix4N.
366      */
367     Matrix4 matrix4Obj2 = Matrix4::CreateIdentity() * DEFAULT_DOUBLE2;
368     Matrix4N matrix4NObj1(COLUMN_NUM);
369     matrix4NObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
370     matrix4NObj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE2);
371     matrix4NObj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE2);
372     matrix4NObj1.SetEntry(VALID_ROW3, VALID_COL3, DEFAULT_DOUBLE0);
373     Matrix4N matrix4NObj2 = matrix4Obj2 * matrix4NObj1;
374     EXPECT_DOUBLE_EQ(matrix4NObj2[VALID_ROW0][VALID_COL0], DEFAULT_DOUBLE2);
375     EXPECT_DOUBLE_EQ(matrix4NObj2[VALID_ROW1][VALID_COL1], DEFAULT_DOUBLE2 * DEFAULT_DOUBLE2);
376     EXPECT_DOUBLE_EQ(matrix4NObj2[VALID_ROW2][VALID_COL2], DEFAULT_DOUBLE2 * DEFAULT_DOUBLE2);
377     EXPECT_DOUBLE_EQ(matrix4NObj2[VALID_ROW3][VALID_COL3], DEFAULT_DOUBLE0);
378 
379     /**
380      * @tc.steps: Test the function operator* of the class Matrix4N whose parameter is MatrixN4.
381      */
382     MatrixN4 matrixN4Obj1(ROW_NUM);
383     matrixN4Obj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
384     matrixN4Obj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE2);
385     matrixN4Obj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE2);
386     matrixN4Obj1.SetEntry(VALID_ROW3, VALID_COL3, DEFAULT_DOUBLE0);
387     Matrix4 matrix4Obj3 = matrix4NObj1 * matrixN4Obj1;
388     EXPECT_DOUBLE_EQ(matrix4Obj3.Get(VALID_ROW0, VALID_COL0), DEFAULT_DOUBLE1);
389     EXPECT_DOUBLE_EQ(matrix4Obj3.Get(VALID_ROW1, VALID_COL1), DEFAULT_DOUBLE2 * DEFAULT_DOUBLE2);
390     EXPECT_DOUBLE_EQ(matrix4Obj3.Get(VALID_ROW2, VALID_COL2), DEFAULT_DOUBLE2 * DEFAULT_DOUBLE2);
391     EXPECT_DOUBLE_EQ(matrix4Obj3.Get(VALID_ROW3, VALID_COL3), DEFAULT_DOUBLE0);
392 
393     /**
394      * @tc.steps: Test the function operator* of the class Matrix4N with invalid input.
395      */
396     MatrixN4 matrixN4Obj2(ROW_NUM - 1);
397     Matrix4 matrix4Obj4 = matrix4NObj1 * matrixN4Obj2;
398     EXPECT_TRUE(matrix4Obj4.IsIdentityMatrix());
399 }
400 
401 /**
402  * @tc.name: Matrix4Test008
403  * @tc.desc: Test other functions of classes Matrix4 and Matrix4N.
404  * @tc.type: FUNC
405  */
406 HWTEST_F(Matrix4Test, Matrix4Test008, TestSize.Level1)
407 {
408     /**
409      * @tc.steps: Test the function about scale of the class Matrix4.
410      */
411     Matrix4 matrix4Obj1 = Matrix4::CreateIdentity();
412     matrix4Obj1.SetScale(DEFAULT_DOUBLE0, DEFAULT_DOUBLE1, DEFAULT_DOUBLE2);
413     EXPECT_DOUBLE_EQ(matrix4Obj1.GetScaleX(), DEFAULT_DOUBLE0);
414     EXPECT_DOUBLE_EQ(matrix4Obj1.GetScaleY(), DEFAULT_DOUBLE1);
415 
416     /**
417      * @tc.steps: Test the function operator[].
418      */
419     EXPECT_DOUBLE_EQ(matrix4Obj1[INVALID_ROW_NEG], DEFAULT_DOUBLE0);
420     EXPECT_DOUBLE_EQ(matrix4Obj1[MATRIXS_LENGTH], DEFAULT_DOUBLE0);
421     EXPECT_DOUBLE_EQ(matrix4Obj1[MATRIXS_LENGTH - 1], DEFAULT_DOUBLE1);
422 
423     /**
424      * @tc.steps: The determinant of identity matrix is 1.
425      */
426     Matrix4 matrix4Obj2 = Matrix4::CreateIdentity();
427     EXPECT_DOUBLE_EQ(matrix4Obj2.Determinant(), DEFAULT_DOUBLE1);
428 
429     /**
430      * @tc.steps: The inverse matrix of the matrix with determinant 0 returns the identity matrix by default.
431      */
432     Matrix4 matrix4Obj3 = matrix4Obj2;
433     matrix4Obj3.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE0);
434     EXPECT_DOUBLE_EQ(matrix4Obj3.Determinant(), DEFAULT_DOUBLE0);
435     EXPECT_EQ(Matrix4::Invert(matrix4Obj3), matrix4Obj2);
436 
437     /**
438      * @tc.steps: Test the inverse operator of matrix with non-zero determinant.
439      */
440     Matrix4 matrix4Obj4 = matrix4Obj2 * DEFAULT_DOUBLE2;
441     EXPECT_EQ(matrix4Obj4.Get(VALID_ROW0, VALID_COL0), DEFAULT_DOUBLE2);
442     Matrix4 matrix4Obj5 = Matrix4::Invert(matrix4Obj4);
443     EXPECT_DOUBLE_EQ(matrix4Obj5.Get(VALID_ROW0, VALID_COL0), 1 / DEFAULT_DOUBLE2);
444 
445     /**
446      * @tc.steps: The product of a given matrix and its inverse matrix is the identity matrix.
447      */
448     Matrix4 matrix4Obj6 = matrix4Obj4 * matrix4Obj5;
449     EXPECT_EQ(matrix4Obj6, matrix4Obj2);
450 }
451 
452 /**
453  * @tc.name: Matrix4Test009
454  * @tc.desc: Test  function QuaternionToMatrix/SetEntry/operator=
455  * @tc.type: FUNC
456  */
457 HWTEST_F(Matrix4Test, Matrix4Test009, TestSize.Level1)
458 {
459     /**
460      * @tc.steps: LessOrEqual 0.0f or not
461      */
462     Matrix4 ret = Matrix4::QuaternionToMatrix(0.0f, 0.0f, 0.0f, 0.0f);
463     EXPECT_EQ(ret.Get(0, 0) == 1.0f, true);
464     Matrix4 ret2 = Matrix4::QuaternionToMatrix(1.0f, 1.0f, 1.0f, 1.0f);
465     EXPECT_EQ(ret2.Get(0, 1) == 0.0f, true);
466 
467     /**
468      * @tc.steps: Matrix4 SetEntry row or col is out of range
469      */
470     // true
471     Matrix4 matrix4Obj = Matrix4::CreateIdentity();
472     matrix4Obj.SetEntry(-1, 0, 1.0f);
473     // false true
474     matrix4Obj.SetEntry(10.0, 0, 1.0f);
475     // false false true
476     matrix4Obj.SetEntry(1.0, -1, 1.0f);
477     // false false false true
478     matrix4Obj.SetEntry(1.0, 10.0, 1.0f);
479 
480     /**
481      * @tc.steps: Matrix4N SetEntry row or col is out of range
482      */
483     Matrix4N mtrix4NObj = Matrix4N(COLUMN_NUM);
484     bool ret3 = mtrix4NObj.SetEntry(-1, 0, 1.0f);
485     EXPECT_EQ(ret3, false);
486     bool ret4 = mtrix4NObj.SetEntry(10.0, 0, 1.0f);
487     EXPECT_EQ(ret4, false);
488     bool ret5 = mtrix4NObj.SetEntry(1.0, -1, 1.0f);
489     EXPECT_EQ(ret5, false);
490     bool ret6 = mtrix4NObj.SetEntry(1.0, COLUMN_NUM, 1.0f);
491     EXPECT_EQ(ret6, false);
492 
493     /**
494      * @tc.steps: MatrixN4 SetEntry row or col is out of range
495      */
496     MatrixN4 mtrixN4Obj = MatrixN4(ROW_NUM);
497     bool ret7 = mtrixN4Obj.SetEntry(-1, 0, 1.0f);
498     EXPECT_EQ(ret7, false);
499     bool ret8 = mtrixN4Obj.SetEntry(ROW_NUM, 0, 1.0f);
500     EXPECT_EQ(ret8, false);
501     bool ret9 = mtrixN4Obj.SetEntry(1.0, -1, 1.0f);
502     EXPECT_EQ(ret9, false);
503     bool ret10 = mtrixN4Obj.SetEntry(1.0, 10.0, 1.0f);
504     EXPECT_EQ(ret10, false);
505 }
506 } // namespace OHOS::Ace
507