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