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 "drag_controller.h"
18 #include "window_helper.h"
19 #include "window_inner_manager.h"
20 #include "window_manager_service.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 class DragControllerTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 void SetUp() override;
32 void TearDown() override;
33 private:
34 static sptr<MoveDragController> moveDragController_;
35 static std::shared_ptr<MMI::IInputEventConsumer> inputListener_;
36 };
37
38 sptr<MoveDragController> DragControllerTest::moveDragController_ = nullptr;
39 std::shared_ptr<MMI::IInputEventConsumer> DragControllerTest::inputListener_ = nullptr;
40
SetUpTestCase()41 void DragControllerTest::SetUpTestCase()
42 {
43 WindowInnerManager::GetInstance().Init();
44 moveDragController_ = WindowInnerManager::GetInstance().moveDragController_;
45 ASSERT_TRUE(moveDragController_);
46 inputListener_ = moveDragController_->inputListener_;
47 ASSERT_TRUE(inputListener_);
48 }
49
TearDownTestCase()50 void DragControllerTest::TearDownTestCase()
51 {
52 moveDragController_ = nullptr;
53 inputListener_ = nullptr;
54 WindowInnerManager::GetInstance().Stop();
55 }
56
SetUp()57 void DragControllerTest::SetUp()
58 {
59 }
60
TearDown()61 void DragControllerTest::TearDown()
62 {
63 }
64
65 namespace {
66 /**
67 * @tc.name: OnInputEvent01
68 * @tc.desc: OnInputEven01, keyEvent
69 * @tc.type: FUNC
70 */
71 HWTEST_F(DragControllerTest, OnInputEvent01, Function | SmallTest | Level2)
72 {
73 ASSERT_TRUE(inputListener_);
74 std::shared_ptr<MMI::KeyEvent> keyEvent;
75 inputListener_->OnInputEvent(keyEvent);
76 keyEvent = MMI::KeyEvent::Create();
77 inputListener_->OnInputEvent(keyEvent);
78 }
79
80 /**
81 * @tc.name: OnInputEvent02
82 * @tc.desc: OnInputEvent02, axisEvent
83 * @tc.type: FUNC
84 */
85 HWTEST_F(DragControllerTest, OnInputEvent02, Function | SmallTest | Level2)
86 {
87 ASSERT_TRUE(inputListener_);
88 std::shared_ptr<MMI::AxisEvent> axisEvent;
89 inputListener_->OnInputEvent(axisEvent);
90 axisEvent = MMI::AxisEvent::Create();
91 inputListener_->OnInputEvent(axisEvent);
92 }
93
94 /**
95 * @tc.name: OnInputEvent03
96 * @tc.desc: OnInputEvent03, pointerEvent
97 * @tc.type: FUNC
98 */
99 HWTEST_F(DragControllerTest, OnInputEvent03, Function | SmallTest | Level2)
100 {
101 ASSERT_TRUE(inputListener_);
102 std::shared_ptr<MMI::PointerEvent> pointerEvent;
103 inputListener_->OnInputEvent(pointerEvent);
104 pointerEvent = MMI::PointerEvent::Create();
105 ASSERT_TRUE(pointerEvent);
106 pointerEvent->SetAgentWindowId(INVALID_WINDOW_ID);
107 ASSERT_TRUE(moveDragController_);
108 moveDragController_->SetActiveWindowId(1);
109 inputListener_->OnInputEvent(pointerEvent);
110 }
111
112 /**
113 * @tc.name: Stop01
114 * @tc.desc: Stop01
115 * @tc.type: FUNC
116 */
117 HWTEST_F(DragControllerTest, Stop01, Function | SmallTest | Level2)
118 {
119 moveDragController_->Stop();
120 }
121
122 /**
123 * @tc.name: Stop02
124 * @tc.desc: Stop02
125 * @tc.type: FUNC
126 */
127 HWTEST_F(DragControllerTest, Stop02, Function | SmallTest | Level2)
128 {
129 ASSERT_TRUE(moveDragController_);
130 moveDragController_->Init();
131 moveDragController_->Stop();
132 moveDragController_->Init();
133 }
134
135 /**
136 * @tc.name: HandleEndUpMovingOrDragging
137 * @tc.desc: HandleEndUpMovingOrDragging
138 * @tc.type: FUNC
139 */
140 HWTEST_F(DragControllerTest, HandleEndUpMovingOrDragging, Function | SmallTest | Level2)
141 {
142 ASSERT_TRUE(moveDragController_);
143 uint32_t windowId = 1; // windowId: 1
144 moveDragController_->HandleEndUpMovingOrDragging(windowId);
145 moveDragController_->activeWindowId_ = windowId;
146 moveDragController_->HandleEndUpMovingOrDragging(windowId);
147 }
148
149 /**
150 * @tc.name: HandleWindowRemovedOrDestroyed
151 * @tc.desc: HandleWindowRemovedOrDestroyed
152 * @tc.type: FUNC
153 */
154 HWTEST_F(DragControllerTest, HandleWindowRemovedOrDestroyed, Function | SmallTest | Level2)
155 {
156 ASSERT_TRUE(moveDragController_);
157 uint32_t windowId = 5; // windowId: 5
158 moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
159 moveDragController_->moveDragProperty_ = new MoveDragProperty();
160 moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
161 moveDragController_->moveDragProperty_->startMoveFlag_ = true;
162 moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
163 moveDragController_->moveDragProperty_->startMoveFlag_ = false;
164 moveDragController_->moveDragProperty_->startDragFlag_ = true;
165 moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
166 moveDragController_->moveDragProperty_->startMoveFlag_ = true;
167 moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
168 moveDragController_->moveDragProperty_ = nullptr;
169 }
170
171 /**
172 * @tc.name: ConvertPointerPosToDisplayGroupPos
173 * @tc.desc: ConvertPointerPosToDisplayGroupPos
174 * @tc.type: FUNC
175 */
176 HWTEST_F(DragControllerTest, ConvertPointerPosToDisplayGroupPos, Function | SmallTest | Level2)
177 {
178 ASSERT_TRUE(moveDragController_);
179 int32_t posX = 0;
180 int32_t posY = 0;
181 moveDragController_->ConvertPointerPosToDisplayGroupPos(0, posX, posY);
182 Rect displayRect = { 0, 0, 720, 1280 }; // displayRect: 0, 0, 720, 1280
183
184 moveDragController_->displayRectMap_.insert(std::make_pair(0, displayRect));
185 moveDragController_->ConvertPointerPosToDisplayGroupPos(1, posX, posY);
186 moveDragController_->ConvertPointerPosToDisplayGroupPos(0, posX, posY);
187 moveDragController_->displayRectMap_.clear();
188 }
189
190 /**
191 * @tc.name: ConsumePointerEvent
192 * @tc.desc: ConsumePointerEvent
193 * @tc.type: FUNC
194 */
195 HWTEST_F(DragControllerTest, ConsumePointerEvent, Function | SmallTest | Level2)
196 {
197 ASSERT_TRUE(moveDragController_);
198 std::shared_ptr<MMI::PointerEvent> pointerEvent;
199 moveDragController_->ConsumePointerEvent(pointerEvent);
200 pointerEvent = MMI::PointerEvent::Create();
201 ASSERT_TRUE(pointerEvent);
202 pointerEvent->SetAgentWindowId(1);
203 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
204 moveDragController_->ConsumePointerEvent(pointerEvent);
205 }
206
207 /**
208 * @tc.name: OnReceiveVsync
209 * @tc.desc: OnReceiveVsync
210 * @tc.type: FUNC
211 */
212 HWTEST_F(DragControllerTest, OnReceiveVsync, Function | SmallTest | Level2)
213 {
214 ASSERT_TRUE(moveDragController_);
215 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
216 ASSERT_TRUE(pointerEvent);
217 moveDragController_->OnReceiveVsync(0);
218 moveDragController_->moveEvent_ = pointerEvent;
219 moveDragController_->OnReceiveVsync(0);
220 }
221
222 /**
223 * @tc.name: GetHotZoneRect
224 * @tc.desc: GetHotZoneRect
225 * @tc.type: FUNC
226 */
227 HWTEST_F(DragControllerTest, GetHotZoneRect, Function | SmallTest | Level2)
228 {
229 ASSERT_TRUE(moveDragController_);
230 Rect displayRect = { 0, 0, 720, 1280 }; // displayRect: 0, 0, 720, 1280
231 moveDragController_->displayRectMap_.insert(std::make_pair(0, displayRect));
232 moveDragController_->moveDragProperty_ = new MoveDragProperty();
233 moveDragController_->moveDragProperty_->targetDisplayId_ = 0;
234 moveDragController_->moveDragProperty_->startRectExceptCorner_ = { 0, 0, 40, 40 };
235
236 moveDragController_->moveDragProperty_->startPointPosX_ = 20; // startPointPosX: 20
237 moveDragController_->moveDragProperty_->startPointPosY_ = 20; // startPointPosY: 20
238 moveDragController_->GetHotZoneRect();
239
240 moveDragController_->moveDragProperty_->startPointPosX_ = -1; // startPointPosX: -1
241 moveDragController_->moveDragProperty_->startPointPosY_ = -1; // startPointPosY: -1
242 moveDragController_->GetHotZoneRect();
243
244 moveDragController_->moveDragProperty_->startPointPosX_ = -1; // startPointPosX: -1
245 moveDragController_->moveDragProperty_->startPointPosY_ = 20; // startPointPosY: 20
246 moveDragController_->GetHotZoneRect();
247
248 moveDragController_->moveDragProperty_->startPointPosX_ = 41; // startPointPosX: 41
249 moveDragController_->moveDragProperty_->startPointPosY_ = 20; // startPointPosY: 20
250 moveDragController_->GetHotZoneRect();
251
252 moveDragController_->moveDragProperty_->startPointPosX_ = 20; // startPointPosX: 20
253 moveDragController_->moveDragProperty_->startPointPosY_ = -1; // startPointPosY: -1
254 moveDragController_->GetHotZoneRect();
255
256 moveDragController_->moveDragProperty_->startPointPosX_ = 20; // startPointPosX: 20
257 moveDragController_->moveDragProperty_->startPointPosY_ = 41; // startPointPosY: 41
258 moveDragController_->GetHotZoneRect();
259
260 moveDragController_->moveDragProperty_->startPointPosX_ = 41; // startPointPosX: 41
261 moveDragController_->moveDragProperty_->startPointPosY_ = 41; // startPointPosY: 41
262 moveDragController_->GetHotZoneRect();
263 moveDragController_->moveDragProperty_ = nullptr;
264 }
265
266 /**
267 * @tc.name: HandleDragEvent01
268 * @tc.desc: HandleDragEvent01
269 * @tc.type: FUNC
270 */
271 HWTEST_F(DragControllerTest, HandleDragEvent01, Function | SmallTest | Level2)
272 {
273 ASSERT_TRUE(moveDragController_);
274 int32_t posX = 0;
275 int32_t posY = 0;
276 int32_t pointId = 0;
277 int32_t sourceType = 0;
278 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
279
280 moveDragController_->moveDragProperty_ = new MoveDragProperty();
281 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
282
283 moveDragController_->moveDragProperty_->startDragFlag_ = true;
284 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
285
286 pointId = 1;
287 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
288
289 pointId = 0;
290 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
291
292 sourceType = 1;
293 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
294
295 sourceType = 0;
296 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
297
298 moveDragController_->moveDragProperty_ = nullptr;
299 }
300
301 /**
302 * @tc.name: HandleDragEvent02
303 * @tc.desc: HandleDragEvent02
304 * @tc.type: FUNC
305 */
306 HWTEST_F(DragControllerTest, HandleDragEvent02, Function | SmallTest | Level2)
307 {
308 ASSERT_TRUE(moveDragController_);
309 int32_t posX = 0;
310 int32_t posY = 0;
311 int32_t pointId = 0;
312 int32_t sourceType = 0;
313 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
314
315 moveDragController_->moveDragProperty_ = new MoveDragProperty();
316 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
317
318 moveDragController_->moveDragProperty_->startDragFlag_ = true;
319 moveDragController_->moveDragProperty_->targetDisplayId_ = 0;
320 moveDragController_->moveDragProperty_->startRectExceptCorner_ = { 0, 0, 40, 40 }; // hotZone: 0, 0, 40, 40
321
322 moveDragController_->moveDragProperty_->startPointPosX_ = -1; // startPointPosX: -1
323 moveDragController_->moveDragProperty_->startPointPosY_ = -1; // startPointPosY: -1
324 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
325
326 moveDragController_->moveDragProperty_->startPointPosX_ = 45; // startPointPosX: 45
327 moveDragController_->moveDragProperty_->startPointPosY_ = -1; // startPointPosY: -1
328 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
329
330 moveDragController_->moveDragProperty_->startPointPosX_ = -1; // startPointPosX: -1
331 moveDragController_->moveDragProperty_->startPointPosY_ = 45; // startPointPosY: 45
332 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
333
334 moveDragController_->moveDragProperty_->startPointPosX_ = 45; // startPointPosX: 45
335 moveDragController_->moveDragProperty_->startPointPosY_ = 45; // startPointPosY: 45
336 moveDragController_->HandleDragEvent(posX, posY, pointId, sourceType);
337
338 moveDragController_->moveDragProperty_ = nullptr;
339 }
340
341 /**
342 * @tc.name: HandleMoveEvent
343 * @tc.desc: HandleMoveEvent
344 * @tc.type: FUNC
345 */
346 HWTEST_F(DragControllerTest, HandleMoveEvent, Function | SmallTest | Level2)
347 {
348 ASSERT_TRUE(moveDragController_);
349 int32_t posX = 0;
350 int32_t posY = 0;
351 int32_t pointId = 0;
352 int32_t sourceType = 0;
353 moveDragController_->HandleMoveEvent(posX, posY, pointId, sourceType);
354
355 moveDragController_->moveDragProperty_ = new MoveDragProperty();
356 moveDragController_->HandleMoveEvent(posX, posY, pointId, sourceType);
357
358 moveDragController_->moveDragProperty_->startMoveFlag_ = true;
359 moveDragController_->HandleMoveEvent(posX, posY, pointId, sourceType);
360
361 pointId = 1;
362 moveDragController_->HandleMoveEvent(posX, posY, pointId, sourceType);
363
364 pointId = 0;
365 moveDragController_->HandleMoveEvent(posX, posY, pointId, sourceType);
366
367 sourceType = 1;
368 moveDragController_->HandleMoveEvent(posX, posY, pointId, sourceType);
369
370 sourceType = 0;
371 moveDragController_->HandleMoveEvent(posX, posY, pointId, sourceType);
372
373 moveDragController_->moveDragProperty_ = nullptr;
374 }
375
376 /**
377 * @tc.name: HandlePointerEvent
378 * @tc.desc: HandlePointerEvent
379 * @tc.type: FUNC
380 */
381 HWTEST_F(DragControllerTest, HandlePointerEvent, Function | SmallTest | Level2)
382 {
383 ASSERT_TRUE(moveDragController_);
384 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
385 ASSERT_TRUE(pointerEvent);
386 pointerEvent->SetAgentWindowId(1);
387 MMI::PointerEvent::PointerItem pointerItem;
388 pointerItem.SetPointerId(0);
389 pointerItem.SetDisplayX(0);
390 pointerItem.SetDisplayY(0);
391 pointerEvent->AddPointerItem(pointerItem);
392 moveDragController_->HandlePointerEvent(pointerEvent);
393
394 pointerEvent->SetPointerId(0);
395 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
396 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
397 moveDragController_->HandlePointerEvent(pointerEvent);
398
399 moveDragController_->windowProperty_ = new WindowProperty();
400 moveDragController_->moveDragProperty_ = new MoveDragProperty();
401 moveDragController_->HandlePointerEvent(pointerEvent);
402
403 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
404 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_RIGHT);
405 moveDragController_->HandlePointerEvent(pointerEvent);
406
407 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
408 moveDragController_->HandlePointerEvent(pointerEvent);
409
410 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
411 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
412 moveDragController_->HandlePointerEvent(pointerEvent);
413
414 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
415 moveDragController_->HandlePointerEvent(pointerEvent);
416
417 moveDragController_->moveDragProperty_->startPointerId_ = 1;
418 moveDragController_->moveDragProperty_->sourceType_ = 2; // sourceType: 2
419 moveDragController_->HandlePointerEvent(pointerEvent);
420
421 moveDragController_->moveDragProperty_->startPointerId_ = 0;
422 moveDragController_->moveDragProperty_->sourceType_ = 2; // sourceType: 2
423 moveDragController_->HandlePointerEvent(pointerEvent);
424
425 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
426 moveDragController_->HandlePointerEvent(pointerEvent);
427
428 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
429 moveDragController_->HandlePointerEvent(pointerEvent);
430
431 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
432 moveDragController_->HandlePointerEvent(pointerEvent);
433
434 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
435 moveDragController_->HandlePointerEvent(pointerEvent);
436
437 moveDragController_->windowProperty_ = nullptr;
438 moveDragController_->moveDragProperty_ = nullptr;
439 }
440 }
441 } // namespace Rosen
442 } // namespace OHOS
443