xref: /foundation/arkui/ace_engine/test/unittest/core/event/gesture_event_hub_test_ng.cpp

/*
 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "test/unittest/core/event/gesture_event_hub_test_ng.h"

#include "test/mock/base/mock_drag_window.h"
#include "test/mock/base/mock_subwindow.h"
#include "base/subwindow/subwindow_manager.h"
#include "test/mock/core/common/mock_container.h"
#include "test/unittest/core/pattern/scrollable/mock_scrollable.h"

#include "frameworks/core/components_ng/pattern/text/text_pattern.h"
#include "core/components_ng/manager/drag_drop/drag_drop_global_controller.h"

using namespace testing;
using namespace testing::ext;

namespace OHOS::Ace::NG {
void GestureEventHubTestNg::SetUpTestSuite()
{
    MockPipelineContext::SetUp();
    MOCK_DRAG_WINDOW = DragWindow::CreateDragWindow("", 0, 0, 0, 0);
    GTEST_LOG_(INFO) << "GestureEventHubTestNg SetUpTestCase";
    MOCK_TASK_EXECUTOR = AceType::MakeRefPtr<MockTaskExecutor>();
}

void GestureEventHubTestNg::TearDownTestSuite()
{
    MockPipelineContext::TearDown();
    MOCK_DRAG_WINDOW = nullptr;
    GTEST_LOG_(INFO) << "GestureEventHubTestNg TearDownTestCase";
}

/**
 * @tc.name: GestureEventHubTest001
 * @tc.desc: Create GestureEventHub and call GetFrameNode
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest001, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: eventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. Test GetFrameNode
     *            case: eventHub is valid
     * @tc.expected: frameNodeOfEvent is not null.
     */
    auto frameNodeOfEvent = gestureEventHub->GetFrameNode();
    EXPECT_TRUE(frameNodeOfEvent);

    /**
     * @tc.steps: step2. Test GetFrameNode
     *            case: eventHub is invalid
     * @tc.expected: frameNodeOfEvent is null.
     */
    eventHub = nullptr;
    frameNode = nullptr;
    frameNodeOfEvent = gestureEventHub->GetFrameNode();
    EXPECT_FALSE(frameNodeOfEvent);
}

/**
 * @tc.name: GestureEventHubTest002
 * @tc.desc: Test ProcessTouchTestHit part1
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest002, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. Test ProcessTouchTestHit
     *            case: eventHub is null && actuators such as scrollableActuator_ & touchEventActuator_ are all null
     * @tc.expected: ProcessTouchTestHit return false,  innerTargets & finalResult is empty
     */
    eventHub = nullptr;
    TouchRestrict touchRestrict;
    TouchTestResult innerTargets;
    TouchTestResult finalResult;
    ResponseLinkResult responseLinkResult;
    auto flag = gestureEventHub->ProcessTouchTestHit(
        COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, PointF(), nullptr, responseLinkResult);
    EXPECT_FALSE(flag);
    auto sizeOfInnerTargets = static_cast<int32_t>(innerTargets.size());
    auto sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
    EXPECT_EQ(sizeOfInnerTargets, 0);
    EXPECT_EQ(sizeOfFinalResult, 0);

    /**
     * @tc.steps: step3. construct touchEventActuator_
     *                   then set it to gestureEventHub
     */
    // reconstruct a gestureEventHub
    eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto framenode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>(), false);
    EXPECT_NE(framenode, nullptr);
    eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(framenode));
    gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    // set touchEventActuator_
    auto touchCallback = [](TouchEventInfo& info) {};
    auto touchEvent = AceType::MakeRefPtr<TouchEventImpl>(std::move(touchCallback));
    gestureEventHub->AddTouchEvent(touchEvent);

    /**
     * @tc.steps: step4. Test ProcessTouchTestHit
     *            case: eventHub is not null && touchEventActuator_ is not null
     * @tc.expected: ProcessTouchTestHit return false,  innerTargets & finalResult have one element
     */
    flag = gestureEventHub->ProcessTouchTestHit(
        COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, PointF(), nullptr, responseLinkResult);
    EXPECT_FALSE(flag);
    sizeOfInnerTargets = static_cast<int32_t>(innerTargets.size());
    sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
    EXPECT_EQ(sizeOfInnerTargets, 1);
    EXPECT_EQ(sizeOfFinalResult, 1);
}

/**
 * @tc.name: GestureEventHubTest003
 * @tc.desc: Test ProcessTouchTestHit part2
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest003, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
    EXPECT_TRUE(eventHub);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. construct scrollableActuator_ and other actuators
     *                   then set them to gestureEventHub
     */

    // set touchEventActuator_
    auto touchCallback = [](TouchEventInfo& info) {};
    auto touchEvent = AceType::MakeRefPtr<TouchEventImpl>(std::move(touchCallback));
    gestureEventHub->AddTouchEvent(touchEvent);

    // set scrollableActuator_
    auto scrollableEvent = AceType::MakeRefPtr<ScrollableEvent>(AXIS_VERTICAL);
    gestureEventHub->AddScrollableEvent(scrollableEvent);

    // set clickEventActuator_
    auto clickCallback = [](GestureEvent& info) {};
    auto clickEvent = AceType::MakeRefPtr<ClickEvent>(std::move(clickCallback));
    gestureEventHub->AddClickEvent(clickEvent);

    // set panEventActuator_
    auto panActionStart = [](GestureEvent& info) {};
    auto panActionUpdate = [](GestureEvent& info) {};
    auto panActionEnd = [](GestureEvent& info) {};
    auto panActionCancel = []() {};
    auto panEvent = AceType::MakeRefPtr<PanEvent>(
        std::move(panActionStart), std::move(panActionUpdate), std::move(panActionEnd), std::move(panActionCancel));
    gestureEventHub->AddPanEvent(panEvent, PAN_DIRECTION_ALL, FINGERS, DISTANCE);

    // set longPressEventActuator_
    auto longPressCallback = [](GestureEvent& info) {};
    auto longPressEvent = AceType::MakeRefPtr<LongPressEvent>(longPressCallback);
    gestureEventHub->SetLongPressEvent(longPressEvent);

    // set dragEventActuator_
    auto dragActionStart = [](GestureEvent& info) {};
    auto dragActionUpdate = [](GestureEvent& info) {};
    auto dragActionEnd = [](GestureEvent& info) {};
    auto dragActionCancel = []() {};
    auto dragEvent = AceType::MakeRefPtr<DragEvent>(
        std::move(dragActionStart), std::move(dragActionUpdate), std::move(dragActionEnd), std::move(dragActionCancel));
    gestureEventHub->SetCustomDragEvent(dragEvent, PAN_DIRECTION_ALL, FINGERS, DISTANCE);
}

/**
 * @tc.name: GestureEventHubTest004
 * @tc.desc: Test AddClickEvent, SetUserOnClick, ActClick & SetFocusClickEvent
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest004, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. call ActClick
     *            case: clickEventActuator_ is null
     * @tc.expected: flag is false
     */
    auto flag = gestureEventHub->ActClick();
    EXPECT_FALSE(flag);

    /**
     * @tc.steps: step3. call ActClick
     *            case: clickEventActuator_ is null, clickRecognizer fingers is 2, count is 1
     * @tc.expected: flag is false
     */
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, 1);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
    EXPECT_FALSE(gestureEventHub->ActClick());
    gestureEventHub->gestureHierarchy_.clear();

    /**
     * @tc.steps: step4. call ActClick
     *            case: clickEventActuator_ is null, clickRecognizer fingers is 1, count is 1
     * @tc.expected: flag is true
     */
    clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(1, 1);
    clickRecognizer->SetOnAction([](GestureEvent& info) {});
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
    EXPECT_TRUE(gestureEventHub->ActClick());
    gestureEventHub->gestureHierarchy_.clear();

    /**
     * @tc.steps: step5. construct two clickCallback
     *            one is for SetUserOnClick, the other is for AddClickEvent
     */
    std::string msg1;
    auto clickCallback = [&msg1](GestureEvent& /* info */) { msg1 = CHECK_TAG_1; };
    gestureEventHub->SetUserOnClick(clickCallback);
    std::string msg2;
    auto clickCallback2 = [&msg2](GestureEvent& /* info */) { msg2 = CHECK_TAG_2; };
    auto clickEvent = AceType::MakeRefPtr<ClickEvent>(std::move(clickCallback2));
    gestureEventHub->AddClickEvent(clickEvent);

    /**
     * @tc.steps: step6. call ActClick
     *                   case: clickEventActuator_ is not null
     * @tc.expected: flag is true & clickCallback & clickCallback2 has be called
     */
    flag = gestureEventHub->ActClick();
    EXPECT_TRUE(flag);
    EXPECT_EQ(msg1, CHECK_TAG_1);
    EXPECT_EQ(msg2, CHECK_TAG_2);

    /**
     * @tc.steps: step7. call eventHub's GetOrCreateFocusHub
     * @tc.expected: return is not null
     */
    auto focusHub = eventHub->GetOrCreateFocusHub();
    EXPECT_TRUE(focusHub);

    /**
     * @tc.steps: step8. call SetFocusClickEvent
     * @tc.expected: no fatal error occur
     */
    msg1 = "";
    auto clickCallback3 = [&msg1](GestureEvent& /* info */) { msg1 = CHECK_TAG_1; };
    gestureEventHub->SetFocusClickEvent(clickCallback3);
}

/**
 * @tc.name: GestureEventHubTest005
 * @tc.desc: Test ActLongClick
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest005, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. call ActLongClick
     *            case: longPressEventActuator_ is null
     * @tc.expected: flag is false
     */
    auto flag = gestureEventHub->ActLongClick();
    EXPECT_FALSE(flag);

    /**
     * @tc.steps: step3. call ActLongClick
     *            case: longPressEventActuator_ is null, longPressRecognizer fingers is 2
     * @tc.expected: flag is false
     */
    auto longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, DOUBLE_FINGERS, false);
    gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
    EXPECT_FALSE(gestureEventHub->ActLongClick());
    gestureEventHub->gestureHierarchy_.clear();

    /**
     * @tc.steps: step4. call ActLongClick
     *            case: longPressEventActuator_ is null, longPressRecognizer fingers is 1
     * @tc.expected: flag is true
     */
    longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, 1, false);
    longPressRecognizer->SetOnAction([](GestureEvent& info) {});
    gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
    EXPECT_TRUE(gestureEventHub->ActLongClick());
    gestureEventHub->gestureHierarchy_.clear();

    /**
     * @tc.steps: step5. construct a longPressCallback
     */
    std::string msg1;
    auto longPressCallback = [&msg1](GestureEvent& /* info */) { msg1 = CHECK_TAG_1; };
    auto longPressEvent = AceType::MakeRefPtr<LongPressEvent>(longPressCallback);
    gestureEventHub->SetLongPressEvent(longPressEvent);

    /**
     * @tc.steps: step6. call ActLongClick
     *                   case: longPressEventActuator_ is not null
     * @tc.expected: flag is true & longPressCallback will be called
     */
    flag = gestureEventHub->ActLongClick();
    EXPECT_TRUE(flag);
    EXPECT_EQ(msg1, CHECK_TAG_1);

    /**
     * @tc.steps: step7. call eventHub's GetOrCreateFocusHub
     * @tc.expected: return is not null
     */
    auto focusHub = eventHub->GetOrCreateFocusHub();
    EXPECT_TRUE(focusHub);

    /**
     * @tc.steps: step8. call SetFocusClickEvent
     * @tc.expected: no fatal error occur
     */
    msg1 = "";
    auto clickCallback3 = [&msg1](GestureEvent& /* info */) { msg1 = CHECK_TAG_1; };
    gestureEventHub->SetFocusClickEvent(clickCallback3);
}

/**
 * @tc.name: GestureEventHubTest006
 * @tc.desc: Test CombineIntoExclusiveRecognizer
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest006, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. call CombineIntoExclusiveRecognizer
     *            case: result is empty
     * @tc.expected: result is empty
     */
    TouchTestResult result;
    gestureEventHub->CombineIntoExclusiveRecognizer(GLOBAL_POINT, LOCAL_POINT, result, TOUCH_ID);
    auto size = static_cast<int32_t>(result.size());
    EXPECT_EQ(size, 0);

    /**
     * @tc.steps: step3. insert element to result
     * @tc.expected: result'size is 3
     */

    // new TouchEventActuator
    auto touchEventActuator = AceType::MakeRefPtr<TouchEventActuator>();

    // new LongPressRecognizer (extends NGGestureRecognizer)
    auto longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(false, false);

    // new ClickRecognizer (extends NGGestureRecognizer)
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();

    result.emplace_back(touchEventActuator);
    result.emplace_back(longPressRecognizer);
    result.emplace_back(clickRecognizer);
    size = static_cast<int32_t>(result.size());
    EXPECT_EQ(size, 3);

    /**
     * @tc.steps: step4. call CombineIntoExclusiveRecognizer
     *            case: recognizers'size > 1
     * @tc.expected: result'size is 2. One is touchEventActuator, the other is a exclusiveRecognizer created by
     *               longPressRecognizer and clickRecognizer
     */
    gestureEventHub->CombineIntoExclusiveRecognizer(GLOBAL_POINT, LOCAL_POINT, result, TOUCH_ID);
    size = static_cast<int32_t>(result.size());
    EXPECT_EQ(size, 2);

    /**
     * @tc.steps: step5. call CombineIntoExclusiveRecognizer
     *            case: recognizers'size = 1
     * @tc.expected: result2'size is 2. One is touchEventActuator, the other is longPressRecognizer
     */
    TouchTestResult result2;
    result2.emplace_back(touchEventActuator);
    result2.emplace_back(longPressRecognizer);
    gestureEventHub->CombineIntoExclusiveRecognizer(GLOBAL_POINT, LOCAL_POINT, result2, TOUCH_ID);
    size = static_cast<int32_t>(result2.size());
    EXPECT_EQ(size, 2);
}

