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 "base/geometry/transform_util.h" 19 20 using namespace testing; 21 using namespace testing::ext; 22 23 namespace OHOS::Ace { 24 namespace { 25 const double NUM_D1 = 1.0; 26 const double NUM_D2 = 0.0; 27 const float PROGRESS = 0.5f; 28 } // namespace 29 30 class TransformUtilTest : public testing::Test {}; 31 32 /** 33 * @tc.name: TransformUtilTest001 34 * @tc.desc: Test the functions of the class TranslateOperation. 35 * @tc.type: FUNC 36 */ 37 HWTEST_F(TransformUtilTest, TransformUtilTest001, TestSize.Level1) 38 { 39 Dimension dimension(NUM_D1); 40 TranslateOperation to(dimension, dimension, dimension); 41 TranslateOperation from(dimension, dimension, dimension); 42 TranslateOperation result = TranslateOperation::Blend(to, from, PROGRESS); 43 EXPECT_EQ(result, to); 44 } 45 46 /** 47 * @tc.name: TransformUtilTest002 48 * @tc.desc: Test the functions of the class ScaleOperation. 49 * @tc.type: FUNC 50 */ 51 HWTEST_F(TransformUtilTest, TransformUtilTest002, TestSize.Level1) 52 { 53 ScaleOperation to(NUM_D1, NUM_D1, NUM_D1); 54 ScaleOperation from(NUM_D1, NUM_D1, NUM_D1); 55 ScaleOperation result = ScaleOperation::Blend(to, from, PROGRESS); 56 EXPECT_EQ(result, to); 57 } 58 59 /** 60 * @tc.name: TransformUtilTest003 61 * @tc.desc: Test the functions of the class SkewOperation. 62 * @tc.type: FUNC 63 */ 64 HWTEST_F(TransformUtilTest, TransformUtilTest003, TestSize.Level1) 65 { 66 SkewOperation to(NUM_D1, NUM_D1); 67 SkewOperation from(NUM_D1, NUM_D1); 68 SkewOperation result = SkewOperation::Blend(to, from, PROGRESS); 69 EXPECT_EQ(result, to); 70 } 71 72 /** 73 * @tc.name: TransformUtilTest004 74 * @tc.desc: Test the functions of the class RotateOperation. 75 * @tc.type: FUNC 76 */ 77 HWTEST_F(TransformUtilTest, TransformUtilTest004, TestSize.Level1) 78 { 79 RotateOperation to(NUM_D1, NUM_D1, NUM_D1, NUM_D1); 80 RotateOperation from(NUM_D1, NUM_D1, NUM_D1, NUM_D1); 81 RotateOperation result = RotateOperation::Blend(to, from, PROGRESS); 82 EXPECT_EQ(result, to); 83 84 to = RotateOperation(NUM_D2, NUM_D2, NUM_D2, NUM_D1); 85 from = RotateOperation(NUM_D1, NUM_D1, NUM_D1, NUM_D1); 86 result = RotateOperation::Blend(to, from, PROGRESS); 87 EXPECT_EQ(result, from); 88 } 89 90 /** 91 * @tc.name: TransformUtilTest005 92 * @tc.desc: Test the functions of the class PerspectiveOperation. 93 * @tc.type: FUNC 94 */ 95 HWTEST_F(TransformUtilTest, TransformUtilTest005, TestSize.Level1) 96 { 97 Dimension dimension(NUM_D1); 98 PerspectiveOperation to(dimension); 99 PerspectiveOperation from(dimension); 100 PerspectiveOperation result = PerspectiveOperation::Blend(to, from, PROGRESS); 101 EXPECT_EQ(result, to); 102 } 103 104 /** 105 * @tc.name: TransformUtilTest006 106 * @tc.desc: Test the functions of the class TransformOperation. 107 * @tc.type: FUNC 108 */ 109 HWTEST_F(TransformUtilTest, TransformUtilTest006, TestSize.Level1) 110 { 111 TransformOperation result; 112 TransformOperation to = TransformOperation::Create(TransformOperationType::UNDEFINED); 113 TransformOperation from = TransformOperation::Create(TransformOperationType::UNDEFINED); 114 result = TransformOperation::Blend(to, from, PROGRESS); 115 EXPECT_EQ(result.matrix4_, Matrix4::CreateIdentity()); 116 from = TransformOperation::Create(TransformOperationType::TRANSLATE); 117 result = TransformOperation::Blend(to, from, PROGRESS); 118 EXPECT_EQ(result.type_, TransformOperationType::TRANSLATE); 119 EXPECT_EQ(result.translateOperation_, TranslateOperation()); 120 result = TransformOperation::Blend(from, to, PROGRESS); 121 EXPECT_EQ(result.type_, TransformOperationType::TRANSLATE); 122 EXPECT_EQ(result.translateOperation_, TranslateOperation()); 123 result = TransformOperation::Blend(from, from, PROGRESS); 124 EXPECT_EQ(result.type_, TransformOperationType::TRANSLATE); 125 EXPECT_EQ(result.translateOperation_, TranslateOperation()); 126 127 from = TransformOperation::Create(TransformOperationType::SCALE); 128 result = TransformOperation::Blend(to, from, PROGRESS); 129 EXPECT_EQ(result.type_, TransformOperationType::SCALE); 130 EXPECT_EQ(result.scaleOperation_, ScaleOperation()); 131 132 from = TransformOperation::Create(TransformOperationType::SKEW); 133 result = TransformOperation::Blend(to, from, PROGRESS); 134 EXPECT_EQ(result.type_, TransformOperationType::SKEW); 135 EXPECT_EQ(result.skewOperation_, SkewOperation()); 136 137 from = TransformOperation::Create(TransformOperationType::ROTATE); 138 result = TransformOperation::Blend(to, from, PROGRESS); 139 EXPECT_EQ(result.type_, TransformOperationType::ROTATE); 140 EXPECT_EQ(result.rotateOperation_, RotateOperation()); 141 142 from = TransformOperation::Create(TransformOperationType::MATRIX); 143 result = TransformOperation::Blend(to, from, PROGRESS); 144 EXPECT_EQ(result.type_, TransformOperationType::MATRIX); 145 EXPECT_EQ(result.matrix4_, Matrix4::CreateIdentity()); 146 147 from = TransformOperation::Create(TransformOperationType::PERSPECTIVE); 148 result = TransformOperation::Blend(to, from, PROGRESS); 149 EXPECT_EQ(result.type_, TransformOperationType::PERSPECTIVE); 150 EXPECT_EQ(result.perspectiveOperation_, PerspectiveOperation()); 151 } 152 153 /** 154 * @tc.name: TransformUtilTest007 155 * @tc.desc: Test the function ToString of the class DecomposedTransform. 156 * @tc.type: FUNC 157 */ 158 HWTEST_F(TransformUtilTest, TransformUtilTest007, TestSize.Level1) 159 { 160 DecomposedTransform decomposedTransform; 161 std::string resStr; 162 resStr.append("translate: ") 163 .append(std::to_string(0.0f)) 164 .append(" ") 165 .append(std::to_string(0.0f)) 166 .append(" ") 167 .append(std::to_string(0.0f)) 168 .append("\n") 169 .append("scale: ") 170 .append(std::to_string(1.0f)) 171 .append(" ") 172 .append(std::to_string(1.0f)) 173 .append(" ") 174 .append(std::to_string(1.0f)) 175 .append("\n") 176 .append("skew: ") 177 .append(std::to_string(0.0f)) 178 .append(" ") 179 .append(std::to_string(0.0f)) 180 .append(" ") 181 .append(std::to_string(0.0f)) 182 .append("\n") 183 .append("perspective: ") 184 .append(std::to_string(0.0f)) 185 .append(" ") 186 .append(std::to_string(0.0f)) 187 .append(" ") 188 .append(std::to_string(0.0f)) 189 .append(" ") 190 .append(std::to_string(1.0f)) 191 .append("\n") 192 .append("quaternion: ") 193 .append(std::to_string(0.0)) 194 .append(" ") 195 .append(std::to_string(0.0)) 196 .append(" ") 197 .append(std::to_string(0.0)) 198 .append(" ") 199 .append(std::to_string(0.0)) 200 .append("\n"); 201 EXPECT_EQ(decomposedTransform.ToString(), resStr); 202 } 203 204 /** 205 * @tc.name: TransformUtilTest008 206 * @tc.desc: Test the functions of the class TransformOperations. 207 * @tc.type: FUNC 208 */ 209 HWTEST_F(TransformUtilTest, TransformUtilTest008, TestSize.Level1) 210 { 211 std::vector<TransformOperation> operations; 212 operations.push_back(TransformOperation::Create(TransformOperationType::TRANSLATE)); 213 operations.push_back(TransformOperation::Create(TransformOperationType::SCALE)); 214 operations.push_back(TransformOperation::Create(TransformOperationType::SKEW)); 215 operations.push_back(TransformOperation::Create(TransformOperationType::ROTATE)); 216 operations.push_back(TransformOperation::Create(TransformOperationType::PERSPECTIVE)); 217 operations.push_back(TransformOperation::Create(TransformOperationType::MATRIX)); 218 operations.push_back(TransformOperation::Create(TransformOperationType::UNDEFINED)); 219 220 TransformOperations::ParseOperationsToMatrix(operations); 221 EXPECT_EQ(operations[0].type_, TransformOperationType::TRANSLATE); 222 EXPECT_EQ(operations[0].translateOperation_, TranslateOperation()); 223 EXPECT_EQ(operations[0].matrix4_, Matrix4::CreateTranslate(NUM_D2, NUM_D2, NUM_D2)); 224 EXPECT_EQ(operations[1].type_, TransformOperationType::SCALE); 225 EXPECT_EQ(operations[1].scaleOperation_, ScaleOperation()); 226 EXPECT_EQ(operations[1].matrix4_, Matrix4::CreateScale(NUM_D1, NUM_D1, NUM_D1)); 227 EXPECT_EQ(operations[2].type_, TransformOperationType::SKEW); 228 EXPECT_EQ(operations[2].skewOperation_, SkewOperation()); 229 EXPECT_EQ(operations[2].matrix4_, Matrix4::CreateSkew(NUM_D2, NUM_D2)); 230 EXPECT_EQ(operations[3].type_, TransformOperationType::ROTATE); 231 EXPECT_EQ(operations[3].rotateOperation_, RotateOperation()); 232 EXPECT_EQ(operations[3].matrix4_, Matrix4::CreateRotate(NUM_D2, NUM_D2, NUM_D2, NUM_D2)); 233 EXPECT_EQ(operations[4].type_, TransformOperationType::PERSPECTIVE); 234 EXPECT_EQ(operations[4].perspectiveOperation_, PerspectiveOperation()); 235 EXPECT_EQ(operations[4].matrix4_, Matrix4::CreatePerspective(NUM_D2)); 236 EXPECT_EQ(operations[5].type_, TransformOperationType::MATRIX); 237 EXPECT_EQ(operations[5].matrix4_, Matrix4::CreateIdentity()); 238 EXPECT_EQ(operations[6].type_, TransformOperationType::UNDEFINED); 239 EXPECT_EQ(operations[6].matrix4_, Matrix4::CreateIdentity()); 240 241 TransformOperations to(operations); 242 TransformOperations from(operations); 243 TransformOperations result = TransformOperations::Blend(to, from, PROGRESS); 244 ASSERT_EQ(result.GetOperations().size(), operations.size()); 245 EXPECT_EQ(result.GetOperations()[0].translateOperation_, TranslateOperation()); 246 EXPECT_EQ(result.GetOperations()[1].scaleOperation_, ScaleOperation()); 247 EXPECT_EQ(result.GetOperations()[2].skewOperation_, SkewOperation()); 248 EXPECT_EQ(result.GetOperations()[3].rotateOperation_, RotateOperation()); 249 EXPECT_EQ(result.GetOperations()[4].perspectiveOperation_, PerspectiveOperation()); 250 } 251 252 /** 253 * @tc.name: TransformUtilTest009 254 * @tc.desc: Test the functions of the class ComposeTransform. 255 * @tc.type: FUNC 256 */ 257 HWTEST_F(TransformUtilTest, TransformUtilTest009, TestSize.Level1) 258 { 259 DecomposedTransform decomposedTransform; 260 decomposedTransform.skew[0] = 1.0f; 261 decomposedTransform.skew[1] = 1.0f; 262 decomposedTransform.skew[2] = 1.0f; 263 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0); 264 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0); 265 } 266 267 /** 268 * @tc.name: TransformUtilTest010 269 * @tc.desc: Test the functions of BuildTranslationMatrix. 270 * @tc.type: FUNC 271 */ 272 HWTEST_F(TransformUtilTest, TransformUtilTest010, TestSize.Level1) 273 { 274 DecomposedTransform decomposedTransform; 275 // 0.000001 true false false 276 decomposedTransform.translate[0] = 0.000001f; 277 decomposedTransform.translate[1] = 1.0f; 278 decomposedTransform.translate[2] = 1.0f; 279 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0); 280 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0); 281 // 0.000001 true true false 282 decomposedTransform.translate[0] = 0.000001f; 283 decomposedTransform.translate[1] = 0.000001f; 284 decomposedTransform.translate[2] = 1.0f; 285 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0); 286 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0); 287 // 0.000001 true true true 288 decomposedTransform.translate[0] = 0.000001f; 289 decomposedTransform.translate[1] = 0.000001f; 290 decomposedTransform.translate[2] = 0.000001f; 291 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0); 292 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0); 293 // 0.000001 false true true 294 decomposedTransform.translate[0] = 1.0f; 295 decomposedTransform.translate[1] = 0.000001f; 296 decomposedTransform.translate[2] = 0.000001f; 297 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0); 298 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0); 299 // 0.000001 true false true 300 decomposedTransform.translate[0] = 0.000001f; 301 decomposedTransform.translate[1] = 1.0f; 302 decomposedTransform.translate[2] = 0.000001f; 303 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0); 304 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0); 305 } 306 307 /** 308 * @tc.name: TransformUtilTest011 309 * @tc.desc: Test the functions of the BuildSkewMatrix 310 * @tc.type: FUNC 311 */ 312 HWTEST_F(TransformUtilTest, TransformUtilTest011, TestSize.Level1) 313 { 314 DecomposedTransform decomposedTransform; 315 decomposedTransform.skew[0] = 0.0f; 316 decomposedTransform.skew[1] = 0.0f; 317 decomposedTransform.skew[2] = 0.0f; 318 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleX(), 1.0); 319 EXPECT_EQ(TransformUtil::ComposeTransform(decomposedTransform).GetScaleY(), 1.0); 320 } 321 322 /** 323 * @tc.name: TransformUtilTest012 324 * @tc.desc: Test the functions of the DecomposeTransform 325 * @tc.type: FUNC 326 */ 327 HWTEST_F(TransformUtilTest, TransformUtilTest012, TestSize.Level1) 328 { 329 // Normalize is false 330 DecomposedTransform out; 331 Matrix4 transform = Matrix4::CreateIdentity(); 332 transform.Set(3, 3, 0.000001f); 333 TransformUtil::DecomposeTransform(out, transform); 334 EXPECT_EQ(transform.Get(3, 3) == 0.000001f, true); 335 // Normalize is true 336 transform.Set(3, 3, 1.0f); 337 // NearZero false false false 338 transform.Set(3, 0, 1.0f); 339 transform.Set(3, 1, 1.0f); 340 transform.Set(3, 2, 1.0f); 341 TransformUtil::DecomposeTransform(out, transform); 342 EXPECT_EQ(out.perspective[0] == 1.0f, true); 343 // NearZero true false false 344 transform.Set(3, 0, 0.000001f); 345 transform.Set(3, 1, 1.0f); 346 transform.Set(3, 2, 1.0f); 347 TransformUtil::DecomposeTransform(out, transform); 348 EXPECT_EQ(out.perspective[0] == 0.000001f, true); 349 // NearZero true true false 350 transform.Set(3, 0, 0.000001f); 351 transform.Set(3, 1, 1.0f); 352 transform.Set(3, 2, 1.0f); 353 TransformUtil::DecomposeTransform(out, transform); 354 EXPECT_EQ(out.perspective[0] == 0.000001f, true); 355 // CreateScale 0.0f 356 Matrix4 transform2 = Matrix4::CreateScale(0.0f, 0.0f, 0.0f); 357 TransformUtil::DecomposeTransform(out, transform2); 358 EXPECT_EQ(out.scale[0] == 0.0f, true); 359 } 360 } // namespace OHOS::Ace 361