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 "window_helper.h" 19 20 using namespace testing; 21 using namespace testing::ext; 22 23 namespace OHOS { 24 namespace Rosen { 25 class WindowHelperTest : public testing::Test { 26 public: 27 static void SetUpTestCase(); 28 static void TearDownTestCase(); 29 virtual void SetUp() override; 30 virtual void TearDown() override; 31 }; 32 SetUpTestCase()33 void WindowHelperTest::SetUpTestCase() 34 { 35 } 36 TearDownTestCase()37 void WindowHelperTest::TearDownTestCase() 38 { 39 } 40 SetUp()41 void WindowHelperTest::SetUp() 42 { 43 } 44 TearDown()45 void WindowHelperTest::TearDown() 46 { 47 } 48 49 namespace { 50 /** 51 * @tc.name: WindowTypeWindowMode 52 * @tc.desc: window type/mode test 53 * @tc.type: FUNC 54 */ 55 HWTEST_F(WindowHelperTest, WindowTypeWindowMode, Function | SmallTest | Level1) 56 { 57 ASSERT_EQ(true, WindowHelper::IsMainFullScreenWindow(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 58 WindowMode::WINDOW_MODE_FULLSCREEN)); 59 ASSERT_EQ(false, WindowHelper::IsMainFullScreenWindow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW, 60 WindowMode::WINDOW_MODE_FULLSCREEN)); 61 ASSERT_EQ(false, WindowHelper::IsMainFullScreenWindow(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 62 WindowMode::WINDOW_MODE_SPLIT_PRIMARY)); 63 64 ASSERT_EQ(true, WindowHelper::IsFloatingWindow(WindowMode::WINDOW_MODE_FLOATING)); 65 ASSERT_EQ(false, WindowHelper::IsFloatingWindow(WindowMode::WINDOW_MODE_FULLSCREEN)); 66 67 ASSERT_EQ(true, WindowHelper::IsFullScreenWindow(WindowMode::WINDOW_MODE_FULLSCREEN)); 68 ASSERT_EQ(false, WindowHelper::IsFullScreenWindow(WindowMode::WINDOW_MODE_FLOATING)); 69 70 ASSERT_EQ(true, WindowHelper::IsDialogWindow(WindowType::WINDOW_TYPE_DIALOG)); 71 ASSERT_EQ(false, WindowHelper::IsDialogWindow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW)); 72 } 73 74 /** 75 * @tc.name: WindowModeSupport 76 * @tc.desc: window mode supported test 77 * @tc.type: FUNC 78 */ 79 HWTEST_F(WindowHelperTest, WindowModeSupport, Function | SmallTest | Level1) 80 { 81 ASSERT_EQ(true, WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL, 82 WindowMode::WINDOW_MODE_FULLSCREEN)); 83 ASSERT_EQ(true, WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL, 84 WindowMode::WINDOW_MODE_FLOATING)); 85 ASSERT_EQ(true, WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL, 86 WindowMode::WINDOW_MODE_SPLIT_PRIMARY)); 87 ASSERT_EQ(true, WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL, 88 WindowMode::WINDOW_MODE_SPLIT_SECONDARY)); 89 ASSERT_EQ(true, WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL, 90 WindowMode::WINDOW_MODE_PIP)); 91 ASSERT_EQ(false, WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL, 92 WindowMode::WINDOW_MODE_UNDEFINED)); 93 } 94 95 /** 96 * @tc.name: WindowRect 97 * @tc.desc: rect test 98 * @tc.type: FUNC 99 */ 100 HWTEST_F(WindowHelperTest, WindowRect, Function | SmallTest | Level1) 101 { 102 Rect rect0 = {0, 0, 0, 0}; 103 ASSERT_EQ(true, WindowHelper::IsEmptyRect(rect0)); 104 105 Rect rect1 = {0, 0, 1, 1}; 106 ASSERT_EQ(false, WindowHelper::IsEmptyRect(rect1)); 107 } 108 109 /** 110 * @tc.name: WindowStringUtil 111 * @tc.desc: string test 112 * @tc.type: FUNC 113 */ 114 HWTEST_F(WindowHelperTest, WindowStringUtil, Function | SmallTest | Level1) 115 { 116 ASSERT_EQ(true, WindowHelper::IsNumber("123")); 117 ASSERT_EQ(false, WindowHelper::IsNumber("1a3")); 118 ASSERT_EQ(false, WindowHelper::IsNumber("")); 119 120 ASSERT_EQ(true, WindowHelper::IsFloatingNumber("1.23")); 121 ASSERT_EQ(true, WindowHelper::IsFloatingNumber(".123")); 122 ASSERT_EQ(false, WindowHelper::IsFloatingNumber("1a3")); 123 ASSERT_EQ(false, WindowHelper::IsFloatingNumber("123..")); 124 125 std::vector<std::string> vec = WindowHelper::Split("123a123a123", "a"); 126 for (size_t i = 0; i < vec.size(); i++) { 127 if (vec[i].compare("123")) { 128 ASSERT_TRUE(false); 129 } 130 } 131 ASSERT_TRUE(true); 132 } 133 134 /** 135 * @tc.name: CalculateOriginPosition 136 * @tc.desc: CalculateOriginPosition test 137 * @tc.type: FUNC 138 */ 139 HWTEST_F(WindowHelperTest, CalculateOriginPosition, Function | SmallTest | Level1) 140 { 141 Rect rect1 { 0, 0, 10, 10 }, rect2 { 100, 100, 200, 200 }; 142 PointInfo point = WindowHelper::CalculateOriginPosition(rect1, rect2, PointInfo { 200, 200 }); 143 PointInfo expectPoint { 5, 5 }; 144 ASSERT_EQ(true, point.x == expectPoint.x); 145 ASSERT_EQ(true, point.y == expectPoint.y); 146 147 Transform transform; 148 transform.scaleX_ = 0.66f; 149 transform.scaleY_ = 1.5f; 150 transform.rotationY_ = 30; 151 transform.translateX_ = 100; 152 transform.translateY_ = 200; 153 transform.translateZ_ = 50; 154 Rect rect { 50, 50, 240, 320 }; 155 TransformHelper::Vector3 pivotPos = { rect.posX_ + transform.pivotX_ * rect.width_, 156 rect.posY_ + transform.pivotY_ * rect.height_, 0 }; 157 TransformHelper::Matrix4 mat = TransformHelper::CreateTranslation(-pivotPos); 158 mat *= WindowHelper::ComputeWorldTransformMat4(transform); 159 mat *= TransformHelper::CreateTranslation(pivotPos); 160 161 TransformHelper::Vector3 expectOriginPoint(0, 0, 0); 162 TransformHelper::Vector3 tranformedPoint = TransformHelper::Transform(expectOriginPoint, mat); 163 PointInfo actialOriginPoint = WindowHelper::CalculateOriginPosition(mat, 164 { static_cast<int32_t>(tranformedPoint.x_), static_cast<int32_t>(tranformedPoint.y_) }); 165 const float errorRange = 2.f; 166 ASSERT_LT(std::abs(expectOriginPoint.x_ - actialOriginPoint.x), errorRange); 167 ASSERT_LT(std::abs(expectOriginPoint.y_ - actialOriginPoint.y), errorRange); 168 } 169 170 /** 171 * @tc.name: TransformRect 172 * @tc.desc: TransformRect test 173 * @tc.type: FUNC 174 */ 175 HWTEST_F(WindowHelperTest, TransformRect, Function | SmallTest | Level1) 176 { 177 Transform transform; 178 Rect rect { 0, 0, 10, 20 }; 179 transform.scaleX_ = transform.scaleY_ = 2.0f; 180 TransformHelper::Vector3 pivotPos = { rect.posX_ + transform.pivotX_ * rect.width_, 181 rect.posY_ + transform.pivotY_ * rect.height_, 0 }; 182 TransformHelper::Matrix4 mat = TransformHelper::CreateTranslation(-pivotPos); 183 mat *= WindowHelper::ComputeWorldTransformMat4(transform); 184 mat *= TransformHelper::CreateTranslation(pivotPos); 185 Rect transformRect = WindowHelper::TransformRect(mat, rect); 186 ASSERT_EQ(rect.width_ * transform.scaleX_, transformRect.width_); 187 ASSERT_EQ(rect.height_ * transform.scaleY_, transformRect.height_); 188 } 189 190 /** 191 * @tc.name: CalculateHotZoneScale 192 * @tc.desc: CalculateHotZoneScale test 193 * @tc.type: FUNC 194 */ 195 HWTEST_F(WindowHelperTest, CalculateHotZoneScale, Function | SmallTest | Level1) 196 { 197 Transform transform; 198 transform.scaleX_ = 0.66f; 199 transform.scaleY_ = 1.5f; 200 transform.pivotX_ = transform.pivotY_ = 0.5f; 201 Rect rect { -1, -2, 2, 4 }; 202 TransformHelper::Vector3 pivotPos = { rect.posX_ + transform.pivotX_ * rect.width_, 203 rect.posY_ + transform.pivotY_ * rect.height_, 0 }; 204 TransformHelper::Matrix4 mat = TransformHelper::CreateTranslation(-pivotPos); 205 mat *= WindowHelper::ComputeWorldTransformMat4(transform); 206 mat *= TransformHelper::CreateTranslation(pivotPos); 207 208 const float errorRange = 0.01f; 209 TransformHelper::Vector2 hotZoneScale = WindowHelper::CalculateHotZoneScale(mat); 210 ASSERT_LT(std::abs(transform.scaleX_ - hotZoneScale.x_), errorRange); 211 ASSERT_LT(std::abs(transform.scaleY_ - hotZoneScale.y_), errorRange); 212 } 213 214 /** 215 * @tc.name: WindowType 216 * @tc.desc: Window Type test 217 * @tc.type: FUNC 218 */ 219 HWTEST_F(WindowHelperTest, WindowType, Function | SmallTest | Level1) 220 { 221 ASSERT_EQ(true, WindowHelper::IsSystemWindow(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW)); 222 ASSERT_EQ(true, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW)); 223 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW)); 224 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_FLOAT)); 225 } 226 227 /** 228 * @tc.name: GetTransformFromWorldMat4 229 * @tc.desc: GetTransformFromWorldMat4 test 230 * @tc.type: FUNC 231 */ 232 HWTEST_F(WindowHelperTest, GetTransformFromWorldMat4, Function | SmallTest | Level1) 233 { 234 Transform transform1; 235 transform1.scaleX_ = 0.66f; 236 transform1.scaleY_ = 1.5f; 237 transform1.translateX_ = 12.f; 238 transform1.translateY_ = 45.f; 239 Rect rect1 { 0, 0, 300, 400 }; 240 TransformHelper::Vector3 pivotPos1 = { rect1.posX_ + transform1.pivotX_ * rect1.width_, 241 rect1.posY_ + transform1.pivotY_ * rect1.height_, 0 }; 242 TransformHelper::Matrix4 mat1 = TransformHelper::CreateTranslation(-pivotPos1); 243 mat1 *= WindowHelper::ComputeWorldTransformMat4(transform1); 244 mat1 *= TransformHelper::CreateTranslation(pivotPos1); 245 246 Rect rect2 = WindowHelper::TransformRect(mat1, rect1); 247 Transform transform2; 248 WindowHelper::GetTransformFromWorldMat4(mat1, rect2, transform2); 249 TransformHelper::Vector3 pivotPos2 = { rect2.posX_ + transform2.pivotX_ * rect2.width_, 250 rect2.posY_ + transform2.pivotY_ * rect2.height_, 0 }; 251 TransformHelper::Matrix4 mat2 = TransformHelper::CreateTranslation(-pivotPos2); 252 mat2 *= WindowHelper::ComputeWorldTransformMat4(transform2); 253 mat2 *= TransformHelper::CreateTranslation(pivotPos2); 254 for (int i = 0; i < TransformHelper::Matrix4::MAT_SIZE; i++) { 255 for (int j = 0; j < TransformHelper::Matrix4::MAT_SIZE; j++) { 256 ASSERT_EQ(true, MathHelper::NearZero(mat1.mat_[i][j] - mat2.mat_[i][j])); 257 } 258 } 259 } 260 } 261 } // namespace Rosen 262 } // namespace OHOS