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 22using namespace testing; 23using namespace testing::ext; 24 25namespace OHOS::Ace { 26namespace { 27const double DEFAULT_DOUBLE0 = 0.0; 28const double DEFAULT_DOUBLE1 = 1.0; 29const double DEFAULT_DOUBLE2 = 2.0; 30const double DEFAULT_DOUBLE6 = 6.0; 31const double DEFAULT_DOUBLE7 = 7.0; 32 33constexpr double ANGLE_UNIT = 0.017453f; 34const int32_t MATRIXS_LENGTH = 16; 35 36const int32_t VALID_ROW0 = 0; 37const int32_t VALID_COL0 = 0; 38const int32_t VALID_ROW1 = 1; 39const int32_t VALID_COL1 = 1; 40const int32_t VALID_ROW2 = 2; 41const int32_t VALID_COL2 = 2; 42const int32_t VALID_ROW3 = 3; 43const int32_t VALID_COL3 = 3; 44const int32_t VALID_ROW4 = 4; 45const int32_t VALID_DIMENSION = 4; 46 47const int32_t INVALID_ROW_NEG = -1; 48const int32_t INVALID_COL_NEG = -1; 49const int32_t INVALID_ROW_POS = 6; 50const int32_t INVALID_COL_POS = 6; 51 52const uint32_t ROW_NUM = 5; 53const uint32_t COLUMN_NUM = 5; 54} // namespace 55 56class 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 */ 63HWTEST_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 */ 137HWTEST_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 */ 175HWTEST_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 */ 207HWTEST_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 */ 242HWTEST_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 */ 303HWTEST_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 */ 343HWTEST_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 */ 406HWTEST_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 */ 457HWTEST_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