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 "event_runner.h"
19 #include "pointer_event.h"
20 #include "window_inner_manager.h"
21 #include "wm_common.h"
22 
23 using namespace testing;
24 using namespace testing::ext;
25 namespace OHOS {
26 namespace Rosen {
27 using InnerTask = std::function<void()>;
28 using EventRunner = OHOS::AppExecFwk::EventRunner;
29 using EventHandler = OHOS::AppExecFwk::EventHandler;
30 using EventPriority = OHOS::AppExecFwk::EventQueue::Priority;
31 
32 namespace {
33 const std::string INNER_WM_THREAD_NAME = "TestInnerWindowManager";
34 constexpr int32_t TEST_CUSTOM_ID = 100;
35 }
36 
37 class WindowInnerManagerTest : public testing::Test {
38 public:
39     static void SetUpTestCase();
40     static void TearDownTestCase();
41     void SetUp() override;
42     void TearDown() override;
43     sptr<WindowInnerManager> wim_ = new WindowInnerManager();
44 };
45 
SetUpTestCase()46 void WindowInnerManagerTest::SetUpTestCase()
47 {
48 }
49 
TearDownTestCase()50 void WindowInnerManagerTest::TearDownTestCase()
51 {
52 }
53 
SetUp()54 void WindowInnerManagerTest::SetUp()
55 {
56 }
57 
TearDown()58 void WindowInnerManagerTest::TearDown()
59 {
60 }
61 
62 namespace {
63 /**
64  * @tc.name: Stop
65  * @tc.desc: test WindowInnerManager Stop
66  * @tc.type: FUNC
67  */
68 HWTEST_F(WindowInnerManagerTest, Stop, Function | SmallTest | Level2)
69 {
70     WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
71     windowInnerManager.state_ = InnerWMRunningState::STATE_RUNNING;
72     windowInnerManager.eventLoop_ = nullptr;
73     windowInnerManager.eventHandler_ = nullptr;
74     windowInnerManager.moveDragController_ = nullptr;
75     windowInnerManager.Stop();
76     ASSERT_EQ(InnerWMRunningState::STATE_NOT_START, windowInnerManager.state_);
77 
78     windowInnerManager.eventLoop_ = AppExecFwk::EventRunner::Create(INNER_WM_THREAD_NAME);
79     windowInnerManager.eventHandler_ = std::make_shared<EventHandler>(windowInnerManager.eventLoop_);
80     windowInnerManager.moveDragController_ = new MoveDragController();
81     windowInnerManager.Stop();
82     ASSERT_EQ(0, windowInnerManager.eventLoop_.use_count());
83     ASSERT_EQ(0, windowInnerManager.eventHandler_.use_count());
84 }
85 
86 /**
87  * @tc.name: NotifyServerReadyToMoveOrDrag
88  * @tc.desc: test WindowInnerManager NotifyServerReadyToMoveOrDrag
89  * @tc.type: FUNC
90  */
91 HWTEST_F(WindowInnerManagerTest, NotifyServerReadyToMoveOrDrag, Function | SmallTest | Level2)
92 {
93     WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
94     windowInnerManager.eventHandler_ = nullptr;
95     windowInnerManager.moveDragController_ = new MoveDragController();
96     windowInnerManager.moveDragController_->activeWindowId_ = 1;
97     uint32_t windowId = 1;
98     sptr<WindowProperty> property = new WindowProperty();
99     ASSERT_NE(property, nullptr);
100     sptr<MoveDragProperty> moveDragProperty = new MoveDragProperty();
101     ASSERT_NE(moveDragProperty, nullptr);
102     auto result = windowInnerManager.NotifyServerReadyToMoveOrDrag(windowId, property, moveDragProperty);
103     ASSERT_EQ(false, result);
104 
105     windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
106     result = windowInnerManager.NotifyServerReadyToMoveOrDrag(windowId, property, moveDragProperty);
107     ASSERT_EQ(true, result);
108 }
109 
110 /**
111  * @tc.name: NotifyWindowEndUpMovingOrDragging
112  * @tc.desc: test WindowInnerManager NotifyWindowEndUpMovingOrDragging
113  * @tc.type: FUNC
114  */
115 HWTEST_F(WindowInnerManagerTest, NotifyWindowEndUpMovingOrDragging, Function | SmallTest | Level2)
116 {
117     WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
118     windowInnerManager.eventHandler_ = nullptr;
119     windowInnerManager.moveDragController_ = new MoveDragController();
120     windowInnerManager.moveDragController_->activeWindowId_ = TEST_CUSTOM_ID;
121 
122     uint32_t windowId = INVALID_WINDOW_ID;
123     windowInnerManager.NotifyWindowEndUpMovingOrDragging(windowId);
124     ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, TEST_CUSTOM_ID);
125 
126     windowId = TEST_CUSTOM_ID;
127     windowInnerManager.NotifyWindowEndUpMovingOrDragging(windowId);
128     ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, INVALID_WINDOW_ID);
129 }
130 /**
131  * @tc.name: NotifyWindowRemovedOrDestroyed
132  * @tc.desc: test WindowInnerManager NotifyWindowRemovedOrDestroyed
133  * @tc.type: FUNC
134  */
135 HWTEST_F(WindowInnerManagerTest, NotifyWindowRemovedOrDestroyed, Function | SmallTest | Level2)
136 {
137     WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
138     windowInnerManager.eventHandler_ = nullptr;
139     windowInnerManager.moveDragController_ = new MoveDragController();
140     windowInnerManager.moveDragController_->activeWindowId_ = TEST_CUSTOM_ID;
141 
142     uint32_t windowId = INVALID_WINDOW_ID;
143     windowInnerManager.NotifyWindowRemovedOrDestroyed(windowId);
144     ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, TEST_CUSTOM_ID);
145 
146     windowId = TEST_CUSTOM_ID;
147 
148     auto moveDragProperty = windowInnerManager.moveDragController_->moveDragProperty_;
149     moveDragProperty->startDragFlag_ = true;
150     moveDragProperty->startMoveFlag_ = true;
151     windowInnerManager.NotifyWindowRemovedOrDestroyed(windowId);
152     ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, INVALID_WINDOW_ID);
153 }
154 
155 /**
156  * @tc.name: SetWindowRoot
157  * @tc.desc: SetWindowRoot Test
158  * @tc.type: FUNC
159  */
160 HWTEST_F(WindowInnerManagerTest, SetWindowRoot, Function | SmallTest | Level2)
161 {
162     wim_->isRecentHolderEnable_ = true;
163     WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
164     sptr<WindowRoot> windowRoot = new WindowRoot(nullptr);
165     windowInnerManager.SetWindowRoot(windowRoot);
166     ASSERT_EQ(wim_->isRecentHolderEnable_, true);
167 }
168 
169 /**
170  * @tc.name: ConsumePointerEvent
171  * @tc.desc: test WindowInnerManager ConsumePointerEvent
172  * @tc.type: FUNC
173  */
174 HWTEST_F(WindowInnerManagerTest, ConsumePointerEvent, Function | SmallTest | Level2)
175 {
176     WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
177     windowInnerManager.eventHandler_ = nullptr;
178     windowInnerManager.moveDragController_ = new MoveDragController();
179 
180     auto pointerEvent = MMI::PointerEvent::Create();
181     pointerEvent->processedCallback_ = nullptr;
182     pointerEvent->sourceType_ = MMI::PointerEvent::SOURCE_TYPE_MOUSE;
183     pointerEvent->buttonId_ = MMI::PointerEvent::MOUSE_BUTTON_RIGHT;
184     pointerEvent->pointerAction_ = MMI::PointerEvent::POINTER_ACTION_MOVE;
185 
186     pointerEvent->agentWindowId_ = 1;
187     windowInnerManager.moveDragController_->activeWindowId_ = 1;
188     windowInnerManager.ConsumePointerEvent(pointerEvent);
189     ASSERT_NE(windowInnerManager.moveDragController_->moveEvent_, nullptr);
190     ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
191 
192     pointerEvent->agentWindowId_ = 1;
193     windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
194     windowInnerManager.ConsumePointerEvent(pointerEvent);
195     ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
196 
197     pointerEvent->agentWindowId_ = INVALID_WINDOW_ID;
198     windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
199     windowInnerManager.ConsumePointerEvent(pointerEvent);
200     ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
201 }
202 
203 /**
204  * @tc.name: Start
205  * @tc.desc: test WindowInnerManager Start
206  * @tc.type: FUNC
207  */
208 HWTEST_F(WindowInnerManagerTest, Start, Function | SmallTest | Level2)
209 {
210     wim_->state_ = InnerWMRunningState::STATE_RUNNING;
211     bool enableRecentholder = false;
212     wim_->Start(enableRecentholder);
213     ASSERT_EQ(wim_->state_, InnerWMRunningState::STATE_RUNNING);
214 }
215 
216 /**
217  * @tc.name: CreateInnerWindow
218  * @tc.desc: test WindowInnerManager CreateInnerWindow
219  * @tc.type: FUNC
220  */
221 HWTEST_F(WindowInnerManagerTest, CreateInnerWindow, Function | SmallTest | Level2)
222 {
223     wim_->isRecentHolderEnable_ = true;
224     std::string name = "test";
225     DisplayId displayId = 1;
226     Rect rect = {0.0, 0.0, 100.0, 100.0};
227     WindowType type = WindowType::WINDOW_TYPE_PLACEHOLDER;
228     WindowMode mode = WindowMode::WINDOW_MODE_FLOATING;
229     wim_->CreateInnerWindow(name, displayId, rect, type, mode);
230     ASSERT_EQ(wim_->isRecentHolderEnable_, true);
231 }
232 
233 /**
234  * @tc.name: DestroyInnerWindow
235  * @tc.desc: test WindowInnerManager DestroyInnerWindow
236  * @tc.type: FUNC
237  */
238 HWTEST_F(WindowInnerManagerTest, DestroyInnerWindow, Function | SmallTest | Level2)
239 {
240     wim_->isRecentHolderEnable_ = true;
241     DisplayId displayId = 1;
242     WindowType type = WindowType::WINDOW_TYPE_PLACEHOLDER;
243     wim_->DestroyInnerWindow(displayId, type);
244     ASSERT_EQ(wim_->isRecentHolderEnable_, true);
245 }
246 
247 /**
248  * @tc.name: UpdateInnerWindow
249  * @tc.desc: test WindowInnerManager UpdateInnerWindow
250  * @tc.type: FUNC
251  */
252 HWTEST_F(WindowInnerManagerTest, UpdateInnerWindow, Function | SmallTest | Level2)
253 {
254     wim_->isRecentHolderEnable_ = true;
255     DisplayId displayId = 1;
256     WindowType type = WindowType::WINDOW_TYPE_PLACEHOLDER;
257     uint32_t width = 200;
258     uint32_t height = 200;
259     wim_->UpdateInnerWindow(displayId, type, width, height);
260     ASSERT_EQ(wim_->isRecentHolderEnable_, true);
261 }
262 
263 /**
264  * @tc.name: TerminateAbility
265  * @tc.desc: test WindowInnerManager TerminateAbility
266  * @tc.type: FUNC
267  */
268 HWTEST_F(WindowInnerManagerTest, TerminateAbility, Function | SmallTest | Level2)
269 {
270     wim_->isRecentHolderEnable_ = true;
271     sptr<WindowNode> node = new WindowNode();
272     wptr<WindowNode> node1 = node;
273     wim_->TerminateAbility(node1);
274     ASSERT_EQ(wim_->isRecentHolderEnable_, true);
275 }
276 
277 /**
278  * @tc.name: CloseAbility
279  * @tc.desc: test WindowInnerManager CloseAbility
280  * @tc.type: FUNC
281  */
282 HWTEST_F(WindowInnerManagerTest, CloseAbility, Function | SmallTest | Level2)
283 {
284     wim_->isRecentHolderEnable_ = true;
285     sptr<WindowNode> node = new WindowNode();
286     wptr<WindowNode> node1 = node;
287     wim_->CloseAbility(node1);
288     ASSERT_EQ(wim_->isRecentHolderEnable_, true);
289 }
290 
291 /**
292  * @tc.name: CompleteFirstFrameDrawing
293  * @tc.desc: test WindowInnerManager CompleteFirstFrameDrawing
294  * @tc.type: FUNC
295  */
296 HWTEST_F(WindowInnerManagerTest, CompleteFirstFrameDrawing, Function | SmallTest | Level2)
297 {
298     wim_->isRecentHolderEnable_ = true;
299     sptr<WindowNode> node = new WindowNode();
300     wptr<WindowNode> node1 = node;
301     wim_->CompleteFirstFrameDrawing(node1);
302     ASSERT_EQ(wim_->isRecentHolderEnable_, true);
303 }
304 
305 /**
306  * @tc.name: UpdateMissionSnapShot
307  * @tc.desc: test WindowInnerManager UpdateMissionSnapShot
308  * @tc.type: FUNC
309  */
310 HWTEST_F(WindowInnerManagerTest, UpdateMissionSnapShot, Function | SmallTest | Level2)
311 {
312     wim_->isRecentHolderEnable_ = true;
313     sptr<WindowNode> node = new WindowNode();
314     wptr<WindowNode> node1 = node;
315     std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>();
316     wim_->UpdateMissionSnapShot(node1, pixelMap);
317     ASSERT_EQ(wim_->isRecentHolderEnable_, true);
318 }
319 
320 /**
321  * @tc.name: GetPid
322  * @tc.desc: test WindowInnerManager GetPid
323  * @tc.type: FUNC
324  */
325 HWTEST_F(WindowInnerManagerTest, GetPid, Function | SmallTest | Level2)
326 {
327     ASSERT_EQ(wim_->GetPid(), INVALID_PID);
328 }
329 
330 /**
331  * @tc.name: SetInputEventConsumer
332  * @tc.desc: test WindowInnerManager SetInputEventConsumer
333  * @tc.type: FUNC
334  */
335 HWTEST_F(WindowInnerManagerTest, SetInputEventConsumer, Function | SmallTest | Level2)
336 {
337     wim_->moveDragController_ = nullptr;
338     wim_->SetInputEventConsumer();
339     ASSERT_EQ(wim_->moveDragController_, nullptr);
340     wim_->moveDragController_ = new MoveDragController();
341     wim_->SetInputEventConsumer();
342     ASSERT_NE(wim_->moveDragController_, nullptr);
343 }
344 
345 /**
346  * @tc.name: StartWindowInfoReportLoop
347  * @tc.desc: test WindowInnerManager StartWindowInfoReportLoop
348  * @tc.type: FUNC
349  */
350 HWTEST_F(WindowInnerManagerTest, StartWindowInfoReportLoop, Function | SmallTest | Level2)
351 {
352     wim_->isReportTaskStart_ = true;
353     wim_->eventHandler_ = nullptr;
354     wim_->StartWindowInfoReportLoop();
355     ASSERT_EQ(wim_->isReportTaskStart_, true);
356     wim_->isReportTaskStart_ = false;
357     wim_->eventHandler_ = std::make_shared<EventHandler>(EventRunner::Create());
358     wim_->StartWindowInfoReportLoop();
359     ASSERT_EQ(wim_->isReportTaskStart_, true);
360 }
361 }
362 }
363 }
364