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