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
TearDownTestCase()35 void WindowHelperTest::TearDownTestCase() {}
36
SetUp()37 void WindowHelperTest::SetUp() {}
38
TearDown()39 void WindowHelperTest::TearDown() {}
40
41 namespace {
42 /**
43 * @tc.name: WindowTypeWindowMode
44 * @tc.desc: window type/mode test
45 * @tc.type: FUNC
46 */
47 HWTEST_F(WindowHelperTest, WindowTypeWindowMode, TestSize.Level1)
48 {
49 ASSERT_EQ(true,
50 WindowHelper::IsMainFullScreenWindow(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
51 WindowMode::WINDOW_MODE_FULLSCREEN));
52 ASSERT_EQ(false,
53 WindowHelper::IsMainFullScreenWindow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW,
54 WindowMode::WINDOW_MODE_FULLSCREEN));
55 ASSERT_EQ(false,
56 WindowHelper::IsMainFullScreenWindow(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW,
57 WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
58
59 ASSERT_EQ(true, WindowHelper::IsFloatingWindow(WindowMode::WINDOW_MODE_FLOATING));
60 ASSERT_EQ(false, WindowHelper::IsFloatingWindow(WindowMode::WINDOW_MODE_FULLSCREEN));
61
62 ASSERT_EQ(true, WindowHelper::IsFullScreenWindow(WindowMode::WINDOW_MODE_FULLSCREEN));
63 ASSERT_EQ(false, WindowHelper::IsFullScreenWindow(WindowMode::WINDOW_MODE_FLOATING));
64
65 ASSERT_EQ(true, WindowHelper::IsDialogWindow(WindowType::WINDOW_TYPE_DIALOG));
66 ASSERT_EQ(false, WindowHelper::IsDialogWindow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW));
67 }
68
69 /**
70 * @tc.name: WindowModeSupport
71 * @tc.desc: window mode supported test
72 * @tc.type: FUNC
73 */
74 HWTEST_F(WindowHelperTest, WindowModeSupport, TestSize.Level1)
75 {
76 ASSERT_EQ(true,
77 WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL,
78 WindowMode::WINDOW_MODE_FULLSCREEN));
79 ASSERT_EQ(true,
80 WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL,
81 WindowMode::WINDOW_MODE_FLOATING));
82 ASSERT_EQ(true,
83 WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL,
84 WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
85 ASSERT_EQ(true,
86 WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL,
87 WindowMode::WINDOW_MODE_SPLIT_SECONDARY));
88 ASSERT_EQ(
89 true,
90 WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL, WindowMode::WINDOW_MODE_PIP));
91 ASSERT_EQ(false,
92 WindowHelper::IsWindowModeSupported(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL,
93 WindowMode::WINDOW_MODE_UNDEFINED));
94 }
95
96 /**
97 * @tc.name: WindowRect
98 * @tc.desc: rect test
99 * @tc.type: FUNC
100 */
101 HWTEST_F(WindowHelperTest, WindowRect, TestSize.Level1)
102 {
103 Rect rect0 = { 0, 0, 0, 0 };
104 ASSERT_EQ(true, WindowHelper::IsEmptyRect(rect0));
105
106 Rect rect1 = { 0, 0, 1, 1 };
107 ASSERT_EQ(false, WindowHelper::IsEmptyRect(rect1));
108 }
109
110 /**
111 * @tc.name: WindowStringUtil
112 * @tc.desc: string test
113 * @tc.type: FUNC
114 */
115 HWTEST_F(WindowHelperTest, WindowStringUtil, TestSize.Level1)
116 {
117 ASSERT_EQ(true, WindowHelper::IsNumber("123"));
118 ASSERT_EQ(false, WindowHelper::IsNumber("1a3"));
119 ASSERT_EQ(false, WindowHelper::IsNumber(""));
120
121 ASSERT_EQ(true, WindowHelper::IsFloatingNumber("1.23"));
122 ASSERT_EQ(true, WindowHelper::IsFloatingNumber(".123"));
123 ASSERT_EQ(false, WindowHelper::IsFloatingNumber("1a3"));
124 ASSERT_EQ(false, WindowHelper::IsFloatingNumber("123.."));
125
126 std::vector<std::string> vec = WindowHelper::Split("123a123a123", "a");
127 for (size_t i = 0; i < vec.size(); i++) {
128 if (vec[i].compare("123")) {
129 ASSERT_TRUE(false);
130 }
131 }
132 ASSERT_TRUE(true);
133 }
134
135 /**
136 * @tc.name: CalculateOriginPosition
137 * @tc.desc: CalculateOriginPosition test
138 * @tc.type: FUNC
139 */
140 HWTEST_F(WindowHelperTest, CalculateOriginPosition, TestSize.Level1)
141 {
142 Rect rect1{ 0, 0, 10, 10 }, rect2{ 100, 100, 200, 200 };
143 PointInfo point = WindowHelper::CalculateOriginPosition(rect1, rect2, PointInfo{ 200, 200 });
144 PointInfo expectPoint{ 5, 5 };
145 ASSERT_EQ(true, point.x == expectPoint.x);
146 ASSERT_EQ(true, point.y == expectPoint.y);
147
148 Transform transform;
149 transform.scaleX_ = 0.66f;
150 transform.scaleY_ = 1.5f;
151 transform.rotationY_ = 30;
152 transform.translateX_ = 100;
153 transform.translateY_ = 200;
154 transform.translateZ_ = 50;
155 Rect rect{ 50, 50, 240, 320 };
156 TransformHelper::Vector3 pivotPos = { rect.posX_ + transform.pivotX_ * rect.width_,
157 rect.posY_ + transform.pivotY_ * rect.height_,
158 0 };
159 TransformHelper::Matrix4 mat = TransformHelper::CreateTranslation(-pivotPos);
160 mat *= WindowHelper::ComputeWorldTransformMat4(transform);
161 mat *= TransformHelper::CreateTranslation(pivotPos);
162
163 TransformHelper::Vector3 expectOriginPoint(0, 0, 0);
164 TransformHelper::Vector3 tranformedPoint = TransformHelper::Transform(expectOriginPoint, mat);
165 PointInfo actialOriginPoint = WindowHelper::CalculateOriginPosition(
166 mat, { static_cast<int32_t>(tranformedPoint.x_), static_cast<int32_t>(tranformedPoint.y_) });
167 const float errorRange = 2.f;
168 ASSERT_LT(std::abs(expectOriginPoint.x_ - actialOriginPoint.x), errorRange);
169 ASSERT_LT(std::abs(expectOriginPoint.y_ - actialOriginPoint.y), errorRange);
170 }
171
172 /**
173 * @tc.name: TransformRect
174 * @tc.desc: TransformRect test
175 * @tc.type: FUNC
176 */
177 HWTEST_F(WindowHelperTest, TransformRect, TestSize.Level1)
178 {
179 Transform transform;
180 Rect rect{ 0, 0, 10, 20 };
181 transform.scaleX_ = transform.scaleY_ = 2.0f;
182 TransformHelper::Vector3 pivotPos = { rect.posX_ + transform.pivotX_ * rect.width_,
183 rect.posY_ + transform.pivotY_ * rect.height_,
184 0 };
185 TransformHelper::Matrix4 mat = TransformHelper::CreateTranslation(-pivotPos);
186 mat *= WindowHelper::ComputeWorldTransformMat4(transform);
187 mat *= TransformHelper::CreateTranslation(pivotPos);
188 Rect transformRect = WindowHelper::TransformRect(mat, rect);
189 ASSERT_EQ(rect.width_ * transform.scaleX_, transformRect.width_);
190 ASSERT_EQ(rect.height_ * transform.scaleY_, transformRect.height_);
191 }
192
193 /**
194 * @tc.name: CalculateHotZoneScale
195 * @tc.desc: CalculateHotZoneScale test
196 * @tc.type: FUNC
197 */
198 HWTEST_F(WindowHelperTest, CalculateHotZoneScale, TestSize.Level1)
199 {
200 Transform transform;
201 transform.scaleX_ = 0.66f;
202 transform.scaleY_ = 1.5f;
203 transform.pivotX_ = transform.pivotY_ = 0.5f;
204 Rect rect{ -1, -2, 2, 4 };
205 TransformHelper::Vector3 pivotPos = { rect.posX_ + transform.pivotX_ * rect.width_,
206 rect.posY_ + transform.pivotY_ * rect.height_,
207 0 };
208 TransformHelper::Matrix4 mat = TransformHelper::CreateTranslation(-pivotPos);
209 mat *= WindowHelper::ComputeWorldTransformMat4(transform);
210 mat *= TransformHelper::CreateTranslation(pivotPos);
211
212 const float errorRange = 0.01f;
213 TransformHelper::Vector2 hotZoneScale = WindowHelper::CalculateHotZoneScale(mat);
214 ASSERT_LT(std::abs(transform.scaleX_ - hotZoneScale.x_), errorRange);
215 ASSERT_LT(std::abs(transform.scaleY_ - hotZoneScale.y_), errorRange);
216 }
217
218 /**
219 * @tc.name: WindowType
220 * @tc.desc: Window Type test
221 * @tc.type: FUNC
222 */
223 HWTEST_F(WindowHelperTest, WindowType, TestSize.Level1)
224 {
225 ASSERT_EQ(true, WindowHelper::IsSystemWindow(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW));
226 ASSERT_EQ(true, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW));
227 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_APP_SUB_WINDOW));
228 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_FLOAT));
229 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_WALLET_SWIPE_CARD));
230 ASSERT_EQ(true, WindowHelper::IsSystemWindow(WindowType::WINDOW_TYPE_WALLET_SWIPE_CARD));
231 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_FLOAT_NAVIGATION));
232 ASSERT_EQ(true, WindowHelper::IsSystemWindow(WindowType::WINDOW_TYPE_FLOAT_NAVIGATION));
233 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_DYNAMIC));
234 ASSERT_EQ(true, WindowHelper::IsSystemWindow(WindowType::WINDOW_TYPE_DYNAMIC));
235 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_MUTISCREEN_COLLABORATION));
236 ASSERT_EQ(true, WindowHelper::IsSystemWindow(WindowType::WINDOW_TYPE_MUTISCREEN_COLLABORATION));
237 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_MAGNIFICATION));
238 ASSERT_EQ(true, WindowHelper::IsSystemWindow(WindowType::WINDOW_TYPE_MAGNIFICATION));
239 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_MAGNIFICATION_MENU));
240 ASSERT_EQ(true, WindowHelper::IsSystemWindow(WindowType::WINDOW_TYPE_MAGNIFICATION_MENU));
241 ASSERT_EQ(false, WindowHelper::IsSystemSubWindow(WindowType::WINDOW_TYPE_SELECTION));
242 ASSERT_EQ(true, WindowHelper::IsSystemWindow(WindowType::WINDOW_TYPE_SELECTION));
243 }
244
245 /**
246 * @tc.name: GetTransformFromWorldMat4
247 * @tc.desc: GetTransformFromWorldMat4 test
248 * @tc.type: FUNC
249 */
250 HWTEST_F(WindowHelperTest, GetTransformFromWorldMat4, TestSize.Level1)
251 {
252 Transform transform1;
253 transform1.scaleX_ = 0.66f;
254 transform1.scaleY_ = 1.5f;
255 transform1.translateX_ = 12.f;
256 transform1.translateY_ = 45.f;
257 Rect rect1{ 0, 0, 300, 400 };
258 TransformHelper::Vector3 pivotPos1 = { rect1.posX_ + transform1.pivotX_ * rect1.width_,
259 rect1.posY_ + transform1.pivotY_ * rect1.height_,
260 0 };
261 TransformHelper::Matrix4 mat1 = TransformHelper::CreateTranslation(-pivotPos1);
262 mat1 *= WindowHelper::ComputeWorldTransformMat4(transform1);
263 mat1 *= TransformHelper::CreateTranslation(pivotPos1);
264
265 Rect rect2 = WindowHelper::TransformRect(mat1, rect1);
266 Transform transform2;
267 WindowHelper::GetTransformFromWorldMat4(mat1, rect2, transform2);
268 TransformHelper::Vector3 pivotPos2 = { rect2.posX_ + transform2.pivotX_ * rect2.width_,
269 rect2.posY_ + transform2.pivotY_ * rect2.height_,
270 0 };
271 TransformHelper::Matrix4 mat2 = TransformHelper::CreateTranslation(-pivotPos2);
272 mat2 *= WindowHelper::ComputeWorldTransformMat4(transform2);
273 mat2 *= TransformHelper::CreateTranslation(pivotPos2);
274 for (int i = 0; i < TransformHelper::Matrix4::MAT_SIZE; i++) {
275 for (int j = 0; j < TransformHelper::Matrix4::MAT_SIZE; j++) {
276 ASSERT_EQ(true, MathHelper::NearZero(mat1.mat_[i][j] - mat2.mat_[i][j]));
277 }
278 }
279 }
280
281 /**
282 * @tc.name: CheckButtonStyleValid
283 * @tc.desc: CheckButtonStyleValid test
284 * @tc.type: FUNC
285 */
286 HWTEST_F(WindowHelperTest, CheckButtonStyleValid, TestSize.Level1)
287 {
288 DecorButtonStyle style;
289 // checkout the side of buttonBackgroundSize
290 style.buttonBackgroundSize = MIN_BUTTON_BACKGROUND_SIZE - 1;
291 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
292 style.buttonBackgroundSize = MAX_BUTTON_BACKGROUND_SIZE + 1;
293 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
294 style.buttonBackgroundSize = MIN_BUTTON_BACKGROUND_SIZE;
295 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
296 style.buttonBackgroundSize = MAX_BUTTON_BACKGROUND_SIZE;
297 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
298
299 // checkout the side of closeButtonRightMargin
300 style.closeButtonRightMargin = MIN_CLOSE_BUTTON_RIGHT_MARGIN - 1;
301 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
302 style.closeButtonRightMargin = MAX_CLOSE_BUTTON_RIGHT_MARGIN + 1;
303 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
304 style.closeButtonRightMargin = MIN_CLOSE_BUTTON_RIGHT_MARGIN;
305 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
306 style.closeButtonRightMargin = MAX_CLOSE_BUTTON_RIGHT_MARGIN;
307 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
308
309 // checkout the side of spacingBetweenButtons
310 style.spacingBetweenButtons = MIN_SPACING_BETWEEN_BUTTONS - 1;
311 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
312 style.spacingBetweenButtons = MAX_SPACING_BETWEEN_BUTTONS + 1;
313 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
314 style.spacingBetweenButtons = MIN_SPACING_BETWEEN_BUTTONS;
315 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
316 style.spacingBetweenButtons = MAX_SPACING_BETWEEN_BUTTONS;
317 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
318
319 // checkout the side of buttonIconSize
320 style.buttonIconSize = MIN_BUTTON_ICON_SIZE - 1;
321 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
322 style.buttonIconSize = MAX_BUTTON_ICON_SIZE + 1;
323 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
324 style.buttonIconSize = MIN_BUTTON_ICON_SIZE;
325 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
326 style.buttonIconSize = MAX_BUTTON_ICON_SIZE;
327 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
328
329 // checkout the side of buttonBackgroundCornerRadius
330 style.buttonBackgroundCornerRadius = MIN_BUTTON_BACKGROUND_CORNER_RADIUS - 1;
331 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
332 style.buttonBackgroundCornerRadius = MAX_BUTTON_BACKGROUND_CORNER_RADIUS + 1;
333 EXPECT_FALSE(WindowHelper::CheckButtonStyleValid(style));
334 style.buttonBackgroundCornerRadius = MIN_BUTTON_BACKGROUND_CORNER_RADIUS;
335 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
336 style.buttonBackgroundCornerRadius = MAX_BUTTON_BACKGROUND_CORNER_RADIUS;
337 EXPECT_TRUE(WindowHelper::CheckButtonStyleValid(style));
338 }
339
340 /**
341 * @tc.name: SplitStringByDelimiter_TestInput
342 * @tc.desc: SplitStringByDelimiter test inputStr
343 * @tc.type: FUNC
344 */
345 HWTEST_F(WindowHelperTest, SplitStringByDelimiter_TestInput, TestSize.Level1)
346 {
347 std::string inputStr = "";
348 std::string delimiter = ",";
349 std::unordered_set<std::string> container;
350 WindowHelper::SplitStringByDelimiter(inputStr, delimiter, container);
351 EXPECT_EQ(0, container.size());
352 }
353
354 /**
355 * @tc.name: SplitStringByDelimiter_TestDelimiter
356 * @tc.desc: SplitStringByDelimiter test delimiter
357 * @tc.type: FUNC
358 */
359 HWTEST_F(WindowHelperTest, SplitStringByDelimiter_TestDelimiter, TestSize.Level1)
360 {
361 std::string inputStr = "a,b,c,d";
362 std::string delimiter = "";
363 std::unordered_set<std::string> container;
364 WindowHelper::SplitStringByDelimiter(inputStr, delimiter, container);
365 EXPECT_EQ(1, container.count(inputStr));
366 EXPECT_EQ(1, container.size());
367 }
368
369 /**
370 * @tc.name: SplitStringByDelimiter_TestOther
371 * @tc.desc: SplitStringByDelimiter test other
372 * @tc.type: FUNC
373 */
374 HWTEST_F(WindowHelperTest, SplitStringByDelimiter_TestOther, TestSize.Level1)
375 {
376 std::string inputStr = "a,b,c,d";
377 std::string delimiter = ",";
378 std::unordered_set<std::string> container;
379 WindowHelper::SplitStringByDelimiter(inputStr, delimiter, container);
380 EXPECT_EQ(0, container.count("e"));
381 EXPECT_EQ(1, container.count("a"));
382 }
383
384 /**
385 * @tc.name: ConvertSupportTypeToSupportModes
386 * @tc.desc: ConvertSupportTypeToSupportModes
387 * @tc.type: FUNC
388 */
389 HWTEST_F(WindowHelperTest, ConvertSupportTypeToSupportModes, TestSize.Level1)
390 {
391 auto supportModes = WindowHelper::ConvertSupportTypeToSupportModes(
392 WindowModeSupport::WINDOW_MODE_SUPPORT_FLOATING);
393 EXPECT_EQ(supportModes.size(), 1);
394 EXPECT_EQ(supportModes[0], AppExecFwk::SupportWindowMode::FLOATING);
395 supportModes = WindowHelper::ConvertSupportTypeToSupportModes(
396 WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_PRIMARY | WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_SECONDARY);
397 EXPECT_EQ(supportModes.size(), 1);
398 EXPECT_EQ(supportModes[0], AppExecFwk::SupportWindowMode::SPLIT);
399 supportModes = WindowHelper::ConvertSupportTypeToSupportModes(WindowModeSupport::WINDOW_MODE_SUPPORT_FULLSCREEN);
400 EXPECT_EQ(supportModes.size(), 1);
401 EXPECT_EQ(supportModes[0], AppExecFwk::SupportWindowMode::FULLSCREEN);
402 }
403 } // namespace
404 } // namespace Rosen
405 } // namespace OHOS