1 /* 2 * Copyright (c) 2025 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 "test/unittest/core/event/gesture_event_hub_test_ng.h" 17 18 #include "test/mock/base/mock_subwindow.h" 19 #include "test/mock/core/common/mock_container.h" 20 #include "test/mock/core/common/mock_interaction_interface.h" 21 #include "base/subwindow/subwindow_manager.h" 22 #include "core/components_ng/manager/drag_drop/drag_drop_global_controller.h" 23 #include "core/components_ng/base/view_abstract.h" 24 #include "core/components_ng/pattern/grid/grid_item_pattern.h" 25 #include "core/components_ng/pattern/grid/grid_pattern.h" 26 #include "core/components_ng/pattern/image/image_pattern.h" 27 #include "core/components_ng/pattern/stage/page_pattern.h" 28 #include "core/components_ng/pattern/text/text_pattern.h" 29 #include "core/components_ng/pattern/menu/menu_view.h" 30 #include "core/components_ng/manager/drag_drop/drag_drop_func_wrapper.h" 31 #include "test/mock/core/render/mock_render_context.h" 32 33 using namespace testing; 34 using namespace testing::ext; 35 36 namespace OHOS::Ace::NG { 37 namespace { 38 struct GestureEventHubAddPanEventTestCase { 39 bool needCreatPanEventActuatorFirst = false; 40 PanDirection panDirectionType; 41 PanDirection comparePanDirectionType; 42 bool expectRecreatePanEvent = false; 43 Dimension expectDistance; GestureEventHubAddPanEventTestCaseOHOS::Ace::NG::__anonfa8501890111::GestureEventHubAddPanEventTestCase44 GestureEventHubAddPanEventTestCase(bool needCreatPanEventActuatorFirst, 45 PanDirection panDirectionType, PanDirection comparePanDirectionType, bool expectRecreatePanEvent, 46 Dimension expectDistance) 47 : needCreatPanEventActuatorFirst(needCreatPanEventActuatorFirst), panDirectionType(panDirectionType), 48 comparePanDirectionType(comparePanDirectionType), expectRecreatePanEvent(expectRecreatePanEvent), 49 expectDistance(expectDistance) 50 {} 51 }; 52 const std::vector<GestureEventHubAddPanEventTestCase> ADD_PAN_EVENT_TEST_CASE = { 53 GestureEventHubAddPanEventTestCase(false, PAN_DIRECTION_ALL, PAN_DIRECTION_ALL, true, DEFAULT_PAN_DISTANCE), 54 GestureEventHubAddPanEventTestCase(false, DRAG_DIRECTION, PAN_DIRECTION_ALL, true, DEFAULT_PAN_DISTANCE), 55 GestureEventHubAddPanEventTestCase(true, DRAG_DIRECTION, PAN_DIRECTION_ALL, true, DEFAULT_PAN_DISTANCE), 56 GestureEventHubAddPanEventTestCase(true, PAN_DIRECTION_ALL, PAN_DIRECTION_ALL, false, DISTANCE), 57 }; 58 } 59 60 /** 61 * @tc.name: CalcFrameNodeOffsetAndSize_001 62 * @tc.desc: Test CalcFrameNodeOffsetAndSize 63 * @tc.type: FUNC 64 */ 65 HWTEST_F(GestureEventHubTestNg, CalcFrameNodeOffsetAndSize_001, TestSize.Level1) 66 { 67 /** 68 * @tc.steps: step1. Create GestureEventHub. 69 * @tc.expected: gestureEventHub is not null. 70 */ 71 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 72 auto renderContext = frameNode->GetRenderContext(); 73 CHECK_NULL_VOID(renderContext); 74 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 75 ASSERT_NE(guestureEventHub, nullptr); 76 77 /** 78 * @tc.steps: step2. updates event and pipeline attributes. 79 */ 80 auto event = guestureEventHub->eventHub_.Upgrade(); 81 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 82 83 auto pipeline = PipelineContext::GetCurrentContext(); 84 EXPECT_TRUE(pipeline); 85 renderContext->UpdateTransformRotate({ 0.0f, 0.0f, 1.0f, 1.0f, 0.0f }); 86 87 /** 88 * @tc.steps: step3. call CalcFrameNodeOffsetAndSize. 89 */ 90 guestureEventHub->CalcFrameNodeOffsetAndSize(frameNode, true); 91 EXPECT_EQ(guestureEventHub->frameNodeSize_.Width(), 0.0); 92 guestureEventHub->CalcFrameNodeOffsetAndSize(frameNode, false); 93 EXPECT_EQ(guestureEventHub->frameNodeSize_.Width(), 0.0); 94 EXPECT_EQ(guestureEventHub->frameNodeOffset_.GetX(), 0.0); 95 EXPECT_EQ(guestureEventHub->frameNodeOffset_.GetY(), 0.0); 96 } 97 98 /** 99 * @tc.name: CalcFrameNodeOffsetAndSize_002 100 * @tc.desc: Test CalcFrameNodeOffsetAndSize 101 * @tc.type: FUNC 102 */ 103 HWTEST_F(GestureEventHubTestNg, CalcFrameNodeOffsetAndSize_002, TestSize.Level1) 104 { 105 /** 106 * @tc.steps: step1. Create GestureEventHub. 107 * @tc.expected: gestureEventHub is not null. 108 */ 109 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 110 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 111 ASSERT_NE(guestureEventHub, nullptr); 112 113 /** 114 * @tc.steps: step2. updates event and pipeline attributes. 115 */ 116 auto event = guestureEventHub->eventHub_.Upgrade(); 117 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 118 DragPreviewOption previewOption; 119 previewOption.sizeChangeEffect = DraggingSizeChangeEffect::SIZE_CONTENT_TRANSITION; 120 frameNode->SetDragPreviewOptions(previewOption); 121 122 auto pipeline = PipelineContext::GetCurrentContext(); 123 EXPECT_TRUE(pipeline); 124 auto dragDropManager = pipeline->GetDragDropManager(); 125 auto menuWrapperNode = FrameNode::CreateFrameNode( 126 V2::MENU_WRAPPER_ETS_TAG, 1, AceType::MakeRefPtr<MenuWrapperPattern>(1)); 127 dragDropManager->SetMenuWrapperNode(menuWrapperNode); 128 129 /** 130 * @tc.steps: step3. call CalcFrameNodeOffsetAndSize. 131 */ 132 guestureEventHub->CalcFrameNodeOffsetAndSize(frameNode, true); 133 EXPECT_EQ(guestureEventHub->frameNodeSize_.Width(), 0.0); 134 guestureEventHub->CalcFrameNodeOffsetAndSize(frameNode, false); 135 EXPECT_EQ(guestureEventHub->frameNodeSize_.Width(), 0.0); 136 } 137 138 /** 139 * @tc.name: GetDefaultPixelMapScale_001 140 * @tc.desc: Test GetDefaultPixelMapScale 141 * @tc.type: FUNC 142 */ 143 HWTEST_F(GestureEventHubTestNg, GetDefaultPixelMapScale_001, TestSize.Level1) 144 { 145 /** 146 * @tc.steps: step1. Create GestureEventHub. 147 * @tc.expected: gestureEventHub is not null. 148 */ 149 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 150 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 151 ASSERT_NE(guestureEventHub, nullptr); 152 153 /** 154 * @tc.steps: step2. updates event and pipeline attributes. 155 */ 156 auto event = guestureEventHub->eventHub_.Upgrade(); 157 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 158 159 auto pipeline = PipelineContext::GetCurrentContext(); 160 EXPECT_TRUE(pipeline); 161 162 /** 163 * @tc.steps: step3. call GetDefaultPixelMapScale. 164 */ 165 GestureEvent info; 166 auto pixelMap = AceType::MakeRefPtr<MockPixelMap>(); 167 guestureEventHub->GetDefaultPixelMapScale(frameNode, info, true, pixelMap); 168 EXPECT_EQ(guestureEventHub->frameNodeSize_.Width(), 0.0); 169 170 guestureEventHub->GetDefaultPixelMapScale(frameNode, info, false, pixelMap); 171 EXPECT_EQ(guestureEventHub->frameNodeSize_.Width(), 0.0); 172 } 173 174 /** 175 * @tc.name: GetPixelMapOffset_001 176 * @tc.desc: Test GetPixelMapOffset 177 * @tc.type: FUNC 178 */ 179 HWTEST_F(GestureEventHubTestNg, GetPixelMapOffset_001, TestSize.Level1) 180 { 181 /** 182 * @tc.steps: step1. Create GestureEventHub. 183 * @tc.expected: gestureEventHub is not null. 184 */ 185 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 186 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 187 ASSERT_NE(guestureEventHub, nullptr); 188 189 /** 190 * @tc.steps: step2. updates event and pipeline attributes. 191 */ 192 auto event = guestureEventHub->eventHub_.Upgrade(); 193 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 194 195 auto pipeline = PipelineContext::GetCurrentContext(); 196 EXPECT_TRUE(pipeline); 197 198 /** 199 * @tc.steps: step3. call GetPixelMapOffset. 200 */ 201 GestureEvent info; 202 SizeF size(0.0f, 0.0f); 203 PreparedInfoForDrag dragInfoData; 204 float scale = 0.0f; 205 RectF innerRect(0.0f, 0.0f, 0.0f, 0.0f); 206 guestureEventHub->GetPixelMapOffset(info, size, dragInfoData, scale, innerRect); 207 EXPECT_EQ(innerRect.Width(), 0.0); 208 209 size.SetWidth(2.0f); 210 size.SetHeight(2.0f); 211 scale = -1.0f; 212 guestureEventHub->frameNodeOffset_.SetX(1.0f); 213 guestureEventHub->frameNodeOffset_.SetY(1.0f); 214 guestureEventHub->GetPixelMapOffset(info, size, dragInfoData, scale, innerRect); 215 EXPECT_EQ(innerRect.Width(), 0.0); 216 217 size.SetWidth(7.0f); 218 size.SetHeight(8.0f); 219 innerRect.SetRect(1.0f, 1.0f, 5.0f, 6.0f); 220 guestureEventHub->GetPixelMapOffset(info, size, dragInfoData, scale, innerRect); 221 EXPECT_EQ(innerRect.Width(), 5.0); 222 223 guestureEventHub->frameNodeSize_.SetWidth(4.0f); 224 guestureEventHub->frameNodeSize_.SetHeight(5.0f); 225 innerRect.SetRect(0.0f, 0.0f, 0.0f, 0.0f); 226 guestureEventHub->GetPixelMapOffset(info, size, dragInfoData, scale, innerRect); 227 EXPECT_EQ(innerRect.Width(), 0); 228 229 dragInfoData.isNeedCreateTiled = true; 230 guestureEventHub->GetPixelMapOffset(info, size, dragInfoData, scale, innerRect); 231 EXPECT_EQ(innerRect.Width(), 0); 232 } 233 234 /** 235 * @tc.name: ProcessMenuPreviewScale_001 236 * @tc.desc: Test ProcessMenuPreviewScale 237 * @tc.type: FUNC 238 */ 239 HWTEST_F(GestureEventHubTestNg, ProcessMenuPreviewScale_001, TestSize.Level1) 240 { 241 /** 242 * @tc.steps: step1. Create GestureEventHub. 243 * @tc.expected: gestureEventHub is not null. 244 */ 245 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 246 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 247 ASSERT_NE(guestureEventHub, nullptr); 248 249 /** 250 * @tc.steps: step2. updates event and pipeline attributes. 251 */ 252 auto event = guestureEventHub->eventHub_.Upgrade(); 253 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 254 255 auto pipeline = PipelineContext::GetCurrentContext(); 256 EXPECT_TRUE(pipeline); 257 258 /** 259 * @tc.steps: step3. call ProcessMenuPreviewScale. 260 */ 261 float scale = 0.0f; 262 float previewScale = 0.0f; 263 float windowScale = 0.0f; 264 float defaultMenuPreviewScale = 0.0f; 265 guestureEventHub->ProcessMenuPreviewScale(frameNode, scale, previewScale, windowScale, defaultMenuPreviewScale); 266 EXPECT_EQ(frameNode->GetOrCreateGestureEventHub()->GetMenuPreviewScale(), scale); 267 } 268 269 /** 270 * @tc.name: GetPreScaledPixelMapIfExist_001 271 * @tc.desc: Test GetPreScaledPixelMapIfExist 272 * @tc.type: FUNC 273 */ 274 HWTEST_F(GestureEventHubTestNg, GetPreScaledPixelMapIfExist_001, TestSize.Level1) 275 { 276 /** 277 * @tc.steps: step1. Create GestureEventHub. 278 * @tc.expected: gestureEventHub is not null. 279 */ 280 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 281 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 282 ASSERT_NE(guestureEventHub, nullptr); 283 guestureEventHub->InitDragDropEvent(); 284 285 /** 286 * @tc.steps: step2. updates event and pipeline attributes. 287 */ 288 auto event = guestureEventHub->eventHub_.Upgrade(); 289 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 290 291 auto pipeline = PipelineContext::GetCurrentContext(); 292 EXPECT_TRUE(pipeline); 293 294 /** 295 * @tc.steps: step3. mock pixelmap and subwindow 296 */ 297 auto pixelMap = AceType::MakeRefPtr<MockPixelMap>(); 298 ASSERT_NE(pixelMap, nullptr); 299 EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(testing::Return(4.0f)); 300 EXPECT_CALL(*pixelMap, GetHeight()).WillRepeatedly(testing::Return(5.0f)); 301 guestureEventHub->SetPixelMap(pixelMap); 302 guestureEventHub->dragEventActuator_->preScaledPixelMap_ = pixelMap; 303 304 /** 305 * @tc.steps: step3. call GetPreScaledPixelMapIfExist. 306 */ 307 EXPECT_NE(guestureEventHub->GetPreScaledPixelMapIfExist(1.0f, pixelMap), nullptr); 308 309 auto frameNode1 = guestureEventHub->GetFrameNode(); 310 DragDropInfo info; 311 info.onlyForLifting = true; 312 frameNode1->SetDragPreview(info); 313 EXPECT_NE(guestureEventHub->GetPreScaledPixelMapIfExist(2.0f, pixelMap), nullptr); 314 } 315 316 /** 317 * @tc.name: GetPixelMapScale_001 318 * @tc.desc: Test GetPixelMapScale 319 * @tc.type: FUNC 320 */ 321 HWTEST_F(GestureEventHubTestNg, GetPixelMapScale_001, TestSize.Level1) 322 { 323 /** 324 * @tc.steps: step1. Create GestureEventHub. 325 * @tc.expected: gestureEventHub is not null. 326 */ 327 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 328 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 329 ASSERT_NE(guestureEventHub, nullptr); 330 331 /** 332 * @tc.steps: step2. updates event and pipeline attributes. 333 */ 334 auto event = guestureEventHub->eventHub_.Upgrade(); 335 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 336 337 auto pipeline = PipelineContext::GetCurrentContext(); 338 EXPECT_TRUE(pipeline); 339 340 /** 341 * @tc.steps: step3. call GetPixelMapScale. 342 */ 343 auto ret = guestureEventHub->GetPixelMapScale(0.0f, 0.0f); 344 EXPECT_EQ(ret, 1); 345 346 ret = guestureEventHub->GetPixelMapScale(1.0f, 1.0f); 347 EXPECT_EQ(ret, 1); 348 } 349 350 /** 351 * @tc.name: GetPixelMapScale_002 352 * @tc.desc: Test GetPixelMapScale 353 * @tc.type: FUNC 354 */ 355 HWTEST_F(GestureEventHubTestNg, GetPixelMapScale_002, TestSize.Level1) 356 { 357 /** 358 * @tc.steps: step1. Create GestureEventHub. 359 * @tc.expected: gestureEventHub is not null. 360 */ 361 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 362 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 363 ASSERT_NE(guestureEventHub, nullptr); 364 365 /** 366 * @tc.steps: step2. updates event and pipeline attributes. 367 */ 368 auto event = guestureEventHub->eventHub_.Upgrade(); 369 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 370 371 auto pipeline = PipelineContext::GetCurrentContext(); 372 EXPECT_TRUE(pipeline); 373 374 /** 375 * @tc.steps: step3. call GetPixelMapScale. 376 */ 377 auto frameNode1 = guestureEventHub->GetFrameNode(); 378 DragPreviewOption dpo = frameNode1->GetDragPreviewOption(); 379 dpo.isScaleEnabled = true; 380 frameNode1->SetDragPreviewOptions(dpo); 381 auto ret = guestureEventHub->GetPixelMapScale(1.0f, 1.0f); 382 EXPECT_EQ(ret, 1); 383 384 SystemProperties::SetDevicePhysicalHeight(1300); 385 ret = guestureEventHub->GetPixelMapScale(1.0f, 1.0f); 386 EXPECT_EQ(ret, 1); 387 388 SystemProperties::SetDevicePhysicalHeight(1300); 389 ret = guestureEventHub->GetPixelMapScale(400.0f, 1.0f); 390 EXPECT_NE(ret, 1); 391 392 SystemProperties::SetDevicePhysicalHeight(600); 393 guestureEventHub->SetTextDraggable(true); 394 ret = guestureEventHub->GetPixelMapScale(250.0f, 450.0f); 395 EXPECT_NE(ret, 1); 396 397 guestureEventHub->SetTextDraggable(false); 398 ret = guestureEventHub->GetPixelMapScale(250.0f, 250.0f); 399 EXPECT_NE(ret, 1); 400 } 401 402 /** 403 * @tc.name: GenerateMousePixelMap_001 404 * @tc.desc: Test GenerateMousePixelMap 405 * @tc.type: FUNC 406 */ 407 HWTEST_F(GestureEventHubTestNg, GenerateMousePixelMap_001, TestSize.Level1) 408 { 409 /** 410 * @tc.steps: step1. Create GestureEventHub. 411 * @tc.expected: gestureEventHub is not null. 412 */ 413 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 414 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 415 ASSERT_NE(guestureEventHub, nullptr); 416 417 /** 418 * @tc.steps: step2. updates event and pipeline attributes. 419 */ 420 auto event = guestureEventHub->eventHub_.Upgrade(); 421 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 422 423 auto pipeline = PipelineContext::GetCurrentContext(); 424 EXPECT_TRUE(pipeline); 425 426 /** 427 * @tc.steps: step3. call GenerateMousePixelMap. 428 */ 429 GestureEvent info; 430 guestureEventHub->SetTextDraggable(true); 431 guestureEventHub->GenerateMousePixelMap(info); 432 EXPECT_TRUE(guestureEventHub->GetTextDraggable()); 433 434 guestureEventHub->SetTextDraggable(false); 435 guestureEventHub->GenerateMousePixelMap(info); 436 EXPECT_FALSE(guestureEventHub->GetTextDraggable()); 437 } 438 439 /** 440 * @tc.name: HandleNotAllowDrag_001 441 * @tc.desc: Test HandleNotAllowDrag 442 * @tc.type: FUNC 443 */ 444 HWTEST_F(GestureEventHubTestNg, HandleNotAllowDrag_001, TestSize.Level1) 445 { 446 /** 447 * @tc.steps: step1. Create GestureEventHub. 448 * @tc.expected: gestureEventHub is not null. 449 */ 450 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 451 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 452 ASSERT_NE(guestureEventHub, nullptr); 453 454 /** 455 * @tc.steps: step2. updates event and pipeline attributes. 456 */ 457 auto event = guestureEventHub->eventHub_.Upgrade(); 458 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 459 460 auto pipeline = PipelineContext::GetCurrentContext(); 461 EXPECT_TRUE(pipeline); 462 463 /** 464 * @tc.steps: step3. call HandleNotAllowDrag. 465 */ 466 GestureEvent info; 467 guestureEventHub->HandleNotAllowDrag(info); 468 EXPECT_TRUE(guestureEventHub->isReceivedDragGestureInfo_); 469 } 470 471 /** 472 * @tc.name: HandleNotAllowDrag_002 473 * @tc.desc: Test HandleNotAllowDrag 474 * @tc.type: FUNC 475 */ 476 HWTEST_F(GestureEventHubTestNg, HandleNotAllowDrag_002, TestSize.Level1) 477 { 478 /** 479 * @tc.steps: step1. Create GestureEventHub. 480 * @tc.expected: gestureEventHub is not null. 481 */ 482 auto frameNode = FrameNode::CreateFrameNode("nnnnn", 102, AceType::MakeRefPtr<Pattern>()); 483 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 484 ASSERT_NE(guestureEventHub, nullptr); 485 486 /** 487 * @tc.steps: step2. updates event and pipeline attributes. 488 */ 489 auto event = guestureEventHub->eventHub_.Upgrade(); 490 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 491 492 auto pipeline = PipelineContext::GetCurrentContext(); 493 EXPECT_TRUE(pipeline); 494 495 /** 496 * @tc.steps: step3. call HandleNotAllowDrag. 497 */ 498 GestureEvent info; 499 guestureEventHub->isReceivedDragGestureInfo_ = false; 500 guestureEventHub->HandleNotAllowDrag(info); 501 EXPECT_FALSE(guestureEventHub->isReceivedDragGestureInfo_); 502 } 503 504 /** 505 * @tc.name: HandleDragThroughTouch_001 506 * @tc.desc: Test HandleDragThroughTouch 507 * @tc.type: FUNC 508 */ 509 HWTEST_F(GestureEventHubTestNg, HandleDragThroughTouch_001, TestSize.Level1) 510 { 511 /** 512 * @tc.steps: step1. Create GestureEventHub. 513 * @tc.expected: gestureEventHub is not null. 514 */ 515 auto frameNode = FrameNode::CreateFrameNode("nnnnn", 102, AceType::MakeRefPtr<Pattern>()); 516 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 517 ASSERT_NE(guestureEventHub, nullptr); 518 519 /** 520 * @tc.steps: step2. updates event and pipeline attributes. 521 */ 522 auto event = guestureEventHub->eventHub_.Upgrade(); 523 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 524 525 auto pipeline = PipelineContext::GetCurrentContext(); 526 EXPECT_TRUE(pipeline); 527 528 /** 529 * @tc.steps: step3. call HandleDragThroughTouch. 530 */ 531 auto pipeline1 = frameNode->GetContextRefPtr(); 532 CHECK_NULL_VOID(pipeline1); 533 auto dragDropManager = pipeline1->GetDragDropManager(); 534 CHECK_NULL_VOID(dragDropManager); 535 dragDropManager->SetGrayedState(true); 536 guestureEventHub->HandleDragThroughTouch(frameNode); 537 EXPECT_TRUE(dragDropManager->GetGrayedState()); 538 539 dragDropManager->SetGrayedState(false); 540 guestureEventHub->HandleDragThroughTouch(frameNode); 541 EXPECT_FALSE(dragDropManager->GetGrayedState()); 542 543 auto overlayManager = pipeline1->GetOverlayManager(); 544 CHECK_NULL_VOID(overlayManager); 545 std::vector<GatherNodeChildInfo> gatherNodeChildrenInfo; 546 overlayManager->MountGatherNodeToRootNode(frameNode, gatherNodeChildrenInfo); 547 guestureEventHub->HandleDragThroughTouch(frameNode); 548 EXPECT_TRUE(dragDropManager->GetGrayedState()); 549 } 550 551 /** 552 * @tc.name: HandleDragThroughMouse_001 553 * @tc.desc: Test HandleDragThroughMouse 554 * @tc.type: FUNC 555 */ 556 HWTEST_F(GestureEventHubTestNg, HandleDragThroughMouse_001, TestSize.Level1) 557 { 558 /** 559 * @tc.steps: step1. Create GestureEventHub. 560 * @tc.expected: gestureEventHub is not null. 561 */ 562 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 563 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 564 ASSERT_NE(guestureEventHub, nullptr); 565 guestureEventHub->InitDragDropEvent(); 566 567 /** 568 * @tc.steps: step2. updates event and pipeline attributes. 569 */ 570 auto event = guestureEventHub->eventHub_.Upgrade(); 571 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 572 573 auto pipeline = PipelineContext::GetCurrentContext(); 574 EXPECT_TRUE(pipeline); 575 576 /** 577 * @tc.steps: step3. call HandleDragThroughMouse. 578 */ 579 auto pipeline1 = frameNode->GetContextRefPtr(); 580 CHECK_NULL_VOID(pipeline1); 581 auto dragDropManager = pipeline1->GetDragDropManager(); 582 CHECK_NULL_VOID(dragDropManager); 583 dragDropManager->SetGrayedState(true); 584 guestureEventHub->HandleDragThroughMouse(frameNode); 585 EXPECT_TRUE(dragDropManager->GetGrayedState()); 586 587 dragDropManager->SetGrayedState(false); 588 guestureEventHub->HandleDragThroughMouse(frameNode); 589 EXPECT_TRUE(dragDropManager->GetGrayedState()); 590 591 dragDropManager->SetGrayedState(false); 592 guestureEventHub->dragEventActuator_->isSelectedItemNode_ = true; 593 guestureEventHub->HandleDragThroughMouse(frameNode); 594 EXPECT_TRUE(dragDropManager->GetGrayedState()); 595 } 596 597 /** 598 * @tc.name: IsNeedSwitchToSubWindow_001 599 * @tc.desc: Test IsNeedSwitchToSubWindow 600 * @tc.type: FUNC 601 */ 602 HWTEST_F(GestureEventHubTestNg, IsNeedSwitchToSubWindow_001, TestSize.Level1) 603 { 604 /** 605 * @tc.steps: step1. Create GestureEventHub. 606 * @tc.expected: gestureEventHub is not null. 607 */ 608 auto frameNode = FrameNode::CreateFrameNode("nnnnn", 102, AceType::MakeRefPtr<Pattern>()); 609 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 610 ASSERT_NE(guestureEventHub, nullptr); 611 guestureEventHub->InitDragDropEvent(); 612 613 /** 614 * @tc.steps: step2. updates event and pipeline attributes. 615 */ 616 auto event = guestureEventHub->eventHub_.Upgrade(); 617 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 618 619 auto pipeline = PipelineContext::GetCurrentContext(); 620 EXPECT_TRUE(pipeline); 621 622 /** 623 * @tc.steps: step3. call IsNeedSwitchToSubWindow. 624 */ 625 PreparedInfoForDrag dragInfoData; 626 dragInfoData.isMenuShow = true; 627 guestureEventHub->IsNeedSwitchToSubWindow(dragInfoData); 628 EXPECT_TRUE(dragInfoData.isMenuShow); 629 630 dragInfoData.isMenuShow = false; 631 dragInfoData.isNeedCreateTiled = true; 632 guestureEventHub->IsNeedSwitchToSubWindow(dragInfoData); 633 EXPECT_TRUE(dragInfoData.isNeedCreateTiled); 634 635 dragInfoData.isMenuShow = false; 636 dragInfoData.isNeedCreateTiled = false; 637 guestureEventHub->IsNeedSwitchToSubWindow(dragInfoData); 638 EXPECT_FALSE(guestureEventHub->IsPixelMapNeedScale()); 639 } 640 641 /** 642 * @tc.name: ParsePixelMapAsync_001 643 * @tc.desc: Test ParsePixelMapAsync 644 * @tc.type: FUNC 645 */ 646 HWTEST_F(GestureEventHubTestNg, ParsePixelMapAsync_001, TestSize.Level1) 647 { 648 /** 649 * @tc.steps: step1. Create GestureEventHub. 650 * @tc.expected: gestureEventHub is not null. 651 */ 652 auto frameNode = FrameNode::CreateFrameNode("nnnnn", 102, AceType::MakeRefPtr<Pattern>()); 653 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 654 ASSERT_NE(guestureEventHub, nullptr); 655 guestureEventHub->InitDragDropEvent(); 656 657 /** 658 * @tc.steps: step2. updates event and pipeline attributes. 659 */ 660 auto event = guestureEventHub->eventHub_.Upgrade(); 661 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 662 663 auto pipeline = PipelineContext::GetCurrentContext(); 664 EXPECT_TRUE(pipeline); 665 666 /** 667 * @tc.steps: step3. call ParsePixelMapAsync. 668 */ 669 auto pixelMap = AceType::MakeRefPtr<MockPixelMap>(); 670 DragDropInfo dragDropInfo; 671 DragDropInfo dragPreviewInfo; 672 GestureEvent info; 673 auto ret = guestureEventHub->ParsePixelMapAsync(dragDropInfo, dragPreviewInfo, info); 674 EXPECT_FALSE(ret); 675 676 dragPreviewInfo.pixelMap = pixelMap; 677 ret = guestureEventHub->ParsePixelMapAsync(dragDropInfo, dragPreviewInfo, info); 678 EXPECT_TRUE(ret); 679 680 guestureEventHub->dragPreviewPixelMap_ = nullptr; 681 dragPreviewInfo.pixelMap = nullptr; 682 RefPtr<UINode> customNode1 = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>()); 683 dragPreviewInfo.customNode = customNode1; 684 ret = guestureEventHub->ParsePixelMapAsync(dragDropInfo, dragPreviewInfo, info); 685 EXPECT_TRUE(ret); 686 687 guestureEventHub->SetDragPreviewPixelMap(pixelMap); 688 ret = guestureEventHub->ParsePixelMapAsync(dragDropInfo, dragPreviewInfo, info); 689 EXPECT_TRUE(ret); 690 691 guestureEventHub->dragPreviewPixelMap_ = nullptr; 692 dragPreviewInfo.inspectorId = ""; 693 dragPreviewInfo.inspectorId = "test"; 694 ret = guestureEventHub->ParsePixelMapAsync(dragDropInfo, dragPreviewInfo, info); 695 EXPECT_TRUE(ret); 696 697 guestureEventHub->dragPreviewPixelMap_ = pixelMap; 698 ret = guestureEventHub->ParsePixelMapAsync(dragDropInfo, dragPreviewInfo, info); 699 EXPECT_TRUE(ret); 700 } 701 702 /** 703 * @tc.name: DoOnDragStartHandling_001 704 * @tc.desc: Test DoOnDragStartHandling 705 * @tc.type: FUNC 706 */ 707 HWTEST_F(GestureEventHubTestNg, DoOnDragStartHandling_001, TestSize.Level1) 708 { 709 /** 710 * @tc.steps: step1. Create GestureEventHub. 711 * @tc.expected: gestureEventHub is not null. 712 */ 713 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 714 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 715 ASSERT_NE(guestureEventHub, nullptr); 716 guestureEventHub->InitDragDropEvent(); 717 718 /** 719 * @tc.steps: step2. updates event and pipeline attributes. 720 */ 721 auto event = guestureEventHub->eventHub_.Upgrade(); 722 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 723 724 auto pipeline = PipelineContext::GetCurrentContext(); 725 EXPECT_TRUE(pipeline); 726 727 /** 728 * @tc.steps: step3. call DoOnDragStartHandling. 729 */ 730 auto pixelMap = AceType::MakeRefPtr<MockPixelMap>(); 731 GestureEvent info; 732 DragDropInfo dragDropInfo; 733 RefPtr<OHOS::Ace::DragEvent> event1 = AceType::MakeRefPtr<OHOS::Ace::DragEvent>(); 734 DragDropInfo dragPreviewInfo; 735 guestureEventHub->DoOnDragStartHandling(info, frameNode, dragDropInfo, event1, dragPreviewInfo, pipeline); 736 EXPECT_EQ(dragDropInfo.pixelMap, 0); 737 738 dragPreviewInfo.pixelMap = pixelMap; 739 guestureEventHub->DoOnDragStartHandling(info, frameNode, dragDropInfo, event1, dragPreviewInfo, pipeline); 740 EXPECT_TRUE(guestureEventHub->ParsePixelMapAsync(dragDropInfo, dragPreviewInfo, info)); 741 } 742 743 /** 744 * @tc.name: DoOnDragStartHandling_002 745 * @tc.desc: Test DoOnDragStartHandling 746 * @tc.type: FUNC 747 */ 748 HWTEST_F(GestureEventHubTestNg, DoOnDragStartHandling_002, TestSize.Level1) 749 { 750 /** 751 * @tc.steps: step1. Create GestureEventHub. 752 * @tc.expected: gestureEventHub is not null. 753 */ 754 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 755 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 756 ASSERT_NE(guestureEventHub, nullptr); 757 guestureEventHub->InitDragDropEvent(); 758 759 /** 760 * @tc.steps: step2. updates event and pipeline attributes. 761 */ 762 auto event = guestureEventHub->eventHub_.Upgrade(); 763 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 764 765 auto pipeline = PipelineContext::GetCurrentContext(); 766 EXPECT_TRUE(pipeline); 767 768 /** 769 * @tc.steps: step3. call DoOnDragStartHandling. 770 */ 771 auto pixelMap = AceType::MakeRefPtr<MockPixelMap>(); 772 GestureEvent info; 773 DragDropInfo dragDropInfo; 774 InputEventType inputEventType_ = InputEventType::TOUCH_SCREEN; 775 info.SetInputEventType(inputEventType_); 776 RefPtr<OHOS::Ace::DragEvent> event1 = AceType::MakeRefPtr<OHOS::Ace::DragEvent>(); 777 DragDropInfo dragPreviewInfo; 778 guestureEventHub->textDraggable_ = true; 779 guestureEventHub->pixelMap_ = pixelMap; 780 guestureEventHub->DoOnDragStartHandling(info, frameNode, dragDropInfo, event1, dragPreviewInfo, pipeline); 781 EXPECT_EQ(dragDropInfo.pixelMap, 0); 782 783 info.inputEventType_ = InputEventType::MOUSE_BUTTON; 784 dragDropInfo.pixelMap = nullptr; 785 guestureEventHub->pixelMap_ = nullptr; 786 guestureEventHub->DoOnDragStartHandling(info, frameNode, dragDropInfo, event1, dragPreviewInfo, pipeline); 787 EXPECT_EQ(dragDropInfo.pixelMap, 0); 788 } 789 790 /** 791 * @tc.name: StartVibratorByDrag_001 792 * @tc.desc: Test StartVibratorByDrag 793 * @tc.type: FUNC 794 */ 795 HWTEST_F(GestureEventHubTestNg, StartVibratorByDrag_001, TestSize.Level1) 796 { 797 /** 798 * @tc.steps: step1. Create GestureEventHub. 799 * @tc.expected: gestureEventHub is not null. 800 */ 801 auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>()); 802 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 803 ASSERT_NE(guestureEventHub, nullptr); 804 guestureEventHub->InitDragDropEvent(); 805 806 /** 807 * @tc.steps: step2. updates event and pipeline attributes. 808 */ 809 auto event = guestureEventHub->eventHub_.Upgrade(); 810 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 811 812 auto pipeline = PipelineContext::GetCurrentContext(); 813 EXPECT_TRUE(pipeline); 814 815 /** 816 * @tc.steps: step3. call StartVibratorByDrag. 817 */ 818 guestureEventHub->StartVibratorByDrag(frameNode); 819 EXPECT_FALSE(OHOS::Ace::NG::DragDropGlobalController::GetInstance().isDragFilterShowing_); 820 821 DragPreviewOption previewOption; 822 previewOption.enableHapticFeedback = true; 823 frameNode->SetDragPreviewOptions(previewOption); 824 guestureEventHub->StartVibratorByDrag(frameNode); 825 826 previewOption.enableHapticFeedback = false; 827 frameNode->SetDragPreviewOptions(previewOption); 828 OHOS::Ace::NG::DragDropGlobalController::GetInstance().isDragFilterShowing_ = true; 829 guestureEventHub->StartVibratorByDrag(frameNode); 830 831 previewOption.enableHapticFeedback = true; 832 frameNode->SetDragPreviewOptions(previewOption); 833 OHOS::Ace::NG::DragDropGlobalController::GetInstance().isDragFilterShowing_ = true; 834 guestureEventHub->StartVibratorByDrag(frameNode); 835 EXPECT_FALSE(OHOS::Ace::NG::DragDropGlobalController::GetInstance().isDragFilterShowing_); 836 } 837 838 /** 839 * @tc.name: GetDragPreviewInitPositionToScreen_001 840 * @tc.desc: Test GetDragPreviewInitPositionToScreen 841 * @tc.type: FUNC 842 */ 843 HWTEST_F(GestureEventHubTestNg, GetDragPreviewInitPositionToScreen_001, TestSize.Level1) 844 { 845 /** 846 * @tc.steps: step1. Create GestureEventHub. 847 * @tc.expected: gestureEventHub is not null. 848 */ 849 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 850 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 851 ASSERT_NE(guestureEventHub, nullptr); 852 guestureEventHub->InitDragDropEvent(); 853 854 /** 855 * @tc.steps: step2. updates event and pipeline attributes. 856 */ 857 auto event = guestureEventHub->eventHub_.Upgrade(); 858 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 859 860 auto pipeline = PipelineContext::GetCurrentContext(); 861 EXPECT_TRUE(pipeline); 862 863 /** 864 * @tc.steps: step3. call GetDragPreviewInitPositionToScreen. 865 */ 866 RefPtr<PipelineBase> context = NG::MockPipelineContext::pipeline_; 867 PreparedInfoForDrag data; 868 auto offsetF = guestureEventHub->GetDragPreviewInitPositionToScreen(context, data); 869 EXPECT_EQ(offsetF.GetX(), 0.0f); 870 871 guestureEventHub->textDraggable_ = true; 872 offsetF = guestureEventHub->GetDragPreviewInitPositionToScreen(context, data); 873 874 guestureEventHub->textDraggable_ = false; 875 offsetF = guestureEventHub->GetDragPreviewInitPositionToScreen(context, data); 876 EXPECT_EQ(offsetF.GetX(), 0.0f); 877 878 data.imageNode = FrameNode::CreateFrameNode(V2::IMAGE_ETS_TAG, 0, AceType::MakeRefPtr<ImagePattern>()); 879 auto frameNode1 =guestureEventHub->GetFrameNode(); 880 frameNode1->tag_ = V2::WEB_ETS_TAG; 881 data.isMenuShow = true; 882 offsetF = guestureEventHub->GetDragPreviewInitPositionToScreen(context, data); 883 EXPECT_EQ(offsetF.GetX(), 0.0f); 884 885 DragPreviewOption previewOption; 886 previewOption.sizeChangeEffect= DraggingSizeChangeEffect::SIZE_TRANSITION; 887 data.imageNode->SetDragPreviewOptions(previewOption); 888 OffsetF dragMovePosition = { 2.0f, 3.0f }; 889 data.dragMovePosition = dragMovePosition; 890 offsetF = guestureEventHub->GetDragPreviewInitPositionToScreen(context, data); 891 EXPECT_EQ(offsetF.GetX(), 2.0f); 892 } 893 894 /** 895 * @tc.name: GetBadgeNumber_001 896 * @tc.desc: Test GetBadgeNumber 897 * @tc.type: FUNC 898 */ 899 HWTEST_F(GestureEventHubTestNg, GetBadgeNumber_001, TestSize.Level1) 900 { 901 /** 902 * @tc.steps: step1. Create GestureEventHub. 903 * @tc.expected: gestureEventHub is not null. 904 */ 905 auto frameNode = FrameNode::CreateFrameNode("nnnnn", 102, AceType::MakeRefPtr<Pattern>()); 906 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 907 ASSERT_NE(guestureEventHub, nullptr); 908 guestureEventHub->InitDragDropEvent(); 909 910 /** 911 * @tc.steps: step2. updates event and pipeline attributes. 912 */ 913 auto event = guestureEventHub->eventHub_.Upgrade(); 914 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 915 916 auto pipeline = PipelineContext::GetCurrentContext(); 917 EXPECT_TRUE(pipeline); 918 919 /** 920 * @tc.steps: step3. call GetBadgeNumber. 921 */ 922 RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>(); 923 ASSERT_NE(dragEvent, nullptr); 924 RefPtr<MockUnifiedData> unifiedData = AceType::MakeRefPtr<MockUnifiedData>(); 925 ASSERT_NE(unifiedData, nullptr); 926 dragEvent->SetData(unifiedData); 927 EXPECT_CALL(*unifiedData, GetSize()).WillRepeatedly(testing::Return(5)); 928 dragEvent->SetUseDataLoadParams(false); 929 auto ret1 = guestureEventHub->GetBadgeNumber(dragEvent); 930 EXPECT_EQ(ret1, 5); 931 932 dragEvent->SetUseDataLoadParams(true); 933 RefPtr<MockDataLoadParams> mockDataLoadParams = AceType::MakeRefPtr<MockDataLoadParams>(); 934 ASSERT_NE(mockDataLoadParams, nullptr); 935 dragEvent->SetDataLoadParams(mockDataLoadParams); 936 EXPECT_CALL(*mockDataLoadParams, GetRecordCount()).WillRepeatedly(testing::Return(-1)); 937 auto ret2 = guestureEventHub->GetBadgeNumber(dragEvent); 938 EXPECT_EQ(ret2, 1); 939 940 EXPECT_CALL(*mockDataLoadParams, GetRecordCount()).WillRepeatedly(testing::Return(0)); 941 auto ret3 = guestureEventHub->GetBadgeNumber(dragEvent); 942 EXPECT_EQ(ret3, 1); 943 944 EXPECT_CALL(*mockDataLoadParams, GetRecordCount()).WillRepeatedly(testing::Return(INT32_MAX + 1)); 945 auto ret4 = guestureEventHub->GetBadgeNumber(dragEvent); 946 EXPECT_EQ(ret4, 1); 947 948 EXPECT_CALL(*mockDataLoadParams, GetRecordCount()).WillRepeatedly(testing::Return(10)); 949 auto ret5 = guestureEventHub->GetBadgeNumber(dragEvent); 950 EXPECT_EQ(ret5, 10); 951 } 952 953 /** 954 * @tc.name: TryDoDragStartAnimation_001 955 * @tc.desc: Test TryDoDragStartAnimation 956 * @tc.type: FUNC 957 */ 958 HWTEST_F(GestureEventHubTestNg, TryDoDragStartAnimation_001, TestSize.Level1) 959 { 960 /** 961 * @tc.steps: step1. Create GestureEventHub. 962 * @tc.expected: gestureEventHub is not null. 963 */ 964 auto frameNode = FrameNode::CreateFrameNode("nnnnn", 102, AceType::MakeRefPtr<Pattern>()); 965 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 966 ASSERT_NE(guestureEventHub, nullptr); 967 guestureEventHub->InitDragDropEvent(); 968 969 /** 970 * @tc.steps: step2. updates event and pipeline attributes. 971 */ 972 auto event = guestureEventHub->eventHub_.Upgrade(); 973 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 974 975 auto pipeline = PipelineContext::GetCurrentContext(); 976 EXPECT_TRUE(pipeline); 977 978 /** 979 * @tc.steps: step3. call TryDoDragStartAnimation. 980 */ 981 RefPtr<PipelineBase> context = NG::MockPipelineContext::pipeline_; 982 RefPtr<Subwindow> subWindow = nullptr; 983 GestureEvent info; 984 PreparedInfoForDrag data; 985 auto ret = guestureEventHub->TryDoDragStartAnimation(context, subWindow, info, data); 986 EXPECT_FALSE(ret); 987 988 auto pipeline1 = AceType::DynamicCast<PipelineContext>(context); 989 auto mainPipeline = PipelineContext::GetMainPipelineContext(); 990 subWindow = SubwindowManager::GetInstance()->ShowPreviewNG((pipeline1 != mainPipeline)); 991 ret = guestureEventHub->TryDoDragStartAnimation(context, subWindow, info, data); 992 EXPECT_FALSE(ret); 993 994 data.imageNode = FrameNode::CreateCommonNode("node", 1, false, AceType::MakeRefPtr<Pattern>()); 995 ret = guestureEventHub->TryDoDragStartAnimation(context, subWindow, info, data); 996 EXPECT_FALSE(ret); 997 } 998 999 /** 1000 * @tc.name: UpdateNodePositionBeforeStartAnimation_001 1001 * @tc.desc: Test UpdateNodePositionBeforeStartAnimation 1002 * @tc.type: FUNC 1003 */ 1004 HWTEST_F(GestureEventHubTestNg, UpdateNodePositionBeforeStartAnimation_001, TestSize.Level1) 1005 { 1006 /** 1007 * @tc.steps: step1. Create GestureEventHub. 1008 * @tc.expected: gestureEventHub is not null. 1009 */ 1010 auto frameNode = FrameNode::CreateFrameNode("nnnnn", 102, AceType::MakeRefPtr<Pattern>()); 1011 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1012 ASSERT_NE(guestureEventHub, nullptr); 1013 guestureEventHub->InitDragDropEvent(); 1014 1015 /** 1016 * @tc.steps: step2. updates event and pipeline attributes. 1017 */ 1018 auto event = guestureEventHub->eventHub_.Upgrade(); 1019 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1020 1021 auto pipeline = PipelineContext::GetCurrentContext(); 1022 EXPECT_TRUE(pipeline); 1023 1024 /** 1025 * @tc.steps: step3. call UpdateNodePositionBeforeStartAnimation. 1026 */ 1027 PreparedInfoForDrag data; 1028 guestureEventHub->UpdateNodePositionBeforeStartAnimation(frameNode, data); 1029 EXPECT_EQ(data.dragPreviewOffsetToScreen.GetX(), 0.0f); 1030 1031 data.isMenuShow = true; 1032 DragPreviewOption previewOption; 1033 previewOption.sizeChangeEffect = DraggingSizeChangeEffect::SIZE_TRANSITION; 1034 frameNode->SetDragPreviewOptions(previewOption); 1035 guestureEventHub->UpdateNodePositionBeforeStartAnimation(frameNode, data); 1036 EXPECT_EQ(data.dragPreviewOffsetToScreen.GetX(), 0.0f); 1037 } 1038 1039 /** 1040 * @tc.name: CheckAllowDrag_001 1041 * @tc.desc: Test CheckAllowDrag 1042 * @tc.type: FUNC 1043 */ 1044 HWTEST_F(GestureEventHubTestNg, CheckAllowDrag_001, TestSize.Level1) 1045 { 1046 /** 1047 * @tc.steps: step1. Create GestureEventHub. 1048 * @tc.expected: gestureEventHub is not null. 1049 */ 1050 auto frameNode = FrameNode::CreateFrameNode("nnnnn", 102, AceType::MakeRefPtr<Pattern>()); 1051 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1052 ASSERT_NE(guestureEventHub, nullptr); 1053 guestureEventHub->InitDragDropEvent(); 1054 1055 /** 1056 * @tc.steps: step2. updates event and pipeline attributes. 1057 */ 1058 auto event = guestureEventHub->eventHub_.Upgrade(); 1059 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1060 1061 auto pipeline = PipelineContext::GetCurrentContext(); 1062 EXPECT_TRUE(pipeline); 1063 1064 /** 1065 * @tc.steps: step3. call CheckAllowDrag. 1066 */ 1067 GestureEvent info; 1068 RefPtr<PipelineBase> context = NG::MockPipelineContext::pipeline_; 1069 auto ret = guestureEventHub->CheckAllowDrag(info, context, frameNode); 1070 EXPECT_FALSE(ret); 1071 1072 auto eventHub = guestureEventHub->eventHub_.Upgrade(); __anonfa8501890202(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) 1073 auto dragStart = [](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) -> DragDropInfo { 1074 NG::DragDropInfo itemInfo; 1075 itemInfo.customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>()); 1076 return itemInfo; 1077 }; 1078 eventHub->SetDefaultOnDragStart(std::move(dragStart)); 1079 ret = guestureEventHub->CheckAllowDrag(info, context, frameNode); 1080 EXPECT_TRUE(ret); 1081 1082 auto frameNode1 = guestureEventHub->GetFrameNode(); 1083 frameNode1->SetDraggable(false); 1084 ret = guestureEventHub->CheckAllowDrag(info, context, frameNode); 1085 EXPECT_FALSE(ret); 1086 1087 frameNode1->SetDraggable(true); 1088 info.inputEventType_ = InputEventType::MOUSE_BUTTON; 1089 auto pipeline1 = AceType::DynamicCast<PipelineContext>(context); 1090 auto eventManager = pipeline1->GetEventManager(); 1091 eventManager->SetLastMoveBeforeUp(true); 1092 ret = guestureEventHub->CheckAllowDrag(info, context, frameNode); 1093 EXPECT_FALSE(ret); 1094 } 1095 1096 /** 1097 * @tc.name: CreateDragEvent_001 1098 * @tc.desc: Test CreateDragEvent 1099 * @tc.type: FUNC 1100 */ 1101 HWTEST_F(GestureEventHubTestNg, CreateDragEvent_001, TestSize.Level1) 1102 { 1103 /** 1104 * @tc.steps: step1. Create GestureEventHub. 1105 * @tc.expected: gestureEventHub is not null. 1106 */ 1107 auto frameNode = FrameNode::CreateFrameNode("nnnnn", 102, AceType::MakeRefPtr<Pattern>()); 1108 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1109 ASSERT_NE(guestureEventHub, nullptr); 1110 guestureEventHub->InitDragDropEvent(); 1111 1112 /** 1113 * @tc.steps: step2. updates event and pipeline attributes. 1114 */ 1115 auto event = guestureEventHub->eventHub_.Upgrade(); 1116 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1117 1118 auto pipeline = PipelineContext::GetCurrentContext(); 1119 EXPECT_TRUE(pipeline); 1120 1121 /** 1122 * @tc.steps: step3. call CreateDragEvent. 1123 */ 1124 GestureEvent info; 1125 RefPtr<PipelineBase> context = NG::MockPipelineContext::pipeline_; 1126 auto dragEvent = guestureEventHub->CreateDragEvent(info, context, frameNode); 1127 EXPECT_EQ(dragEvent->GetX(), 0); 1128 } 1129 1130 /** 1131 * @tc.name: CreateDragEvent_002 1132 * @tc.desc: Test CreateDragEvent 1133 * @tc.type: FUNC 1134 */ 1135 HWTEST_F(GestureEventHubTestNg, CreateDragEvent_002, TestSize.Level1) 1136 { 1137 /** 1138 * @tc.steps: step1. Create GestureEventHub. 1139 * @tc.expected: gestureEventHub is not null. 1140 */ 1141 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 1142 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1143 ASSERT_NE(guestureEventHub, nullptr); 1144 guestureEventHub->InitDragDropEvent(); 1145 1146 /** 1147 * @tc.steps: step2. updates event and pipeline attributes. 1148 */ 1149 auto event = guestureEventHub->eventHub_.Upgrade(); 1150 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1151 1152 auto pipeline = PipelineContext::GetCurrentContext(); 1153 EXPECT_TRUE(pipeline); 1154 1155 /** 1156 * @tc.steps: step3. call CreateDragEvent. 1157 */ 1158 GestureEvent info; 1159 RefPtr<PipelineBase> context = NG::MockPipelineContext::pipeline_; 1160 auto dragEvent = guestureEventHub->CreateDragEvent(info, context, frameNode); 1161 EXPECT_EQ(dragEvent->GetX(), 0); 1162 } 1163 1164 /** 1165 * @tc.name: AddPreviewMenuHandleDragEnd_001 1166 * @tc.desc: Test AddPreviewMenuHandleDragEnd 1167 * @tc.type: FUNC 1168 */ 1169 HWTEST_F(GestureEventHubTestNg, AddPreviewMenuHandleDragEnd_001, TestSize.Level1) 1170 { 1171 /** 1172 * @tc.steps: step1. Create GestureEventHub. 1173 * @tc.expected: gestureEventHub is not null. 1174 */ 1175 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 1176 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1177 ASSERT_NE(guestureEventHub, nullptr); 1178 guestureEventHub->InitDragDropEvent(); 1179 1180 /** 1181 * @tc.steps: step2. updates event and pipeline attributes. 1182 */ 1183 auto event = guestureEventHub->eventHub_.Upgrade(); 1184 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1185 1186 auto pipeline = PipelineContext::GetCurrentContext(); 1187 EXPECT_TRUE(pipeline); 1188 1189 /** 1190 * @tc.steps: step3. call AddPreviewMenuHandleDragEnd. 1191 */ __anonfa8501890302(const GestureEvent& info) 1192 auto actionEnd = [](const GestureEvent& info) { 1193 return; 1194 }; 1195 guestureEventHub->AddPreviewMenuHandleDragEnd(actionEnd); 1196 EXPECT_NE(guestureEventHub->scrollableActuator_, nullptr); 1197 1198 guestureEventHub->AddPreviewMenuHandleDragEnd(actionEnd); 1199 EXPECT_NE(guestureEventHub->scrollableActuator_, nullptr); 1200 } 1201 1202 /** 1203 * @tc.name: SetDragEventd_001 1204 * @tc.desc: Test SetDragEvent 1205 * @tc.type: FUNC 1206 */ 1207 HWTEST_F(GestureEventHubTestNg, SetDragEvent_001, TestSize.Level1) 1208 { 1209 /** 1210 * @tc.steps: step1. Create GestureEventHub. 1211 * @tc.expected: gestureEventHub is not null. 1212 */ 1213 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 1214 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1215 ASSERT_NE(guestureEventHub, nullptr); 1216 guestureEventHub->InitDragDropEvent(); 1217 1218 /** 1219 * @tc.steps: step2. updates event and pipeline attributes. 1220 */ 1221 auto event = guestureEventHub->eventHub_.Upgrade(); 1222 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1223 1224 auto pipeline = PipelineContext::GetCurrentContext(); 1225 EXPECT_TRUE(pipeline); 1226 1227 /** 1228 * @tc.steps: step3. call SetDragEvent. 1229 */ 1230 RefPtr<DragEvent> dragEvent = nullptr; 1231 PanDirection direction; 1232 int32_t fingers = 0; 1233 Dimension distance; 1234 guestureEventHub->SetDragEvent(dragEvent, direction, fingers, distance); 1235 EXPECT_NE(guestureEventHub->dragEventActuator_, nullptr); 1236 1237 guestureEventHub->dragEventActuator_->SetIsNewFwk(true); 1238 guestureEventHub->SetDragEvent(dragEvent, direction, fingers, distance); 1239 EXPECT_NE(guestureEventHub->dragEventActuator_, nullptr); 1240 1241 guestureEventHub->dragEventActuator_ = nullptr; 1242 guestureEventHub->SetDragEvent(dragEvent, direction, fingers, distance); 1243 EXPECT_NE(guestureEventHub->dragEventActuator_, nullptr); 1244 } 1245 1246 /** 1247 * @tc.name: SetDragDropEvent_001 1248 * @tc.desc: Test SetDragDropEvent 1249 * @tc.type: FUNC 1250 */ 1251 HWTEST_F(GestureEventHubTestNg, SetDragDropEvent_001, TestSize.Level1) 1252 { 1253 /** 1254 * @tc.steps: step1. Create GestureEventHub. 1255 * @tc.expected: gestureEventHub is not null. 1256 */ 1257 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 1258 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1259 ASSERT_NE(guestureEventHub, nullptr); 1260 guestureEventHub->InitDragDropEvent(); 1261 1262 /** 1263 * @tc.steps: step2. updates event and pipeline attributes. 1264 */ 1265 auto event = guestureEventHub->eventHub_.Upgrade(); 1266 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1267 1268 auto pipeline = PipelineContext::GetCurrentContext(); 1269 EXPECT_TRUE(pipeline); 1270 1271 /** 1272 * @tc.steps: step3. call SetDragDropEvent. 1273 */ 1274 guestureEventHub->SetDragDropEvent(); 1275 EXPECT_TRUE(guestureEventHub->isDragNewFwk_); 1276 1277 guestureEventHub->dragEventActuator_->SetIsNewFwk(true); 1278 guestureEventHub->SetDragDropEvent(); 1279 EXPECT_TRUE(guestureEventHub->isDragNewFwk_); 1280 1281 guestureEventHub->dragEventActuator_ = nullptr; 1282 guestureEventHub->SetDragDropEvent(); 1283 EXPECT_TRUE(guestureEventHub->isDragNewFwk_); 1284 } 1285 1286 /** 1287 * @tc.name: RemoveDragEvent_001 1288 * @tc.desc: Test RemoveDragEvent 1289 * @tc.type: FUNC 1290 */ 1291 HWTEST_F(GestureEventHubTestNg, RemoveDragEvent_001, TestSize.Level1) 1292 { 1293 /** 1294 * @tc.steps: step1. Create GestureEventHub. 1295 * @tc.expected: gestureEventHub is not null. 1296 */ 1297 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 1298 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1299 ASSERT_NE(guestureEventHub, nullptr); 1300 guestureEventHub->InitDragDropEvent(); 1301 1302 /** 1303 * @tc.steps: step2. updates event and pipeline attributes. 1304 */ 1305 auto event = guestureEventHub->eventHub_.Upgrade(); 1306 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1307 1308 auto pipeline = PipelineContext::GetCurrentContext(); 1309 EXPECT_TRUE(pipeline); 1310 1311 /** 1312 * @tc.steps: step3. call RemoveDragEvent. 1313 */ 1314 guestureEventHub->RemoveDragEvent(); 1315 EXPECT_NE(guestureEventHub->dragEventActuator_, nullptr); 1316 1317 guestureEventHub->dragEventActuator_->SetIsNewFwk(true); 1318 guestureEventHub->RemoveDragEvent(); 1319 EXPECT_EQ(guestureEventHub->dragEventActuator_, 0); 1320 1321 guestureEventHub->dragEventActuator_ = nullptr; 1322 guestureEventHub->RemoveDragEvent(); 1323 EXPECT_EQ(guestureEventHub->dragEventActuator_, 0); 1324 } 1325 1326 /** 1327 * @tc.name: SetThumbnailCallback_001 1328 * @tc.desc: Test SetThumbnailCallback 1329 * @tc.type: FUNC 1330 */ 1331 HWTEST_F(GestureEventHubTestNg, SetThumbnailCallback_001, TestSize.Level1) 1332 { 1333 /** 1334 * @tc.steps: step1. Create GestureEventHub. 1335 * @tc.expected: gestureEventHub is not null. 1336 */ 1337 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 1338 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1339 ASSERT_NE(guestureEventHub, nullptr); 1340 guestureEventHub->InitDragDropEvent(); 1341 1342 /** 1343 * @tc.steps: step2. updates event and pipeline attributes. 1344 */ 1345 auto event = guestureEventHub->eventHub_.Upgrade(); 1346 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1347 1348 auto pipeline = PipelineContext::GetCurrentContext(); 1349 EXPECT_TRUE(pipeline); 1350 1351 /** 1352 * @tc.steps: step3. call SetThumbnailCallback. 1353 */ __anonfa8501890402(Offset offset) 1354 auto func = [](Offset offset) { 1355 return; 1356 }; 1357 guestureEventHub->SetThumbnailCallback(func); 1358 EXPECT_NE(guestureEventHub->dragEventActuator_, nullptr); 1359 1360 guestureEventHub->dragEventActuator_ = nullptr; 1361 guestureEventHub->SetThumbnailCallback(func); 1362 EXPECT_EQ(guestureEventHub->dragEventActuator_, 0); 1363 } 1364 1365 /** 1366 * @tc.name: CheckNeedDragDropFrameworkStatus_001 1367 * @tc.desc: Test CheckNeedDragDropFrameworkStatus 1368 * @tc.type: FUNC 1369 */ 1370 HWTEST_F(GestureEventHubTestNg, CheckNeedDragDropFrameworkStatus_001, TestSize.Level1) 1371 { 1372 /** 1373 * @tc.steps: step1. Create GestureEventHub. 1374 * @tc.expected: gestureEventHub is not null. 1375 */ 1376 auto frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>()); 1377 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1378 ASSERT_NE(guestureEventHub, nullptr); 1379 guestureEventHub->InitDragDropEvent(); 1380 1381 /** 1382 * @tc.steps: step2. updates event and pipeline attributes. 1383 */ 1384 auto event = guestureEventHub->eventHub_.Upgrade(); 1385 event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode)); 1386 1387 auto pipeline = PipelineContext::GetCurrentContext(); 1388 EXPECT_TRUE(pipeline); 1389 1390 /** 1391 * @tc.steps: step3. call CheckNeedDragDropFrameworkStatus. 1392 */ 1393 SystemProperties::dragDropFrameworkStatus_ = 0; 1394 guestureEventHub->InitDragDropEvent(); 1395 1396 SystemProperties::dragDropFrameworkStatus_ = 1; 1397 guestureEventHub->InitDragDropEvent(); 1398 auto frameNode1 = guestureEventHub->GetFrameNode(); 1399 EXPECT_EQ(frameNode1->GetTag(), "Web"); 1400 } 1401 1402 /** 1403 * @tc.name: UpdateMenuNode001 1404 * @tc.desc: Test UpdateMenuNode 1405 * @tc.type: FUNC 1406 */ 1407 HWTEST_F(GestureEventHubTestNg, UpdateMenuNode001, TestSize.Level1) 1408 { 1409 auto rootNode = FrameNode::CreateFrameNode( 1410 V2::ROOT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1411 ASSERT_NE(rootNode, nullptr); 1412 auto targetNode = FrameNode::CreateFrameNode( 1413 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1414 ASSERT_NE(targetNode, nullptr); 1415 auto textNode = FrameNode::CreateFrameNode( 1416 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1417 ASSERT_NE(textNode, nullptr); 1418 targetNode->MountToParent(rootNode); 1419 textNode->MountToParent(targetNode); 1420 MenuParam menuParam; 1421 menuParam.type = MenuType::CONTEXT_MENU; 1422 menuParam.previewMode = MenuPreviewMode::CUSTOM; 1423 auto customNode = FrameNode::CreateFrameNode( 1424 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1425 ASSERT_NE(customNode, nullptr); 1426 auto customGeometryNode = customNode->GetGeometryNode(); 1427 ASSERT_NE(customGeometryNode, nullptr); 1428 customGeometryNode->SetFrameSize(SizeF(0.0f, 0.0f)); 1429 auto menuWrapperNode = 1430 MenuView::Create(textNode, targetNode->GetId(), V2::TEXT_ETS_TAG, menuParam, true, customNode); 1431 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), __anonfa8501890502() 1432 []() { return AceType::MakeRefPtr<Pattern>(); }); 1433 ASSERT_NE(frameNode, nullptr); 1434 PreparedInfoForDrag data; 1435 DragPreviewOption previewOption; 1436 previewOption.sizeChangeEffect = DraggingSizeChangeEffect::DEFAULT; 1437 frameNode->SetDragPreviewOptions(previewOption); 1438 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1439 guestureEventHub->UpdateMenuNode(menuWrapperNode, data, frameNode); 1440 previewOption.sizeChangeEffect = DraggingSizeChangeEffect::SIZE_TRANSITION; 1441 frameNode->SetDragPreviewOptions(previewOption); 1442 guestureEventHub->UpdateMenuNode(menuWrapperNode, data, frameNode); 1443 RectF RECT(0.0f, 0.0f, 0.0f, 0.0f); 1444 EXPECT_EQ(data.frameNodeRect, RECT); 1445 EXPECT_EQ(data.menuRect, RECT); 1446 EXPECT_EQ(data.menuPositionLeft, 0.0f); 1447 EXPECT_EQ(data.menuPositionTop, 0.0f); 1448 EXPECT_EQ(data.menuPositionRight, 0.0f); 1449 EXPECT_EQ(data.menuPositionBottom, 0.0f); 1450 } 1451 1452 /** 1453 * @tc.name: UpdateMenuNode002 1454 * @tc.desc: Test UpdateMenuNode 1455 * @tc.type: FUNC 1456 */ 1457 HWTEST_F(GestureEventHubTestNg, UpdateMenuNode002, TestSize.Level1) 1458 { 1459 auto rootNode = FrameNode::CreateFrameNode( 1460 V2::ROOT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1461 ASSERT_NE(rootNode, nullptr); 1462 auto targetNode = FrameNode::CreateFrameNode( 1463 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1464 ASSERT_NE(targetNode, nullptr); 1465 auto textNode = FrameNode::CreateFrameNode( 1466 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1467 ASSERT_NE(textNode, nullptr); 1468 targetNode->MountToParent(rootNode); 1469 textNode->MountToParent(targetNode); 1470 MenuParam menuParam; 1471 menuParam.type = MenuType::CONTEXT_MENU; 1472 menuParam.previewMode = MenuPreviewMode::CUSTOM; 1473 auto customNode = FrameNode::CreateFrameNode( 1474 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1475 ASSERT_NE(customNode, nullptr); 1476 auto customGeometryNode = customNode->GetGeometryNode(); 1477 ASSERT_NE(customGeometryNode, nullptr); 1478 customGeometryNode->SetFrameSize(SizeF(0.0f, 0.0f)); 1479 auto menuWrapperNode = 1480 MenuView::Create(textNode, targetNode->GetId(), V2::TEXT_ETS_TAG, menuParam, true, customNode); 1481 ASSERT_NE(menuWrapperNode, nullptr); 1482 auto menuWrapperPattern = menuWrapperNode->GetPattern<MenuWrapperPattern>(); 1483 ASSERT_NE(menuWrapperPattern, nullptr); 1484 auto previewNode = menuWrapperPattern->GetPreview(); 1485 ASSERT_NE(previewNode, nullptr); 1486 auto previewRenderContext = previewNode->GetRenderContext(); 1487 ASSERT_NE(previewRenderContext, nullptr); 1488 auto mockRenderContext = AceType::DynamicCast<MockRenderContext>(previewRenderContext); 1489 RectF frameSize(1.0f, 1.0f, 1.0f, 1.0f); 1490 mockRenderContext->SetPaintRectWithTransform(frameSize); 1491 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), __anonfa8501890602() 1492 []() { return AceType::MakeRefPtr<Pattern>(); }); 1493 ASSERT_NE(frameNode, nullptr); 1494 PreparedInfoForDrag data; 1495 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1496 DragPreviewOption previewOption; 1497 previewOption.sizeChangeEffect = DraggingSizeChangeEffect::SIZE_TRANSITION; 1498 frameNode->SetDragPreviewOptions(previewOption); 1499 guestureEventHub->UpdateMenuNode(menuWrapperNode, data, frameNode); 1500 RectF RECT(0.0f, 0.0f, 0.0f, 0.0f); 1501 EXPECT_EQ(data.frameNodeRect, frameSize); 1502 EXPECT_EQ(data.menuRect, RECT); 1503 EXPECT_EQ(data.menuPositionLeft, -1.0f); 1504 EXPECT_EQ(data.menuPositionTop, -1.0f); 1505 EXPECT_EQ(data.menuPositionRight, 2.0f); 1506 EXPECT_EQ(data.menuPositionBottom, 2.0f); 1507 } 1508 1509 /** 1510 * @tc.name: UpdateMenuNode003 1511 * @tc.desc: Test UpdateMenuNode 1512 * @tc.type: FUNC 1513 */ 1514 HWTEST_F(GestureEventHubTestNg, UpdateMenuNode003, TestSize.Level1) 1515 { 1516 auto rootNode = FrameNode::CreateFrameNode( 1517 V2::ROOT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1518 ASSERT_NE(rootNode, nullptr); 1519 auto targetNode = FrameNode::CreateFrameNode( 1520 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1521 ASSERT_NE(targetNode, nullptr); 1522 auto textNode = FrameNode::CreateFrameNode( 1523 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1524 ASSERT_NE(textNode, nullptr); 1525 targetNode->MountToParent(rootNode); 1526 textNode->MountToParent(targetNode); 1527 MenuParam menuParam; 1528 auto customNode = FrameNode::CreateFrameNode( 1529 V2::TEXT_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 1530 ASSERT_NE(customNode, nullptr); 1531 auto menuWrapperNode = 1532 MenuView::Create(textNode, targetNode->GetId(), V2::TEXT_ETS_TAG, menuParam, true, customNode); 1533 ASSERT_NE(menuWrapperNode, nullptr); 1534 auto menuWrapperPattern = menuWrapperNode->GetPattern<MenuWrapperPattern>(); 1535 ASSERT_NE(menuWrapperPattern, nullptr); 1536 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::IMAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), __anonfa8501890702() 1537 []() { return AceType::MakeRefPtr<Pattern>(); }); 1538 ASSERT_NE(frameNode, nullptr); 1539 PreparedInfoForDrag data; 1540 auto guestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1541 DragPreviewOption previewOption; 1542 previewOption.sizeChangeEffect = DraggingSizeChangeEffect::DEFAULT; 1543 frameNode->SetDragPreviewOptions(previewOption); 1544 guestureEventHub->UpdateMenuNode(menuWrapperNode, data, frameNode); 1545 EXPECT_EQ(data.menuNode, nullptr); 1546 previewOption.sizeChangeEffect = DraggingSizeChangeEffect::SIZE_TRANSITION; 1547 frameNode->SetDragPreviewOptions(previewOption); 1548 menuWrapperPattern->SetHasTransitionEffect(true); 1549 guestureEventHub->UpdateMenuNode(menuWrapperNode, data, frameNode); 1550 EXPECT_EQ(data.menuNode, nullptr); 1551 menuWrapperPattern->SetHasTransitionEffect(false); 1552 menuWrapperPattern->SetMenuStatus(MenuStatus::ON_HIDE_ANIMATION); 1553 guestureEventHub->UpdateMenuNode(menuWrapperNode, data, frameNode); 1554 EXPECT_EQ(data.menuNode, nullptr); 1555 } 1556 1557 /** 1558 * @tc.name: MinRecognizerGroupLoopSizeTest001 1559 * @tc.desc: Test ProcessTouchTestHit 1560 * @tc.type: FUNC 1561 */ 1562 HWTEST_F(GestureEventHubTestNg, MinRecognizerGroupLoopSizeTest001, TestSize.Level1) 1563 { 1564 /** 1565 * @tc.steps: step1. Create GestureEventHub. 1566 * @tc.expected: gestureEventHub is not null. 1567 */ 1568 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>()); 1569 auto gestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1570 ASSERT_NE(gestureEventHub, nullptr); 1571 OffsetF coordinateOffset; 1572 TouchRestrict touchRestrict; 1573 TouchTestResult innerTargets; 1574 TouchTestResult finalResult; 1575 ResponseLinkResult responseLinkResult; 1576 PointF localPoint; 1577 1578 /** 1579 * @tc.steps: step2. create userRecognizer and set to gestureHierarchy_. 1580 */ 1581 auto longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, 1, false); 1582 gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer); 1583 PanDirection panDirection; 1584 panDirection.type = PanDirection::ALL; 1585 auto panRecognizer = AceType::MakeRefPtr<PanRecognizer>(1, panDirection, 0.0); 1586 panRecognizer->SetPriority(GesturePriority::Parallel); 1587 gestureEventHub->gestureHierarchy_.emplace_back(panRecognizer); 1588 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(); 1589 gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer); 1590 1591 auto otherFrameNode = FrameNode::CreateFrameNode("otherButton", 1592 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>()); 1593 auto otherClickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(); 1594 otherClickRecognizer->AttachFrameNode(otherFrameNode); 1595 std::vector<RefPtr<NGGestureRecognizer>> exclusiveRecognizerGroup; 1596 exclusiveRecognizerGroup.push_back(otherClickRecognizer); 1597 auto exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(exclusiveRecognizerGroup); 1598 gestureEventHub->externalExclusiveRecognizer_.push_back(exclusiveRecognizer); 1599 1600 /** 1601 * @tc.steps: step3. call ProcessTouchTestHit , recognizer is not instance of recognizer group 1602 * @tc.expected: result is false 1603 */ 1604 auto result = gestureEventHub->ProcessTouchTestHit( 1605 coordinateOffset, touchRestrict, innerTargets, finalResult, 2, localPoint, nullptr, responseLinkResult); 1606 auto sizeOfResponseLinkResult = static_cast<int32_t>(responseLinkResult.size()); 1607 EXPECT_FALSE(result); 1608 EXPECT_EQ(sizeOfResponseLinkResult, 3); 1609 } 1610 1611 /** 1612 * @tc.name: GestureEventHubProcessTouchHitTest001 1613 * @tc.desc: Test ProcessTouchTestHit 1614 * @tc.type: FUNC 1615 */ 1616 HWTEST_F(GestureEventHubTestNg, GestureEventHubProcessTouchHitTest001, TestSize.Level1) 1617 { __anonfa8501890802(GestureEvent& info) 1618 auto panActionStart = [](GestureEvent& info) {}; __anonfa8501890902(GestureEvent& info) 1619 auto panActionUpdate = [](GestureEvent& info) {}; __anonfa8501890a02(GestureEvent& info) 1620 auto panActionEnd = [](GestureEvent& info) {}; __anonfa8501890b02() 1621 auto panActionCancel = []() {}; 1622 auto panEvent = AceType::MakeRefPtr<PanEvent>( 1623 std::move(panActionStart), std::move(panActionUpdate), std::move(panActionEnd), std::move(panActionCancel)); 1624 1625 for (const auto &testCase : ADD_PAN_EVENT_TEST_CASE) { 1626 /** 1627 * @tc.steps: step1. Create GestureEventHub. 1628 * @tc.expected: gestureEventHub is not null. 1629 */ 1630 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>()); 1631 auto gestureEventHub = frameNode->GetOrCreateGestureEventHub(); 1632 ASSERT_NE(gestureEventHub, nullptr); 1633 PanDistanceMapDimension distanceMap = { { SourceTool::UNKNOWN, DISTANCE } }; 1634 PanDistanceMapDimension expectDistanceMap = { { SourceTool::UNKNOWN, DEFAULT_PAN_DISTANCE } }; 1635 auto panEventActuator = AceType::MakeRefPtr<PanEventActuator>( 1636 AceType::WeakClaim(AceType::RawPtr(gestureEventHub)), 1637 testCase.panDirectionType, FINGERS_NUMBER, distanceMap); 1638 ASSERT_NE(panEventActuator, nullptr); 1639 if (testCase.needCreatPanEventActuatorFirst) { 1640 gestureEventHub->panEventActuator_ = panEventActuator; 1641 } else { 1642 gestureEventHub->panEventActuator_ = nullptr; 1643 } 1644 gestureEventHub->AddPanEvent(panEvent, testCase.comparePanDirectionType, FINGERS, expectDistanceMap); 1645 if (testCase.expectRecreatePanEvent) { 1646 EXPECT_NE(gestureEventHub->panEventActuator_, panEventActuator); 1647 } else { 1648 EXPECT_EQ(gestureEventHub->panEventActuator_, panEventActuator); 1649 } 1650 ASSERT_NE(gestureEventHub->panEventActuator_, nullptr); 1651 auto panRecognizer = gestureEventHub->panEventActuator_->panRecognizer_; 1652 ASSERT_NE(panRecognizer, nullptr); 1653 EXPECT_EQ(panRecognizer->GetDistance(), testCase.expectDistance.ConvertToPx()); 1654 } 1655 } 1656 1657 /** 1658 * @tc.name: ProcessTouchTestHitSequence001 1659 * @tc.desc: Test ProcessTouchTestHit 1660 * @tc.type: FUNC 1661 */ 1662 HWTEST_F(GestureEventHubTestNg, ProcessTouchTestHitSequence001, TestSize.Level1) 1663 { 1664 /** 1665 * @tc.steps: step1. create recognizer and add to innerTargets. 1666 */ 1667 OffsetF coordinateOffset; 1668 TouchRestrict touchRestrict; 1669 TouchTestResult innerTargets; 1670 TouchTestResult finalResult; 1671 ResponseLinkResult responseLinkResult; 1672 PointF localPoint; 1673 PanDirection panDirection; 1674 panDirection.type = PanDirection::ALL; 1675 auto panRecognizer = AceType::MakeRefPtr<PanRecognizer>(1, panDirection, 0.0); 1676 panRecognizer->SetPriority(GesturePriority::Low); 1677 innerTargets.emplace_back(panRecognizer); 1678 1679 auto otherFrameNode = FrameNode::CreateFrameNode( 1680 "scroll", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>()); 1681 auto scrollGestureEventHub = otherFrameNode->GetOrCreateGestureEventHub(); 1682 auto scrollableActuator = 1683 AceType::MakeRefPtr<ScrollableActuator>(AceType::WeakClaim(AceType::RawPtr(scrollGestureEventHub))); 1684 1685 auto scrollableEvent = AceType::MakeRefPtr<ScrollableEvent>(Axis::VERTICAL); 1686 auto scrollable = AceType::MakeRefPtr<Scrollable>(); 1687 auto panRecognizerNG = AceType::MakeRefPtr<PanRecognizer>(1, panDirection, 0.0); 1688 scrollable->panRecognizerNG_ = panRecognizerNG; 1689 scrollableEvent->SetScrollable(scrollable); 1690 scrollableActuator->AddScrollableEvent(scrollableEvent); 1691 EXPECT_EQ(scrollableActuator->scrollableEvents_.size(), 1); 1692 scrollGestureEventHub->scrollableActuator_ = scrollableActuator; 1693 1694 /** 1695 * @tc.steps: step2. call ProcessTouchTestHit , recognizer is not instance of recognizer group 1696 * @tc.expected: result is false 1697 */ 1698 auto result = scrollGestureEventHub->ProcessTouchTestHit( 1699 coordinateOffset, touchRestrict, innerTargets, finalResult, 2, localPoint, nullptr, responseLinkResult); 1700 EXPECT_FALSE(result); 1701 EXPECT_FALSE(panRecognizer->IsSystemGesture()); 1702 } 1703 } // namespace OHOS::Ace::NG