/**
 * @tc.name: GestureEventHubTest007
 * @tc.desc: Test InitDragDropEvent
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest007, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. Call InitDragDropEvent.
     * @tc.expected: dragEventActuator_ is not null.
     */
    gestureEventHub->InitDragDropEvent();
    EXPECT_TRUE(gestureEventHub->dragEventActuator_);
}

/**
 * @tc.name: GestureEventHubTest008
 * @tc.desc: Test Functions related with drag
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest008, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. call HandleOnDragStart
     *            case: eventHub->HasOnDragStart() is null
     * @tc.expected: dragDropProxy_ is null.
     */
    GestureEvent info;
    gestureEventHub->HandleOnDragStart(info);
    EXPECT_FALSE(gestureEventHub->dragDropProxy_);

    /**
     * @tc.steps: step3. set OnDragStart for eventHub
     *            after that eventHub->HasOnDragStart() is not null
     *            case: dragDropInfo.customNode is not null
     */
    RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    auto onDragStart = [&customNode](
                           const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
        DragDropInfo dragDropInfo;
        dragDropInfo.customNode = customNode;
        return dragDropInfo;
    };
    eventHub->SetOnDragStart(std::move(onDragStart));

    /**
     * @tc.steps: step4. call HandleOnDragStart
     *            case: dragDropInfo.customNode is not null
     * @tc.expected: dragDropProxy_ is not null.
     */
    gestureEventHub->HandleOnDragStart(info);
    EXPECT_FALSE(gestureEventHub->dragDropProxy_);

    /**
     * @tc.steps: step5. set OnDragStart for eventHub2
     *            after that eventHub->HasOnDragStart() is not null
     *            case: dragDropInfo.pixelMap is not null
     */
    void* voidPtr = static_cast<void*>(new char[0]);
    RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
    auto onDragStart2 = [&pixelMap](
                            const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
        DragDropInfo dragDropInfo;
        dragDropInfo.pixelMap = pixelMap;
        return dragDropInfo;
    };
    auto eventHub2 = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub2);
    eventHub2->SetOnDragStart(std::move(onDragStart2));
    auto gestureEventHub2 = AceType::MakeRefPtr<GestureEventHub>(eventHub2);
    EXPECT_TRUE(gestureEventHub2);

    /**
     * @tc.steps: step6. call HandleOnDragStart
     *            case: dragDropInfo.pixelMap is not null
     * @tc.expected: dragDropProxy_ is not null.
     */
    gestureEventHub2->HandleOnDragStart(info);
    EXPECT_FALSE(gestureEventHub2->dragDropProxy_);

    /**
     * @tc.steps: step7. call HandleOnDragStart again
     *            case: dragDropProxy_ need to reset
     * @tc.expected: dragDropProxy_ is not null.
     */
    gestureEventHub2->HandleOnDragStart(info);
    EXPECT_FALSE(gestureEventHub2->dragDropProxy_);

    /**
     * @tc.steps: step8. call HandleOnDragUpdate
     * @tc.expected: dragDropProxy_ is not null.
     */
    gestureEventHub2->HandleOnDragUpdate(info);
    EXPECT_FALSE(gestureEventHub2->dragDropProxy_);

    /**
     * @tc.steps: step9. call HandleOnDragCancel
     * @tc.expected: dragDropProxy_ is null.
     */
    gestureEventHub2->HandleOnDragCancel();
    EXPECT_FALSE(gestureEventHub2->dragDropProxy_);

    /**
     * @tc.steps: step10. call HandleOnDragEnd
     *            case: eventHub->HasOnDrop() is false
     * @tc.expected: dragDropProxy_ is null.
     */
    gestureEventHub->HandleOnDragEnd(info);
    EXPECT_FALSE(gestureEventHub->dragDropProxy_);

    /**
     * @tc.steps: step10. call HandleOnDragEnd
     *            case: eventHub->HasOnDrop() is true
     * @tc.expected: dragDropProxy_ is null
     *               onDrop has been called, msg1 = CHECK_TAG_1
     */
    std::string msg1;
    auto onDrop = [&msg1](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
        msg1 = CHECK_TAG_1;
    };
    eventHub->SetOnDrop(std::move(onDrop));
    gestureEventHub->HandleOnDragStart(info);
    gestureEventHub->HandleOnDragEnd(info);
    EXPECT_FALSE(gestureEventHub->dragDropProxy_);
    EXPECT_EQ(msg1, "");
}

/**
 * @tc.name: GestureEventHubTest009
 * @tc.desc: Test ModifyDone & UpdateGestureHierarchy
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest009, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. call OnModifyDone
     *            case: recreateGesture_ is true & gestures_.size() == gestureHierarchy_.size() == 0
     * @tc.expected: recreateGesture_ = false
     */
    gestureEventHub->OnModifyDone();
    EXPECT_FALSE(gestureEventHub->recreateGesture_);

    /**
     * @tc.steps: step3. call OnModifyDone
     *            case: recreateGesture_ is false
     * @tc.expected: recreateGesture_ = false
     */
    gestureEventHub->OnModifyDone();
    EXPECT_FALSE(gestureEventHub->recreateGesture_);

    /**
     * @tc.steps: step4. call OnModifyDone
     *            case: recreateGesture_ is true & gestures_.size() != gestureHierarchy_.size()
     * @tc.expected: recreateGesture_ = false
     *               gestures_ has cleared & gestureHierarchy_ has one element
     */
    gestureEventHub->recreateGesture_ = true;
    auto longPressGesture = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
    gestureEventHub->gestures_.emplace_back(longPressGesture);
    gestureEventHub->OnModifyDone();
    EXPECT_FALSE(gestureEventHub->recreateGesture_);
    auto sizeGestures = static_cast<int32_t>(gestureEventHub->gestures_.size());
    auto sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
    EXPECT_EQ(sizeGestures, 0);
    EXPECT_EQ(sizeGestureHierarchy, 1);
}

/**
 * @tc.name: GestureEventHubTest010
 * @tc.desc: Test ProcessTouchTestHierarchy
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest010, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. call ProcessTouchTestHierarchy
     *            case: innerRecognizers & gestureHierarchy_ is empty, current is null
     * @tc.expected: finalResult is empty
     */
    TouchRestrict touchRestrict;
    std::list<RefPtr<NGGestureRecognizer>> innerTargets;
    TouchTestResult finalResult;
    ResponseLinkResult responseLinkResult;

    std::vector<RefPtr<NGGestureRecognizer>> vc;
    vc.push_back(AceType::MakeRefPtr<ClickRecognizer>());
    auto exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(vc);
    std::vector<RefPtr<NGGestureRecognizer>> parallelVc;
    parallelVc.push_back(AceType::MakeRefPtr<ClickRecognizer>());
    auto parallelRecognizer = AceType::MakeRefPtr<ParallelRecognizer>(parallelVc);

    gestureEventHub->externalExclusiveRecognizer_.push_back(exclusiveRecognizer);
    gestureEventHub->externalParallelRecognizer_.push_back(parallelRecognizer);
    EXPECT_EQ(static_cast<int32_t>(gestureEventHub->externalExclusiveRecognizer_.size()), 1);
    EXPECT_EQ(static_cast<int32_t>(gestureEventHub->externalParallelRecognizer_.size()), 1);

    gestureEventHub->ProcessTouchTestHierarchy(
        COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, nullptr, responseLinkResult);
    EXPECT_TRUE(finalResult.empty());

    /**
     * @tc.steps: step3. call ProcessTouchTestHierarchy several
     *            case: innerRecognizers & gestureHierarchy_ is not all empty
     * @tc.expected: finalResult's size has increased by 1 per call
     */
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Low
    innerTargets.emplace_back(clickRecognizer);

    gestureEventHub->gestureHierarchy_.emplace_back(nullptr);
    auto clickRecognizer2 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1);
    clickRecognizer2->SetPriorityMask(GestureMask::IgnoreInternal);           // current will assigned to this
    auto clickRecognizer3 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::High
    clickRecognizer3->SetPriority(GesturePriority::High);
    auto clickRecognizer4 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Parallel
    clickRecognizer4->SetPriority(GesturePriority::Parallel);
    auto clickRecognizer5 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Parallel
    clickRecognizer5->SetPriority(GesturePriority::Parallel);

    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer4);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer2);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer3);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer5);

    gestureEventHub->ProcessTouchTestHierarchy(
        COORDINATE_OFFSET, touchRestrict, innerTargets, finalResult, TOUCH_ID, nullptr, responseLinkResult);
    auto sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
    EXPECT_EQ(sizeOfFinalResult, 1);

    auto clickRecognizer6 = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1); // priority == GesturePriority::Low
    std::list<RefPtr<NGGestureRecognizer>> innerTargets2;
    innerTargets2.emplace_back(clickRecognizer);
    innerTargets2.emplace_back(clickRecognizer6);
    gestureEventHub->ProcessTouchTestHierarchy(
        COORDINATE_OFFSET, touchRestrict, innerTargets2, finalResult, TOUCH_ID, nullptr, responseLinkResult);
    sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
    EXPECT_EQ(sizeOfFinalResult, 2);

    std::list<RefPtr<NGGestureRecognizer>> innerTargets3;
    innerTargets3.emplace_back(clickRecognizer);
    innerTargets3.emplace_back(clickRecognizer6);
    gestureEventHub->ProcessTouchTestHierarchy(
        COORDINATE_OFFSET, touchRestrict, innerTargets3, finalResult, TOUCH_ID, nullptr, responseLinkResult);
    sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
    EXPECT_EQ(sizeOfFinalResult, 3);

    std::list<RefPtr<NGGestureRecognizer>> innerTargets4;
    gestureEventHub->gestureHierarchy_.clear();
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer4);
    gestureEventHub->ProcessTouchTestHierarchy(
        COORDINATE_OFFSET, touchRestrict, innerTargets4, finalResult, TOUCH_ID, nullptr, responseLinkResult);
    sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
    EXPECT_EQ(sizeOfFinalResult, 4);

    std::list<RefPtr<NGGestureRecognizer>> innerTargets5;
    gestureEventHub->gestureHierarchy_.clear();
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
    gestureEventHub->ProcessTouchTestHierarchy(
        COORDINATE_OFFSET, touchRestrict, innerTargets5, finalResult, TOUCH_ID, nullptr, responseLinkResult);
    sizeOfFinalResult = static_cast<int32_t>(finalResult.size());
    EXPECT_EQ(sizeOfFinalResult, 5);
}

/**
 * @tc.name: GestureEventHubTest011
 * @tc.desc: Test IsAccessibilityClickable and IsAccessibiityLongClickable
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest011, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    ASSERT_NE(eventHub, nullptr);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    ASSERT_NE(gestureEventHub, nullptr);

    /**
     * @tc.steps: step2. gestureHierarchy_ has ClickRecognizer, the number of fingers is two or click count is two
     * @tc.expected: IsAccessibilityClickable is false
     */
    EXPECT_FALSE(gestureEventHub->IsAccessibilityClickable());

    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, 1);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
    EXPECT_FALSE(gestureEventHub->IsAccessibilityClickable());
    gestureEventHub->gestureHierarchy_.clear();
    clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(1, CLICK_COUNTS);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
    EXPECT_FALSE(gestureEventHub->IsAccessibilityClickable());
    gestureEventHub->gestureHierarchy_.clear();

    /**
     * @tc.steps: step3. gestureHierarchy_ has ClickRecognizer, the number of fingers is one
     * @tc.expected: IsAccessibilityClickable is true
     */
    clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGERS, 1);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);
    EXPECT_TRUE(gestureEventHub->IsAccessibilityClickable());
    gestureEventHub->gestureHierarchy_.clear();

    /**
     * @tc.steps: step4. call AddClickEvent
     * @tc.expected: IsAccessibilityClickable is true
     */
    auto clickCallback = [](GestureEvent& info) {};
    auto clickEvent = AceType::MakeRefPtr<ClickEvent>(std::move(clickCallback));
    gestureEventHub->AddClickEvent(clickEvent);
    EXPECT_TRUE(gestureEventHub->IsAccessibilityClickable());

    /**
     * @tc.steps: step5. gestureHierarchy_ has LongPressRecognizer, the number of fingers is two
     * @tc.expected: IsAccessibilityLongClickable is false
     */
    EXPECT_FALSE(gestureEventHub->IsAccessibilityLongClickable());

    auto longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, DOUBLE_FINGERS, false);
    gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
    EXPECT_FALSE(gestureEventHub->IsAccessibilityLongClickable());
    gestureEventHub->gestureHierarchy_.clear();

    /**
     * @tc.steps: step6. gestureHierarchy_ has LongPressRecognizer, the number of fingers is one
     * @tc.expected: IsAccessibilityLongClickable is false
     */
    longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, 1, false);
    gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
    EXPECT_TRUE(gestureEventHub->IsAccessibilityLongClickable());
    gestureEventHub->gestureHierarchy_.clear();

    /**
     * @tc.steps: step7. call SetLongPressEvent
     * @tc.expected: IsAccessibilityLongClickable is true
     */
    auto longPressCallback = [](GestureEvent& info) {};
    auto longPressEvent = AceType::MakeRefPtr<LongPressEvent>(longPressCallback);
    gestureEventHub->SetLongPressEvent(longPressEvent);
    EXPECT_TRUE(gestureEventHub->IsAccessibilityLongClickable());
}

