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 */
HWTEST_F(Matrix4Test, Matrix4Test001, TestSize.Level1)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 */
HWTEST_F(Matrix4Test, Matrix4Test002, TestSize.Level1)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 */
HWTEST_F(Matrix4Test, Matrix4Test003, TestSize.Level1)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 */
HWTEST_F(Matrix4Test, Matrix4Test004, TestSize.Level1)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 */
HWTEST_F(Matrix4Test, Matrix4Test005, TestSize.Level1)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 */
HWTEST_F(Matrix4Test, Matrix4Test006, TestSize.Level1)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 */
HWTEST_F(Matrix4Test, Matrix4Test007, TestSize.Level1)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 */
HWTEST_F(Matrix4Test, Matrix4Test008, TestSize.Level1)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 */
HWTEST_F(Matrix4Test, Matrix4Test009, TestSize.Level1)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