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 #include "gtest/gtest.h"
18 #include "base/geometry/matrix3.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS::Ace {
24 namespace {
25 constexpr double DEFAULT_DOUBLE0 = 0.0;
26 constexpr double DEFAULT_DOUBLE1 = 1.0;
27 constexpr double DEFAULT_DOUBLE2 = 2.0;
28 constexpr double DEFAULT_DOUBLE3 = 3.0;
29
30 constexpr int32_t VALID_ROW0 = 0;
31 constexpr int32_t VALID_COL0 = 0;
32 constexpr int32_t VALID_ROW1 = 1;
33 constexpr int32_t VALID_COL1 = 1;
34 constexpr int32_t VALID_ROW2 = 2;
35 constexpr int32_t VALID_COL2 = 2;
36 constexpr uint32_t VALID_DIMENSION = 3;
37
38 constexpr int32_t INVALID_ROW_NEG = -1;
39 constexpr int32_t INVALID_COL_NEG = -1;
40 constexpr int32_t INVALID_ROW_POS = 5;
41 constexpr int32_t INVALID_COL_POS = 5;
42
43 constexpr uint32_t ROW_NUM = 4;
44 constexpr uint32_t COLUMN_NUM = 4;
45 }
46
47 class Matrix3Test : public testing::Test {
48 public:
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 void SetUp();
52 void TearDown();
53 };
54
SetUpTestCase()55 void Matrix3Test::SetUpTestCase()
56 {
57 GTEST_LOG_(INFO) << "Matrix3Test SetUpTestCase";
58 }
59
TearDownTestCase()60 void Matrix3Test::TearDownTestCase()
61 {
62 GTEST_LOG_(INFO) << "Matrix3Test TearDownTestCase";
63 }
64
SetUp()65 void Matrix3Test::SetUp()
66 {
67 GTEST_LOG_(INFO) << "Matrix3Test SetUp";
68 }
69
TearDown()70 void Matrix3Test::TearDown()
71 {
72 GTEST_LOG_(INFO) << "Matrix3Test TearDown";
73 }
74
75 /**
76 * @tc.name: Matrix3Test001
77 * @tc.desc: Test the function SetEntry of the classes Matrix3, Matrix3N and MatrixN3.
78 * @tc.type: FUNC
79 */
80 HWTEST_F(Matrix3Test, Matrix3Test001, TestSize.Level1)
81 {
82 /**
83 * @tc.steps1: initialize parameters.
84 */
85 Matrix3 matrixObj1;
86 std::string initStrObj1 = matrixObj1.ToString();
87 Matrix3N matrix3NObj1(COLUMN_NUM);
88 std::string initStr3NObj1 = matrix3NObj1.ToString();
89 MatrixN3 matrixN3Obj1(ROW_NUM);
90 std::string initStrN3Obj1 = matrixN3Obj1.ToString();
91
92 /**
93 * @tc.steps2: Call the function SetEntry of the classes Matrix3.
94 * @tc.expected: Set the value of a legal location, the value of the corresponding location changes normally.
95 * Set the value of an illegal location, there is no change.
96 */
97 matrixObj1.SetEntry(INVALID_ROW_NEG, INVALID_COL_NEG, DEFAULT_DOUBLE1);
98 EXPECT_EQ(matrixObj1.ToString(), initStrObj1);
99 matrixObj1.SetEntry(INVALID_ROW_POS, INVALID_COL_POS, DEFAULT_DOUBLE1);
100 EXPECT_EQ(matrixObj1.ToString(), initStrObj1);
101 matrixObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
102 EXPECT_DOUBLE_EQ(matrixObj1[VALID_ROW0][VALID_COL0], DEFAULT_DOUBLE1);
103
104 /**
105 * @tc.steps3: Call the function SetEntry of the classes Matrix3N.
106 * @tc.expected: Set the value of a legal location, the value of the corresponding location changes normally.
107 * Set the value of an illegal location, there is no change.
108 */
109 matrix3NObj1.SetEntry(INVALID_ROW_POS, INVALID_COL_POS, DEFAULT_DOUBLE1);
110 EXPECT_EQ(matrix3NObj1.ToString(), initStr3NObj1);
111 matrix3NObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
112 EXPECT_DOUBLE_EQ(matrix3NObj1[VALID_ROW0][VALID_COL0], DEFAULT_DOUBLE1);
113
114 /**
115 * @tc.steps4: Call the function SetEntry of the classes MatrixN3.
116 * @tc.expected: Set the value of a legal location, the value of the corresponding location changes normally.
117 * Set the value of an illegal location, there is no change.
118 */
119 matrixN3Obj1.SetEntry(INVALID_ROW_POS, INVALID_COL_POS, DEFAULT_DOUBLE1);
120 EXPECT_EQ(matrixN3Obj1.ToString(), initStrN3Obj1);
121 matrixN3Obj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
122 EXPECT_DOUBLE_EQ(matrixN3Obj1[VALID_ROW0][VALID_COL0], DEFAULT_DOUBLE1);
123 }
124
125 /**
126 * @tc.name: Matrix3Test002
127 * @tc.desc: Test the function Transpose of the classes Matrix3, Matrix3N and MatrixN3.
128 * @tc.type: FUNC
129 */
130 HWTEST_F(Matrix3Test, Matrix3Test002, TestSize.Level1)
131 {
132 /**
133 * @tc.steps1: initialize parameters.
134 */
135 Matrix3 matrixObj1;
136 matrixObj1.SetEntry(VALID_ROW0, VALID_COL2, DEFAULT_DOUBLE1);
137 Matrix3N matrix3NObj1(COLUMN_NUM);
138 matrix3NObj1.SetEntry(VALID_ROW0, VALID_COL2, DEFAULT_DOUBLE1);
139 MatrixN3 matrixN3Obj1(ROW_NUM);
140 matrixN3Obj1.SetEntry(VALID_ROW0, VALID_COL2, DEFAULT_DOUBLE1);
141
142 /**
143 * @tc.steps2: Call the function Transpose of the classes Matrix3.
144 * @tc.expected: The value of corresponding locations of two matrixes is equal.
145 */
146 Matrix3 matrixObj2 = matrixObj1.Transpose();
147 EXPECT_DOUBLE_EQ(matrixObj2[VALID_ROW2][VALID_COL0], DEFAULT_DOUBLE1);
148
149 /**
150 * @tc.steps3: Call the function Transpose of the classes Matrix3N.
151 * @tc.expected: The value of corresponding locations of two matrixes is equal.
152 */
153 MatrixN3 matrixN3Obj2 = matrix3NObj1.Transpose();
154 EXPECT_DOUBLE_EQ(matrixN3Obj2[VALID_ROW2][VALID_COL0], DEFAULT_DOUBLE1);
155
156 /**
157 * @tc.steps4: Call the function Transpose of the classes MatrixN3.
158 * @tc.expected: The value of corresponding locations of two matrixes is equal.
159 */
160 Matrix3N matrix3NObj2 = matrixN3Obj1.Transpose();
161 EXPECT_DOUBLE_EQ(matrix3NObj2[VALID_ROW2][VALID_COL0], DEFAULT_DOUBLE1);
162 }
163
164 /**
165 * @tc.name: Matrix3Test003
166 * @tc.desc: Test the function inverse of the class Matrix3.
167 * @tc.type: FUNC
168 */
169 HWTEST_F(Matrix3Test, Matrix3Test003, TestSize.Level1)
170 {
171 /**
172 * @tc.steps1: initialize parameters.
173 */
174 Matrix3 matrixObj1;
175 matrixObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
176 Matrix3 matrixObj2;
177 std::string initStrObj2 = matrixObj2.ToString();
178
179 /**
180 * @tc.steps2: Call the function inverse of the matrix with determinant 0.
181 * @tc.expected: The function inverse does not work, and the matrix matrixObj2 is not changed.
182 */
183 EXPECT_FALSE(matrixObj1.Invert(matrixObj2));
184 EXPECT_EQ(matrixObj2.ToString(), initStrObj2);
185
186 /**
187 * @tc.steps3: Set the matrix matrixObj1 to identity matrix.
188 */
189 matrixObj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE1);
190 matrixObj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE1);
191
192 /**
193 * @tc.steps4: Call the function inverse of the identity matrix.
194 * @tc.expected: The inverse matrix of matrixObj2 is the identity matrix, and is set to the matrix matrixObj2.
195 */
196 EXPECT_TRUE(matrixObj1.Invert(matrixObj2));
197 EXPECT_NE(matrixObj2.ToString(), initStrObj2);
198 EXPECT_DOUBLE_EQ(matrixObj2[VALID_ROW0][VALID_COL0], DEFAULT_DOUBLE1);
199 EXPECT_DOUBLE_EQ(matrixObj2[VALID_ROW1][VALID_COL1], DEFAULT_DOUBLE1);
200 EXPECT_DOUBLE_EQ(matrixObj2[VALID_ROW2][VALID_COL2], DEFAULT_DOUBLE1);
201 }
202
203 /**
204 * @tc.name: Matrix3Test004
205 * @tc.desc: Test the function operator* of classes Matrix3 and Matrix3N.
206 * @tc.type: FUNC
207 */
208 HWTEST_F(Matrix3Test, Matrix3Test004, TestSize.Level1)
209 {
210 /**
211 * @tc.steps1: initialize parameters.
212 */
213 Matrix3 matrixObj1;
214 matrixObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
215 matrixObj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE1);
216 matrixObj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE1);
217 Matrix3N matrix3NObj1(COLUMN_NUM);
218 matrix3NObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
219 matrix3NObj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE2);
220 matrix3NObj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE3);
221 MatrixN3 matrixN3Obj1(ROW_NUM);
222 matrixN3Obj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
223 matrixN3Obj1.SetEntry(VALID_ROW1, VALID_COL1, 1.0 / DEFAULT_DOUBLE2);
224 matrixN3Obj1.SetEntry(VALID_ROW2, VALID_COL2, 1.0 / DEFAULT_DOUBLE3);
225
226 /**
227 * @tc.steps2: Call the function operator* of classes Matrix3 with the identity matrix matrixObj1.
228 * @tc.expected: The product of matrixes matrixObj1 and matrix3NObj1 is equal to matrix3NObj2.
229 */
230 Matrix3N matrix3NObj2 = matrixObj1 * matrix3NObj1;
231 EXPECT_EQ(matrix3NObj1.ToString(), matrix3NObj2.ToString());
232
233 /**
234 * @tc.steps3: Call the function operator* of classes Matrix3N.
235 * @tc.expected: The product of matrixes matrix3NObj1 and matrixN3Obj1 is equal to matrixObj1.
236 */
237 Matrix3 matrixObj2 = matrix3NObj1 * matrixN3Obj1;
238 EXPECT_EQ(matrixObj2.ToString(), matrixObj1.ToString());
239 }
240
241 /**
242 * @tc.name: Matrix3Test005
243 * @tc.desc: Test the function MapScalars of the class Matrix3.
244 * @tc.type: FUNC
245 */
246 HWTEST_F(Matrix3Test, Matrix3Test005, TestSize.Level1)
247 {
248 /**
249 * @tc.steps1: initialize parameters.
250 */
251 Matrix3 matrixObj1;
252 matrixObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
253 matrixObj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE2);
254 matrixObj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE3);
255
256 /**
257 * @tc.steps2: Given the vector srcVec whose size is invalid, test the
258 * function MapScalars with single parameter.
259 * @tc.expected: The function MapScalars does not work and all values of the return vector are equal to zero.
260 */
261 std::vector<double> srcVec = { DEFAULT_DOUBLE1, DEFAULT_DOUBLE1 };
262 std::vector<double> dstVec = matrixObj1.MapScalars(srcVec);
263 EXPECT_EQ(dstVec.size(), VALID_DIMENSION);
264 EXPECT_EQ(dstVec[0], DEFAULT_DOUBLE0);
265 EXPECT_EQ(dstVec[1], DEFAULT_DOUBLE0);
266 EXPECT_EQ(dstVec[2], DEFAULT_DOUBLE0);
267
268 /**
269 * @tc.steps3: Given the vector srcVec whose size is valid, test the
270 * function MapScalars with single parameter.
271 * @tc.expected: The values of return vector is equal to values on the diagonal of matrixObj1.
272 */
273 srcVec.push_back(DEFAULT_DOUBLE1);
274 dstVec = matrixObj1.MapScalars(srcVec);
275 EXPECT_EQ(dstVec[0], DEFAULT_DOUBLE1);
276 EXPECT_EQ(dstVec[1], DEFAULT_DOUBLE2);
277 EXPECT_EQ(dstVec[2], DEFAULT_DOUBLE3);
278
279 /**
280 * @tc.steps4: Given the vector srcVec whose size is invalid, test the
281 * function MapScalars with two parameters.
282 * @tc.expected: The function MapScalars does not work and the return vector is empty.
283 */
284 srcVec.clear();
285 dstVec.clear();
286 srcVec.push_back(DEFAULT_DOUBLE1);
287 srcVec.push_back(DEFAULT_DOUBLE1);
288 EXPECT_FALSE(matrixObj1.MapScalars(srcVec, dstVec));
289 EXPECT_TRUE(dstVec.empty());
290
291 /**
292 * @tc.steps5: Given the vector srcVec whose size is valid, test the
293 * function MapScalars with two parameters.
294 * @tc.expected: The values of return vector is equal to values on the diagonal of matrixObj1.
295 */
296 srcVec.push_back(DEFAULT_DOUBLE1);
297 EXPECT_TRUE(matrixObj1.MapScalars(srcVec, dstVec));
298 EXPECT_EQ(dstVec[0], DEFAULT_DOUBLE1);
299 EXPECT_EQ(dstVec[1], DEFAULT_DOUBLE2);
300 EXPECT_EQ(dstVec[2], DEFAULT_DOUBLE3);
301 }
302
303 /**
304 * @tc.name: Matrix3Test006
305 * @tc.desc: Test the function MapScalars of the class Matrix3N.
306 * @tc.type: FUNC
307 */
308 HWTEST_F(Matrix3Test, Matrix3Test006, TestSize.Level1)
309 {
310 /**
311 * @tc.steps1: initialize parameters.
312 */
313 Matrix3N matrix3NObj1(COLUMN_NUM);
314 matrix3NObj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
315 matrix3NObj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE2);
316 matrix3NObj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE3);
317
318 /**
319 * @tc.steps2: Given the vector srcVec whose size is invalid, test the
320 * function MapScalars with single parameter.
321 * @tc.expected: The function MapScalars does not work and all values of the return vector are equal to zero.
322 */
323 std::vector<double> srcVec = { DEFAULT_DOUBLE1, DEFAULT_DOUBLE1 };
324 std::vector<double> dstVec = matrix3NObj1.MapScalars(srcVec);
325 EXPECT_EQ(dstVec.size(), VALID_DIMENSION);
326 EXPECT_EQ(dstVec[0], DEFAULT_DOUBLE0);
327 EXPECT_EQ(dstVec[1], DEFAULT_DOUBLE0);
328 EXPECT_EQ(dstVec[2], DEFAULT_DOUBLE0);
329
330 /**
331 * @tc.steps3: Given the vector srcVec whose size is valid, test the
332 * function MapScalars with single parameter.
333 * @tc.expected: The values of return vector is equal to values on the diagonal of matrix3NObj1.
334 */
335 srcVec.push_back(DEFAULT_DOUBLE1);
336 srcVec.push_back(DEFAULT_DOUBLE1);
337 dstVec = matrix3NObj1.MapScalars(srcVec);
338 EXPECT_EQ(dstVec[0], DEFAULT_DOUBLE1);
339 EXPECT_EQ(dstVec[1], DEFAULT_DOUBLE2);
340 EXPECT_EQ(dstVec[2], DEFAULT_DOUBLE3);
341
342 /**
343 * @tc.steps4: Given the vector srcVec whose size is invalid, test the
344 * function MapScalars with two parameters.
345 * @tc.expected: The function MapScalars does not work and the return vector is empty.
346 */
347 srcVec.clear();
348 dstVec.clear();
349 srcVec.push_back(DEFAULT_DOUBLE1);
350 srcVec.push_back(DEFAULT_DOUBLE1);
351 EXPECT_FALSE(matrix3NObj1.MapScalars(srcVec, dstVec));
352 EXPECT_TRUE(dstVec.empty());
353
354 /**
355 * @tc.steps: Given the vector srcVec whose size is valid, test the
356 * function MapScalars with two parameters.
357 * @tc.expected: The values of return vector is equal to values on the diagonal of matrix3NObj1.
358 */
359 srcVec.push_back(DEFAULT_DOUBLE1);
360 srcVec.push_back(DEFAULT_DOUBLE1);
361 EXPECT_TRUE(matrix3NObj1.MapScalars(srcVec, dstVec));
362 EXPECT_EQ(dstVec[0], DEFAULT_DOUBLE1);
363 EXPECT_EQ(dstVec[1], DEFAULT_DOUBLE2);
364 EXPECT_EQ(dstVec[2], DEFAULT_DOUBLE3);
365 }
366
367 /**
368 * @tc.name: Matrix3Test007
369 * @tc.desc: Test the function MapScalars of the class MatrixN3.
370 * @tc.type: FUNC
371 */
372 HWTEST_F(Matrix3Test, Matrix3Test007, TestSize.Level1)
373 {
374 /**
375 * @tc.steps1: initialize parameters.
376 */
377 MatrixN3 matrixN3Obj1(ROW_NUM);
378 matrixN3Obj1.SetEntry(VALID_ROW0, VALID_COL0, DEFAULT_DOUBLE1);
379 matrixN3Obj1.SetEntry(VALID_ROW1, VALID_COL1, DEFAULT_DOUBLE2);
380 matrixN3Obj1.SetEntry(VALID_ROW2, VALID_COL2, DEFAULT_DOUBLE3);
381
382 /**
383 * @tc.steps2: Given the vector srcVec whose size is invalid, test the function MapScalars.
384 * @tc.expected: The function MapScalars does not work and all values of the return vector are equal to zero.
385 */
386 std::vector<double> srcVec = { DEFAULT_DOUBLE1, DEFAULT_DOUBLE1 };
387 std::vector<double> dstVec = matrixN3Obj1.MapScalars(srcVec);
388 EXPECT_EQ(dstVec.size(), ROW_NUM);
389 EXPECT_EQ(dstVec[0], DEFAULT_DOUBLE0);
390 EXPECT_EQ(dstVec[1], DEFAULT_DOUBLE0);
391 EXPECT_EQ(dstVec[2], DEFAULT_DOUBLE0);
392 EXPECT_EQ(dstVec[3], DEFAULT_DOUBLE0);
393
394 /**
395 * @tc.steps3: Given the vector srcVec whose size is valid, test the function MapScalars.
396 * @tc.expected: The values of return vector is equal to values on the diagonal of matrixN3Obj1.
397 */
398 srcVec.push_back(DEFAULT_DOUBLE1);
399 dstVec = matrixN3Obj1.MapScalars(srcVec);
400 EXPECT_EQ(dstVec[0], DEFAULT_DOUBLE1);
401 EXPECT_EQ(dstVec[1], DEFAULT_DOUBLE2);
402 EXPECT_EQ(dstVec[2], DEFAULT_DOUBLE3);
403 EXPECT_EQ(dstVec[3], DEFAULT_DOUBLE0);
404 }
405 } // namespace OHOS::Ace