/**
 * @tc.name: GestureEventHubTest012
 * @tc.desc: Test UpdateGestureHierarchy
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest012, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    ASSERT_NE(eventHub, nullptr);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    ASSERT_NE(gestureEventHub, nullptr);

    /**
     * @tc.steps: step2. call OnModifyDone
     * @tc.expected: gestureHierarchy_ has two elements
     */
    gestureEventHub->recreateGesture_ = true;
    auto tapGesture = AceType::MakeRefPtr<TapGesture>(FINGERS, 1);
    gestureEventHub->gestures_.emplace_back(tapGesture);
    auto longPressGesture = AceType::MakeRefPtr<LongPressGesture>(FINGERS, false, 1);
    gestureEventHub->gestures_.emplace_back(longPressGesture);
    auto onAccessibilityEvent = gestureEventHub->GetOnAccessibilityEventFunc();
    ASSERT_NE(onAccessibilityEvent, nullptr);
    onAccessibilityEvent(AccessibilityEventType::CLICK);
    gestureEventHub->OnModifyDone();

    auto sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
    EXPECT_EQ(sizeGestureHierarchy, GESTURES_COUNTS);
}

/**
 * @tc.name: GestureEventHubTest013
 * @tc.desc: Test ProcessTouchTestHit
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest013, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);
    OffsetF coordinateOffset;
    TouchRestrict touchRestrict;
    TouchTestResult innerTargets;
    TouchTestResult finalResult;
    ResponseLinkResult responseLinkResult;
    PointF localPoint;

    PanDirection panDirection;
    /**
     * @tc.steps: step2. call ProcessTouchTestHit
     * @tc.expected: result is true
     */
    guestureEventHub->scrollableActuator_ =
        AceType::MakeRefPtr<ScrollableActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
    guestureEventHub->touchEventActuator_ = AceType::MakeRefPtr<TouchEventActuator>();
    guestureEventHub->clickEventActuator_ =
        AceType::MakeRefPtr<ClickEventActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
    guestureEventHub->panEventActuator_ = AceType::MakeRefPtr<PanEventActuator>(
        AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
    guestureEventHub->longPressEventActuator_ =
        AceType::MakeRefPtr<LongPressEventActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
    guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
        AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
    auto result = guestureEventHub->ProcessTouchTestHit(
        coordinateOffset, touchRestrict, innerTargets, finalResult, 2, localPoint, nullptr, responseLinkResult);
    EXPECT_FALSE(result);
}

/**
 * @tc.name: GestureEventHubTest014
 * @tc.desc: Test IsAllowedDrag
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest014, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);

    auto eventHub = guestureEventHub->eventHub_.Upgrade();

    auto event = guestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
    auto result = guestureEventHub->IsAllowedDrag(eventHub);
    EXPECT_FALSE(result);
    /**
     * @tc.steps: step2. call IsAllowedDrag
     * @tc.expected: result is correct
     */
    frameNode->userSet_ = true;
    result = guestureEventHub->IsAllowedDrag(eventHub);
    EXPECT_FALSE(result);

    frameNode->userSet_ = false;
    auto func = [](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) { return DragDropInfo(); };
    eventHub->onDragStart_ = func;
    result = guestureEventHub->IsAllowedDrag(eventHub);
    EXPECT_TRUE(result);

    guestureEventHub->HandleOnDragStart(GestureEvent());

    frameNode->draggable_ = true;
    result = guestureEventHub->IsAllowedDrag(eventHub);
    EXPECT_TRUE(result);

    frameNode->draggable_ = true;
    eventHub->onDragStart_ = nullptr;
    result = guestureEventHub->IsAllowedDrag(eventHub);
    EXPECT_FALSE(result);
}

/**
 * @tc.name: GestureEventHubTest015
 * @tc.desc: Test StartDragTaskForWeb HandleNotAllowDrag
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest015, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);

    auto event = guestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));

    guestureEventHub->StartDragTaskForWeb();

    guestureEventHub->isReceivedDragGestureInfo_ = true;
    guestureEventHub->StartDragTaskForWeb();
    EXPECT_FALSE(guestureEventHub->isReceivedDragGestureInfo_);

    guestureEventHub->HandleNotAllowDrag(GestureEvent());

    frameNode = FrameNode::CreateFrameNode("Web", 102, AceType::MakeRefPtr<Pattern>());
    guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    event = guestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));

    frameNode->userSet_ = false;
    auto func = [](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) { return DragDropInfo(); };
    event->onDragStart_ = func;
    guestureEventHub->HandleOnDragStart(GestureEvent());

    guestureEventHub->HandleNotAllowDrag(GestureEvent());
    EXPECT_TRUE(guestureEventHub->isReceivedDragGestureInfo_);
}

/**
 * @tc.name: GestureEventHubTest016
 * @tc.desc: Test BindMenu
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest016, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);

    auto eventHub = guestureEventHub->eventHub_.Upgrade();
    eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));

    auto pipline = PipelineContext::GetCurrentContext();
    auto func = [](GestureEvent& info) {};
    guestureEventHub->BindMenu(func);

    guestureEventHub->showMenu_ = AceType::MakeRefPtr<ClickEvent>([](GestureEvent& info) {});
    guestureEventHub->BindMenu(func);

    guestureEventHub->clickEventActuator_ = nullptr;
    guestureEventHub->ClearUserOnClick();
    guestureEventHub->ClearUserOnTouch();

    guestureEventHub->clickEventActuator_ =
        AceType::MakeRefPtr<ClickEventActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
    guestureEventHub->touchEventActuator_ = AceType::MakeRefPtr<TouchEventActuator>();
    guestureEventHub->ClearUserOnClick();
    guestureEventHub->ClearUserOnTouch();
    EXPECT_FALSE(guestureEventHub->clickEventActuator_->userCallback_);
}

/**
 * @tc.name: GestureEventHubTest017
 * @tc.desc: Test ProcessTouchTestHit
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest017, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);
    OffsetF coordinateOffset;
    TouchRestrict touchRestrict;
    TouchTestResult innerTargets;
    TouchTestResult finalResult;
    ResponseLinkResult responseLinkResult;
    PointF localPoint;

    PanDirection panDirection;
    guestureEventHub->panEventActuator_ = AceType::MakeRefPtr<PanEventActuator>(
        AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
    /**
     * @tc.steps: step2. call ProcessTouchTestHit , recognizer is not instance of recognizer group
     * @tc.expected: result is false
     */
    guestureEventHub->longPressEventActuator_ =
        AceType::MakeRefPtr<LongPressEventActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
    guestureEventHub->dragEventActuator_ = nullptr;

    auto result = guestureEventHub->ProcessTouchTestHit(
        coordinateOffset, touchRestrict, innerTargets, finalResult, 2, localPoint, nullptr, responseLinkResult);
    EXPECT_FALSE(result);
    /**
     * @tc.steps: step3. call ProcessTouchTestHit , recognizer is instance of recognizer group.
     * @tc.expected: result is false
     */
    GestureEventFunc callback = [](GestureEvent& info) {};
    auto longPressEvent = AceType::MakeRefPtr<LongPressEvent>(std::move(callback));
    guestureEventHub->longPressEventActuator_->SetLongPressEvent(longPressEvent);

    guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
        AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);

    auto dragActionStart = [](GestureEvent& info) {};
    auto dragActionUpdate = [](GestureEvent& info) {};
    auto dragActionEnd = [](GestureEvent& info) {};
    auto dragActionCancel = []() {};
    auto dragEvent = AceType::MakeRefPtr<DragEvent>(
        std::move(dragActionStart), std::move(dragActionUpdate), std::move(dragActionEnd), std::move(dragActionCancel));
    guestureEventHub->dragEventActuator_->userCallback_ = dragEvent;
    guestureEventHub->userParallelClickEventActuator_ =
        AceType::MakeRefPtr<ClickEventActuator>(AceType::WeakClaim(AceType::RawPtr(guestureEventHub)));
    result = guestureEventHub->ProcessTouchTestHit(
        coordinateOffset, touchRestrict, innerTargets, finalResult, 2, localPoint, nullptr, responseLinkResult);
    EXPECT_FALSE(result);
}

/**
 * @tc.name: GestureEventHubTest018
 * @tc.desc: Test HandleOnDragStart
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest018, TestSize.Level1)
{
    /**
     * @tc.steps: step1. create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. update the input parameter attributes.
     */
    RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    auto onDragStart = [&customNode](
                           const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
        DragDropInfo dragDropInfo;
        dragDropInfo.customNode = customNode;
        return dragDropInfo;
    };
    eventHub->SetOnDragStart(std::move(onDragStart));

    auto retFlag = gestureEventHub->IsAllowedDrag(eventHub);
    EXPECT_TRUE(retFlag);

    auto eventManager = AceType::MakeRefPtr<EventManager>();
    EXPECT_TRUE(eventManager);
    eventManager->SetLastMoveBeforeUp(true);

    auto pipeline = PipelineContext::GetCurrentContext();
    pipeline->SetEventManager(eventManager);

    GestureEvent gestureEvent;
    gestureEvent.SetInputEventType(InputEventType::MOUSE_BUTTON);
    gestureEventHub->HandleOnDragStart(gestureEvent);
    EXPECT_TRUE(pipeline->GetEventManager());
    eventManager->SetLastMoveBeforeUp(false);
    gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);

    /**
     * @tc.steps: step3. call HandleOnDragStart with SourceType::MOUSE_BUTTON and InputEventType::TOUCH_SCREEN.
     * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
     */
    gestureEventHub->HandleOnDragStart(gestureEvent);
    EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
}

/**
 * @tc.name: GestureEventHubTest0181
 * @tc.desc: Test HandleOnDragStart
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest0181, TestSize.Level1)
{
    /**
     * @tc.steps: step1. create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::WEB_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());

    /**
     * @tc.steps: step2. update the input parameter attributes.
     */
    RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    DragDropInfo dragDropInfo;
    dragDropInfo.customNode = customNode;
    frameNode->SetDragPreview(dragDropInfo);

    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    auto onDragStart = [&customNode](
                           const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
        DragDropInfo dragDropInfo;
        dragDropInfo.customNode = customNode;
        return dragDropInfo;
    };
    eventHub->SetOnDragStart(std::move(onDragStart));

    auto eventManager = AceType::MakeRefPtr<EventManager>();
    EXPECT_TRUE(eventManager);

    auto pipeline = PipelineContext::GetCurrentContext();
    pipeline->SetEventManager(eventManager);
    eventManager->SetLastMoveBeforeUp(false);

    /**
     * @tc.steps: step3. call HandleOnDragStart with SourceType::MOUSE and InputEventType::TOUCH_SCREEN.
     * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
     */
    GestureEvent gestureEvent;
    gestureEvent.SetSourceDevice(SourceType::MOUSE);
    gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
    gestureEventHub->HandleOnDragStart(gestureEvent);
    EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
}

/**
 * @tc.name: GestureEventHubTest0183
 * @tc.desc: Test HandleOnDragStart
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest0183, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXTINPUT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());

    /**
     * @tc.steps: step2. update the input parameter attributes.
     */
    void* voidPtr = static_cast<void*>(new char[0]);
    RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
    RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    DragDropInfo dragDropInfo;
    dragDropInfo.customNode = customNode;
    dragDropInfo.pixelMap = pixelMap;
    frameNode->SetDragPreview(dragDropInfo);

    auto hostPattern = frameNode->GetPattern<TextDragBase>();
    EXPECT_TRUE(hostPattern);

    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    auto onDragStart = [&customNode](
                           const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
        DragDropInfo dragDropInfo;
        dragDropInfo.customNode = customNode;
        return dragDropInfo;
    };
    eventHub->SetOnDragStart(std::move(onDragStart));

    auto eventManager = AceType::MakeRefPtr<EventManager>();
    EXPECT_TRUE(eventManager);

    auto pipeline = PipelineContext::GetCurrentContext();
    pipeline->SetEventManager(eventManager);
    eventManager->SetLastMoveBeforeUp(false);

    /**
     * @tc.steps: step3. call HandleOnDragStart with SourceType::NONE and InputEventType::TOUCH_SCREEN.
     * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
     */
    GestureEvent gestureEvent;
    gestureEvent.SetSourceDevice(SourceType::NONE);
    gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
    gestureEventHub->HandleOnDragStart(gestureEvent);
    EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
}

