1 /*
2 * Copyright (c) 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 #include <memory>
18 #include <pointer_event.h>
19 #include "session/host/include/move_drag_controller.h"
20 #include "session/host/include/session.h"
21 #include "ui/rs_surface_node.h"
22 #include "window_manager_hilog.h"
23 #include "session/host/include/scene_session.h"
24 #include "session/screen/include/screen_session.h"
25 #include "screen_session_manager_client/include/screen_session_manager_client.h"
26 #include "screen_manager.h"
27 #include "scene_board_judgement.h"
28 #include "window_scene.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35 class MoveDragControllerTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp() override;
40 void TearDown() override;
41 sptr<MoveDragController> moveDragController;
42 sptr<Session> session_;
43 };
44
SetUpTestCase()45 void MoveDragControllerTest::SetUpTestCase()
46 {
47 }
48
TearDownTestCase()49 void MoveDragControllerTest::TearDownTestCase()
50 {
51 }
52
SetUp()53 void MoveDragControllerTest::SetUp()
54 {
55 SessionInfo info;
56 info.abilityName_ = "testSession1";
57 info.moduleName_ = "testSession2";
58 info.bundleName_ = "testSession3";
59 session_ = sptr<Session>::MakeSptr(info);
60 moveDragController = sptr<MoveDragController>::MakeSptr(session_->GetPersistentId(), session_->GetWindowType());
61 }
62
TearDown()63 void MoveDragControllerTest::TearDown()
64 {
65 session_ = nullptr;
66 moveDragController = nullptr;
67 }
68
69 namespace {
70 /**
71 * @tc.name: SetStartMoveFlag
72 * @tc.desc: test function : SetStartMoveFlag
73 * @tc.type: FUNC
74 */
75 HWTEST_F(MoveDragControllerTest, SetStartMoveFlag, Function | SmallTest | Level1)
76 {
77 moveDragController->hasPointDown_ = false;
78 moveDragController->SetStartMoveFlag(true);
79 ASSERT_FALSE(moveDragController->isStartMove_);
80 moveDragController->hasPointDown_ = true;
81 moveDragController->SetStartMoveFlag(true);
82 ASSERT_TRUE(moveDragController->isStartMove_);
83 moveDragController->hasPointDown_ = false;
84 }
85
86 /**
87 * @tc.name: GetStartMoveFlag
88 * @tc.desc: test function : GetStartMoveFlag
89 * @tc.type: FUNC
90 */
91 HWTEST_F(MoveDragControllerTest, GetStartMoveFlag, Function | SmallTest | Level1)
92 {
93 auto preIsStartMove = moveDragController->isStartMove_;
94 auto preHasPointDown = moveDragController->hasPointDown_;
95 moveDragController->hasPointDown_ = false;
96 moveDragController->SetStartMoveFlag(true);
97 bool res = moveDragController->GetStartMoveFlag();
98 ASSERT_EQ(preIsStartMove, res);
99 moveDragController->SetStartMoveFlag(false);
100 res = moveDragController->GetStartMoveFlag();
101 ASSERT_EQ(false, res);
102 moveDragController->hasPointDown_ = true;
103 moveDragController->SetStartMoveFlag(true);
104 res = moveDragController->GetStartMoveFlag();
105 ASSERT_EQ(true, res);
106 moveDragController->SetStartMoveFlag(false);
107 res = moveDragController->GetStartMoveFlag();
108 ASSERT_EQ(false, res);
109 moveDragController->isStartMove_ = preIsStartMove;
110 moveDragController->hasPointDown_ = preHasPointDown;
111 }
112
113 /**
114 * @tc.name: GetStartDragFlag
115 * @tc.desc: test function : GetStartDragFlag
116 * @tc.type: FUNC
117 */
118 HWTEST_F(MoveDragControllerTest, GetStartDragFlag, Function | SmallTest | Level1)
119 {
120 bool res = moveDragController->GetStartDragFlag();
121 ASSERT_EQ(false, res);
122 }
123
124 /**
125 * @tc.name: GetMoveDragStartDisplayId
126 * @tc.desc: test function : GetMoveDragStartDisplayId
127 * @tc.type: FUNC
128 */
129 HWTEST_F(MoveDragControllerTest, GetMoveDragStartDisplayId, Function | SmallTest | Level1)
130 {
131 uint64_t res = moveDragController->GetMoveDragStartDisplayId();
132 ASSERT_EQ(-1ULL, res);
133 }
134
135 /**
136 * @tc.name: GetMoveDragEndDisplayId
137 * @tc.desc: test function : GetMoveDragEndDisplayId
138 * @tc.type: FUNC
139 */
140 HWTEST_F(MoveDragControllerTest, GetMoveDragEndDisplayId, Function | SmallTest | Level1)
141 {
142 uint64_t res = moveDragController->GetMoveDragEndDisplayId();
143 ASSERT_EQ(-1ULL, res);
144 }
145
146 /**
147 * @tc.name: GetInitParentNodeId
148 * @tc.desc: test function : GetInitParentNodeId
149 * @tc.type: FUNC
150 */
151 HWTEST_F(MoveDragControllerTest, GetInitParentNodeId, Function | SmallTest | Level1)
152 {
153 uint64_t res = moveDragController->GetInitParentNodeId();
154 ASSERT_EQ(-1ULL, res);
155 }
156
157 /**
158 * @tc.name: GetDisplayIdsDuringMoveDrag
159 * @tc.desc: test function : GetDisplayIdsDuringMoveDrag
160 * @tc.type: FUNC
161 */
162 HWTEST_F(MoveDragControllerTest, GetDisplayIdsDuringMoveDrag, Function | SmallTest | Level1)
163 {
164 std::set<uint64_t> res = moveDragController->GetDisplayIdsDuringMoveDrag();
165 ASSERT_EQ(true, res.empty());
166 }
167
168 /**
169 * @tc.name: GetTargetRect
170 * @tc.desc: test function : GetTargetRect
171 * @tc.type: FUNC
172 */
173 HWTEST_F(MoveDragControllerTest, GetTargetRect, Function | SmallTest | Level1)
174 {
175 uint32_t tmp = 0;
176 int32_t pos = 0;
177 moveDragController->InitMoveDragProperty();
178 WSRect res = moveDragController->GetTargetRect(MoveDragController::TargetRectCoordinate::GLOBAL);
179 ASSERT_EQ(tmp, res.height_);
180 ASSERT_EQ(tmp, res.width_);
181 ASSERT_EQ(pos, res.posX_);
182 ASSERT_EQ(pos, res.posY_);
183
184 res = moveDragController->GetTargetRect(MoveDragController::TargetRectCoordinate::RELATED_TO_START_DISPLAY);
185 ASSERT_EQ(tmp, res.height_);
186 ASSERT_EQ(tmp, res.width_);
187 ASSERT_EQ(pos, res.posX_);
188 ASSERT_EQ(pos, res.posY_);
189 }
190
191 /**
192 * @tc.name: InitMoveDragProperty
193 * @tc.desc: test function : InitMoveDragProperty
194 * @tc.type: FUNC
195 */
196 HWTEST_F(MoveDragControllerTest, InitMoveDragProperty, Function | SmallTest | Level1)
197 {
198 int32_t res = 0;
199 moveDragController->InitMoveDragProperty();
200 ASSERT_EQ(0, res);
201 }
202
203 /**
204 * @tc.name: InitCrossDisplayProperty
205 * @tc.desc: test function : InitCrossDisplayProperty
206 * @tc.type: FUNC
207 */
208 HWTEST_F(MoveDragControllerTest, InitCrossDisplayProperty, Function | SmallTest | Level1)
209 {
210 moveDragController->InitCrossDisplayProperty(1, 2);
211 ASSERT_EQ(1, moveDragController->GetMoveDragStartDisplayId());
212 ASSERT_EQ(2, moveDragController->GetInitParentNodeId());
213 ASSERT_EQ(true, moveDragController->GetDisplayIdsDuringMoveDrag().find(1) !=
214 moveDragController->GetDisplayIdsDuringMoveDrag().end());
215 ScreenId screenId = 1;
216 ScreenSessionConfig config;
217 sptr<ScreenSession> screenSession =
218 sptr<ScreenSession>::MakeSptr(config, ScreenSessionReason::CREATE_SESSION_FOR_CLIENT);
219 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(screenId, screenSession));
220 moveDragController->InitCrossDisplayProperty(1, 2);
221 ASSERT_EQ(1, moveDragController->GetMoveDragStartDisplayId());
222 ASSERT_EQ(2, moveDragController->GetInitParentNodeId());
223 ASSERT_EQ(true, moveDragController->GetDisplayIdsDuringMoveDrag().find(1) !=
224 moveDragController->GetDisplayIdsDuringMoveDrag().end());
225 }
226
227 /**
228 * @tc.name: SetOriginalMoveDragPos
229 * @tc.desc: test function : SetOriginalMoveDragPos
230 * @tc.type: FUNC
231 */
232 HWTEST_F(MoveDragControllerTest, SetOriginalMoveDragPos, Function | SmallTest | Level1)
233 {
234 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
235 int32_t pointerId = pointerEvent->GetPointerId();
236 int32_t pointerType = pointerEvent->GetSourceType();
237 int32_t pointerPosX = 10;
238 int32_t pointerPosY = 30;
239 int32_t pointerWindowX = 10;
240 int32_t pointerWindowY = 10;
241 WSRect winRect = { 100, 100, 1000, 1000 };
242 moveDragController->SetOriginalMoveDragPos(
243 pointerId, pointerType, pointerPosX, pointerPosY, pointerWindowX, pointerWindowY, winRect);
244 ASSERT_EQ(moveDragController->moveDragProperty_.pointerId_, pointerId);
245 ASSERT_EQ(moveDragController->moveDragProperty_.pointerType_, pointerType);
246 ASSERT_EQ(moveDragController->moveDragProperty_.originalPointerPosX_, pointerPosX);
247 ASSERT_EQ(moveDragController->moveDragProperty_.originalPointerPosY_, pointerPosY);
248 ASSERT_EQ(moveDragController->moveDragProperty_.originalPointerWindowX_, pointerWindowX);
249 ASSERT_EQ(moveDragController->moveDragProperty_.originalPointerWindowY_, pointerWindowY);
250 ASSERT_EQ(moveDragController->moveDragProperty_.originalRect_, winRect);
251 }
252
253 /**
254 * @tc.name: SetAspectRatio
255 * @tc.desc: test function : SetAspectRatio
256 * @tc.type: FUNC
257 */
258 HWTEST_F(MoveDragControllerTest, SetAspectRatio, Function | SmallTest | Level1)
259 {
260 moveDragController->SetAspectRatio(0.5);
261 ASSERT_EQ(moveDragController->aspectRatio_, 0.5);
262 }
263
264 /**
265 * @tc.name: UpdateGravityWhenDrag
266 * @tc.desc: test function : UpdateGravityWhenDrag
267 * @tc.type: FUNC
268 */
269 HWTEST_F(MoveDragControllerTest, UpdateGravityWhenDrag, Function | SmallTest | Level1)
270 {
271 struct RSSurfaceNodeConfig config;
272 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
273 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
274 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
275 ASSERT_NE(nullptr, surfaceNode);
276 ASSERT_NE(nullptr, pointerEvent);
277 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
278 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
279 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
280 auto tempPointerEvent = pointerEvent;
281 pointerEvent = nullptr;
282 moveDragController->UpdateGravityWhenDrag(pointerEvent, surfaceNode);
283 pointerEvent = tempPointerEvent;
284 auto tempSurfaceNode = surfaceNode;
285 surfaceNode = nullptr;
286 moveDragController->UpdateGravityWhenDrag(pointerEvent, surfaceNode);
287 surfaceNode = tempSurfaceNode;
288 moveDragController->type_ = AreaType::UNDEFINED;
289 moveDragController->UpdateGravityWhenDrag(pointerEvent, surfaceNode);
290 moveDragController->type_ = AreaType::RIGHT;
291 moveDragController->UpdateGravityWhenDrag(pointerEvent, surfaceNode);
292
293 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
294 moveDragController->UpdateGravityWhenDrag(pointerEvent, surfaceNode);
295
296 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
297 moveDragController->UpdateGravityWhenDrag(pointerEvent, surfaceNode);
298
299 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
300 moveDragController->UpdateGravityWhenDrag(pointerEvent, surfaceNode);
301
302 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
303 moveDragController->UpdateGravityWhenDrag(pointerEvent, surfaceNode);
304 }
305 }
306
307 /**
308 * @tc.name: CalcMoveTargetRect
309 * @tc.desc: test function : CalcMoveTargetRect
310 * @tc.type: FUNC
311 */
312 HWTEST_F(MoveDragControllerTest, CalcMoveTargetRect, Function | SmallTest | Level1)
313 {
314 int32_t res = 0;
315 moveDragController->InitMoveDragProperty();
316 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
317 WSRect originalRect = { 100, 100, 1000, 1000 };
318
319 moveDragController->CalcMoveTargetRect(pointerEvent, originalRect);
320 ASSERT_EQ(0, res);
321
322 pointerEvent = MMI::PointerEvent::Create();
323 int32_t pointerId = pointerEvent->GetPointerId();
324 int32_t pointerType = pointerEvent->GetSourceType();
325 int32_t pointerPosX = 10;
326 int32_t pointerPosY = 30;
327 int32_t pointerWindowX = 10;
328 int32_t pointerWindowY = 10;
329 moveDragController->SetOriginalMoveDragPos(
330 pointerId, pointerType, pointerPosX, pointerPosY, pointerWindowX, pointerWindowY, originalRect);
331 moveDragController->CalcMoveTargetRect(pointerEvent, originalRect);
332 ASSERT_EQ(0, res);
333 }
334
335 /**
336 * @tc.name: CalcMoveInputBarRect
337 * @tc.desc: test function : CalcMoveInputBarRect
338 * @tc.type: FUNC
339 */
340 HWTEST_F(MoveDragControllerTest, CalcMoveInputBarRect, Function | SmallTest | Level1)
341 {
342 moveDragController->InitMoveDragProperty();
343 moveDragController->SetMoveAvailableArea({0, 75, 3120, 1980});
344 moveDragController->SetMoveInputBarStartDisplayId(1);
345 WSRect originalRect = {10, 20, 336, 146};
346
347 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
348 pointerEvent->SetTargetDisplayId(1);
349 pointerEvent->SetPointerId(1);
350 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
351 MMI::PointerEvent::PointerItem pointerItem;
352 pointerItem.SetPointerId(1);
353 pointerItem.SetDisplayX(100);
354 pointerItem.SetDisplayY(200);
355 pointerEvent->AddPointerItem(pointerItem);
356 int32_t pointerPosX = 10;
357 int32_t pointerPosY = 30;
358 int32_t pointerWindowX = 10;
359 int32_t pointerWindowY = 10;
360 moveDragController->SetOriginalMoveDragPos(pointerEvent->GetPointerId(),
361 pointerEvent->GetSourceType(), pointerPosX, pointerPosY, pointerWindowX,
362 pointerWindowY, originalRect);
363 moveDragController->CalcMoveInputBarRect(pointerEvent, originalRect);
364
365 ASSERT_EQ(90, moveDragController->moveDragProperty_.targetRect_.posX_);
366 ASSERT_EQ(190, moveDragController->moveDragProperty_.targetRect_.posY_);
367 }
368
369 /**
370 * @tc.name: AdjustTargetPositionByAvailableArea
371 * @tc.desc: test function : AdjustTargetPositionByAvailableArea
372 * @tc.type: FUNC
373 */
374 HWTEST_F(MoveDragControllerTest, AdjustTargetPositionByAvailableArea, Function | SmallTest | Level1)
375 {
376 DMRect moveAvailableArea = {0, 75, 3120, 1980};
377 WSRect originalRect = {10, 20, 336, 146};
378 moveDragController->moveAvailableArea_ = moveAvailableArea;
379 moveDragController->moveDragProperty_.originalRect_ = originalRect;
380
381 int32_t x;
382 int32_t y;
383
384 x = 50, y = 100;
385 moveDragController->AdjustTargetPositionByAvailableArea(x, y);
386 EXPECT_EQ(x, 50);
387 EXPECT_EQ(y, 100);
388
389 x = -10, y = 100;
390 moveDragController->AdjustTargetPositionByAvailableArea(x, y);
391 EXPECT_EQ(x, 0);
392 EXPECT_EQ(y, 100);
393
394 x = 3200, y = 200;
395 moveDragController->AdjustTargetPositionByAvailableArea(x, y);
396 EXPECT_EQ(x, 2784);
397 EXPECT_EQ(y, 200);
398
399 x = 100, y = 60;
400 moveDragController->AdjustTargetPositionByAvailableArea(x, y);
401 EXPECT_EQ(x, 100);
402 EXPECT_EQ(y, 75);
403
404 x = 100, y = 1980;
405 moveDragController->AdjustTargetPositionByAvailableArea(x, y);
406 EXPECT_EQ(x, 100);
407 EXPECT_EQ(y, 1909);
408 }
409
410 /**
411 * @tc.name: EventDownInit
412 * @tc.desc: test function : EventDownInit
413 * @tc.type: FUNC
414 */
415 HWTEST_F(MoveDragControllerTest, EventDownInit, Function | SmallTest | Level1)
416 {
417 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
418 SystemSessionConfig sysConfig;
419 moveDragController->InitMoveDragProperty();
420 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
421 WSRect originalRect = { 100, 100, 1000, 1000 };
422
423 pointerEvent = MMI::PointerEvent::Create();
424 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_RIGHT);
425 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
426
427 auto res = moveDragController->EventDownInit(pointerEvent, originalRect, property, sysConfig);
428 ASSERT_EQ(false, res);
429 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
430 pointerEvent->SetTargetDisplayId(0);
431 MMI::PointerEvent::PointerItem pointerItem;
432 pointerItem.SetPointerId(0);
433 originalRect = { 10, 10, 10, 10 };
434 pointerItem.SetWindowX(100000000);
435 pointerItem.SetWindowY(100000000);
436 pointerEvent->AddPointerItem(pointerItem);
437 res = moveDragController->EventDownInit(pointerEvent, originalRect, property, sysConfig);
438 ASSERT_EQ(true, res);
439 }
440
441 /**
442 * @tc.name: EventDownInit01
443 * @tc.desc: test function : EventDownInit
444 * @tc.type: FUNC
445 */
446 HWTEST_F(MoveDragControllerTest, EventDownInit01, Function | SmallTest | Level1)
447 {
448 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
449 property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
450 property->SetDecorEnable(true);
451
452 SystemSessionConfig sysConfig;
453 moveDragController->InitMoveDragProperty();
454 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
455 WSRect originalRect = { 100, 100, 1000, 1000 };
456 MMI::PointerEvent::PointerItem pointerItem;
457 pointerItem.SetPointerId(1);
458 pointerItem.SetWindowX(1);
459 pointerItem.SetWindowY(1);
460 pointerEvent->AddPointerItem(pointerItem);
461 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
462 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
463 auto res = moveDragController->EventDownInit(pointerEvent, originalRect, property, sysConfig);
464 ASSERT_EQ(true, res);
465 }
466
467 /**
468 * @tc.name: CalcFreeformTargetRect
469 * @tc.desc: test function : CalcFreeformTargetRect
470 * @tc.type: FUNC
471 */
472 HWTEST_F(MoveDragControllerTest, CalcFreeformTargetRect, Function | SmallTest | Level1)
473 {
474 AreaType type = AreaType::RIGHT;
475 WSRect originalRect = { 100, 100, 1000, 1000 };
476 int32_t tranX = 10;
477 int32_t tranY = 30;
478 ASSERT_TRUE((moveDragController != nullptr));
479 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
480 type = AreaType::LEFT;
481 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
482 type = AreaType::RIGHT;
483 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
484 type = AreaType::BOTTOM;
485 ASSERT_TRUE((moveDragController != nullptr));
486 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
487 originalRect = { 100, 100, 1000, 0 };
488 ASSERT_TRUE((moveDragController != nullptr));
489 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
490 originalRect = { 100, 100, 500, 100 };
491 moveDragController->limits_ = { 3, 3, 3, 3, 2.0, 2.0 };
492 ASSERT_TRUE((moveDragController != nullptr));
493 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
494 type = AreaType::RIGHT;
495 originalRect = { 100, 100, 500, 0 };
496 ASSERT_TRUE((moveDragController != nullptr));
497 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
498 originalRect = { 100, 100, 100, 100 };
499 ASSERT_TRUE((moveDragController != nullptr));
500 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
501 type = AreaType::UNDEFINED;
502 originalRect = { 100, 100, 500, 100 };
503 ASSERT_TRUE((moveDragController != nullptr));
504 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
505 type = AreaType::RIGHT;
506 ASSERT_TRUE((moveDragController != nullptr));
507 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
508 moveDragController->limits_ = { 3, 3, 3, 3, 0.0001, 0.0001 };
509 ASSERT_TRUE((moveDragController != nullptr));
510 moveDragController->CalcFreeformTargetRect(type, tranX, tranY, originalRect);
511 }
512
513 /**
514 * @tc.name: CalcFixedAspectRatioTargetRect01
515 * @tc.desc: test function : CalcFixedAspectRatioTargetRect01
516 * @tc.type: FUNC
517 */
518 HWTEST_F(MoveDragControllerTest, CalcFixedAspectRatioTargetRect01, Function | SmallTest | Level1)
519 {
520 AreaType type = AreaType::RIGHT;
521 float aspectRatio = 0.5;
522 WSRect originalRect = { 100, 100, 1000, 1000 };
523 int32_t tranX = 0;
524 int32_t tranY = 0;
525 ASSERT_TRUE((moveDragController != nullptr));
526 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
527 }
528
529 /**
530 * @tc.name: CalcFixedAspectRatioTargetRect02
531 * @tc.desc: test function : CalcFixedAspectRatioTargetRect02
532 * @tc.type: FUNC
533 */
534 HWTEST_F(MoveDragControllerTest, CalcFixedAspectRatioTargetRect02, Function | SmallTest | Level1)
535 {
536 AreaType type = AreaType::RIGHT;
537 float aspectRatio = 0.5;
538 WSRect originalRect = { 100, 100, 1000, 1000 };
539 int32_t tranX = 20;
540 int32_t tranY = 20;
541 ASSERT_TRUE((moveDragController != nullptr));
542 type = AreaType::UNDEFINED;
543 moveDragController->mainMoveAxis_ = MoveDragController::AxisType::UNDEFINED;
544 tranX = 0;
545 tranY = 0;
546 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
547 type = AreaType::RIGHT;
548 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
549 moveDragController->mainMoveAxis_ = MoveDragController::AxisType::X_AXIS;
550 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
551 type = AreaType::LEFT_TOP;
552 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
553 type = AreaType::RIGHT_TOP;
554 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
555 type = AreaType::RIGHT_BOTTOM;
556 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
557 type = AreaType::LEFT_BOTTOM;
558 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
559 type = AreaType::LEFT;
560 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
561 type = AreaType::TOP;
562 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
563 type = AreaType::RIGHT;
564 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
565 type = AreaType::BOTTOM;
566 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
567 type = AreaType::UNDEFINED;
568 moveDragController->CalcFixedAspectRatioTargetRect(type, tranX, tranY, aspectRatio, originalRect);
569 }
570
571 /**
572 * @tc.name: CalcFreeformTranslateLimits01
573 * @tc.desc: test function : CalcFreeformTranslateLimits01
574 * @tc.type: FUNC
575 */
576 HWTEST_F(MoveDragControllerTest, CalcFreeformTranslateLimits01, Function | SmallTest | Level1)
577 {
578 AreaType type = AreaType::RIGHT;
579 ASSERT_TRUE((moveDragController != nullptr));
580 moveDragController->CalcFreeformTranslateLimits(type);
581 type = AreaType::BOTTOM;
582 moveDragController->CalcFreeformTranslateLimits(type);
583 type = AreaType::TOP;
584 moveDragController->CalcFreeformTranslateLimits(type);
585 type = AreaType::LEFT;
586 moveDragController->CalcFreeformTranslateLimits(type);
587 }
588
589 /**
590 * @tc.name: CalcFixedAspectRatioTranslateLimits01
591 * @tc.desc: test function : CalcFixedAspectRatioTranslateLimits01
592 * @tc.type: FUNC
593 */
594 HWTEST_F(MoveDragControllerTest, CalcFixedAspectRatioTranslateLimits01, Function | SmallTest | Level1)
595 {
596 moveDragController->limits_ = { 30, 60, 30, 60, 2.0, 2.0 };
597 moveDragController->aspectRatio_ = 1.0f;
598 AreaType type = AreaType::RIGHT;
599 ASSERT_TRUE((moveDragController != nullptr));
600 moveDragController->isDecorEnable_ = true;
601 moveDragController->CalcFixedAspectRatioTranslateLimits(type);
602 moveDragController->isDecorEnable_ = false;
603 moveDragController->CalcFixedAspectRatioTranslateLimits(type);
604 moveDragController->limits_ = { 60, 60, 60, 60, 2.0, 2.0 };
605 moveDragController->CalcFixedAspectRatioTranslateLimits(type);
606 type = AreaType::LEFT;
607 moveDragController->CalcFixedAspectRatioTranslateLimits(type);
608 type = AreaType::BOTTOM;
609 moveDragController->CalcFixedAspectRatioTranslateLimits(type);
610 type = AreaType::TOP;
611 moveDragController->CalcFixedAspectRatioTranslateLimits(type);
612 }
613
614 /**
615 * @tc.name: FixTranslateByLimits01
616 * @tc.desc: test function : FixTranslateByLimits01
617 * @tc.type: FUNC
618 */
619 HWTEST_F(MoveDragControllerTest, FixTranslateByLimits01, Function | SmallTest | Level1)
620 {
621 int32_t tranX = 100;
622 int32_t tranY = 100;
623 moveDragController->maxTranX_ = 50;
624 moveDragController->maxTranY_ = 50;
625 ASSERT_TRUE((moveDragController != nullptr));
626 moveDragController->FixTranslateByLimits(tranX, tranY);
627 tranX = 10;
628 moveDragController->FixTranslateByLimits(tranX, tranY);
629 tranY = 10;
630 moveDragController->FixTranslateByLimits(tranX, tranY);
631 }
632
633 /**
634 * @tc.name: InitMainAxis01
635 * @tc.desc: test function : InitMainAxis01
636 * @tc.type: FUNC
637 */
638 HWTEST_F(MoveDragControllerTest, InitMainAxis01, Function | SmallTest | Level1)
639 {
640 AreaType type = AreaType::LEFT;
641 int32_t tranX = 100;
642 int32_t tranY = 100;
643 ASSERT_TRUE((moveDragController != nullptr));
644 moveDragController->InitMainAxis(type, tranX, tranY);
645 type = AreaType::RIGHT;
646 moveDragController->InitMainAxis(type, tranX, tranY);
647 type = AreaType::TOP;
648 moveDragController->InitMainAxis(type, tranX, tranY);
649 type = AreaType::BOTTOM;
650 moveDragController->InitMainAxis(type, tranX, tranY);
651 type = AreaType::UNDEFINED;
652 tranX = 0;
653 tranY = 0;
654 moveDragController->InitMainAxis(type, tranX, tranY);
655 tranY = 1;
656 moveDragController->InitMainAxis(type, tranX, tranY);
657 }
658
659 /**
660 * @tc.name: ConvertXYByAspectRatio01
661 * @tc.desc: test function : ConvertXYByAspectRatio01
662 * @tc.type: FUNC
663 */
664 HWTEST_F(MoveDragControllerTest, ConvertXYByAspectRatio01, Function | SmallTest | Level1)
665 {
666 float aspectRatio = 1.0f;
667 int32_t tx = 100;
668 int32_t ty = 100;
669 moveDragController->mainMoveAxis_ = MoveDragController::AxisType::X_AXIS;
670 ASSERT_TRUE((moveDragController != nullptr));
671 moveDragController->ConvertXYByAspectRatio(tx, ty, aspectRatio);
672 moveDragController->mainMoveAxis_ = MoveDragController::AxisType::Y_AXIS;
673 moveDragController->ConvertXYByAspectRatio(tx, ty, aspectRatio);
674 }
675
676 /**
677 * @tc.name: InitDecorValue01
678 * @tc.desc: test function : InitDecorValue01
679 * @tc.type: FUNC
680 */
681 HWTEST_F(MoveDragControllerTest, InitDecorValue01, Function | SmallTest | Level1)
682 {
683 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
684 SystemSessionConfig sysConfig;
685 ASSERT_TRUE((moveDragController != nullptr));
686 moveDragController->InitDecorValue(property, sysConfig);
687 }
688
689 /**
690 * @tc.name: ConsumeMoveEvent
691 * @tc.desc: test function : ConsumeMoveEvent
692 * @tc.type: FUNC
693 */
694 HWTEST_F(MoveDragControllerTest, ConsumeMoveEvent, Function | SmallTest | Level1)
695 {
696 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
697 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
698 ASSERT_NE(nullptr, pointerEvent);
699 WSRect originalRect = { 100, 100, 1000, 1000 };
700 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(nullptr, originalRect));
701 auto preStratDragFlag = moveDragController->GetStartDragFlag();
702 moveDragController->isStartDrag_ = true;
703 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
704 moveDragController->isStartDrag_ = false;
705 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
706 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
707 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
708 pointerEvent->SetSourceType(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
709 moveDragController->SetStartMoveFlag(false);
710 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
711 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
712 moveDragController->hasPointDown_ = false;
713 moveDragController->moveDragIsInterrupted_ = true;
714 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
715 moveDragController->moveDragIsInterrupted_ = false;
716 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
717 moveDragController->hasPointDown_ = true;
718 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
719 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
720 moveDragController->SetStartMoveFlag(true);
721 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
722 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
723 moveDragController->moveDragIsInterrupted_ = true;
724 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
725 moveDragController->moveDragIsInterrupted_ = false;
726 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN);
727 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
728 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UNKNOWN);
729 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
730 moveDragController->moveDragProperty_.pointerId_ = -2;
731 moveDragController->moveDragProperty_.pointerType_ = -2;
732 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
733 ASSERT_EQ(false, moveDragController->ConsumeMoveEvent(pointerEvent, originalRect));
734 moveDragController->isStartDrag_ = preStratDragFlag;
735 }
736 }
737
738 /**
739 * @tc.name: ProcessWindowDragHotAreaFunc
740 * @tc.desc: test function : ProcessWindowDragHotAreaFunc
741 * @tc.type: FUNC
742 */
743 HWTEST_F(MoveDragControllerTest, ProcessWindowDragHotAreaFunc, Function | SmallTest | Level1)
744 {
745 bool isSendHotAreaMessage = true;
746 SizeChangeReason reason = SizeChangeReason::UNDEFINED;
747 moveDragController->ProcessWindowDragHotAreaFunc(isSendHotAreaMessage, reason);
748 ASSERT_EQ(true, isSendHotAreaMessage);
__anon77c5f7500202(DisplayId displayId, int32_t type, SizeChangeReason reason) 749 auto dragHotAreaFunc = [](DisplayId displayId, int32_t type, SizeChangeReason reason) {
750 type = 0;
751 };
752 auto preFunc = moveDragController->windowDragHotAreaFunc_;
753 moveDragController->windowDragHotAreaFunc_ = dragHotAreaFunc;
754 moveDragController->ProcessWindowDragHotAreaFunc(isSendHotAreaMessage, reason);
755 ASSERT_EQ(true, isSendHotAreaMessage);
756 moveDragController->windowDragHotAreaFunc_ = preFunc;
757 }
758
759 /**
760 * @tc.name: ConsumeDragEvent
761 * @tc.desc: test function : ConsumeDragEvent
762 * @tc.type: FUNC
763 */
764 HWTEST_F(MoveDragControllerTest, ConsumeDragEvent, Function | SmallTest | Level1)
765 {
766 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
767 moveDragController->moveDragProperty_.pointerId_ = pointerEvent->GetPointerId();
768 moveDragController->moveDragProperty_.pointerType_ = pointerEvent->GetSourceType();
769 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
770 ASSERT_NE(nullptr, pointerEvent);
771 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
772 WSRect originalRect = { 100, 100, 1000, 1000 };
773 SystemSessionConfig sysConfig;
774 moveDragController->GetVirtualPixelRatio();
775 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(nullptr, originalRect, property, sysConfig));
776 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, nullptr, sysConfig));
777 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
778 moveDragController->SetStartMoveFlag(true);
779 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
780 moveDragController->SetStartMoveFlag(false);
781 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_DOWN));
782 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
783 MMI::PointerEvent::PointerItem pointerItem;
784 pointerItem.SetPointerId(0);
785 pointerItem.SetWindowX(0);
786 pointerItem.SetWindowY(0);
787 pointerEvent->AddPointerItem(pointerItem);
788 pointerEvent->SetPointerId(0);
789 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_DOWN));
790 ASSERT_EQ(true, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
791 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
792 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_RIGHT);
793 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
794 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_MOVE));
795 ASSERT_EQ(true, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
796 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_UP));
797 ASSERT_EQ(true, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
798 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_UNKNOWN));
799 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
800 moveDragController->moveDragProperty_.pointerId_ = pointerEvent->GetPointerId() + 1;
801 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
802 moveDragController->moveDragProperty_.pointerId_ = pointerEvent->GetPointerId();
803 moveDragController->moveDragProperty_.pointerType_ = pointerEvent->GetSourceType() + 1;
804 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
805 }
806 }
807
808 /**
809 * @tc.name: ConsumeDragEvent2
810 * @tc.desc: test function : ConsumeDragEvent2
811 * @tc.type: FUNC
812 */
813 HWTEST_F(MoveDragControllerTest, ConsumeDragEvent2, Function | SmallTest | Level1)
814 {
815 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
816 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
817 ASSERT_NE(nullptr, pointerEvent);
818 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
819 WSRect originalRect = { 100, 100, 1000, 1000 };
820 SystemSessionConfig sysConfig;
821 moveDragController->GetVirtualPixelRatio();
822 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(nullptr, originalRect, property, sysConfig));
823 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, nullptr, sysConfig));
824 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
825 moveDragController->SetStartMoveFlag(true);
826 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
827 moveDragController->SetStartMoveFlag(false);
828 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_DOWN));
829 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
830 MMI::PointerEvent::PointerItem pointerItem;
831 pointerItem.SetPointerId(0);
832 pointerItem.SetWindowX(0);
833 pointerItem.SetWindowY(0);
834 pointerEvent->AddPointerItem(pointerItem);
835 pointerEvent->SetPointerId(0);
836 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_DOWN));
837 ASSERT_EQ(true, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
838 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
839 moveDragController->moveDragProperty_.pointerId_ = pointerEvent->GetPointerId();
840 moveDragController->moveDragProperty_.pointerType_ = pointerEvent->GetSourceType();
841 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_RIGHT);
842 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
843 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_MOVE));
844 ASSERT_EQ(true, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
845 moveDragController->moveDragIsInterrupted_ = false;
846 ASSERT_EQ(true, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
847 moveDragController->moveDragIsInterrupted_ = true;
848 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_UP));
849 ASSERT_EQ(true, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
850 moveDragController->hasPointDown_ = false;
851 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
852 moveDragController->hasPointDown_ = true;
853 moveDragController->moveDragIsInterrupted_ = false;
854 ScreenProperty screenProperty0;
855 ScreenSessionManagerClient::GetInstance().screenSessionMap_[0] =
856 sptr<ScreenSession>::MakeSptr(0, screenProperty0, 0);
857 moveDragController->moveDragStartDisplayId_ = 0;
858 ASSERT_EQ(false, moveDragController->ConsumeDragEvent(pointerEvent, originalRect, property, sysConfig));
859 }
860 }
861
862 /**
863 * @tc.name: UpdateDragType01
864 * @tc.desc: test function : UpdateDragType
865 * @tc.type: FUNC
866 */
867 HWTEST_F(MoveDragControllerTest, UpdateDragType01, Function | SmallTest | Level1)
868 {
869 moveDragController->rectExceptCorner_.posX_ = 2;
870 moveDragController->rectExceptCorner_.width_ = 2;
871 moveDragController->rectExceptCorner_.posY_ = 0;
872 moveDragController->rectExceptCorner_.height_ = 0;
873 moveDragController->UpdateDragType(3, 3);
874 ASSERT_EQ(moveDragController->dragType_, MoveDragController::DragType::DRAG_BOTTOM_OR_TOP);
875 }
876
877 /**
878 * @tc.name: UpdateDragType02
879 * @tc.desc: test function : UpdateDragType
880 * @tc.type: FUNC
881 */
882 HWTEST_F(MoveDragControllerTest, UpdateDragType02, Function | SmallTest | Level1)
883 {
884 moveDragController->rectExceptCorner_.posX_ = 0;
885 moveDragController->rectExceptCorner_.width_ = 0;
886 moveDragController->rectExceptCorner_.posY_ = 2;
887 moveDragController->rectExceptCorner_.height_ = 2;
888 moveDragController->UpdateDragType(3, 3);
889 ASSERT_EQ(moveDragController->dragType_, MoveDragController::DragType::DRAG_LEFT_OR_RIGHT);
890 }
891
892 /**
893 * @tc.name: UpdateDragType03
894 * @tc.desc: test function : UpdateDragType
895 * @tc.type: FUNC
896 */
897 HWTEST_F(MoveDragControllerTest, UpdateDragType03, Function | SmallTest | Level1)
898 {
899 moveDragController->rectExceptCorner_.posX_ = 1;
900 moveDragController->rectExceptCorner_.width_ = 0;
901 moveDragController->rectExceptCorner_.posY_ = 1;
902 moveDragController->rectExceptCorner_.height_ = 0;
903 moveDragController->UpdateDragType(1, 1);
904 ASSERT_EQ(moveDragController->dragType_, MoveDragController::DragType::DRAG_LEFT_TOP_CORNER);
905 }
906
907 /**
908 * @tc.name: IsPointInDragHotZone01
909 * @tc.desc: test function : IsPointInDragHotZone
910 * @tc.type: FUNC
911 */
912 HWTEST_F(MoveDragControllerTest, IsPointInDragHotZone01, Function | SmallTest | Level1)
913 {
914 WSRect winRect = { 10, 10, 10, 10 };
915 int32_t sourceType = MMI::PointerEvent::SOURCE_TYPE_MOUSE;
916 int32_t startPointPosX = 1;
917 int32_t startPointPosY = 1;
918 bool res = moveDragController->IsPointInDragHotZone(startPointPosX, startPointPosY, sourceType, winRect);
919 ASSERT_EQ(res, false);
920 }
921
922 /**
923 * @tc.name: IsPointInDragHotZone02
924 * @tc.desc: test function : IsPointInDragHotZone
925 * @tc.type: FUNC
926 */
927 HWTEST_F(MoveDragControllerTest, IsPointInDragHotZone02, Function | SmallTest | Level1)
928 {
929 WSRect winRect = { 5, 5, 0, 0 };
930 int32_t startPointPosX = 1;
931 int32_t startPointPosY = 1;
932 bool res = moveDragController->IsPointInDragHotZone(startPointPosX, startPointPosY, 0, winRect);
933 ASSERT_EQ(res, true);
934 }
935
936 /**
937 * @tc.name: CalculateStartRectExceptHotZone
938 * @tc.desc: test function : CalculateStartRectExceptHotZone
939 * @tc.type: FUNC
940 */
941 HWTEST_F(MoveDragControllerTest, CalculateStartRectExceptHotZone, Function | SmallTest | Level1)
942 {
943 float vpr = 1.0f;
944 WSRect winRect;
945 winRect.posX_ = 100;
946 winRect.posY_ = 100;
947 winRect.width_ = 100;
948 winRect.height_ = 100;
949 moveDragController->CalculateStartRectExceptHotZone(vpr, winRect);
950
951 EXPECT_EQ(moveDragController->rectExceptFrame_.posX_, 105);
952 EXPECT_EQ(moveDragController->rectExceptFrame_.posY_, 105);
953 EXPECT_EQ(moveDragController->rectExceptFrame_.width_, 90);
954 EXPECT_EQ(moveDragController->rectExceptFrame_.height_, 90);
955
956 EXPECT_EQ(moveDragController->rectExceptCorner_.posX_, 116);
957 EXPECT_EQ(moveDragController->rectExceptCorner_.posY_, 116);
958 EXPECT_EQ(moveDragController->rectExceptCorner_.width_, 68);
959 EXPECT_EQ(moveDragController->rectExceptCorner_.height_, 68);
960 }
961
962 /**
963 * @tc.name: CalcFirstMoveTargetRect
964 * @tc.desc: test function : CalcFirstMoveTargetRect
965 * @tc.type: FUNC
966 */
967 HWTEST_F(MoveDragControllerTest, CalcFirstMoveTargetRect, Function | SmallTest | Level1)
968 {
969 int res = 0;
970 WSRect windowRect = { 0, 0, 0, 0 };
971 moveDragController->CalcFirstMoveTargetRect(windowRect, false);
972 res++;
973 moveDragController->moveTempProperty_.pointerId_ = 0;
974 moveDragController->CalcFirstMoveTargetRect(windowRect, false);
975 ASSERT_EQ(res, 1);
976 auto preIsStartMove = moveDragController->GetStartMoveFlag();
977 auto preMoveTempProperty = moveDragController->moveTempProperty_;
978 moveDragController->isStartMove_ = false;
979 moveDragController->moveTempProperty_ = { -1, -1, -1, -1, -1, -1, -1, -1 };
980 moveDragController->CalcFirstMoveTargetRect(windowRect, false);
981 ASSERT_EQ(res, 1);
982 moveDragController->moveTempProperty_ = { 1, 1, 1, 1, 1, 1, 1, 1 };
983 moveDragController->CalcFirstMoveTargetRect(windowRect, false);
984 ASSERT_EQ(res, 1);
985 moveDragController->isStartMove_ = true;
986 moveDragController->CalcFirstMoveTargetRect(windowRect, false);
987 ASSERT_EQ(res, 1);
988 moveDragController->moveTempProperty_ = { -1, -1, -1, -1, -1, -1, -1, -1 };
989 moveDragController->CalcFirstMoveTargetRect(windowRect, false);
990 ASSERT_EQ(res, 1);
991 moveDragController->moveTempProperty_ = { 1, 1, 1, 1, 1, 1, 1, 1 };
992 moveDragController->CalcFirstMoveTargetRect(windowRect, false);
993 ASSERT_EQ(res, 1);
994 moveDragController->CalcFirstMoveTargetRect(windowRect, true);
995 ASSERT_EQ(res, 1);
996 moveDragController->isStartMove_ = preIsStartMove;
997 moveDragController->moveTempProperty_ = preMoveTempProperty;
998 }
999
1000 /**
1001 * @tc.name: CalcFirstMoveTargetRect001
1002 * @tc.desc: test function : CalcFirstMoveTargetRect001
1003 * @tc.type: FUNC
1004 */
1005 HWTEST_F(MoveDragControllerTest, CalcFirstMoveTargetRect001, Function | SmallTest | Level1)
1006 {
1007 WSRect windowRect = { 1, 2, 3, 4 };
1008 moveDragController->InitMoveDragProperty();
1009 moveDragController->SetStartMoveFlag(true);
1010 moveDragController->CalcFirstMoveTargetRect(windowRect, true);
1011 WSRect targetRect = moveDragController->GetTargetRect(
1012 MoveDragController::TargetRectCoordinate::RELATED_TO_START_DISPLAY);
1013 ASSERT_EQ(targetRect.posX_, 0);
1014 }
1015
1016 /**
1017 * @tc.name: GetFullScreenToFloatingRect
1018 * @tc.desc: test function : GetFullScreenToFloatingRect
1019 * @tc.type: FUNC
1020 */
1021 HWTEST_F(MoveDragControllerTest, GetFullScreenToFloatingRect, Function | SmallTest | Level1)
1022 {
1023 WSRect originalRect = { 1, 2, 0, 4 };
1024 WSRect windowRect = { 5, 6, 7, 8 };
1025 auto preMoveTempProperty = moveDragController->moveTempProperty_;
1026 moveDragController->moveTempProperty_ = { -1, -1, -1, -1, -1, -1, -1, -1 };
1027 WSRect rect = moveDragController->GetFullScreenToFloatingRect(originalRect, windowRect);
1028 // move temporary property is empty
1029 ASSERT_EQ(originalRect.posX_, rect.posX_);
1030 moveDragController->moveTempProperty_ = { 1, 1, 1, 1, 1, 1, 1, 1 };
1031 rect = moveDragController->GetFullScreenToFloatingRect(originalRect, windowRect);
1032 // original rect witch is zero
1033 ASSERT_EQ(windowRect.posX_, rect.posX_);
1034 originalRect = { 1, 2, 3, 4 };
1035 rect = moveDragController->GetFullScreenToFloatingRect(originalRect, windowRect);
1036 WSRect targetRect = { 1, 2, 7, 8};
1037 ASSERT_EQ(targetRect.posX_, rect.posX_);
1038 moveDragController->moveTempProperty_ = preMoveTempProperty;
1039 }
1040
1041 /**
1042 * @tc.name: CheckDragEventLegal
1043 * @tc.desc: test function : CheckDragEventLegal
1044 * @tc.type: FUNC
1045 */
1046 HWTEST_F(MoveDragControllerTest, CheckDragEventLegal, Function | SmallTest | Level1)
1047 {
1048 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
1049 ASSERT_NE(pointerEvent, nullptr);
1050 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1051 ASSERT_NE(property, nullptr);
1052 auto tempPointerEvent = pointerEvent;
1053 pointerEvent = nullptr;
1054 auto result = moveDragController->CheckDragEventLegal(pointerEvent, property);
1055 ASSERT_EQ(result, false);
1056 pointerEvent = tempPointerEvent;
1057 result = moveDragController->CheckDragEventLegal(pointerEvent, nullptr);
1058 ASSERT_EQ(result, false);
1059 moveDragController->isStartMove_ = true;
1060 result = moveDragController->CheckDragEventLegal(pointerEvent, property);
1061 ASSERT_EQ(result, false);
1062 moveDragController->isStartMove_ = false;
1063 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_UP));
1064 result = moveDragController->CheckDragEventLegal(pointerEvent, property);
1065 ASSERT_EQ(result, false);
1066 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_DOWN));
1067 result = moveDragController->CheckDragEventLegal(pointerEvent, property);
1068 ASSERT_EQ(result, true);
1069 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN));
1070 result = moveDragController->CheckDragEventLegal(pointerEvent, property);
1071 ASSERT_EQ(result, true);
1072 auto preMoveDragProperty = moveDragController->moveDragProperty_;
1073 moveDragController->moveDragProperty_.pointerId_ = -1;
1074 result = moveDragController->CheckDragEventLegal(pointerEvent, property);
1075 ASSERT_EQ(result, true);
1076 moveDragController->moveDragProperty_ = preMoveDragProperty;
1077 }
1078
1079 /**
1080 * @tc.name: UpdateMoveTempProperty
1081 * @tc.desc: test function : UpdateMoveTempProperty
1082 * @tc.type: FUNC
1083 */
1084 HWTEST_F(MoveDragControllerTest, UpdateMoveTempProperty, Function | SmallTest | Level1)
1085 {
1086 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
1087 ASSERT_NE(pointerEvent, nullptr);
1088 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1089 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_RIGHT);
1090 auto result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1091 ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
1092 MMI::PointerEvent::PointerItem pointerItem;
1093 pointerItem.SetPointerId(0);
1094 pointerEvent->AddPointerItem(pointerItem);
1095 pointerEvent->SetPointerId(0);
1096 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
1097 result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1098 ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
1099 pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
1100 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_RIGHT);
1101 result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1102 ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
1103 pointerEvent->SetButtonId(MMI::PointerEvent::MOUSE_BUTTON_LEFT);
1104 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN));
1105 result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1106 ASSERT_EQ(result, WSError::WS_OK);
1107 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_DOWN));
1108 result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1109 ASSERT_EQ(result, WSError::WS_OK);
1110 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_MOVE));
1111 result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1112 ASSERT_EQ(result, WSError::WS_OK);
1113 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_UP));
1114 result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1115 ASSERT_EQ(result, WSError::WS_OK);
1116 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP));
1117 result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1118 ASSERT_EQ(result, WSError::WS_OK);
1119 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_CANCEL));
1120 result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1121 ASSERT_EQ(result, WSError::WS_OK);
1122 pointerEvent->SetPointerAction(static_cast<int32_t>(MMI::PointerEvent::POINTER_ACTION_UNKNOWN));
1123 result = moveDragController->UpdateMoveTempProperty(pointerEvent);
1124 ASSERT_EQ(result, WSError::WS_OK);
1125 }
1126
1127 /**
1128 * @tc.name: UpdateHotAreaType
1129 * @tc.desc: UpdateHotAreaType
1130 * @tc.type: FUNC
1131 */
1132 HWTEST_F(MoveDragControllerTest, UpdateHotAreaType, Function | SmallTest | Level1)
1133 {
1134 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
1135 ASSERT_NE(pointerEvent, nullptr);
1136 moveDragController->UpdateHotAreaType(pointerEvent);
1137 MMI::PointerEvent::PointerItem pointerItem;
1138 pointerItem.SetPointerId(0);
1139 pointerEvent->AddPointerItem(pointerItem);
1140 pointerEvent->SetPointerId(0);
1141 moveDragController->UpdateHotAreaType(pointerEvent);
1142 auto preWindowDragHotAreaType = moveDragController->windowDragHotAreaType_;
1143 moveDragController->windowDragHotAreaType_ = WINDOW_HOT_AREA_TYPE_UNDEFINED;
1144 moveDragController->UpdateHotAreaType(pointerEvent);
1145 moveDragController->windowDragHotAreaType_ = preWindowDragHotAreaType;
1146 }
1147
1148 /**
1149 * @tc.name: OnLostFocus
1150 * @tc.desc: OnLostFocus
1151 * @tc.type: FUNC
1152 */
1153 HWTEST_F(MoveDragControllerTest, OnLostFocus, Function | SmallTest | Level1)
1154 {
1155 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
1156 ASSERT_NE(pointerEvent, nullptr);
1157 moveDragController->isStartMove_ = true;
1158 moveDragController->isStartDrag_ = false;
1159 moveDragController->OnLostFocus();
1160 moveDragController->isStartMove_ = false;
1161 moveDragController->isStartDrag_ = true;
1162 int windowHotAreaTypeOther = 1;
1163 moveDragController->windowDragHotAreaType_ = windowHotAreaTypeOther;
1164 moveDragController->OnLostFocus();
1165 moveDragController->windowDragHotAreaType_ = WINDOW_HOT_AREA_TYPE_UNDEFINED;
1166 moveDragController->OnLostFocus();
1167 }
1168
1169 /**
1170 * @tc.name: NotifyWindowInputPidChange
1171 * @tc.desc: NotifyWindowInputPidChange
1172 * @tc.type: FUNC
1173 */
1174 HWTEST_F(MoveDragControllerTest, NotifyWindowInputPidChange, Function | SmallTest | Level1)
1175 {
1176 bool isServerPid = true;
1177 auto preCallback = moveDragController->pidChangeCallback_;
1178 moveDragController->NotifyWindowInputPidChange(isServerPid);
1179 isServerPid = false;
1180 moveDragController->NotifyWindowInputPidChange(isServerPid);
1181 moveDragController->SetNotifyWindowPidChangeCallback(nullptr);
1182 ASSERT_EQ(moveDragController->pidChangeCallback_, nullptr);
1183 isServerPid = true;
1184 moveDragController->NotifyWindowInputPidChange(isServerPid);
1185 isServerPid = false;
1186 moveDragController->NotifyWindowInputPidChange(isServerPid);
1187 moveDragController->SetNotifyWindowPidChangeCallback(preCallback);
1188 }
1189
1190 /**
1191 * @tc.name: HasPointDown
1192 * @tc.desc: HasPointDown
1193 * @tc.type: FUNC
1194 */
1195 HWTEST_F(MoveDragControllerTest, HasPointDown, Function | SmallTest | Level1)
1196 {
1197 bool preHasPointDown = moveDragController->hasPointDown_;
1198 moveDragController->hasPointDown_ = true;
1199 bool res = moveDragController->HasPointDown();
1200 ASSERT_EQ(res, true);
1201 moveDragController->hasPointDown_ = false;
1202 res = moveDragController->HasPointDown();
1203 ASSERT_EQ(res, false);
1204 moveDragController->hasPointDown_ = preHasPointDown;
1205 }
1206
1207 /**
1208 * @tc.name: ProcessSessionRectChange
1209 * @tc.desc: ProcessSessionRectChange
1210 * @tc.type: FUNC
1211 */
1212 HWTEST_F(MoveDragControllerTest, ProcessSessionRectChange, Function | SmallTest | Level1)
1213 {
1214 int32_t res = 0;
1215 auto preCallback = moveDragController->moveDragCallback_;
1216 SizeChangeReason reason = SizeChangeReason::UNDEFINED;
__anon77c5f7500302(SizeChangeReason reason) 1217 MoveDragCallback callBack = [](SizeChangeReason reason) {
1218 return;
1219 };
1220 moveDragController->moveDragCallback_ = callBack;
1221 moveDragController->ProcessSessionRectChange(reason);
1222 moveDragController->moveDragCallback_ = nullptr;
1223 moveDragController->ProcessSessionRectChange(reason);
1224 moveDragController->moveDragCallback_ = preCallback;
1225 ASSERT_EQ(0, res);
1226 }
1227
1228 /**
1229 * @tc.name: GetOriginalPointerPosX
1230 * @tc.desc: GetOriginalPointerPosX
1231 * @tc.type: FUNC
1232 */
1233 HWTEST_F(MoveDragControllerTest, GetOriginalPointerPosX, Function | SmallTest | Level1)
1234 {
1235 int32_t posX = moveDragController->moveDragProperty_.originalPointerPosX_;
1236 int32_t res = moveDragController->GetOriginalPointerPosX();
1237 ASSERT_EQ(posX, res);
1238 }
1239
1240 /**
1241 * @tc.name: GetOriginalPointerPosY
1242 * @tc.desc: GetOriginalPointerPosY
1243 * @tc.type: FUNC
1244 */
1245 HWTEST_F(MoveDragControllerTest, GetOriginalPointerPosY, Function | SmallTest | Level1)
1246 {
1247 int32_t posY = moveDragController->moveDragProperty_.originalPointerPosY_;
1248 int32_t res = moveDragController->GetOriginalPointerPosY();
1249 ASSERT_EQ(posY, res);
1250 }
1251
1252 /**
1253 * @tc.name: GetPointerType
1254 * @tc.desc: GetPointerType
1255 * @tc.type: FUNC
1256 */
1257 HWTEST_F(MoveDragControllerTest, GetPointerType, Function | SmallTest | Level1)
1258 {
1259 int32_t testType = MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
1260 moveDragController->moveDragProperty_.pointerType_ = testType;
1261 ASSERT_EQ(testType, moveDragController->GetPointerType());
1262 }
1263
1264 /**
1265 * @tc.name: GetNewAddedDisplayIdsDuringMoveDrag
1266 * @tc.desc: test function : GetNewAddedDisplayIdsDuringMoveDrag
1267 * @tc.type: FUNC
1268 */
1269 HWTEST_F(MoveDragControllerTest, GetNewAddedDisplayIdsDuringMoveDrag, Function | SmallTest | Level1)
1270 {
1271 std::set<uint64_t> res = moveDragController->GetDisplayIdsDuringMoveDrag();
1272 ASSERT_EQ(true, res.empty());
1273 }
1274
1275 /**
1276 * @tc.name: GetNewAddedDisplayIdsDuringMoveDrag02
1277 * @tc.desc: test function : GetNewAddedDisplayIdsDuringMoveDrag02
1278 * @tc.type: FUNC
1279 */
1280 HWTEST_F(MoveDragControllerTest, GetNewAddedDisplayIdsDuringMoveDrag02, Function | SmallTest | Level1)
1281 {
1282 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
1283 std::set<uint64_t> res = moveDragController->GetNewAddedDisplayIdsDuringMoveDrag();
1284 ASSERT_EQ(true, res.empty());
1285 moveDragController->displayIdSetDuringMoveDrag_.insert(0);
1286 moveDragController->displayIdSetDuringMoveDrag_.insert(1001);
1287 ScreenProperty screenProperty0;
1288 ScreenSessionManagerClient::GetInstance().screenSessionMap_[0] =
1289 sptr<ScreenSession>::MakeSptr(0, screenProperty0, 0);
1290 res = moveDragController->GetNewAddedDisplayIdsDuringMoveDrag();
1291 ASSERT_EQ(true, res.empty());
1292 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
1293 }
1294
1295 /**
1296 * @tc.name: CalcUnifiedTranslate
1297 * @tc.desc: test function : CalcUnifiedTranslate
1298 * @tc.type: FUNC
1299 */
1300 HWTEST_F(MoveDragControllerTest, CalcUnifiedTranslate, Function | SmallTest | Level1)
1301 {
1302 moveDragController->InitMoveDragProperty();
1303 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
1304 pointerEvent->SetTargetDisplayId(0);
1305 MMI::PointerEvent::PointerItem pointerItem;
1306 pointerItem.SetPointerId(0);
1307 pointerItem.SetDisplayX(10);
1308 pointerItem.SetDisplayY(30);
1309 pointerEvent->AddPointerItem(pointerItem);
1310 std::pair<int32_t, int32_t> res = moveDragController->CalcUnifiedTranslate(pointerEvent);
1311 ASSERT_EQ(0, res.first);
1312 ASSERT_EQ(0, res.second);
1313 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr();
1314 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
1315 ScreenSessionManagerClient::GetInstance().screenSessionMap_.insert(std::make_pair(0, screenSession));
1316 res = moveDragController->CalcUnifiedTranslate(pointerEvent);
1317 ASSERT_EQ(1, res.first);
1318 ASSERT_EQ(1, res.second);
1319 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
1320 }
1321
1322 /**
1323 * @tc.name: MoveDragInterrupted
1324 * @tc.desc: test function : MoveDragInterrupted
1325 * @tc.type: FUNC
1326 */
1327 HWTEST_F(MoveDragControllerTest, MoveDragInterrupted, Function | SmallTest | Level1)
1328 {
1329 moveDragController->MoveDragInterrupted();
1330 ASSERT_EQ(false, moveDragController->GetStartDragFlag());
1331 ASSERT_EQ(false, moveDragController->GetStartMoveFlag());
1332 ASSERT_EQ(false, moveDragController->hasPointDown_);
1333 moveDragController->isStartMove_ = true;
1334 ASSERT_EQ(false, moveDragController->GetStartDragFlag());
1335 ASSERT_EQ(true, moveDragController->GetStartMoveFlag());
1336 ASSERT_EQ(false, moveDragController->hasPointDown_);
1337 moveDragController->isStartMove_ = false;
1338 }
1339
1340 /**
1341 * @tc.name: ResetCrossMoveDragProperty
1342 * @tc.desc: test function : ResetCrossMoveDragProperty
1343 * @tc.type: FUNC
1344 */
1345 HWTEST_F(MoveDragControllerTest, ResetCrossMoveDragProperty, Function | SmallTest | Level1)
1346 {
1347 moveDragController->ResetCrossMoveDragProperty();
1348 ASSERT_EQ(false, moveDragController->hasPointDown_);
1349 }
1350
1351 /**
1352 * @tc.name: OnConnect
1353 * @tc.desc: test function : OnConnect
1354 * @tc.type: FUNC
1355 */
1356 HWTEST_F(MoveDragControllerTest, OnConnect, Function | SmallTest | Level1)
1357 {
1358 ScreenId screenId = 1001;
1359 moveDragController->OnConnect(screenId);
1360 ASSERT_EQ(moveDragController->moveDragIsInterrupted_, true);
1361 }
1362
1363 /**
1364 * @tc.name: OnDisconnect
1365 * @tc.desc: test function : OnDisconnect
1366 * @tc.type: FUNC
1367 */
1368 HWTEST_F(MoveDragControllerTest, OnDisconnect, Function | SmallTest | Level1)
1369 {
1370 ScreenId screenId = 1001;
1371 moveDragController->OnDisconnect(screenId);
1372 ASSERT_EQ(moveDragController->moveDragIsInterrupted_, true);
1373 }
1374
1375 /**
1376 * @tc.name: OnChange
1377 * @tc.desc: test function : OnChange
1378 * @tc.type: FUNC
1379 */
1380 HWTEST_F(MoveDragControllerTest, OnChange, Function | SmallTest | Level1)
1381 {
1382 ScreenId screenId = 1001;
1383 moveDragController->OnChange(screenId);
1384 ASSERT_EQ(moveDragController->moveDragIsInterrupted_, true);
1385 }
1386
1387 /**
1388 * @tc.name: StopMoving
1389 * @tc.desc: test function : StopMoving
1390 * @tc.type: FUNC
1391 */
1392 HWTEST_F(MoveDragControllerTest, StopMoving, Function | SmallTest | Level1)
1393 {
1394 moveDragController->isStartMove_ = true;
1395 moveDragController->StopMoving();
1396 ASSERT_EQ(false, moveDragController->GetStartMoveFlag());
1397 ASSERT_EQ(false, moveDragController->hasPointDown_);
1398 }
1399
1400 /**
1401 * @tc.name: HandleStartMovingWithCoordinate
1402 * @tc.desc: test function : HandleStartMovingWithCoordinate
1403 * @tc.type: FUNC
1404 */
1405 HWTEST_F(MoveDragControllerTest, HandleStartMovingWithCoordinate, Function | SmallTest | Level1)
1406 {
1407 WSRect winRect = { 200, 200, 1000, 1000 };
1408 moveDragController->HandleStartMovingWithCoordinate(100, 50, 300, 500, winRect);
1409 ASSERT_EQ(300, moveDragController->moveTempProperty_.lastDownPointerPosX_);
1410 ASSERT_EQ(500, moveDragController->moveTempProperty_.lastDownPointerPosY_);
1411 ASSERT_EQ(300, moveDragController->moveTempProperty_.lastMovePointerPosX_);
1412 ASSERT_EQ(500, moveDragController->moveTempProperty_.lastMovePointerPosY_);
1413 ASSERT_EQ(100, moveDragController->moveTempProperty_.lastDownPointerWindowX_);
1414 ASSERT_EQ(50, moveDragController->moveTempProperty_.lastDownPointerWindowY_);
1415 }
1416
1417 /**
1418 * @tc.name: GetTargetRectByDisplayId
1419 * @tc.desc: test function : GetTargetRectByDisplayId
1420 * @tc.type: FUNC
1421 */
1422 HWTEST_F(MoveDragControllerTest, GetTargetRectByDisplayId, Function | SmallTest | Level1)
1423 {
1424 ScreenSessionManagerClient::GetInstance().screenSessionMap_.clear();
1425 WSRect ret = moveDragController->GetTargetRectByDisplayId(0);
1426 ASSERT_EQ(ret, moveDragController->moveDragProperty_.targetRect_);
1427 ScreenProperty screenProperty0;
1428 ScreenSessionManagerClient::GetInstance().screenSessionMap_[0] =
1429 sptr<ScreenSession>::MakeSptr(0, screenProperty0, 0);
1430 ret = moveDragController->GetTargetRectByDisplayId(0);
1431 int32_t currentDisplayOffsetX = static_cast<int32_t>(screenProperty0.GetStartX());
1432 int32_t currentDisplayOffsetY = static_cast<int32_t>(screenProperty0.GetStartY());
1433 WSRect testRect = { moveDragController->moveDragProperty_.targetRect_.posX_ +
1434 moveDragController->originalDisplayOffsetX_ - currentDisplayOffsetX,
1435 moveDragController->moveDragProperty_.targetRect_.posY_ +
1436 moveDragController->originalDisplayOffsetY_ - currentDisplayOffsetY,
1437 moveDragController->moveDragProperty_.targetRect_.width_,
1438 moveDragController->moveDragProperty_.targetRect_.height_ };
1439 ASSERT_EQ(ret, testRect);
1440 }
1441
1442 /**
1443 * @tc.name: UpdateMoveAvailableArea
1444 * @tc.desc: test function : UpdateMoveAvailableArea
1445 * @tc.type: FUNC
1446 */
1447 HWTEST_F(MoveDragControllerTest, UpdateMoveAvailableArea, Function | SmallTest | Level1)
1448 {
1449 moveDragController->UpdateMoveAvailableArea(-1);
1450 ASSERT_EQ(moveDragController->moveAvailableArea_.posX_, 0);
1451 SessionOption option = {
1452 .rsId_ = 0,
1453 .isExtend_ = false,
1454 .screenId_ = 0,
1455 };
1456 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
1457 ScreenSessionManagerClient::GetInstance().OnScreenConnectionChanged(option, screenEvent);
1458 moveDragController->UpdateMoveAvailableArea(0);
1459 ASSERT_EQ(moveDragController->moveAvailableArea_.posX_, 0);
1460 }
1461
1462 /**
1463 * @tc.name: GetMoveInputBarStartDisplayId
1464 * @tc.desc: test function : GetMoveInputBarStartDisplayId
1465 * @tc.type: FUNC
1466 */
1467 HWTEST_F(MoveDragControllerTest, GetMoveInputBarStartDisplayId, Function | SmallTest | Level1)
1468 {
1469 auto ret = moveDragController->GetMoveInputBarStartDisplayId();
1470 ASSERT_EQ(moveDragController->moveInputBarStartDisplayId_, ret);
1471 }
1472
1473 /**
1474 * @tc.name: SetCurrentScreenProperty
1475 * @tc.desc: test function : SetCurrentScreenProperty
1476 * @tc.type: FUNC
1477 */
1478 HWTEST_F(MoveDragControllerTest, SetCurrentScreenProperty, Function | SmallTest | Level1)
1479 {
1480 SessionOption option = {
1481 .rsId_ = 0,
1482 .isExtend_ = false,
1483 .screenId_ = 0,
1484 };
1485 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
1486 ScreenSessionManagerClient::GetInstance().OnScreenConnectionChanged(option, screenEvent);
1487 moveDragController->SetCurrentScreenProperty(-1);
1488 ASSERT_EQ(moveDragController->screenSizeProperty_.currentDisplayStartX, 0);
1489 moveDragController->SetCurrentScreenProperty(0);
1490 ASSERT_EQ(moveDragController->screenSizeProperty_.currentDisplayStartX, 0);
1491 }
1492
1493 /**
1494 * @tc.name: UpdateSubWindowGravityWhenFollow
1495 * @tc.desc: UpdateSubWindowGravityWhenFollow
1496 * @tc.type: FUNC
1497 */
1498 HWTEST_F(MoveDragControllerTest, UpdateSubWindowGravityWhenFollow01, Function | SmallTest | Level1)
1499 {
1500 SessionInfo info;
1501 sptr<Session> followSession = sptr<Session>::MakeSptr(info);
1502
1503 sptr<MoveDragController> followController =
1504 sptr<MoveDragController>::MakeSptr(session_->GetPersistentId(), session_->GetWindowType());
1505 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
1506 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig,
1507 RSSurfaceNodeType::DEFAULT);
1508
1509 followController->type_ = AreaType::UNDEFINED;
1510 moveDragController->UpdateSubWindowGravityWhenFollow(nullptr, nullptr);
1511 auto gravityIter = surfaceNode->propertyModifiers_.find(RSModifierType::FRAME_GRAVITY);
1512 ASSERT_EQ(gravityIter, surfaceNode->propertyModifiers_.end());
1513
1514 moveDragController->UpdateSubWindowGravityWhenFollow(nullptr, surfaceNode);
1515 gravityIter = surfaceNode->propertyModifiers_.find(RSModifierType::FRAME_GRAVITY);
1516 ASSERT_EQ(gravityIter, surfaceNode->propertyModifiers_.end());
1517
1518 moveDragController->UpdateSubWindowGravityWhenFollow(followController, surfaceNode);
1519 gravityIter = surfaceNode->propertyModifiers_.find(RSModifierType::FRAME_GRAVITY);
1520 ASSERT_EQ(gravityIter, surfaceNode->propertyModifiers_.end());
1521
1522 followController->type_ = AreaType::TOP;
1523 moveDragController->UpdateSubWindowGravityWhenFollow(followController, surfaceNode);
1524 gravityIter = surfaceNode->propertyModifiers_.find(RSModifierType::FRAME_GRAVITY);
1525 ASSERT_NE(gravityIter, surfaceNode->propertyModifiers_.end());
1526 }
1527 }
1528 }
1529 }