1 /*
2  * Copyright (c) 2022-2023 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 "display_manager.h"
19 #include "drag_controller.h"
20 #include "window_helper.h"
21 #include "window_inner_manager.h"
22 #include "window_manager_service.h"
23 
24 using namespace testing;
25 using namespace testing::ext;
26 
27 namespace OHOS {
28 namespace Rosen {
29 constexpr uint32_t WINDOW_ID = 1000;
30 class DragControllerTest : public testing::Test {
31 public:
32     static void SetUpTestCase();
33     static void TearDownTestCase();
34     void SetUp() override;
35     void TearDown() override;
36     static sptr<WindowRoot> windowRoot_;
37 private:
38     static sptr<MoveDragController> moveDragController_;
39     static std::shared_ptr<MMI::IInputEventConsumer> inputListener_;
40 };
41 
42 sptr<MoveDragController> DragControllerTest::moveDragController_ = nullptr;
43 std::shared_ptr<MMI::IInputEventConsumer> DragControllerTest::inputListener_ = nullptr;
44 sptr<WindowRoot> DragControllerTest::windowRoot_ = nullptr;
45 
SetUpTestCase()46 void DragControllerTest::SetUpTestCase()
47 {
48     WindowInnerManager::GetInstance().Init();
49     moveDragController_ = WindowInnerManager::GetInstance().moveDragController_;
50 
51     auto display = DisplayManager::GetInstance().GetDefaultDisplay();
52     ASSERT_TRUE((display != nullptr));
53     sptr<DisplayInfo> displayInfo = display->GetDisplayInfo();
54     ASSERT_TRUE((displayInfo != nullptr));
55     ASSERT_TRUE((display != nullptr));
56     ASSERT_TRUE((display->GetDisplayInfo() != nullptr));
57     ASSERT_TRUE(moveDragController_);
58     inputListener_ = moveDragController_->inputListener_;
59     ASSERT_TRUE(inputListener_);
60 }
61 
TearDownTestCase()62 void DragControllerTest::TearDownTestCase()
63 {
64     moveDragController_ = nullptr;
65     inputListener_ = nullptr;
66     WindowInnerManager::GetInstance().Stop();
67 }
68 
SetUp()69 void DragControllerTest::SetUp()
70 {
71     windowRoot_ = new WindowRoot(nullptr);
72 }
73 
TearDown()74 void DragControllerTest::TearDown()
75 {
76     windowRoot_ = nullptr;
77 }
78 
79 namespace {
80 /**
81  * @tc.name: OnInputEvent01
82  * @tc.desc: OnInputEven01, keyEvent
83  * @tc.type: FUNC
84  */
85 HWTEST_F(DragControllerTest, OnInputEvent01, Function | SmallTest | Level2)
86 {
87     ASSERT_TRUE(inputListener_);
88     std::shared_ptr<MMI::KeyEvent> keyEvent;
89     inputListener_->OnInputEvent(keyEvent);
90     keyEvent = MMI::KeyEvent::Create();
91     inputListener_->OnInputEvent(keyEvent);
92 }
93 
94 /**
95  * @tc.name: OnInputEvent02
96  * @tc.desc: OnInputEvent02, axisEvent
97  * @tc.type: FUNC
98  */
99 HWTEST_F(DragControllerTest, OnInputEvent02, Function | SmallTest | Level2)
100 {
101     ASSERT_TRUE(inputListener_);
102     std::shared_ptr<MMI::AxisEvent> axisEvent;
103     inputListener_->OnInputEvent(axisEvent);
104     axisEvent = MMI::AxisEvent::Create();
105     inputListener_->OnInputEvent(axisEvent);
106 }
107 
108 /**
109  * @tc.name: OnInputEvent03
110  * @tc.desc: OnInputEvent03, pointerEvent
111  * @tc.type: FUNC
112  */
113 HWTEST_F(DragControllerTest, OnInputEvent03, Function | SmallTest | Level2)
114 {
115     ASSERT_TRUE(inputListener_);
116     std::shared_ptr<MMI::PointerEvent> pointerEvent;
117     inputListener_->OnInputEvent(pointerEvent);
118     pointerEvent = MMI::PointerEvent::Create();
119     ASSERT_TRUE(pointerEvent);
120     pointerEvent->SetAgentWindowId(INVALID_WINDOW_ID);
121     ASSERT_TRUE(moveDragController_);
122     moveDragController_->SetActiveWindowId(1);
123     inputListener_->OnInputEvent(pointerEvent);
124 }
125 
126 /**
127  * @tc.name: Stop02
128  * @tc.desc: Stop02
129  * @tc.type: FUNC
130  */
131 HWTEST_F(DragControllerTest, Stop02, Function | SmallTest | Level2)
132 {
133     ASSERT_TRUE(moveDragController_);
134     moveDragController_->Init();
135     moveDragController_->Stop();
136     moveDragController_->Init();
137 }
138 
139 /**
140  * @tc.name: HandleEndUpMovingOrDragging
141  * @tc.desc: HandleEndUpMovingOrDragging
142  * @tc.type: FUNC
143  */
144 HWTEST_F(DragControllerTest, HandleEndUpMovingOrDragging, Function | SmallTest | Level2)
145 {
146     ASSERT_TRUE(moveDragController_);
147     uint32_t windowId = 1; // windowId: 1
148     moveDragController_->HandleEndUpMovingOrDragging(windowId);
149     moveDragController_->activeWindowId_ = windowId;
150     moveDragController_->HandleEndUpMovingOrDragging(windowId);
151 }
152 
153 /**
154  * @tc.name: HandleWindowRemovedOrDestroyed
155  * @tc.desc: HandleWindowRemovedOrDestroyed
156  * @tc.type: FUNC
157  */
158 HWTEST_F(DragControllerTest, HandleWindowRemovedOrDestroyed, Function | SmallTest | Level2)
159 {
160     ASSERT_TRUE(moveDragController_);
161     uint32_t windowId = 5; // windowId: 5
162     moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
163     moveDragController_->moveDragProperty_ = new MoveDragProperty();
164     moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
165     moveDragController_->moveDragProperty_->startMoveFlag_ = true;
166     moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
167     moveDragController_->moveDragProperty_->startMoveFlag_ = false;
168     moveDragController_->moveDragProperty_->startDragFlag_ = true;
169     moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
170     moveDragController_->moveDragProperty_->startMoveFlag_ = true;
171     moveDragController_->HandleWindowRemovedOrDestroyed(windowId);
172     moveDragController_->moveDragProperty_ = nullptr;
173 }
174 
175 /**
176  * @tc.name: ConvertPointerPosToDisplayGroupPos
177  * @tc.desc: ConvertPointerPosToDisplayGroupPos
178  * @tc.type: FUNC
179  */
180 HWTEST_F(DragControllerTest, ConvertPointerPosToDisplayGroupPos, Function | SmallTest | Level2)
181 {
182     ASSERT_TRUE(moveDragController_);
183 
184     auto displayInfo = new DisplayInfo();
185     displayInfo->SetDisplayId(0);
186     displayInfo->SetWidth(720);   // displayWidth: 720
187     displayInfo->SetHeight(1280); // displayHeight: 1280
188     displayInfo->SetOffsetX(0);
189     displayInfo->SetOffsetY(0);
190     DisplayGroupInfo::GetInstance().AddDisplayInfo(displayInfo);
191 
192     int32_t posX = 0;
193     int32_t posY = 0;
194     moveDragController_->ConvertPointerPosToDisplayGroupPos(0, posX, posY);
195 
196     moveDragController_->ConvertPointerPosToDisplayGroupPos(1, posX, posY);
197     moveDragController_->ConvertPointerPosToDisplayGroupPos(0, posX, posY);
198     DisplayGroupInfo::GetInstance().RemoveDisplayInfo(0);
199 }
200 
201 /**
202  * @tc.name: ConsumePointerEvent
203  * @tc.desc: ConsumePointerEvent
204  * @tc.type: FUNC
205  */
206 HWTEST_F(DragControllerTest, ConsumePointerEvent, Function | SmallTest | Level2)
207 {
208     ASSERT_TRUE(moveDragController_);
209     std::shared_ptr<MMI::PointerEvent> pointerEvent;
210     moveDragController_->ConsumePointerEvent(pointerEvent);
211     pointerEvent = MMI::PointerEvent::Create();
212     ASSERT_TRUE(pointerEvent);
213     pointerEvent->SetAgentWindowId(1);
214     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
215     moveDragController_->ConsumePointerEvent(pointerEvent);
216 }
217 
218 /**
219  * @tc.name: RequestVsync
220  * @tc.desc: RequestVsync Test
221  * @tc.type: FUNC
222  */
223 HWTEST_F(DragControllerTest, RequestVsync, Function | SmallTest | Level2)
224 {
225     ASSERT_TRUE(moveDragController_);
226     NodeId nodeId = 0;
227     uint32_t windowId = 1;
228     std::shared_ptr<VsyncStation> vsyncStation = std::make_shared<VsyncStation>(nodeId);
229     moveDragController_->vsyncStationMap_.emplace(windowId, vsyncStation);
230     std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
231     pointerEvent->SetAgentWindowId(windowId);
232     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
233     moveDragController_->ConsumePointerEvent(pointerEvent);
234     ASSERT_NE(vsyncStation, nullptr);
235 }
236 
237 /**
238  * @tc.name: OnReceiveVsync
239  * @tc.desc: OnReceiveVsync
240  * @tc.type: FUNC
241  */
242 HWTEST_F(DragControllerTest, OnReceiveVsync, Function | SmallTest | Level2)
243 {
244     ASSERT_TRUE(moveDragController_);
245     std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
246     ASSERT_TRUE(pointerEvent);
247     moveDragController_->OnReceiveVsync(0);
248     moveDragController_->moveEvent_ = pointerEvent;
249     moveDragController_->OnReceiveVsync(0);
250 }
251 
252 /**
253  * @tc.name: GetVsyncStationByWindowId1
254  * @tc.desc: GetVsyncStationByWindowId Test Succ
255  * @tc.type: FUNC
256  */
257 HWTEST_F(DragControllerTest, GetVsyncStationByWindowId1, Function | SmallTest | Level2)
258 {
259     ASSERT_TRUE(moveDragController_);
260     NodeId nodeId = 0;
261     uint32_t windowId = WINDOW_ID;
262     std::shared_ptr<VsyncStation> vsyncStation = std::make_shared<VsyncStation>(nodeId);
263     moveDragController_->vsyncStationMap_.emplace(windowId, vsyncStation);
264     std::shared_ptr<VsyncStation> vsyncStationRes = moveDragController_->GetVsyncStationByWindowId(windowId);
265     ASSERT_EQ(vsyncStation, vsyncStationRes);
266 }
267 
268 /**
269  * @tc.name: GetVsyncStationByWindowId2
270  * @tc.desc: GetVsyncStationByWindowId Test Fail
271  * @tc.type: FUNC
272  */
273 HWTEST_F(DragControllerTest, GetVsyncStationByWindowId2, Function | SmallTest | Level2)
274 {
275     ASSERT_TRUE(moveDragController_);
276     uint32_t windowId = 100;
277     moveDragController_->vsyncStationMap_.clear();
278     moveDragController_->SetWindowRoot(windowRoot_);
279     std::shared_ptr<VsyncStation> vsyncStation = moveDragController_->GetVsyncStationByWindowId(windowId);
280     ASSERT_EQ(vsyncStation, nullptr);
281 }
282 
283 /**
284  * @tc.name: GetHotZoneRect
285  * @tc.desc: GetHotZoneRect
286  * @tc.type: FUNC
287  */
288 HWTEST_F(DragControllerTest, GetHotZoneRect, Function | SmallTest | Level2)
289 {
290     ASSERT_TRUE(moveDragController_);
291 
292     auto displayInfo = new DisplayInfo();
293     displayInfo->SetDisplayId(0);
294     displayInfo->SetWidth(720);   // displayWidth: 720
295     displayInfo->SetHeight(1280); // displayHeight: 1280
296     displayInfo->SetOffsetX(0);
297     displayInfo->SetOffsetY(0);
298     DisplayGroupInfo::GetInstance().AddDisplayInfo(displayInfo);
299     moveDragController_->moveDragProperty_ = new MoveDragProperty();
300     moveDragController_->moveDragProperty_->targetDisplayId_ = 0;
301     moveDragController_->moveDragProperty_->startRectExceptCorner_ = { 0, 0, 40, 40 };
302 
303     moveDragController_->moveDragProperty_->startPointPosX_ = 20; // startPointPosX: 20
304     moveDragController_->moveDragProperty_->startPointPosY_ = 20; // startPointPosY: 20
305     moveDragController_->GetHotZoneRect();
306 
307     moveDragController_->moveDragProperty_->startPointPosX_ = -1; // startPointPosX: -1
308     moveDragController_->moveDragProperty_->startPointPosY_ = -1; // startPointPosY: -1
309     moveDragController_->GetHotZoneRect();
310 
311     moveDragController_->moveDragProperty_->startPointPosX_ = -1; // startPointPosX: -1
312     moveDragController_->moveDragProperty_->startPointPosY_ = 20; // startPointPosY: 20
313     moveDragController_->GetHotZoneRect();
314 
315     moveDragController_->moveDragProperty_->startPointPosX_ = 41; // startPointPosX: 41
316     moveDragController_->moveDragProperty_->startPointPosY_ = 20; // startPointPosY: 20
317     moveDragController_->GetHotZoneRect();
318 
319     moveDragController_->moveDragProperty_->startPointPosX_ = 20; // startPointPosX: 20
320     moveDragController_->moveDragProperty_->startPointPosY_ = -1; // startPointPosY: -1
321     moveDragController_->GetHotZoneRect();
322 
323     moveDragController_->moveDragProperty_->startPointPosX_ = 20; // startPointPosX: 20
324     moveDragController_->moveDragProperty_->startPointPosY_ = 41; // startPointPosY: 41
325     moveDragController_->GetHotZoneRect();
326 
327     moveDragController_->moveDragProperty_->startPointPosX_ = 41; // startPointPosX: 41
328     moveDragController_->moveDragProperty_->startPointPosY_ = 41; // startPointPosY: 41
329     moveDragController_->GetHotZoneRect();
330     moveDragController_->moveDragProperty_ = nullptr;
331 }
332 
333 /**
334  * @tc.name: HandleDragEvent01
335  * @tc.desc: HandleDragEvent01
336  * @tc.type: FUNC
337  */
338 HWTEST_F(DragControllerTest, HandleDragEvent01, Function | SmallTest | Level2)
339 {
340     ASSERT_TRUE(moveDragController_);
341     int32_t posX = 0;
342     int32_t posY = 0;
343     int32_t pointId = 0;
344     int32_t sourceType = 0;
345     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
346 
347     moveDragController_->moveDragProperty_ = new MoveDragProperty();
348     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
349 
350     moveDragController_->moveDragProperty_->startDragFlag_ = true;
351     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
352 
353     pointId = 1;
354     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
355 
356     pointId = 0;
357     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
358 
359     sourceType = 1;
360     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
361 
362     sourceType = 0;
363     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
364 
365     moveDragController_->moveDragProperty_ = nullptr;
366 }
367 
368 /**
369  * @tc.name: HandleDragEvent02
370  * @tc.desc: HandleDragEvent02
371  * @tc.type: FUNC
372  */
373 HWTEST_F(DragControllerTest, HandleDragEvent02, Function | SmallTest | Level2)
374 {
375     ASSERT_TRUE(moveDragController_);
376     int32_t posX = 0;
377     int32_t posY = 0;
378     int32_t pointId = 0;
379     int32_t sourceType = 0;
380     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
381 
382     moveDragController_->moveDragProperty_ = new MoveDragProperty();
383     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
384 
385     moveDragController_->moveDragProperty_->startDragFlag_ = true;
386     moveDragController_->moveDragProperty_->targetDisplayId_ = 0;
387     moveDragController_->moveDragProperty_->startRectExceptCorner_ = { 0, 0, 40, 40 }; // hotZone: 0, 0, 40, 40
388 
389     moveDragController_->moveDragProperty_->startPointPosX_ = -1; // startPointPosX: -1
390     moveDragController_->moveDragProperty_->startPointPosY_ = -1; // startPointPosY: -1
391     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
392 
393     moveDragController_->moveDragProperty_->startPointPosX_ = 45; // startPointPosX: 45
394     moveDragController_->moveDragProperty_->startPointPosY_ = -1; // startPointPosY: -1
395     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
396 
397     moveDragController_->moveDragProperty_->startPointPosX_ = -1; // startPointPosX: -1
398     moveDragController_->moveDragProperty_->startPointPosY_ = 45; // startPointPosY: 45
399     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
400 
401     moveDragController_->moveDragProperty_->startPointPosX_ = 45; // startPointPosX: 45
402     moveDragController_->moveDragProperty_->startPointPosY_ = 45; // startPointPosY: 45
403     moveDragController_->HandleDragEvent(0, posX, posY, pointId, sourceType);
404 
405     moveDragController_->moveDragProperty_ = nullptr;
406 }
407 
408 /**
409  * @tc.name: HandleMoveEvent
410  * @tc.desc: HandleMoveEvent
411  * @tc.type: FUNC
412  */
413 HWTEST_F(DragControllerTest, HandleMoveEvent, Function | SmallTest | Level2)
414 {
415     ASSERT_TRUE(moveDragController_);
416     int32_t posX = 0;
417     int32_t posY = 0;
418     int32_t pointId = 0;
419     int32_t sourceType = 0;
420     moveDragController_->HandleMoveEvent(0, posX, posY, pointId, sourceType);
421 
422     moveDragController_->moveDragProperty_ = new MoveDragProperty();
423     moveDragController_->HandleMoveEvent(0, posX, posY, pointId, sourceType);
424 
425         moveDragController_->moveDragProperty_->startMoveFlag_ = true;
426     moveDragController_->HandleMoveEvent(0, posX, posY, pointId, sourceType);
427 
428     pointId = 1;
429     moveDragController_->HandleMoveEvent(0, posX, posY, pointId, sourceType);
430 
431     pointId = 0;
432     moveDragController_->HandleMoveEvent(0, posX, posY, pointId, sourceType);
433 
434     sourceType = 1;
435     moveDragController_->HandleMoveEvent(0, posX, posY, pointId, sourceType);
436 
437     sourceType = 0;
438     moveDragController_->HandleMoveEvent(0, posX, posY, pointId, sourceType);
439 
440     moveDragController_->moveDragProperty_ = nullptr;
441 }
442 
443 /**
444  * @tc.name: HandlePointerEvent
445  * @tc.desc: HandlePointerEvent
446  * @tc.type: FUNC
447  */
448 HWTEST_F(DragControllerTest, HandlePointerEvent, Function | SmallTest | Level2)
449 {
450     ASSERT_TRUE(moveDragController_);
451     std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
452     ASSERT_TRUE(pointerEvent);
453     pointerEvent->SetAgentWindowId(1);
454     MMI::PointerEvent::PointerItem pointerItem;
455     pointerItem.SetPointerId(0);
456     pointerItem.SetDisplayX(0);
457     pointerItem.SetDisplayY(0);
458     pointerEvent->AddPointerItem(pointerItem);
459     moveDragController_->HandlePointerEvent(pointerEvent);
460 
461     pointerEvent->SetPointerId(0);
462     pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
463     pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
464     moveDragController_->HandlePointerEvent(pointerEvent);
465 
466     moveDragController_->windowProperty_ = new WindowProperty();
467     moveDragController_->moveDragProperty_ = new MoveDragProperty();
468     moveDragController_->HandlePointerEvent(pointerEvent);
469 
470     pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
471     pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_RIGHT);
472     moveDragController_->HandlePointerEvent(pointerEvent);
473 
474     pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
475     moveDragController_->HandlePointerEvent(pointerEvent);
476 
477     pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
478     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
479     moveDragController_->HandlePointerEvent(pointerEvent);
480 
481     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
482     moveDragController_->HandlePointerEvent(pointerEvent);
483 
484     moveDragController_->moveDragProperty_->startPointerId_ = 1;
485     moveDragController_->moveDragProperty_->sourceType_ = 2; // sourceType: 2
486     moveDragController_->HandlePointerEvent(pointerEvent);
487 
488     moveDragController_->moveDragProperty_->startPointerId_ = 0;
489     moveDragController_->moveDragProperty_->sourceType_ = 2; // sourceType: 2
490     moveDragController_->HandlePointerEvent(pointerEvent);
491 
492     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
493     moveDragController_->HandlePointerEvent(pointerEvent);
494 
495     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
496     moveDragController_->HandlePointerEvent(pointerEvent);
497 
498     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
499     moveDragController_->HandlePointerEvent(pointerEvent);
500 
501     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
502     moveDragController_->HandlePointerEvent(pointerEvent);
503 
504     moveDragController_->windowProperty_ = nullptr;
505     moveDragController_->moveDragProperty_ = nullptr;
506 }
507 
508 /**
509  * @tc.name: UpdateDragInfo01
510  * @tc.desc: UpdateDragInfo01
511  * @tc.type: FUNC
512  */
513 HWTEST_F(DragControllerTest, UpdateDragInfo01, Function | SmallTest | Level2)
514 {
515     ASSERT_TRUE(moveDragController_);
516     uint32_t windowId = 0;
517     sptr<DragController> dragcontroller = new DragController(windowRoot_);
518     dragcontroller->UpdateDragInfo(windowId);
519 }
520 
521 /**
522  * @tc.name: UpdateDragInfo02
523  * @tc.desc: UpdateDragInfo02
524  * @tc.type: FUNC
525  */
526 HWTEST_F(DragControllerTest, UpdateDragInfo02, Function | SmallTest | Level2)
527 {
528     uint32_t windowId = 1;
529     sptr<DragController> dragcontroller = new DragController(windowRoot_);
530     dragcontroller->UpdateDragInfo(windowId);
531     sptr<WindowNode> dragNode = windowRoot_->GetWindowNode(windowId);
532     ASSERT_EQ(dragNode, nullptr);
533 }
534 
535 /**
536  * @tc.name: StartDrag01
537  * @tc.desc: StartDrag01
538  * @tc.type: FUNC
539  */
540 HWTEST_F(DragControllerTest, StartDrag01, Function | SmallTest | Level2)
541 {
542     uint32_t windowId = 1;
543     sptr<DragController> dragcontroller = new DragController(windowRoot_);
544     dragcontroller->StartDrag(windowId);
545     sptr<WindowNode> dragNode = windowRoot_->GetWindowNode(windowId);
546     ASSERT_EQ(dragNode, nullptr);
547 }
548 
549 /**
550  * @tc.name: FinishDrag01
551  * @tc.desc: FinishDrag01
552  * @tc.type: FUNC
553  */
554 HWTEST_F(DragControllerTest, FinishDrag01, Function | SmallTest | Level2)
555 {
556     uint32_t windowId = 1;
557     sptr<DragController> dragcontroller = new DragController(windowRoot_);
558     dragcontroller->FinishDrag(windowId);
559     sptr<WindowNode> dragNode = windowRoot_->GetWindowNode(windowId);
560     ASSERT_EQ(dragNode, nullptr);
561 }
562 
563 /**
564  * @tc.name: GetHitWindow01
565  * @tc.desc: GetHitWindow01
566  * @tc.type: FUNC
567  */
568 HWTEST_F(DragControllerTest, GetHitWindow01, Function | SmallTest | Level2)
569 {
570     DisplayId id = 0;
571     PointInfo point;
572     point.x = 1;
573     point.y = 1;
574     sptr<DragController> dragcontroller = new DragController(windowRoot_);
575     ASSERT_EQ(nullptr, dragcontroller->GetHitWindow(id, point));
576 }
577 
578 /**
579  * @tc.name: GetHitWindow02
580  * @tc.desc: GetHitWindow02
581  * @tc.type: FUNC
582  */
583 HWTEST_F(DragControllerTest, GetHitWindow02, Function | SmallTest | Level2)
584 {
585     DisplayId id = DISPLAY_ID_INVALID;
586     PointInfo point;
587     point.x = 1;
588     point.y = 2;
589     sptr<DragController> dragcontroller = new DragController(windowRoot_);
590     ASSERT_EQ(nullptr, dragcontroller->GetHitWindow(id, point));
591 }
592 
593 /**
594  * @tc.name: GetHitWindow03
595  * @tc.desc: GetHitWindow03
596  * @tc.type: FUNC
597  */
598 HWTEST_F(DragControllerTest, GetHitWindow03, Function | SmallTest | Level2)
599 {
600     DisplayId id = 1;
601     PointInfo point;
602     point.x = 1;
603     point.y = 2;
604     sptr<DragController> dragcontroller = new DragController(windowRoot_);
605     sptr<WindowNodeContainer> container = windowRoot_->GetOrCreateWindowNodeContainer(id);
606     ASSERT_EQ(nullptr, container);
607     ASSERT_EQ(nullptr, dragcontroller->GetHitWindow(id, point));
608 }
609 
610 /**
611  * @tc.name: Init01
612  * @tc.desc: Init01
613  * @tc.type: FUNC
614  */
615 HWTEST_F(DragControllerTest, Init02, Function | SmallTest | Level2)
616 {
617     ASSERT_TRUE(moveDragController_);
618     auto ret = moveDragController_->Init();
619     ASSERT_EQ(true, ret);
620 }
621 
622 /**
623  * @tc.name: StartDrag02
624  * @tc.desc: StartDrag
625  * @tc.type: FUNC
626  */
627 HWTEST_F(DragControllerTest, StartDrag02, Function | SmallTest | Level2)
628 {
629     uint32_t windowId = 0;
630     sptr<DragController> dragcontroller = new DragController(windowRoot_);
631     dragcontroller->StartDrag(windowId);
632     sptr<WindowNode> dragNode = nullptr;
633     ASSERT_TRUE(moveDragController_);
634 }
635 
636 /**
637  * @tc.name: FinishDrag02
638  * @tc.desc: FinishDrag
639  * @tc.type: FUNC
640  */
641 HWTEST_F(DragControllerTest, FinishDrag02, Function | SmallTest | Level2)
642 {
643     uint32_t windowId = 0;
644     sptr<DragController> dragcontroller = new DragController(windowRoot_);
645     dragcontroller->StartDrag(windowId);
646     uint64_t hitWindowId_ = 10;
647     sptr<WindowNode> hitWindow = windowRoot_->GetWindowNode(hitWindowId_);
648     ASSERT_TRUE(moveDragController_);
649 }
650 
651 /**
652  * @tc.name: GetHitWindow04
653  * @tc.desc: GetHitWindow04
654  * @tc.type: FUNC
655  */
656 HWTEST_F(DragControllerTest, GetHitWindow04, Function | SmallTest | Level2)
657 {
658     DisplayId id = 0;
659     PointInfo point;
660     sptr<DragController> dragcontroller = new DragController(windowRoot_);
661     ASSERT_EQ(nullptr, dragcontroller->GetHitWindow(id, point));
662 }
663 
664 /**
665  * @tc.name: GetHitPoint
666  * @tc.desc: GetHitPoint
667  * @tc.type: FUNC
668  */
669 HWTEST_F(DragControllerTest, GetHitPoint, Function | SmallTest | Level2)
670 {
671     uint32_t windowId = 0;
672     PointInfo point;
673     sptr<DragController> dragcontroller = new DragController(windowRoot_);
674     auto result = dragcontroller->GetHitPoint(windowId, point);
675     sptr<WindowNode> windowNode = nullptr;
676     ASSERT_EQ(result, false);
677 }
678 
679 /**
680  * @tc.name: HandleEndUpMovingOrDragging01
681  * @tc.desc: HandleEndUpMovingOrDragging01
682  * @tc.type: FUNC
683  */
684 HWTEST_F(DragControllerTest, HandleEndUpMovingOrDragging01, Function | SmallTest | Level2)
685 {
686     ASSERT_TRUE(moveDragController_);
687     uint32_t windowId = 1; // windowId: 1
688     uint32_t activeWindowId_ = INVALID_WINDOW_ID;
689     ASSERT_NE(activeWindowId_, windowId);
690     moveDragController_->HandleEndUpMovingOrDragging(windowId);
691 }
692 
693 /**
694  * @tc.name: HandleDisplayLimitRectChange
695  * @tc.desc: HandleDisplayLimitRectChange
696  * @tc.type: FUNC
697  */
698 HWTEST_F(DragControllerTest, HandleDisplayLimitRectChange, Function | SmallTest | Level2)
699 {
700     std::map<DisplayId, Rect> limitRectMap;
701     moveDragController_->HandleDisplayLimitRectChange(limitRectMap);
702     ASSERT_TRUE(moveDragController_);
703 }
704 }
705 } // namespace Rosen
706 } // namespace OHOS