/**
 * @tc.name: GestureEventHubTest0184
 * @tc.desc: Test HandleOnDragStart
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest0184, TestSize.Level1)
{
    /**
     * @tc.steps: step1. create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::SEARCH_Field_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());

    /**
     * @tc.steps: step2. update the input parameter attributes.
     */
    DragDropInfo dragDropInfo;
    dragDropInfo.customNode = nullptr;
    dragDropInfo.pixelMap = nullptr;
    frameNode->SetDragPreview(dragDropInfo);

    auto hostPattern = frameNode->GetPattern<TextDragBase>();
    EXPECT_TRUE(hostPattern);

    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    auto onDragStart = [&customNode](
                           const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
        DragDropInfo dragDropInfo;
        dragDropInfo.customNode = customNode;
        return dragDropInfo;
    };
    eventHub->SetOnDragStart(std::move(onDragStart));

    auto eventManager = AceType::MakeRefPtr<EventManager>();
    EXPECT_TRUE(eventManager);
    auto pipeline = PipelineContext::GetCurrentContext();
    pipeline->SetEventManager(eventManager);
    eventManager->SetLastMoveBeforeUp(false);

    /**
     * @tc.steps: step3. call HandleOnDragStart with SourceType::MOUSE and InputEventType::TOUCH_SCREEN.
     * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
     */
    GestureEvent gestureEvent;
    gestureEvent.SetSourceDevice(SourceType::MOUSE);
    gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
    gestureEventHub->HandleOnDragStart(gestureEvent);
    EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
}

/**
 * @tc.name: GestureEventHubTest0185
 * @tc.desc: Test HandleOnDragStart
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest0185, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());

    /**
     * @tc.steps: step2. Build PixelMap and UINode, and update the properties of DragDropInfo.
     */
    void* voidPtr = static_cast<void*>(new char[0]);
    RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
    RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    DragDropInfo dragDropInfo;
    dragDropInfo.customNode = customNode;
    dragDropInfo.pixelMap = pixelMap;
    frameNode->SetDragPreview(dragDropInfo);

    auto hostPattern = frameNode->GetPattern<TextDragBase>();
    EXPECT_TRUE(hostPattern);

    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    auto onDragStart = [&customNode](
                           const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
        DragDropInfo dragDropInfo;
        dragDropInfo.customNode = customNode;
        return dragDropInfo;
    };
    eventHub->SetOnDragStart(std::move(onDragStart));

    auto eventManager = AceType::MakeRefPtr<EventManager>();
    EXPECT_TRUE(eventManager);
    auto pipeline = PipelineContext::GetCurrentContext();
    pipeline->SetEventManager(eventManager);
    eventManager->SetLastMoveBeforeUp(false);

    /**
     * @tc.steps: step3. call HandleOnDragStart with SourceType::NONE and InputEventType::TOUCH_SCREEN.
     * @tc.expected: eventManager->IsLastMoveBeforeUp() the return value is false.
     */
    GestureEvent gestureEvent;
    gestureEvent.SetSourceDevice(SourceType::NONE);
    gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
    gestureEventHub->HandleOnDragStart(gestureEvent);
    EXPECT_FALSE(eventManager->IsLastMoveBeforeUp());
}

/**
 * @tc.name: GestureEventHubTest019
 * @tc.desc: Test KeyBoardShortCutClick
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest019, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. construct a clickEventActuator and update gestureEventHub attributes.
     */
    auto clickEventActuator = AceType::MakeRefPtr<ClickEventActuator>(WeakPtr<NG::GestureEventHub>(gestureEventHub));
    gestureEventHub->clickEventActuator_ = clickEventActuator;

    /**
     * @tc.steps: step3. call KeyBoardShortCutClick with event and frameNode.
     * @tc.expected: retFlag is false.
     */
    KeyEvent event;
    bool retFlag = gestureEventHub->KeyBoardShortCutClick(event, WeakPtr<NG::FrameNode>(frameNode));
    EXPECT_TRUE(retFlag);
}

/**
 * @tc.name: GestureEventHubTest020
 * @tc.desc: taskScheduler of Test StartDragTaskForWeb were true branches
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest020, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);

    /**
     * @tc.steps: step2. updates event and pipeline attributes.
     */
    auto event = guestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));

    auto pipeline = PipelineContext::GetCurrentContext();
    EXPECT_TRUE(pipeline);

    /**
     * @tc.steps: step3. call StartDragTaskForWeb.
     * @tc.expected: taskScheduler is true.
     */
    guestureEventHub->isReceivedDragGestureInfo_ = true;
    guestureEventHub->StartDragTaskForWeb();
    auto taskScheduler = pipeline->GetTaskExecutor();
    EXPECT_FALSE(taskScheduler);
}

/**
 * @tc.name: GestureEventHubTest021
 * @tc.desc: Test StartLongPressActionForWeb
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest021, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. construct a PipelineContext and update pipeline attributes.
     */
    auto pipeline = PipelineContext::GetCurrentContext();
    EXPECT_TRUE(pipeline);

    /**
     * @tc.steps: step3. call StartLongPressActionForWeb.
     * @tc.expected: taskScheduler is false.
     */
    gestureEventHub->StartLongPressActionForWeb();
    auto taskScheduler = pipeline->GetTaskExecutor();
    EXPECT_FALSE(taskScheduler);
}

/**
 * @tc.name: GestureEventHubTest022
 * @tc.desc: Test HandleOnDragUpdate
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest022, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. construct a dragDropProxy and update gestureEventHub attributes.
     */
    constexpr int64_t PROXY_ID_NOT_FIT = 101;
    auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
    gestureEventHub->dragDropProxy_ = dragDropProxy;

    /**
     * @tc.steps: step3. call HandleOnDragUpdate with GestureEvent.
     * @tc.expected: gestureEventHub->dragDropProxy_ is true.
     */
    GestureEvent info;
    gestureEventHub->HandleOnDragUpdate(info);
    EXPECT_TRUE(gestureEventHub->dragDropProxy_);

    /**
     * @tc.steps: step4. call HandleOnDragUpdate with GestureEvent.
     * @tc.expected: gestureEventHub->IsDragged() the return value is false.
     */
    auto pipeline = PipelineContext::GetCurrentContext();
    auto dragDropManager = pipeline->GetDragDropManager();
    dragDropManager->SetIsDragged(false);
    gestureEventHub->HandleOnDragUpdate(info);
    EXPECT_FALSE(dragDropManager->IsDragged());
}

/**
 * @tc.name: GestureEventHubTest024
 * @tc.desc: Test HandleOnDragEnd
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest024, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);

    /**
     * @tc.steps: step2. construct a func and update eventHub attributes.
     */
    auto func = [](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) { return DragDropInfo(); };
    eventHub->SetOnDrop(func);
    eventHub->customerOnDrop_ = func;

    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    auto pipeline = PipelineContext::GetCurrentContext();
    pipeline->SetMinPlatformVersion(12);

    /**
     * @tc.steps: step3. call HandleOnDragEnd with GestureEvent.
     * @tc.expected: The return value of gestureEventHub->GetFrameNode() is true.
     */
    GestureEvent info;
    gestureEventHub->HandleOnDragEnd(info);
    EXPECT_TRUE(gestureEventHub->GetFrameNode());

    constexpr int64_t PROXY_ID_NOT_FIT = 101;
    auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
    gestureEventHub->dragDropProxy_ = dragDropProxy;
    pipeline->SetMinPlatformVersion(9);

    /**
     * @tc.steps: step4. call HandleOnDragEnd with GestureEvent.
     * @tc.expected: The return value of gestureEventHub->dragDropProxy_ is false.
     */
    gestureEventHub->HandleOnDragEnd(info);
    EXPECT_FALSE(gestureEventHub->dragDropProxy_);
}

/**
 * @tc.name: GestureEventHubTest025
 * @tc.desc: Test HandleOnDragEnd
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest025, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::WEB_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);

    /**
     * @tc.steps: step2. construct a func and update eventHub attributes.
     */
    auto func = [](const RefPtr<OHOS::Ace::DragEvent>&, const std::string&) { return DragDropInfo(); };
    eventHub->SetOnDrop(func);
    eventHub->customerOnDrop_ = func;

    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    auto pipeline = PipelineContext::GetCurrentContext();
    pipeline->SetMinPlatformVersion(9);

    constexpr int64_t PROXY_ID_NOT_FIT = 101;
    auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
    gestureEventHub->dragDropProxy_ = dragDropProxy;

    /**
     * @tc.steps: step3. call HandleOnDragEnd with GestureEvent.
     * @tc.expected: gestureEventHub->dragDropProxy_ is null.
     */
    GestureEvent info;
    gestureEventHub->HandleOnDragEnd(info);
    EXPECT_FALSE(gestureEventHub->dragDropProxy_);

    eventHub->onDrop_ = nullptr;
    eventHub->customerOnDrop_ = nullptr;
    gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);

    /**
     * @tc.steps: step4. call HandleOnDragEnd with GestureEvent.
     * @tc.expected: The return value of eventHub->HasOnDrop() is false.
     */
    gestureEventHub->HandleOnDragEnd(info);
    EXPECT_FALSE(eventHub->HasOnDrop());
}

/**
 * @tc.name: GestureEventHubTest026
 * @tc.desc: Test HandleOnDragCancel
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest026, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. construct a dragDropProxy and update gestureEventHub attribute.
     */
    constexpr int64_t PROXY_ID_NOT_FIT = 101;
    auto dragDropProxy = AceType::MakeRefPtr<DragDropProxy>(PROXY_ID_NOT_FIT);
    gestureEventHub->dragDropProxy_ = dragDropProxy;

    /**
     * @tc.steps: step3. call HandleOnDragCancel.
     * @tc.expected: gestureEventHub->dragDropProxy_ is null.
     */
    gestureEventHub->HandleOnDragCancel();
    EXPECT_FALSE(gestureEventHub->dragDropProxy_);
}

/**
 * @tc.name: GestureEventHubTest027
 * @tc.desc: Test SetOnGestureJudgeBegin and SetOnGestureJudgeNativeBegin
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest027, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. construct a gestureJudgeFunc.
     */
    auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo,
                                const std::shared_ptr<BaseGestureEvent>&) -> GestureJudgeResult {
        return GestureJudgeResult(1);
    };

    /**
     * @tc.steps: step3. call SetOnGestureJudgeBegin with gestureJudgeFunc.
     * @tc.expected: gestureEventHub->gestureJudgeFunc_ is not null.
     */
    gestureEventHub->SetOnGestureJudgeBegin(gestureJudgeFunc);
    EXPECT_TRUE(gestureEventHub->gestureJudgeFunc_);

    /**
     * @tc.steps: step4. call SetOnGestureJudgeNativeBegin with gestureJudgeFunc.
     * @tc.expected: gestureEventHub->gestureJudgeNativeFunc_ is not null.
     */
    gestureEventHub->SetOnGestureJudgeNativeBegin(gestureJudgeFunc);
    EXPECT_TRUE(gestureEventHub->gestureJudgeNativeFunc_);
}

/**
 * @tc.name: GestureEventHubTest028
 * @tc.desc: Test IsAccessibilityClickable and IsAccessibilityLongClickable
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest028, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. Updated properties for gestureEventHub.
     */
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, FINGERS);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);

    /**
     * @tc.steps: step3. call IsAccessibilityClickable.
     * @tc.expected: retFlag is false.
     */
    bool retFlag = gestureEventHub->IsAccessibilityClickable();
    EXPECT_FALSE(retFlag);

    /**
     * @tc.steps: step3. call IsAccessibilityLongClickable.
     * @tc.expected: retFlag is false.
     */
    retFlag = gestureEventHub->IsAccessibilityLongClickable();
    EXPECT_FALSE(retFlag);
}

/**
 * @tc.name: GestureEventHubTest029
 * @tc.desc: Test GetHitTestModeStr
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest029, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. call GetHitTestModeStr with hitTestMode_ == -1.
     * @tc.expected: retStr is equal to "HitTestMode.Default".
     */
    gestureEventHub->SetHitTestMode(HitTestMode(-1));
    std::string retStr = GestureEventHub::GetHitTestModeStr(gestureEventHub);
    EXPECT_EQ(retStr, "HitTestMode.Default");

    /**
     * @tc.steps: step3. call GetHitTestModeStr with hitTestMode_ == 4.
     * @tc.expected: retStr is equal to "HitTestMode.Default".
     */
    gestureEventHub->SetHitTestMode(HitTestMode(4));
    retStr = GestureEventHub::GetHitTestModeStr(gestureEventHub);
    EXPECT_EQ(retStr, "HitTestMode.Default");
}

/**
 * @tc.name: GestureEventHubTest030
 * @tc.desc: Test ActClick
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest030, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. Updated properties for gestureEventHub.
     */
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(DOUBLE_FINGERS, CLICK_COUNTS);
    gestureEventHub->gestureHierarchy_.emplace_back(clickRecognizer);

    /**
     * @tc.steps: step3. call ActClick.
     * @tc.expected: retFlag is false.
     */
    bool retFlag = gestureEventHub->ActClick();
    EXPECT_FALSE(retFlag);
}

