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