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