/**
 * @tc.name: GestureEventHubTest031
 * @tc.desc: Test UpdateGestureHierarchy
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTest031, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    ASSERT_NE(eventHub, nullptr);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    ASSERT_NE(gestureEventHub, nullptr);

    /**
     * @tc.steps: step2. Updated properties for gestureEventHub.
     */
    gestureEventHub->recreateGesture_ = true;
    auto tapGesture = AceType::MakeRefPtr<TapGesture>(FINGERS, 1);
    gestureEventHub->gestures_.emplace_back(tapGesture);
    auto longPressRecognizer = AceType::MakeRefPtr<LongPressRecognizer>(1, 1, false);
    gestureEventHub->gestureHierarchy_.emplace_back(longPressRecognizer);
    gestureEventHub->UpdateGestureHierarchy();

    /**
     * @tc.steps: step3. call UpdateGestureHierarchy.
     * @tc.expected: gestureHierarchy_ has one elements.
     */
    auto sizeGestureHierarchy = static_cast<int32_t>(gestureEventHub->gestureHierarchy_.size());
    EXPECT_EQ(sizeGestureHierarchy, 1);
}

/**
 * @tc.name: ResetDragActionForWeb001
 * @tc.desc: Test ResetDragActionForWeb
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, ResetDragActionForWeb001, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("myButton", 102, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);
    guestureEventHub->ResetDragActionForWeb();
    EXPECT_EQ(guestureEventHub->isReceivedDragGestureInfo_, false);
}

/**
 * @tc.name: ResetDragActionForWeb001
 * @tc.desc: Test ResetDragActionForWeb
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, OnDragStart001, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);
    auto eventHub = guestureEventHub->eventHub_.Upgrade();
    GestureEvent info;
    auto pipline = PipelineContext::GetCurrentContext();
    auto EventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(EventHub);
    auto frameNodeOfEvent = EventHub->GetFrameNode();
    EXPECT_TRUE(frameNodeOfEvent);
    RefPtr<OHOS::Ace::DragEvent> event = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
    auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
    event->SetData(unifiedData);
    RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    DragDropInfo dragDropInfo;
    dragDropInfo.customNode = customNode;
    event->SetResult(DragRet::DRAG_FAIL);
    guestureEventHub->OnDragStart(info, pipline, frameNode, dragDropInfo, event);
    event->SetResult(DragRet::DRAG_CANCEL);
    guestureEventHub->OnDragStart(info, pipline, frameNode, dragDropInfo, event);
    EXPECT_TRUE(EventHub->dragDropProxy_ == false);
}

/**
 * @tc.name: SetMouseDragGatherPixelMaps001
 * @tc.desc: Test SetMouseDragGatherPixelMaps
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, SetMouseDragGatherPixelMaps001, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);
    auto eventHub = guestureEventHub->eventHub_.Upgrade();
    guestureEventHub->SetMouseDragGatherPixelMaps();
    guestureEventHub->SetNotMouseDragGatherPixelMaps();
    EXPECT_NE(PipelineContext::GetCurrentContext(), nullptr);
}

/**
 * @tc.name: IsTextCategoryComponent001
 * @tc.desc: Test IsTextCategoryComponent
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, IsTextCategoryComponent001, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    string frameTag = V2::TEXTAREA_ETS_TAG;
    bool result = guestureEventHub->IsTextCategoryComponent(frameTag);
    EXPECT_TRUE(result);
    frameTag = V2::TEXT_ETS_TAG;
    result = guestureEventHub->IsTextCategoryComponent(frameTag);
    EXPECT_TRUE(result);
    frameTag = V2::TEXTINPUT_ETS_TAG;
    result = guestureEventHub->IsTextCategoryComponent(frameTag);
    EXPECT_TRUE(result);
    frameTag = V2::SEARCH_Field_ETS_TAG;
    result = guestureEventHub->IsTextCategoryComponent(frameTag);
    EXPECT_TRUE(result);
    frameTag = V2::RICH_EDITOR_ETS_TAG;
    result = guestureEventHub->IsTextCategoryComponent(frameTag);
    EXPECT_TRUE(result);
    frameTag = "";
    result = guestureEventHub->IsTextCategoryComponent(frameTag);
    EXPECT_FALSE(result);
}

/**
 * @tc.name: SetResponseRegion001
 * @tc.desc: Test SetResponseRegion
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, SetResponseRegion001, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    std::vector<DimensionRect> responseRegion;
    guestureEventHub->SetResponseRegion(responseRegion);
    responseRegion.push_back(DimensionRect());
    int32_t callbackInfo = 0;
    guestureEventHub->SetResponseRegionFunc([&callbackInfo](const std::vector<DimensionRect>& /*reponseRegion*/) {
        callbackInfo = 1;
    });
    guestureEventHub->SetResponseRegion(responseRegion);
    EXPECT_TRUE(guestureEventHub->isResponseRegion_);
}

/**
 * @tc.name: RemoveLastResponseRect001
 * @tc.desc: Test RemoveLastResponseRect
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, RemoveLastResponseRect001, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    std::vector<DimensionRect> responseRegion;
    guestureEventHub->RemoveLastResponseRect();
    responseRegion.push_back(DimensionRect());
    responseRegion.push_back(DimensionRect());
    guestureEventHub->SetResponseRegion(responseRegion);
    guestureEventHub->RemoveLastResponseRect();
    int32_t callbackInfo = 0;
    guestureEventHub->SetResponseRegionFunc([&callbackInfo](const std::vector<DimensionRect>& /*reponseRegion*/) {
        callbackInfo = 1;
    });
    guestureEventHub->RemoveLastResponseRect();
    EXPECT_FALSE(guestureEventHub->isResponseRegion_);
}

/**
 * @tc.name: SetJSFrameNodeOnTouchEvent001
 * @tc.desc: Test SetJSFrameNodeOnTouchEvent
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, SetJSFrameNodeOnTouchEvent001, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("myButton", 101, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    guestureEventHub->touchEventActuator_ = nullptr;
    TouchEventFunc touchEventFunc = [](TouchEventInfo& info) {};
    guestureEventHub->SetJSFrameNodeOnTouchEvent(std::move(touchEventFunc));
    EXPECT_NE(guestureEventHub->touchEventActuator_, nullptr);
}

/**
 * @tc.name: SetDropAnimationTest
 * @tc.desc: Test SetDropAnimation function.
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, SetDropAnimation, TestSize.Level1)
{
    auto dropAnimationFun = []() {};
    RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
    EXPECT_FALSE(dragEvent->HasDropAnimation());
    dragEvent->SetDropAnimation(std::move(dropAnimationFun));
    EXPECT_TRUE(dragEvent->HasDropAnimation());
}

/**
 * @tc.name: ExecuteDropAnimation
 * @tc.desc: Test ExecuteDropAnimation function.
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, ExecuteDropAnimation, TestSize.Level1)
{
    bool isExecuted = false;
    auto dropAnimationFun = [&isExecuted]() { isExecuted = true; };
    RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
    EXPECT_FALSE(isExecuted);
    dragEvent->SetDropAnimation(std::move(dropAnimationFun));
    dragEvent->ExecuteDropAnimation();
    EXPECT_TRUE(isExecuted);
}

/**
 * @tc.name: StartVibratorByDrag001
 * @tc.desc: Test StartVibratorByDrag
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, StartVibratorByDrag001, TestSize.Level1)
{
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::WEB_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    NG::DragPreviewOption previewOption;
    previewOption.enableHapticFeedback = true;
    frameNode->SetDragPreviewOptions(previewOption, false);
    DragDropGlobalController::GetInstance().UpdateDragFilterShowingStatus(true);
    guestureEventHub->StartVibratorByDrag(frameNode);
    bool dragFilter = DragDropGlobalController::GetInstance().IsDragFilterShowing();
    EXPECT_FALSE(dragFilter);
}

/**
 * @tc.name: StartVibratorByDrag002
 * @tc.desc: Test StartVibratorByDrag
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, StartVibratorByDrag002, TestSize.Level1)
{
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::RICH_EDITOR_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    NG::DragPreviewOption previewOption;
    previewOption.enableHapticFeedback = true;
    frameNode->SetDragPreviewOptions(previewOption, false);
    DragDropGlobalController::GetInstance().UpdateDragFilterShowingStatus(true);
    guestureEventHub->StartVibratorByDrag(frameNode);
    bool dragFilter = DragDropGlobalController::GetInstance().IsDragFilterShowing();
    EXPECT_FALSE(dragFilter);
}

/**
 * @tc.name: GetGestureEventInfo
 * @tc.desc: Test GetGestureEventInfo and GetClickInfo
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetGestureEventInfo001, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    /**
     * @tc.steps: step2. construct a clickEventActuator
     */
    auto clickCallback = [](GestureEvent& info) {};
    auto clickEvent = AceType::MakeRefPtr<ClickEvent>(std::move(clickCallback));
    gestureEventHub->AddClickEvent(clickEvent);
    auto eventInfo = gestureEventHub->GetGestureEventInfo();
    auto clickInfo = gestureEventHub->GetClickInfo();
    EXPECT_EQ(eventInfo.GetPointerEventId(), 0);
    EXPECT_EQ(clickInfo.GetFingerId(), 0);
    /**
     * @tc.steps: step3. construct a clickEventActuator null
     */
    gestureEventHub->clickEventActuator_ = nullptr;
    eventInfo = gestureEventHub->GetGestureEventInfo();
    clickInfo = gestureEventHub->GetClickInfo();
    EXPECT_EQ(eventInfo.GetPointerEventId(), 0);
    EXPECT_EQ(clickInfo.GetFingerId(), -1);
}

