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#include "window_proxy.h"
18
19#include "window_agent.h"
20
21using namespace testing;
22using namespace testing::ext;
23namespace OHOS {
24namespace Rosen {
25class WindowProxyTest : public testing::Test {
26public:
27    static void SetUpTestCase();
28    static void TearDownTestCase();
29    void SetUp() override;
30    void TearDown() override;
31    sptr<WindowAgent> mockWindowAgent_;
32    sptr<WindowProxy> windowProxy_;
33};
34
35void WindowProxyTest::SetUpTestCase()
36{
37}
38
39void WindowProxyTest::TearDownTestCase()
40{
41}
42
43void WindowProxyTest::SetUp()
44{
45    sptr<WindowOption> option = new WindowOption();
46    sptr<WindowImpl> window = new WindowImpl(option);
47    mockWindowAgent_ = new WindowAgent(window);
48    windowProxy_ = new WindowProxy(mockWindowAgent_);
49}
50
51void WindowProxyTest::TearDown()
52{
53}
54
55namespace {
56/**
57 * @tc.name: UpdateWindowRect01
58 * @tc.desc: normal function
59 * @tc.type: FUNC
60 */
61HWTEST_F(WindowProxyTest, UpdateWindowRect01, Function | SmallTest | Level2)
62{
63    WMError err = windowProxy_->UpdateWindowRect(Rect {0, 0, 0, 0}, false, WindowSizeChangeReason::HIDE);
64    ASSERT_EQ(err, WMError::WM_OK);
65}
66
67/**
68 * @tc.name: UpdateWindowMode01
69 * @tc.desc: normal function
70 * @tc.type: FUNC
71 */
72HWTEST_F(WindowProxyTest, UpdateWindowMode01, Function | SmallTest | Level2)
73{
74    WMError err = windowProxy_->UpdateWindowMode(WindowMode::WINDOW_MODE_FLOATING);
75    ASSERT_EQ(err, WMError::WM_OK);
76}
77
78/**
79 * @tc.name: UpdateWindowModeSupportInfo01
80 * @tc.desc: normal function
81 * @tc.type: FUNC
82 */
83HWTEST_F(WindowProxyTest, UpdateWindowModeSupportInfo01, Function | SmallTest | Level2)
84{
85    WMError err = windowProxy_->UpdateWindowModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_PRIMARY);
86    ASSERT_EQ(err, WMError::WM_OK);
87}
88
89/**
90 * @tc.name: UpdateFocusStatus01
91 * @tc.desc: normal function
92 * @tc.type: FUNC
93 */
94HWTEST_F(WindowProxyTest, UpdateFocusStatus01, Function | SmallTest | Level2)
95{
96    WMError err = windowProxy_->UpdateFocusStatus(false);
97    ASSERT_EQ(err, WMError::WM_OK);
98}
99
100/**
101 * @tc.name: UpdateAvoidArea01
102 * @tc.desc: normal function
103 * @tc.type: FUNC
104 */
105HWTEST_F(WindowProxyTest, UpdateAvoidArea01, Function | SmallTest | Level2)
106{
107    const sptr<AvoidArea>& avoidArea = new AvoidArea();
108    WMError err = windowProxy_->UpdateAvoidArea(avoidArea, AvoidAreaType::TYPE_SYSTEM);
109    ASSERT_EQ(err, WMError::WM_OK);
110}
111
112/**
113 * @tc.name: UpdateWindowState01
114 * @tc.desc: normal function
115 * @tc.type: FUNC
116 */
117HWTEST_F(WindowProxyTest, UpdateWindowState01, Function | SmallTest | Level2)
118{
119    WMError err = windowProxy_->UpdateWindowState(WindowState::STATE_BOTTOM);
120    ASSERT_EQ(err, WMError::WM_OK);
121}
122
123/**
124 * @tc.name: UpdateWindowDragInfo01
125 * @tc.desc: normal function
126 * @tc.type: FUNC
127 */
128HWTEST_F(WindowProxyTest, UpdateWindowDragInfo01, Function | SmallTest | Level2)
129{
130    PointInfo point;
131    point.x = 1;
132    point.y = 2;
133    WMError err = windowProxy_->UpdateWindowDragInfo(point, DragEvent::DRAG_EVENT_MOVE);
134    ASSERT_EQ(err, WMError::WM_OK);
135}
136
137/**
138 * @tc.name: UpdateDisplayId01
139 * @tc.desc: normal function
140 * @tc.type: FUNC
141 */
142HWTEST_F(WindowProxyTest, UpdateDisplayId01, Function | SmallTest | Level2)
143{
144    WMError err = windowProxy_->UpdateDisplayId(0, 1);
145    ASSERT_EQ(err, WMError::WM_OK);
146}
147
148/**
149 * @tc.name: UpdateOccupiedAreaChangeInfo01
150 * @tc.desc: normal function
151 * @tc.type: FUNC
152 */
153HWTEST_F(WindowProxyTest, UpdateOccupiedAreaChangeInfo01, Function | SmallTest | Level2)
154{
155    Rect overlapRect = {0, 0, 0, 0};
156    sptr<OccupiedAreaChangeInfo> info = new OccupiedAreaChangeInfo(OccupiedAreaType::TYPE_INPUT, overlapRect);
157    WMError err = windowProxy_->UpdateOccupiedAreaChangeInfo(info);
158    ASSERT_EQ(err, WMError::WM_OK);
159}
160
161/**
162 * @tc.name: UpdateActiveStatus01
163 * @tc.desc: normal function
164 * @tc.type: FUNC
165 */
166HWTEST_F(WindowProxyTest, UpdateActiveStatus01, Function | SmallTest | Level2)
167{
168    WMError err = windowProxy_->UpdateActiveStatus(false);
169    ASSERT_EQ(err, WMError::WM_OK);
170}
171
172/**
173 * @tc.name: NotifyTouchOutside01
174 * @tc.desc: normal function
175 * @tc.type: FUNC
176 */
177HWTEST_F(WindowProxyTest, NotifyTouchOutside01, Function | SmallTest | Level2)
178{
179    WMError err = windowProxy_->NotifyTouchOutside();
180    ASSERT_EQ(err, WMError::WM_OK);
181}
182
183/**
184 * @tc.name: DumpInfo01
185 * @tc.desc: normal function
186 * @tc.type: FUNC
187 */
188HWTEST_F(WindowProxyTest, DumpInfo01, Function | SmallTest | Level2)
189{
190    std::vector<std::string> params;
191    WMError err = windowProxy_->DumpInfo(params);
192    ASSERT_EQ(err, WMError::WM_OK);
193}
194
195/**
196 * @tc.name: NotifyDestroy01
197 * @tc.desc: normal function
198 * @tc.type: FUNC
199 */
200HWTEST_F(WindowProxyTest, NotifyDestroy01, Function | SmallTest | Level2)
201{
202    WMError err = windowProxy_->NotifyDestroy();
203    ASSERT_EQ(err, WMError::WM_OK);
204}
205
206
207/**
208 * @tc.name: NotifyForeground01
209 * @tc.desc: normal function
210 * @tc.type: FUNC
211 */
212HWTEST_F(WindowProxyTest, NotifyForeground01, Function | SmallTest | Level2)
213{
214    WMError err = windowProxy_->NotifyForeground();
215    ASSERT_EQ(err, WMError::WM_OK);
216}
217
218
219/**
220 * @tc.name: NotifyBackground01
221 * @tc.desc: normal function
222 * @tc.type: FUNC
223 */
224HWTEST_F(WindowProxyTest, NotifyBackground01, Function | SmallTest | Level2)
225{
226    WMError err = windowProxy_->NotifyBackground();
227    ASSERT_EQ(err, WMError::WM_OK);
228}
229
230/**
231 * @tc.name: NotifyWindowClientPointUp01
232 * @tc.desc: param is nullptr
233 * @tc.type: FUNC
234 */
235HWTEST_F(WindowProxyTest, NotifyWindowClientPointUp01, Function | SmallTest | Level2)
236{
237    WMError err = windowProxy_->NotifyWindowClientPointUp(nullptr);
238    ASSERT_EQ(err, WMError::WM_ERROR_NULLPTR);
239}
240
241/**
242 * @tc.name: NotifyWindowClientPointUp02
243 * @tc.desc: normal function
244 * @tc.type: FUNC
245 */
246HWTEST_F(WindowProxyTest, NotifyWindowClientPointUp02, Function | SmallTest | Level2)
247{
248    auto pointerEvent = MMI::PointerEvent::Create();
249    WMError err = windowProxy_->NotifyWindowClientPointUp(pointerEvent);
250    ASSERT_EQ(err, WMError::WM_OK);
251}
252
253/**
254 * @tc.name: UpdateZoomTransform01
255 * @tc.desc: normal function
256 * @tc.type: FUNC
257 */
258HWTEST_F(WindowProxyTest, UpdateZoomTransform01, Function | SmallTest | Level2)
259{
260    Transform transform;
261    WMError err = windowProxy_->UpdateZoomTransform(transform, false);
262    ASSERT_EQ(err, WMError::WM_OK);
263}
264
265/**
266 * @tc.name: RestoreSplitWindowMode01
267 * @tc.desc: normal function
268 * @tc.type: FUNC
269 */
270HWTEST_F(WindowProxyTest, RestoreSplitWindowMode01, Function | SmallTest | Level2)
271{
272    WMError err = windowProxy_->RestoreSplitWindowMode(200);
273    ASSERT_EQ(err, WMError::WM_OK);
274}
275
276/**
277 * @tc.name: NotifyScreenshot
278 * @tc.desc: normal function
279 * @tc.type: FUNC
280 */
281HWTEST_F(WindowProxyTest, NotifyScreenshot, Function | SmallTest | Level2)
282{
283    WMError err = windowProxy_->NotifyScreenshot();
284    ASSERT_EQ(err, WMError::WM_OK);
285}
286
287/**
288 * @tc.name: NotifyForegroundInteractiveStatus
289 * @tc.desc: normal function
290 * @tc.type: FUNC
291 */
292HWTEST_F(WindowProxyTest, NotifyForegroundInteractiveStatus, Function | SmallTest | Level2)
293{
294    ASSERT_NE(windowProxy_, nullptr);
295    WMError err = WMError::WM_OK;
296    bool interactive = false;
297    windowProxy_->NotifyForegroundInteractiveStatus(interactive);
298    ASSERT_EQ(err, WMError::WM_OK);
299}
300
301}
302}
303}
304