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 /**
132 * @tc.name: NotifyWindowRemovedOrDestroyed
133 * @tc.desc: test WindowInnerManager NotifyWindowRemovedOrDestroyed
134 * @tc.type: FUNC
135 */
136 HWTEST_F(WindowInnerManagerTest, NotifyWindowRemovedOrDestroyed, Function | SmallTest | Level2)
137 {
138 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
139 windowInnerManager.eventHandler_ = nullptr;
140 windowInnerManager.moveDragController_ = new MoveDragController();
141 windowInnerManager.moveDragController_->activeWindowId_ = TEST_CUSTOM_ID;
142
143 uint32_t windowId = INVALID_WINDOW_ID;
144 windowInnerManager.NotifyWindowRemovedOrDestroyed(windowId);
145 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, TEST_CUSTOM_ID);
146
147 windowId = TEST_CUSTOM_ID;
148
149 auto moveDragProperty = windowInnerManager.moveDragController_->moveDragProperty_;
150 moveDragProperty->startDragFlag_ = true;
151 moveDragProperty->startMoveFlag_ = true;
152 windowInnerManager.NotifyWindowRemovedOrDestroyed(windowId);
153 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, INVALID_WINDOW_ID);
154 }
155
156 /**
157 * @tc.name: SetWindowRoot
158 * @tc.desc: SetWindowRoot Test
159 * @tc.type: FUNC
160 */
161 HWTEST_F(WindowInnerManagerTest, SetWindowRoot, Function | SmallTest | Level2)
162 {
163 wim_->isRecentHolderEnable_ = true;
164 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
165 sptr<WindowRoot> windowRoot = new WindowRoot(nullptr);
166 windowInnerManager.SetWindowRoot(windowRoot);
167 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
168 }
169
170 /**
171 * @tc.name: ConsumePointerEvent
172 * @tc.desc: test WindowInnerManager ConsumePointerEvent
173 * @tc.type: FUNC
174 */
175 HWTEST_F(WindowInnerManagerTest, ConsumePointerEvent, Function | SmallTest | Level2)
176 {
177 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
178 windowInnerManager.eventHandler_ = nullptr;
179 windowInnerManager.moveDragController_ = new MoveDragController();
180
181 auto pointerEvent = MMI::PointerEvent::Create();
182 pointerEvent->processedCallback_ = nullptr;
183 pointerEvent->sourceType_ = MMI::PointerEvent::SOURCE_TYPE_MOUSE;
184 pointerEvent->buttonId_ = MMI::PointerEvent::MOUSE_BUTTON_RIGHT;
185 pointerEvent->pointerAction_ = MMI::PointerEvent::POINTER_ACTION_MOVE;
186
187 pointerEvent->agentWindowId_ = 1;
188 windowInnerManager.moveDragController_->activeWindowId_ = 1;
189 windowInnerManager.ConsumePointerEvent(pointerEvent);
190 ASSERT_NE(windowInnerManager.moveDragController_->moveEvent_, nullptr);
191 ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
192
193 pointerEvent->agentWindowId_ = 1;
194 windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
195 windowInnerManager.ConsumePointerEvent(pointerEvent);
196 ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
197
198 pointerEvent->agentWindowId_ = INVALID_WINDOW_ID;
199 windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
200 windowInnerManager.ConsumePointerEvent(pointerEvent);
201 ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
202 }
203
204 /**
205 * @tc.name: Start
206 * @tc.desc: test WindowInnerManager Start
207 * @tc.type: FUNC
208 */
209 HWTEST_F(WindowInnerManagerTest, Start, Function | SmallTest | Level2)
210 {
211 wim_->state_ = InnerWMRunningState::STATE_RUNNING;
212 bool enableRecentholder = false;
213 wim_->Start(enableRecentholder);
214 ASSERT_EQ(wim_->state_, InnerWMRunningState::STATE_RUNNING);
215 }
216
217 /**
218 * @tc.name: CreateInnerWindow
219 * @tc.desc: test WindowInnerManager CreateInnerWindow
220 * @tc.type: FUNC
221 */
222 HWTEST_F(WindowInnerManagerTest, CreateInnerWindow, Function | SmallTest | Level2)
223 {
224 wim_->isRecentHolderEnable_ = true;
225 std::string name = "test";
226 DisplayId displayId = 1;
227 Rect rect = {0.0, 0.0, 100.0, 100.0};
228 WindowType type = WindowType::WINDOW_TYPE_PLACEHOLDER;
229 WindowMode mode = WindowMode::WINDOW_MODE_FLOATING;
230 wim_->CreateInnerWindow(name, displayId, rect, type, mode);
231 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
232 }
233
234 /**
235 * @tc.name: DestroyInnerWindow
236 * @tc.desc: test WindowInnerManager DestroyInnerWindow
237 * @tc.type: FUNC
238 */
239 HWTEST_F(WindowInnerManagerTest, DestroyInnerWindow, Function | SmallTest | Level2)
240 {
241 wim_->isRecentHolderEnable_ = true;
242 DisplayId displayId = 1;
243 WindowType type = WindowType::WINDOW_TYPE_PLACEHOLDER;
244 wim_->DestroyInnerWindow(displayId, type);
245 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
246 }
247
248 /**
249 * @tc.name: UpdateInnerWindow
250 * @tc.desc: test WindowInnerManager UpdateInnerWindow
251 * @tc.type: FUNC
252 */
253 HWTEST_F(WindowInnerManagerTest, UpdateInnerWindow, Function | SmallTest | Level2)
254 {
255 wim_->isRecentHolderEnable_ = true;
256 DisplayId displayId = 1;
257 WindowType type = WindowType::WINDOW_TYPE_PLACEHOLDER;
258 uint32_t width = 200;
259 uint32_t height = 200;
260 wim_->UpdateInnerWindow(displayId, type, width, height);
261 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
262 }
263
264 /**
265 * @tc.name: TerminateAbility
266 * @tc.desc: test WindowInnerManager TerminateAbility
267 * @tc.type: FUNC
268 */
269 HWTEST_F(WindowInnerManagerTest, TerminateAbility, Function | SmallTest | Level2)
270 {
271 wim_->isRecentHolderEnable_ = true;
272 sptr<WindowNode> node = new WindowNode();
273 wptr<WindowNode> node1 = node;
274 wim_->TerminateAbility(node1);
275 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
276 }
277
278 /**
279 * @tc.name: CloseAbility
280 * @tc.desc: test WindowInnerManager CloseAbility
281 * @tc.type: FUNC
282 */
283 HWTEST_F(WindowInnerManagerTest, CloseAbility, Function | SmallTest | Level2)
284 {
285 wim_->isRecentHolderEnable_ = true;
286 sptr<WindowNode> node = new WindowNode();
287 wptr<WindowNode> node1 = node;
288 wim_->CloseAbility(node1);
289 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
290 }
291
292 /**
293 * @tc.name: CompleteFirstFrameDrawing
294 * @tc.desc: test WindowInnerManager CompleteFirstFrameDrawing
295 * @tc.type: FUNC
296 */
297 HWTEST_F(WindowInnerManagerTest, CompleteFirstFrameDrawing, Function | SmallTest | Level2)
298 {
299 wim_->isRecentHolderEnable_ = true;
300 sptr<WindowNode> node = new WindowNode();
301 wptr<WindowNode> node1 = node;
302 wim_->CompleteFirstFrameDrawing(node1);
303 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
304 }
305
306 /**
307 * @tc.name: UpdateMissionSnapShot
308 * @tc.desc: test WindowInnerManager UpdateMissionSnapShot
309 * @tc.type: FUNC
310 */
311 HWTEST_F(WindowInnerManagerTest, UpdateMissionSnapShot, Function | SmallTest | Level2)
312 {
313 wim_->isRecentHolderEnable_ = true;
314 sptr<WindowNode> node = new WindowNode();
315 wptr<WindowNode> node1 = node;
316 std::shared_ptr<Media::PixelMap> pixelMap = std::make_shared<Media::PixelMap>();
317 wim_->UpdateMissionSnapShot(node1, pixelMap);
318 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
319 }
320
321 /**
322 * @tc.name: GetPid
323 * @tc.desc: test WindowInnerManager GetPid
324 * @tc.type: FUNC
325 */
326 HWTEST_F(WindowInnerManagerTest, GetPid, Function | SmallTest | Level2)
327 {
328 ASSERT_EQ(wim_->GetPid(), INVALID_PID);
329 }
330
331 /**
332 * @tc.name: SetInputEventConsumer
333 * @tc.desc: test WindowInnerManager SetInputEventConsumer
334 * @tc.type: FUNC
335 */
336 HWTEST_F(WindowInnerManagerTest, SetInputEventConsumer, Function | SmallTest | Level2)
337 {
338 wim_->moveDragController_ = nullptr;
339 wim_->SetInputEventConsumer();
340 ASSERT_EQ(wim_->moveDragController_, nullptr);
341 wim_->moveDragController_ = new MoveDragController();
342 wim_->SetInputEventConsumer();
343 ASSERT_NE(wim_->moveDragController_, nullptr);
344 }
345
346 /**
347 * @tc.name: StartWindowInfoReportLoop
348 * @tc.desc: test WindowInnerManager StartWindowInfoReportLoop
349 * @tc.type: FUNC
350 */
351 HWTEST_F(WindowInnerManagerTest, StartWindowInfoReportLoop, Function | SmallTest | Level2)
352 {
353 wim_->isReportTaskStart_ = true;
354 wim_->eventHandler_ = nullptr;
355 wim_->StartWindowInfoReportLoop();
356 ASSERT_EQ(wim_->isReportTaskStart_, true);
357 wim_->isReportTaskStart_ = false;
358 wim_->eventHandler_ = std::make_shared<EventHandler>(EventRunner::Create());
359 wim_->StartWindowInfoReportLoop();
360 ASSERT_EQ(wim_->isReportTaskStart_, true);
361 }
362 }
363 }
364 }
365