/**
 * @tc.name: CheckLastInnerRecognizerCollected001
 * @tc.desc: Test CheckLastInnerRecognizerCollected
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CheckLastInnerRecognizerCollected001, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizer->node_ = frameNode;
    std::vector<RefPtr<NGGestureRecognizer>> subRecognizers = { clickRecognizer };
    auto parallelRecognizer = AceType::MakeRefPtr<ParallelRecognizer>(subRecognizers);
    gestureEventHub->externalParallelRecognizer_.clear();
    gestureEventHub->externalParallelRecognizer_.push_back(parallelRecognizer);
    auto res = gestureEventHub->CheckLastInnerRecognizerCollected(GesturePriority::Parallel, PARALLEL_INDEX_1);
    EXPECT_FALSE(res);
}

/**
 * @tc.name: CheckLastInnerRecognizerCollected002
 * @tc.desc: Test CheckLastInnerRecognizerCollected
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CheckLastInnerRecognizerCollected002, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizer->node_ = frameNode;
    std::vector<RefPtr<NGGestureRecognizer>> subRecognizers = { clickRecognizer };
    auto parallelRecognizer = AceType::MakeRefPtr<ParallelRecognizer>(subRecognizers);
    gestureEventHub->externalParallelRecognizer_.clear();
    gestureEventHub->externalParallelRecognizer_.push_back(parallelRecognizer);
    auto res = gestureEventHub->CheckLastInnerRecognizerCollected(GesturePriority::Parallel, PARALLEL_INDEX_2);
    EXPECT_TRUE(res);
}

/**
 * @tc.name: CheckLastInnerRecognizerCollected003
 * @tc.desc: Test CheckLastInnerRecognizerCollected
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CheckLastInnerRecognizerCollected003, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizer->node_ = frameNode;
    std::vector<RefPtr<NGGestureRecognizer>> subRecognizers = { clickRecognizer };
    auto parallelRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(subRecognizers);
    gestureEventHub->externalExclusiveRecognizer_.clear();
    gestureEventHub->externalExclusiveRecognizer_.push_back(parallelRecognizer);
    auto res = gestureEventHub->CheckLastInnerRecognizerCollected(GesturePriority::High, PARALLEL_INDEX_1);
    EXPECT_FALSE(res);
}

/**
 * @tc.name: CheckLastInnerRecognizerCollected004
 * @tc.desc: Test CheckLastInnerRecognizerCollected
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CheckLastInnerRecognizerCollected004, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizer->node_ = frameNode;
    std::vector<RefPtr<NGGestureRecognizer>> subRecognizers = { clickRecognizer };
    auto parallelRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(subRecognizers);
    gestureEventHub->externalExclusiveRecognizer_.clear();
    gestureEventHub->externalExclusiveRecognizer_.push_back(parallelRecognizer);
    auto res = gestureEventHub->CheckLastInnerRecognizerCollected(GesturePriority::High, PARALLEL_INDEX_2);
    EXPECT_TRUE(res);
}

/**
 * @tc.name: CheckLastInnerRecognizerCollected005
 * @tc.desc: Test CheckLastInnerRecognizerCollected
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CheckLastInnerRecognizerCollected005, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
    std::vector<RefPtr<NGGestureRecognizer>> subRecognizers = { clickRecognizer };
    auto parallelRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(subRecognizers);
    gestureEventHub->externalExclusiveRecognizer_.clear();
    gestureEventHub->externalExclusiveRecognizer_.push_back(parallelRecognizer);
    auto res = gestureEventHub->CheckLastInnerRecognizerCollected(GesturePriority::High, PARALLEL_INDEX_2);
    EXPECT_FALSE(res);
}

/**
 * @tc.name: CheckLastInnerRecognizerCollected006
 * @tc.desc: Test CheckLastInnerRecognizerCollected
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CheckLastInnerRecognizerCollected006, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizer->SetIsSystemGesture(true);
    auto groupClickRecognizerOne = AceType::MakeRefPtr<ClickRecognizer>();
    auto groupClickRecognizerTwo = AceType::MakeRefPtr<ClickRecognizer>();
    std::vector<RefPtr<NGGestureRecognizer>> groupSubRecognizers = { groupClickRecognizerOne, groupClickRecognizerTwo };
    auto childExclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(groupSubRecognizers);
    std::vector<RefPtr<NGGestureRecognizer>> subRecognizers = { nullptr, childExclusiveRecognizer, clickRecognizer };
    auto exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(subRecognizers);
    exclusiveRecognizer->recognizers_.emplace_front(nullptr);
    gestureEventHub->externalExclusiveRecognizer_.clear();
    gestureEventHub->externalExclusiveRecognizer_.push_back(exclusiveRecognizer);
    auto res = gestureEventHub->CheckLastInnerRecognizerCollected(GesturePriority::High, PARALLEL_INDEX_2);
    EXPECT_FALSE(res);
}

/**
 * @tc.name: CheckLastInnerRecognizerCollected007
 * @tc.desc: Test CheckLastInnerRecognizerCollected
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CheckLastInnerRecognizerCollected007, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizer->SetIsSystemGesture(true);
    auto groupClickRecognizerOne = AceType::MakeRefPtr<ClickRecognizer>();
    groupClickRecognizerOne->SetIsSystemGesture(true);
    auto groupClickRecognizerTwo = AceType::MakeRefPtr<ClickRecognizer>();
    std::vector<RefPtr<NGGestureRecognizer>> groupSubRecognizers = { groupClickRecognizerOne, groupClickRecognizerTwo };
    auto childExclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(groupSubRecognizers);
    auto clickRecognizerTwo = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizerTwo->node_ = frameNode;
    std::vector<RefPtr<NGGestureRecognizer>> subRecognizers = { childExclusiveRecognizer, clickRecognizer,
        clickRecognizerTwo };
    auto exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(subRecognizers);
    gestureEventHub->externalExclusiveRecognizer_.clear();
    gestureEventHub->externalExclusiveRecognizer_.push_back(exclusiveRecognizer);
    auto res = gestureEventHub->CheckLastInnerRecognizerCollected(GesturePriority::High, PARALLEL_INDEX_2);
    EXPECT_FALSE(res);
}

/**
 * @tc.name: CheckLastInnerRecognizerCollected008
 * @tc.desc: Test CheckLastInnerRecognizerCollected
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CheckLastInnerRecognizerCollected008, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizer->SetIsSystemGesture(true);
    std::vector<RefPtr<NGGestureRecognizer>> subRecognizers = { clickRecognizer };
    auto parallelRecognizer = AceType::MakeRefPtr<ParallelRecognizer>(subRecognizers);
    gestureEventHub->externalParallelRecognizer_.clear();
    gestureEventHub->externalParallelRecognizer_.push_back(parallelRecognizer);
    auto res = gestureEventHub->CheckLastInnerRecognizerCollected(GesturePriority::Parallel, PARALLEL_INDEX_2);
    EXPECT_FALSE(res);
}

/**
 * @tc.name: CheckLastInnerRecognizerCollected009
 * @tc.desc: Test CheckLastInnerRecognizerCollected
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CheckLastInnerRecognizerCollected009, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);
    auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizer->SetIsSystemGesture(true);
    auto clickRecognizerTwo = AceType::MakeRefPtr<ClickRecognizer>();
    clickRecognizerTwo->node_ = frameNode;
    std::vector<RefPtr<NGGestureRecognizer>> subRecognizers = { clickRecognizer, clickRecognizerTwo };
    auto parallelRecognizer = AceType::MakeRefPtr<ParallelRecognizer>(subRecognizers);
    gestureEventHub->externalParallelRecognizer_.clear();
    gestureEventHub->externalParallelRecognizer_.push_back(parallelRecognizer);
    auto res = gestureEventHub->CheckLastInnerRecognizerCollected(GesturePriority::Parallel, PARALLEL_INDEX_2);
    EXPECT_FALSE(res);
}

/**
 * @tc.name: GestureEventHubSetPanEvent001
 * @tc.desc: Verify SetPanEvent (Dimension version) with new actuator creation
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubSetPanEvent001, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    ASSERT_NE(eventHub, nullptr);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    ASSERT_NE(gestureEventHub, nullptr);

    RefPtr<PanEvent> panEvent = AceType::MakeRefPtr<PanEvent>(
        [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, []() {});

    PanDirection direction;
    direction.type = PanDirection::ALL;

    gestureEventHub->SetPanEvent(panEvent, direction, 1, 10.0_px); // 10.0_px is initial distance threshold
    auto panEventActuator = gestureEventHub->panEventActuator_;
    ASSERT_NE(panEventActuator, nullptr);
    EXPECT_EQ(panEventActuator->userCallback_, panEvent);
}

/**
 * @tc.name: GestureEventHubSetPanEvent002
 * @tc.desc: Verify SetPanEvent when actuator already exists (Dimension version)
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubSetPanEvent002, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    ASSERT_NE(eventHub, nullptr);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    ASSERT_NE(gestureEventHub, nullptr);

    auto initialEvent = AceType::MakeRefPtr<PanEvent>(
        [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, []() {});
    PanDirection direction { PanDirection::VERTICAL };
    gestureEventHub->SetPanEvent(initialEvent, direction, 1, 10.0_px); // 10.0_px is initial distance threshold

    auto newPanEvent = AceType::MakeRefPtr<PanEvent>(
        [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, []() {});

    gestureEventHub->SetPanEvent(newPanEvent, direction, 1, 10.0_px); // 10.0_px is initial distance threshold
    auto panEventActuator = gestureEventHub->panEventActuator_;
    ASSERT_NE(panEventActuator, nullptr);
    EXPECT_EQ(panEventActuator->userCallback_, newPanEvent);
}

/**
 * @tc.name: GestureEventHubSetPanEvent003
 * @tc.desc: Verify SetPanEvent (PanDistanceMap version) with new actuator creation
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubSetPanEvent003, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    ASSERT_NE(eventHub, nullptr);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    ASSERT_NE(gestureEventHub, nullptr);

    auto panEvent = AceType::MakeRefPtr<PanEvent>(
        [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, []() {});

    PanDirection direction { PanDirection::HORIZONTAL };
    PanDistanceMap distanceMap;
    distanceMap[SourceTool::FINGER] = 10.0; // 10.0 is initial distance threshold for FINGER source

    gestureEventHub->SetPanEvent(panEvent, direction, 1, distanceMap);

    auto panEventActuator = gestureEventHub->panEventActuator_;
    ASSERT_NE(panEventActuator, nullptr);
    EXPECT_EQ(panEventActuator->userCallback_, panEvent);
}

/**
 * @tc.name: GestureEventHubSetPanEvent004
 * @tc.desc: Verify SetPanEvent when actuator already exists (PanDistanceMap version)
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubSetPanEvent004, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    ASSERT_NE(eventHub, nullptr);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    ASSERT_NE(gestureEventHub, nullptr);

    auto initialEvent = AceType::MakeRefPtr<PanEvent>(
        [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, []() {});
    PanDistanceMap initMap;
    initMap[SourceTool::FINGER] = 10.0; // 10.0 is initial distance threshold for FINGER source

    PanDirection direction { PanDirection::ALL };
    gestureEventHub->SetPanEvent(initialEvent, direction, 1, initMap);

    auto newPanEvent = AceType::MakeRefPtr<PanEvent>(
        [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, [](GestureEvent& /*info*/) {}, []() {});
    gestureEventHub->SetPanEvent(newPanEvent, direction, 1, initMap);

    auto panEventActuator = gestureEventHub->panEventActuator_;
    ASSERT_NE(panEventActuator, nullptr);
    EXPECT_EQ(panEventActuator->userCallback_, newPanEvent);
}

/**
 * @tc.name: GetDefaultPixelMapScaleTest001
 * @tc.desc: Test GetDefaultPixelMapScale
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDefaultPixelMapScaleTest001, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub and test data
     * @tc.expected: Return default scale when pixelMap is null
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_NE(eventHub, nullptr);
    GestureEventHub gestureHub(eventHub);
    GestureEvent info;
    info.SetInputEventType(InputEventType::AXIS);

    float result = gestureHub.GetDefaultPixelMapScale(nullptr, info, false, nullptr);
    EXPECT_FLOAT_EQ(result, DEFALUT_DRAG_PPIXELMAP_SCALE);
}

/**
 * @tc.name: GetDefaultPixelMapScaleTest002
 * @tc.desc: Test GetDefaultPixelMapScale with mouse event
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDefaultPixelMapScaleTest002, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub and test data
     * @tc.expected: Return 1.0 for mouse event regardless of other conditions
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_NE(eventHub, nullptr);
    auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>());
    EXPECT_NE(frameNode, nullptr);
    GestureEventHub gestureHub(eventHub);
    GestureEvent info;
    info.SetInputEventType(InputEventType::MOUSE_BUTTON);

    auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
    EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(Return(PIXELMAP_WIDTH_LARGE));
    EXPECT_NE(pixelMap, nullptr);
    float result = gestureHub.GetDefaultPixelMapScale(frameNode, info, false, pixelMap);
    EXPECT_FLOAT_EQ(result, EXPECT_SCALE);
}

/**
 * @tc.name: GetDefaultPixelMapScaleTest003
 * @tc.desc: Test GetDefaultPixelMapScale with menu show and valid preview scale
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDefaultPixelMapScaleTest003, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_NE(eventHub, nullptr);
    GestureEventHub gestureHub(eventHub);
    GestureEvent info;
    info.SetInputEventType(InputEventType::AXIS);

    auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto dragPreview = frameNode->GetDragPreview();
    dragPreview.onlyForLifting = false;
    frameNode->SetDragPreview(dragPreview);

    gestureHub.menuPreviewScale_ = PREVIEW_DOWN_SCALE;

    auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
    EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(Return(PIXELMAP_WIDTH_LARGE));

    float result = gestureHub.GetDefaultPixelMapScale(frameNode, info, true, pixelMap);
    EXPECT_FLOAT_EQ(result, PREVIEW_DOWN_SCALE);
}

/**
 * @tc.name: GetDefaultPixelMapScaleTest004
 * @tc.desc: Test GetDefaultPixelMapScale with menu show and adjusted scale
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDefaultPixelMapScaleTest004, TestSize.Level1)
{
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    ASSERT_NE(eventHub, nullptr);
    GestureEventHub gestureHub(eventHub);
    GestureEvent info;
    info.SetInputEventType(InputEventType::AXIS);

    auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto dragPreview = frameNode->GetDragPreview();
    dragPreview.onlyForLifting = false;
    frameNode->SetDragPreview(dragPreview);

    gestureHub.frameNodeSize_ = SizeF(SIZE_X, SIZE_Y);
    gestureHub.menuPreviewScale_ = PREVIEW_UP_SCALE;

    auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
    EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(Return(PIXELMAP_WIDTH_LARGE));
    EXPECT_CALL(*pixelMap, GetHeight()).WillRepeatedly(Return(PIXELMAP_HEIGHT));

    float result = gestureHub.GetDefaultPixelMapScale(frameNode, info, true, pixelMap);
    EXPECT_FLOAT_EQ(result, PIXELMAP_DEFALUT_LIMIT_SCALE);
}

/**
 * @tc.name: GetDefaultPixelMapScaleTest005
 * @tc.desc: Test GetDefaultPixelMapScale with menu not show
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDefaultPixelMapScaleTest005, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub and test data
     * @tc.expected: Return default scale when menu not show
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_NE(eventHub, nullptr);
    GestureEventHub gestureHub(eventHub);
    GestureEvent info;
    info.SetInputEventType(InputEventType::AXIS);

    auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>());
    EXPECT_NE(frameNode, nullptr);
    auto dragPreview = frameNode->GetDragPreview();
    dragPreview.onlyForLifting = false;
    frameNode->SetDragPreview(dragPreview);
    gestureHub.frameNodeSize_ = SizeF(SIZE_X, SIZE_Y);
    gestureHub.menuPreviewScale_ = PREVIEW_DOWN_SCALE;

    auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
    EXPECT_NE(pixelMap, nullptr);
    EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(Return(PIXELMAP_WIDTH_LARGE));

    float result = gestureHub.GetDefaultPixelMapScale(frameNode, info, false, pixelMap);
    EXPECT_FLOAT_EQ(result, DEFALUT_DRAG_PPIXELMAP_SCALE);
}

/**
 * @tc.name: GetDefaultPixelMapScaleTest006
 * @tc.desc: Test GetDefaultPixelMapScale with onlyForLifting true
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDefaultPixelMapScaleTest006, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub and test data
     * @tc.expected: Return default scale when onlyForLifting is true
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_NE(eventHub, nullptr);
    GestureEventHub gestureHub(eventHub);
    GestureEvent info;
    info.SetInputEventType(InputEventType::AXIS);

    auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>());
    EXPECT_NE(frameNode, nullptr);
    auto dragPreview = frameNode->GetDragPreview();
    dragPreview.onlyForLifting = true;
    frameNode->SetDragPreview(dragPreview);
    gestureHub.frameNodeSize_ = SizeF(SIZE_X, SIZE_Y);
    gestureHub.menuPreviewScale_ = PREVIEW_DOWN_SCALE;

    auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
    EXPECT_NE(pixelMap, nullptr);
    EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(Return(PIXELMAP_WIDTH_LARGE));

    float result = gestureHub.GetDefaultPixelMapScale(frameNode, info, true, pixelMap);
    EXPECT_FLOAT_EQ(result, DEFALUT_DRAG_PPIXELMAP_SCALE);
}

/**
 * @tc.name: GetDefaultPixelMapScaleTest007
 * @tc.desc: Test GetDefaultPixelMapScale with invalid menuPreviewScale_
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDefaultPixelMapScaleTest007, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub and test data
     * @tc.expected: Return default scale when menuPreviewScale_ is invalid
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_NE(eventHub, nullptr);
    GestureEventHub gestureHub(eventHub);
    GestureEvent info;
    info.SetInputEventType(InputEventType::AXIS);

    auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>());
    EXPECT_NE(frameNode, nullptr);
    auto dragPreview = frameNode->GetDragPreview();
    dragPreview.onlyForLifting = false;
    frameNode->SetDragPreview(dragPreview);
    gestureHub.frameNodeSize_ = SizeF(SIZE_X, SIZE_Y);
    gestureHub.menuPreviewScale_ = PREVIEW_NEGA_SCALE;
    auto pixelMap = AceType::MakeRefPtr<MockPixelMap>();
    EXPECT_NE(pixelMap, nullptr);
    EXPECT_CALL(*pixelMap, GetWidth()).WillRepeatedly(Return(PIXELMAP_WIDTH_LARGE));

    /**
     * @tc.steps: step2. Call the function under test
     */
    float result = gestureHub.GetDefaultPixelMapScale(frameNode, info, true, pixelMap);

    /**
     * @tc.steps: step3. Verify the return value
     * @tc.expected: Return the default DEFALUT_DRAG_PPIXELMAP_SCALE value
     */
    EXPECT_FLOAT_EQ(result, DEFALUT_DRAG_PPIXELMAP_SCALE);

    /**
     * @tc.steps: step4. Verify menuPreviewScale_ is not modified
     * @tc.expected: menuPreviewScale_ remains the original invalid value
     */
    EXPECT_FLOAT_EQ(gestureHub.menuPreviewScale_, PREVIEW_NEGA_SCALE);
}

