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
20using namespace testing;
21using namespace testing::ext;
22
23namespace OHOS {
24namespace Rosen {
25class WindowHelperTest : public testing::Test {
26public:
27    static void SetUpTestCase();
28    static void TearDownTestCase();
29    virtual void SetUp() override;
30    virtual void TearDown() override;
31};
32
33void WindowHelperTest::SetUpTestCase()
34{
35}
36
37void WindowHelperTest::TearDownTestCase()
38{
39}
40
41void WindowHelperTest::SetUp()
42{
43}
44
45void WindowHelperTest::TearDown()
46{
47}
48
49namespace {
50/**
51 * @tc.name: WindowTypeWindowMode
52 * @tc.desc: window type/mode test
53 * @tc.type: FUNC
54 */
55HWTEST_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 */
79HWTEST_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 */
100HWTEST_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 */
114HWTEST_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 */
139HWTEST_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 */
175HWTEST_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 */
195HWTEST_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 */
219HWTEST_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 */
232HWTEST_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