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
24using namespace testing;
25using namespace testing::ext;
26
27namespace OHOS {
28namespace Rosen {
29constexpr uint32_t WINDOW_ID = 1000;
30class DragControllerTest : public testing::Test {
31public:
32    static void SetUpTestCase();
33    static void TearDownTestCase();
34    void SetUp() override;
35    void TearDown() override;
36    static sptr<WindowRoot> windowRoot_;
37private:
38    static sptr<MoveDragController> moveDragController_;
39    static std::shared_ptr<MMI::IInputEventConsumer> inputListener_;
40};
41
42sptr<MoveDragController> DragControllerTest::moveDragController_ = nullptr;
43std::shared_ptr<MMI::IInputEventConsumer> DragControllerTest::inputListener_ = nullptr;
44sptr<WindowRoot> DragControllerTest::windowRoot_ = nullptr;
45
46void 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
62void DragControllerTest::TearDownTestCase()
63{
64    moveDragController_ = nullptr;
65    inputListener_ = nullptr;
66    WindowInnerManager::GetInstance().Stop();
67}
68
69void DragControllerTest::SetUp()
70{
71    windowRoot_ = new WindowRoot(nullptr);
72}
73
74void DragControllerTest::TearDown()
75{
76    windowRoot_ = nullptr;
77}
78
79namespace {
80/**
81 * @tc.name: OnInputEvent01
82 * @tc.desc: OnInputEven01, keyEvent
83 * @tc.type: FUNC
84 */
85HWTEST_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 */
99HWTEST_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 */
113HWTEST_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 */
131HWTEST_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 */
144HWTEST_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 */
158HWTEST_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 */
180HWTEST_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 */
206HWTEST_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 */
223HWTEST_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 */
242HWTEST_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 */
257HWTEST_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 */
273HWTEST_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 */
288HWTEST_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 */
338HWTEST_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 */
373HWTEST_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 */
413HWTEST_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 */
448HWTEST_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 */
513HWTEST_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 */
526HWTEST_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 */
540HWTEST_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 */
554HWTEST_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 */
568HWTEST_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 */
583HWTEST_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 */
598HWTEST_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 */
615HWTEST_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 */
627HWTEST_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 */
641HWTEST_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 */
656HWTEST_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 */
669HWTEST_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 */
684HWTEST_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 */
698HWTEST_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