/**
 * @tc.name: GestureEventOnDragStartTest001
 * @tc.desc: Test OnDragStart resets drag position-related values.
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventOnDragStartTest001, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create FrameNode, EventHub, GestureEventHub and DragEventActuator.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    ASSERT_NE(eventHub, nullptr);
    auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());
    ASSERT_NE(frameNode, nullptr);
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    ASSERT_NE(gestureEventHub, nullptr);

    /**
     * @tc.steps: step2. Prepare pipeline and set non-zero drag position values in dragDropManager.
     */
    auto pipeline = PipelineContext::GetCurrentContext();
    ASSERT_NE(pipeline, nullptr);
    auto dragDropManager = pipeline->GetDragDropManager();
    ASSERT_NE(dragDropManager, nullptr);
    dragDropManager->dragMovePosition_ = OffsetF(INIT_MOVE_X, INIT_MOVE_Y);
    dragDropManager->lastDragMovePosition_ = OffsetF(LAST_MOVE_X, LAST_MOVE_Y);
    dragDropManager->dragTotalMovePosition_ = OffsetF(TOTAL_MOVE_X, TOTAL_MOVE_Y);

    /**
     * @tc.steps: step3. Call OnDragStart with a valid GestureEvent and DragDropInfo containing a pixelMap.
     * @tc.expected: All position values in dragDropManager are reset to OffsetF().
     */
    auto pixelMap = PixelMap::CreatePixelMap(static_cast<void*>(new char[0]));
    ASSERT_NE(pixelMap, nullptr);
    DragDropInfo dragDropInfo;
    dragDropInfo.pixelMap = pixelMap;
    RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
    ASSERT_NE(dragEvent, nullptr);

    GestureEvent gestureEvent;
    gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
    gestureEventHub->OnDragStart(gestureEvent, pipeline, frameNode, dragDropInfo, dragEvent);

    EXPECT_EQ(dragDropManager->dragMovePosition_, OffsetF());
    EXPECT_EQ(dragDropManager->lastDragMovePosition_, OffsetF());
    EXPECT_EQ(dragDropManager->dragTotalMovePosition_, OffsetF());
}

/**
 * @tc.name: GetDragPreviewInitPositionToScreen001
 * @tc.desc: Test GetDragPreviewInitPositionToScreen when frameNode is null, expect default OffsetF() to be returned
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDragPreviewInitPositionToScreen001, TestSize.Level1)
{
    PreparedInfoForDrag data;
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(nullptr);
    ASSERT_NE(gestureEventHub, nullptr);
    OffsetF result = gestureEventHub->GetDragPreviewInitPositionToScreen(nullptr, data);
    EXPECT_EQ(result, OffsetF());
}

/**
 * @tc.name: GetDragPreviewInitPositionToScreen002
 * @tc.desc: Test when pixelMap is null, expect subtraction with pixelMapHalfSize(0, 0) to proceed normally
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDragPreviewInitPositionToScreen002, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->frameNodeOffset_ = OffsetF(FRAME_OFFSET_X, FRAME_OFFSET_Y);
    gestureEventHub->frameNodeSize_ = SizeF(FRAME_WIDTH, FRAME_HEIGHT);
    PreparedInfoForDrag data;
    data.pixelMap = nullptr;
    data.isMenuShow = true;
    data.sizeChangeEffect = DraggingSizeChangeEffect::DEFAULT;
    data.badgeNumber = 1;
    data.dragMovePosition = OffsetF(MOVE_OFFSET_X / 2, MOVE_OFFSET_Y);
    OffsetF result = gestureEventHub->GetDragPreviewInitPositionToScreen(PipelineContext::GetCurrentContext(), data);

    EXPECT_NE(result, OffsetF());
}

/**
 * @tc.name: GetDragPreviewInitPositionToScreen003
 * @tc.desc: Test WEB component pixelMap scaling path with matching frameTag branch
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDragPreviewInitPositionToScreen003, TestSize.Level1)
{
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::WEB_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);

    PreparedInfoForDrag data;
    auto mockPixelMap = AceType::MakeRefPtr<MockPixelMap>();
    EXPECT_CALL(*mockPixelMap, GetWidth()).WillRepeatedly(Return(PIXELMAP_WIDTH));
    EXPECT_CALL(*mockPixelMap, GetHeight()).WillRepeatedly(Return(PIXELMAP_HEIGHT));
    data.pixelMap = mockPixelMap;
    DragPreviewOption option;
    option.isScaleEnabled = true;
    frameNode->SetDragPreviewOptions(option);
    gestureEventHub->frameNodeOffset_ = OffsetF(MOVE_OFFSET_X, MOVE_OFFSET_Y);

    OffsetF result = gestureEventHub->GetDragPreviewInitPositionToScreen(PipelineContext::GetCurrentContext(), data);
    EXPECT_NE(result, OffsetF());
}

/**
 * @tc.name: GetDragPreviewInitPositionToScreen004
 * @tc.desc: Test menu case when isMenuShow is true, badgeNumber = 1, and sizeChangeEffect = DEFAULT
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDragPreviewInitPositionToScreen004, TestSize.Level1)
{
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::MENU_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->frameNodeOffset_ = OffsetF(FRAME_OFFSET_X, FRAME_OFFSET_Y);
    gestureEventHub->frameNodeSize_ = SizeF(FRAME_WIDTH, FRAME_HEIGHT);

    PreparedInfoForDrag data;
    data.pixelMap = AceType::MakeRefPtr<MockPixelMap>();
    data.isMenuShow = true;
    data.sizeChangeEffect = DraggingSizeChangeEffect::DEFAULT;
    data.badgeNumber = 1;
    data.dragMovePosition = OffsetF(MOVE_OFFSET_X / 2, MOVE_OFFSET_Y / 2);

    OffsetF result = gestureEventHub->GetDragPreviewInitPositionToScreen(PipelineContext::GetCurrentContext(), data);
    EXPECT_NE(result, OffsetF());
}

/**
 * @tc.name: GetDragPreviewInitPositionToScreen005
 * @tc.desc: Test menu case when isMenuShow is true, badgeNumber > 1, and sizeChangeEffect = SIZE_TRANSITION
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetDragPreviewInitPositionToScreen005, TestSize.Level1)
{
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::MENU_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->frameNodeOffset_ = OffsetF(FRAME_OFFSET_X, FRAME_OFFSET_Y);
    gestureEventHub->frameNodeSize_ = SizeF(FRAME_WIDTH, FRAME_HEIGHT);

    PreparedInfoForDrag data;
    data.pixelMap = AceType::MakeRefPtr<MockPixelMap>();
    data.isMenuShow = true;
    data.sizeChangeEffect = DraggingSizeChangeEffect::SIZE_TRANSITION;
    data.badgeNumber = 2;
    data.dragMovePosition = OffsetF(MOVE_OFFSET_X, MOVE_OFFSET_Y);

    OffsetF result = gestureEventHub->GetDragPreviewInitPositionToScreen(PipelineContext::GetCurrentContext(), data);
    EXPECT_NE(result, OffsetF());
}

/**
 * @tc.name: GetBadgeNumber001
 * @tc.desc: Test GetBadgeNumber when GetFrameNode returns null, expect default value 1
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetBadgeNumber001, TestSize.Level1)
{
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(nullptr);
    ASSERT_NE(gestureEventHub, nullptr);
    auto result = gestureEventHub->GetBadgeNumber(nullptr);
    EXPECT_EQ(result, 1);
}

/**
 * @tc.name: GetBadgeNumber002
 * @tc.desc: Test GetBadgeNumber when pattern->GetDragRecordSize() >= 0, expect that value to be returned
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetBadgeNumber002, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("test", 101, AceType::MakeRefPtr<TextPattern>());
    ASSERT_NE(frameNode, nullptr);
    frameNode->GetPattern<TextPattern>()->ResetDragRecordSize(2);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->InitDragDropEvent();
    auto event = gestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
    RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
    auto result = gestureEventHub->GetBadgeNumber(dragEvent);
    EXPECT_EQ(result, 2);
}

/**
 * @tc.name: GetBadgeNumber003
 * @tc.desc: Test GetBadgeNumber when pattern->GetDragRecordSize() < 0 and unifiedData size > 1, expect unifiedData size
 * to be returned
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetBadgeNumber003, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("test", 101, AceType::MakeRefPtr<TextPattern>());
    ASSERT_NE(frameNode, nullptr);
    frameNode->GetPattern<TextPattern>()->ResetDragRecordSize(-1);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->InitDragDropEvent();
    auto event = gestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
    RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
    auto unifiedData = AceType::MakeRefPtr<MockUnifiedData>();
    EXPECT_CALL(*unifiedData, GetSize()).WillOnce(testing::Return(2));
    dragEvent->SetData(unifiedData);
    auto result = gestureEventHub->GetBadgeNumber(dragEvent);
    EXPECT_EQ(result, 2);
}

/**
 * @tc.name: GetBadgeNumber004
 * @tc.desc: Test GetBadgeNumber when DragPreviewOption sets a custom badgeNumber, expect the set value to be returned
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GetBadgeNumber004, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("test", 101, AceType::MakeRefPtr<TextPattern>());
    ASSERT_NE(frameNode, nullptr);
    frameNode->GetPattern<TextPattern>()->ResetDragRecordSize(-1);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->InitDragDropEvent();
    auto event = gestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
    DragPreviewOption option;
    option.badgeNumber = 2;
    option.isNumber = true;
    frameNode->SetDragPreviewOptions(option, true);
    RefPtr<OHOS::Ace::DragEvent> dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
    auto result = gestureEventHub->GetBadgeNumber(dragEvent);
    EXPECT_EQ(result, 2);
}

/**
 * @tc.name: TryDoDragStartAnimation001
 * @tc.desc: Test TryDoDragStartAnimation when subWindow is null
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, TryDoDragStartAnimation001, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("testNode", 101, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->InitDragDropEvent();

    auto event = gestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));

    RefPtr<PipelineBase> context = NG::MockPipelineContext::pipeline_;
    RefPtr<Subwindow> subWindow = nullptr;
    GestureEvent info;
    PreparedInfoForDrag data;
    auto ret = gestureEventHub->TryDoDragStartAnimation(context, subWindow, info, data);
    EXPECT_FALSE(ret);
}

/**
 * @tc.name: TryDoDragStartAnimation002
 * @tc.desc: Test TryDoDragStartAnimation when imageNode is null
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, TryDoDragStartAnimation002, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("testNode", 101, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->InitDragDropEvent();

    auto event = gestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));

    RefPtr<PipelineBase> context = NG::MockPipelineContext::pipeline_;
    auto pipeline = AceType::DynamicCast<PipelineContext>(context);
    auto mainPipeline = PipelineContext::GetMainPipelineContext();
    RefPtr<Subwindow> subWindow = SubwindowManager::GetInstance()->ShowPreviewNG((pipeline != mainPipeline));
    GestureEvent info;
    PreparedInfoForDrag data;

    auto ret = gestureEventHub->TryDoDragStartAnimation(context, subWindow, info, data);
    EXPECT_FALSE(ret);
}

/**
 * @tc.name: TryDoDragStartAnimation003
 * @tc.desc: Test TryDoDragStartAnimation when all conditions satisfied
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, TryDoDragStartAnimation003, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode("testNode", 101, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->InitDragDropEvent();

    auto event = gestureEventHub->eventHub_.Upgrade();
    event->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));

    RefPtr<PipelineContext> context = AceType::DynamicCast<PipelineContext>(NG::MockPipelineContext::pipeline_);
    frameNode->AttachContext(AceType::RawPtr(context));
    auto pipeline = AceType::DynamicCast<PipelineContext>(context);
    ASSERT_NE(pipeline, nullptr);

    auto mockContainer = AceType::MakeRefPtr<MockContainer>(context);
    EXPECT_CALL(*mockContainer, GetInstanceId()).WillRepeatedly(Return(INSTANCE_ID));
    MockContainer::container_ = mockContainer;
    Container::UpdateCurrent(INSTANCE_ID);
    auto container = Container::Current();
    ASSERT_NE(container, nullptr);

    auto mainPipeline = PipelineContext::GetMainPipelineContext();
    auto mockSubwindow = AceType::MakeRefPtr<MockSubwindow>();
    EXPECT_CALL(*mockSubwindow, GetOverlayManager()).WillRepeatedly(Return(pipeline->GetOverlayManager()));
    RefPtr<Subwindow> subWindow = mockSubwindow;
    ASSERT_NE(subWindow, nullptr);
    GestureEvent info;
    PreparedInfoForDrag data;
    data.imageNode = FrameNode::CreateCommonNode("imageNode", 201, false, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(data.imageNode, nullptr);
    auto ret = gestureEventHub->TryDoDragStartAnimation(context, subWindow, info, data);
    EXPECT_TRUE(ret);
}

/**
 * @tc.name: GestureEventHubTestGetPixelMapOffset001
 * @tc.desc: Test GetPixelMapOffset covering all branches
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, GestureEventHubTestGetPixelMapOffset001, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create frameNode and associated GestureEventHub, set offset and simulate gesture location.
     */
    GestureEvent info;
    PreparedInfoForDrag dragInfoData;
    SizeF size(SIZE_X, SIZE_Y * 2);
    auto frameNode = FrameNode::CreateFrameNode("test", 1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);
    gestureEventHub->frameNodeOffset_ = OffsetF(FRAME_OFFSET_X, FRAME_OFFSET_Y);
    info.SetGlobalLocation(Offset(GESTURE_GLOBAL_X, GESTURE_GLOBAL_Y));

    /**
     * @tc.steps: step2. Test when innerRect is valid and offset is calculated with scale = 1.0.
     * @tc.expected: X offset should be less than or equal to 0, Y offset greater than or equal to -200.
     */
    RectF innerRect(OffsetF(INNER_OFFSET_X, INNER_OFFSET_Y), SizeF(SIZE_X / 2, SIZE_Y));
    OffsetF offset = gestureEventHub->GetPixelMapOffset(info, size, dragInfoData, DEFAULT_SCALE, innerRect);
    EXPECT_LE(offset.GetX(), 0);
    EXPECT_GE(offset.GetY(), -200);

    /**
     * @tc.steps: step3. Test when frameNodeSize is (0, 0), expect fallback logic.
     * @tc.expected: X offset should be less than 0.
     */
    gestureEventHub->frameNodeSize_ = SizeF(SIZE_ZERO, SIZE_ZERO);
    offset = gestureEventHub->GetPixelMapOffset(info, size, dragInfoData, DEFAULT_SCALE * 2, RectF());
    EXPECT_LT(offset.GetX(), SIZE_ZERO);

    /**
     * @tc.steps: step4. Test when isNeedCreateTiled is true and frameNodeSize is set.
     * @tc.expected: X offset should equal -size.Width() / 2.
     */
    gestureEventHub->frameNodeSize_ = SizeF(SIZE_X, SIZE_Y);
    dragInfoData.isNeedCreateTiled = true;
    offset = gestureEventHub->GetPixelMapOffset(info, size, dragInfoData, DEFAULT_SCALE, RectF());
    EXPECT_FLOAT_EQ(offset.GetX(), -size.Width() / 2);

    /**
     * @tc.steps: step5. Test when touch point calculation is based on final preview and dragPreviewRect is provided.
     * @tc.expected: X offset should be less than 0.
     */
    NG::DragPreviewOption option;
    option.isTouchPointCalculationBasedOnFinalPreviewEnable = true;
    frameNode->SetDragPreviewOptions(option, false);
    dragInfoData.isNeedCreateTiled = false;
    dragInfoData.dragPreviewRect = RectF(OffsetF(DRAG_OFFSET_X, DRAG_OFFSET_Y), SizeF(SIZE_X, SIZE_Y));
    offset = gestureEventHub->GetPixelMapOffset(info, size, dragInfoData, DEFAULT_SCALE, RectF());
    EXPECT_LT(offset.GetX(), SIZE_ZERO);

    /**
     * @tc.steps: step6. Repeat test with same configuration to ensure deterministic behavior.
     * @tc.expected: X offset should be less than 0.
     */
    option.isTouchPointCalculationBasedOnFinalPreviewEnable = true;
    frameNode->SetDragPreviewOptions(option, false);
    offset = gestureEventHub->GetPixelMapOffset(info, size, dragInfoData, DEFAULT_SCALE, RectF());
    EXPECT_LT(offset.GetX(), SIZE_ZERO);
}

/**
 * @tc.name: CalcFrameNodeOffsetAndSize001
 * @tc.desc: Test CalcFrameNodeOffsetAndSize when frameNode is null
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CalcFrameNodeOffsetAndSize001, TestSize.Level1)
{
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(AceType::MakeRefPtr<EventHub>());
    ASSERT_NE(gestureEventHub, nullptr);
    EXPECT_TRUE(gestureEventHub);
    gestureEventHub->CalcFrameNodeOffsetAndSize(nullptr, true);
    EXPECT_EQ(gestureEventHub->frameNodeSize_.Width(), SIZE_ZERO);
    EXPECT_EQ(gestureEventHub->frameNodeSize_.Height(), SIZE_ZERO);
}

/**
 * @tc.name: CalcFrameNodeOffsetAndSize002
 * @tc.desc: Test CalcFrameNodeOffsetAndSize frameNode tag is TEXT_ETS_TAG, should use TextDragBase path
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CalcFrameNodeOffsetAndSize002, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 101, AceType::MakeRefPtr<TextPattern>());
    ASSERT_NE(frameNode, nullptr);
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);
    guestureEventHub->CalcFrameNodeOffsetAndSize(frameNode, false);
    EXPECT_EQ(guestureEventHub->frameNodeSize_.Width(), SIZE_ZERO);
    EXPECT_EQ(guestureEventHub->frameNodeSize_.Height(), SIZE_ZERO);
}

/**
 * @tc.name: CalcFrameNodeOffsetAndSize003
 * @tc.desc: Test CalcFrameNodeOffsetAndSize frameNode tag is not text category, fallback to default path and not WEB
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CalcFrameNodeOffsetAndSize003, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode(V2::BUTTON_ETS_TAG, 101, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(guestureEventHub, nullptr);
    guestureEventHub->CalcFrameNodeOffsetAndSize(frameNode, false);
    EXPECT_TRUE(guestureEventHub->frameNodeSize_.Width() >= SIZE_ZERO);
}

/**
 * @tc.name: CalcFrameNodeOffsetAndSize004
 * @tc.desc: Test CalcFrameNodeOffsetAndSize where menuPreviewScale is zero (menu not applied)
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, CalcFrameNodeOffsetAndSize004, TestSize.Level1)
{
    auto frameNode = FrameNode::CreateFrameNode(V2::BUTTON_ETS_TAG, 101, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    auto gestureEventHub = frameNode->GetOrCreateGestureEventHub();
    ASSERT_NE(gestureEventHub, nullptr);

    gestureEventHub->menuPreviewScale_ = SIZE_ZERO;
    gestureEventHub->CalcFrameNodeOffsetAndSize(frameNode, true);
    EXPECT_NE(gestureEventHub->frameNodeSize_, SizeF(SIZE_X, SIZE_Y));
}

/**
 * @tc.name: HandleOnDragStartSetDragStatus001
 * @tc.desc: Verify UpdateDragDropInitiatingStatus sets currentDragNode_ correctly
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, HandleOnDragStartSetDragStatus001, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Create GestureEventHub.
     * @tc.expected: gestureEventHub is not null.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    EXPECT_TRUE(eventHub);
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<TextPattern>());

    /**
     * @tc.steps: step2. Build PixelMap and UINode, and update the properties of DragDropInfo.
     */
    void* voidPtr = static_cast<void*>(new char[0]);
    RefPtr<PixelMap> pixelMap = PixelMap::CreatePixelMap(voidPtr);
    RefPtr<UINode> customNode = AceType::MakeRefPtr<FrameNode>(NODE_TAG, -1, AceType::MakeRefPtr<Pattern>());
    DragDropInfo dragDropInfo;
    dragDropInfo.customNode = customNode;
    dragDropInfo.pixelMap = pixelMap;
    frameNode->SetDragPreview(dragDropInfo);

    auto hostPattern = frameNode->GetPattern<TextDragBase>();
    EXPECT_TRUE(hostPattern);

    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    EXPECT_TRUE(gestureEventHub);

    auto onDragStart = [&customNode](
                           const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */, const std::string& /* param */) {
        DragDropInfo dragDropInfo;
        dragDropInfo.customNode = customNode;
        return dragDropInfo;
    };
    eventHub->SetOnDragStart(std::move(onDragStart));

    auto eventManager = AceType::MakeRefPtr<EventManager>();
    EXPECT_TRUE(eventManager);
    auto pipeline = PipelineContext::GetCurrentContext();
    pipeline->SetEventManager(eventManager);
    eventManager->SetLastMoveBeforeUp(false);

    /**
     * @tc.steps: step3. call HandleOnDragStart with SourceType::NONE and InputEventType::TOUCH_SCREEN.
     * @tc.expected: DragDropGlobalController::currentDragNode_ should be updated to frameNode.
     */
    GestureEvent gestureEvent;
    gestureEvent.SetSourceDevice(SourceType::NONE);
    gestureEvent.SetInputEventType(InputEventType::TOUCH_SCREEN);
    DragDropGlobalController::GetInstance().SetDragStartRequestStatus(DragStartRequestStatus::WAITING);
    gestureEventHub->HandleOnDragStart(gestureEvent);
    EXPECT_EQ(DragDropGlobalController::GetInstance().currentDragNode_, frameNode);
}

/**
 * @tc.name: FireCustomerOnDragEndResetStatus001
 * @tc.desc: Test FireCustomerOnDragEnd resets currentDragNode_ in DragDropGlobalController
 * @tc.type: FUNC
 */
HWTEST_F(GestureEventHubTestNg, FireCustomerOnDragEndResetStatus001, TestSize.Level1)
{
    /**
     * @tc.steps: step1. Set currentDragNode_ in DragDropGlobalController to a known node.
     * @tc.expected: currentDragNode_ is not null before reset.
     */
    auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
    ASSERT_NE(frameNode, nullptr);
    DragDropGlobalController::GetInstance().UpdateDragDropInitiatingStatus(frameNode, DragDropInitiatingStatus::MOVING);
    EXPECT_EQ(DragDropGlobalController::GetInstance().currentDragNode_, frameNode);

    /**
     * @tc.steps: step2. Create EventHub and GestureEventHub, attach to frameNode.
     */
    auto eventHub = AceType::MakeRefPtr<EventHub>();
    eventHub->AttachHost(frameNode);
    auto gestureEventHub = AceType::MakeRefPtr<GestureEventHub>(eventHub);
    ASSERT_NE(gestureEventHub, nullptr);

    /**
     * @tc.steps: step3. Create PipelineContext and bind DragDropManager.
     */
    auto pipeline = PipelineContext::GetCurrentContext();
    ASSERT_NE(pipeline, nullptr);
    auto eventManager = AceType::MakeRefPtr<EventManager>();
    pipeline->SetEventManager(eventManager);
    ASSERT_NE(eventManager, nullptr);
    auto dragDropManager = pipeline->GetDragDropManager();
    ASSERT_NE(dragDropManager, nullptr);

    /**
     * @tc.steps: step4. Call FireCustomerOnDragEnd.
     * @tc.expected: currentDragNode_ is reset to nullptr.
     */
    WeakPtr<EventHub> hubWeak(eventHub);
    gestureEventHub->FireCustomerOnDragEnd(pipeline, hubWeak);
    EXPECT_EQ(DragDropGlobalController::GetInstance().currentDragNode_, nullptr);
}
} // namespace OHOS::Ace::NG