1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "test/unittest/core/gestures/gestures_common_test_ng.h"
17 
18 using namespace testing;
19 using namespace testing::ext;
20 
21 namespace OHOS::Ace::NG {
22 class GestureRecognizerTestNg : public GesturesCommonTestNg {
23 public:
24     static void SetUpTestSuite();
25     static void TearDownTestSuite();
26 };
27 
SetUpTestSuite()28 void GestureRecognizerTestNg::SetUpTestSuite()
29 {
30     MockPipelineContext::SetUp();
31 }
32 
TearDownTestSuite()33 void GestureRecognizerTestNg::TearDownTestSuite()
34 {
35     MockPipelineContext::TearDown();
36 }
37 
38 /**
39  * @tc.name: TriggerGestureJudgeCallbackTest001
40  * @tc.desc: Test Recognizer function: TriggerGestureJudgeCallbackTest001
41  * @tc.type: FUNC
42  */
43 HWTEST_F(GestureRecognizerTestNg, TriggerGestureJudgeCallbackTest001, TestSize.Level1)
44 {
45     /**
46      * @tc.steps: step1. create Recognizer、TargetComponent.
47      */
48     RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
49     RefPtr<LongPressRecognizer> longPressRecognizerPtr = AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
50         FINGER_NUMBER, false);
51     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
52     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
53     RefPtr<PinchRecognizer> pinchRecognizerPtr = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER,
54         PINCH_GESTURE_DISTANCE);
55     RefPtr<RotationRecognizer> rotationRecognizerPtr =
56         AceType::MakeRefPtr<RotationRecognizer>(SINGLE_FINGER_NUMBER, ROTATION_GESTURE_ANGLE);
57     SwipeDirection swipeDirection;
58     RefPtr<SwipeRecognizer> swipeRecognizerPtr =
59         AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
60 
61     RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
62 
__anon3ec0c5700102(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 63     auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
64         return GestureJudgeResult::REJECT;};
65     targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
66     /**
67      * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
68      * @tc.expected: step2. result equals CONTINUE.
69      */
70     clickRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
71     clickRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
72     auto result = clickRecognizerPtr->TriggerGestureJudgeCallback();
73     EXPECT_EQ(result, GestureJudgeResult::CONTINUE);
74     longPressRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
75     longPressRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
76     result = longPressRecognizerPtr->TriggerGestureJudgeCallback();
77     panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
78     panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
79     result = panRecognizerPtr->TriggerGestureJudgeCallback();
80     pinchRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
81     pinchRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
82     result = pinchRecognizerPtr->TriggerGestureJudgeCallback();
83     rotationRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
84     rotationRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
85     result = rotationRecognizerPtr->TriggerGestureJudgeCallback();
86     swipeRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
87     swipeRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
88     result = swipeRecognizerPtr->TriggerGestureJudgeCallback();
89     EXPECT_EQ(result, GestureJudgeResult::CONTINUE);
90     /**
91      * @tc.steps: step3. targetComponent_ is not null, call TriggerGestureJudgeCallback function and compare result.
92      * @tc.expected: step3. result equals PREVENT.
93      */
94     clickRecognizerPtr->targetComponent_ = targetComponent;
95     EXPECT_EQ(clickRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
96 
97     longPressRecognizerPtr->targetComponent_ = targetComponent;
98     EXPECT_EQ(longPressRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
99 
100     panRecognizerPtr->targetComponent_ = targetComponent;
101     EXPECT_EQ(panRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
102 
103     pinchRecognizerPtr->targetComponent_ = targetComponent;
104     EXPECT_EQ(pinchRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
105 
106     rotationRecognizerPtr->targetComponent_ = targetComponent;
107     EXPECT_EQ(rotationRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
108 
109     swipeRecognizerPtr->targetComponent_ = targetComponent;
110     EXPECT_EQ(swipeRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
111 }
112 
113 /**
114  * @tc.name: TransformTest001
115  * @tc.desc: Test Transform in Default Condition
116  */
117 HWTEST_F(GestureRecognizerTestNg, TransformTest001, TestSize.Level1)
118 {
119     /**
120      * @tc.steps: step1. create FrameNode.
121      */
122     RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>());
123     RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>());
124     RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>());
125     FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1));
126     FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0));
127 
128     /**
129      * @tc.steps: step2. mock local matrix.
130      */
131     FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity();
132     FRAME_NODE_1->localMat_ = Matrix4::CreateIdentity();
133     FRAME_NODE_2->localMat_ = Matrix4::CreateIdentity();
134 
135     /**
136      * @tc.steps: step2. call callback function.
137      */
138     PointF f1(1.0, 1.0);
139     NGGestureRecognizer::Transform(f1, WeakPtr<FrameNode>(FRAME_NODE_2));
140     PointF f2(1.000000, 1.000000);
141     EXPECT_EQ(f1, f2);
142 }
143 
144 /**
145  * @tc.name: TransformTest002
146  * @tc.desc: Test Transform with Matrix
147  */
148 HWTEST_F(GestureRecognizerTestNg, TransformTest002, TestSize.Level1)
149 {
150     /**
151      * @tc.steps: step1. create FrameNode.
152      */
153     RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>());
154     RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>());
155     RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>());
156     FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1));
157     FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0));
158 
159     /**
160      * @tc.steps: step2. mock local matrix.
161      */
162     FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity();
163     FRAME_NODE_1->localMat_ = Matrix4::Invert(
164             Matrix4::CreateTranslate(100, 200, 0) * Matrix4::CreateRotate(90, 0, 0, 1) *
165             Matrix4::CreateScale(0.6, 0.8, 1));
166     FRAME_NODE_2->localMat_ = Matrix4::Invert(
167             Matrix4::CreateTranslate(400, 300, 0) * Matrix4::CreateRotate(30, 0, 0, 1) *
168             Matrix4::CreateScale(0.5, 0.5, 1));
169 
170     /**
171      * @tc.steps: step3. call callback function.
172      */
173     PointF f1(1.0, 1.0);
174     NGGestureRecognizer::Transform(f1, WeakPtr<FrameNode>(FRAME_NODE_2));
175     PointF f2(-1443.533813, 426.392731);
176     EXPECT_EQ(f1, f2);
177 }
178 
179 /**
180  * @tc.name: TransformTest003
181  * @tc.desc: Test Transform with Matrix in Reverse Order
182  */
183 HWTEST_F(GestureRecognizerTestNg, TransformTest003, TestSize.Level1)
184 {
185     /**
186      * @tc.steps: step1. create FrameNode.
187      */
188     RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>());
189     RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>());
190     RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>());
191     FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1));
192     FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0));
193 
194     /**
195      * @tc.steps: step2. mock local matrix.
196      */
197     FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity();
198     FRAME_NODE_2->localMat_ = Matrix4::Invert(
199             Matrix4::CreateTranslate(100, 200, 0) * Matrix4::CreateRotate(90, 0, 0, 1) *
200             Matrix4::CreateScale(0.6, 0.8, 1));
201     FRAME_NODE_1->localMat_ = Matrix4::Invert(
202             Matrix4::CreateTranslate(400, 300, 0) * Matrix4::CreateRotate(30, 0, 0, 1) *
203             Matrix4::CreateScale(0.5, 0.5, 1));
204 
205     /**
206      * @tc.steps: step3. call callback function.
207      */
208     PointF f1(1.0, 1.0);
209     NGGestureRecognizer::Transform(f1, WeakPtr<FrameNode>(FRAME_NODE_2));
210     PointF f2(-531.471924, 1362.610352);
211     EXPECT_EQ(f1, f2);
212 }
213 
214 /**
215  * @tc.name: PanPressRecognizerHandleTouchMoveEventTest001
216  * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
217  * @tc.type: FUNC
218  */
219 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest001, TestSize.Level1)
220 {
221     /**
222      * @tc.steps: step1. create and set Recognizer、TargetComponent.
223      */
224 
225     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
226     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
227     RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anon3ec0c5700202(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 228     auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
229         return GestureJudgeResult::REJECT;};
230     auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
231     auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
232     PanDirection panDirection;
233     panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
234     panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
235     targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
236     panRecognizerPtr->targetComponent_ = targetComponent;
237     panRecognizerPtr->targetComponent_->node_ = frameNode;
238     TouchEvent touchEvent;
239     touchEvent.tiltX.emplace(1.0f);
240     touchEvent.tiltY.emplace(1.0f);
241     panRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
242     panRecognizerPtr->direction_.type = PanDirection::ALL;
243     panRecognizerPtr->isFlushTouchEventsEnd_ = true;
244     panRecognizerPtr->averageDistance_ = Offset(0, -1);
245     panRecognizerPtr->distance_ = 0;
246     panRecognizerPtr->currentFingers_ = 1;
247     panRecognizerPtr->fingers_ = 1;
248 
249     /**
250      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
251      * @tc.steps: case1: gestureInfo_ is nullptr touchEvent
252      * @tc.expected: step2. result equals REJECT.
253      */
254     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
255     panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
256     EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::NONE);
257 
258     /**
259      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
260      * @tc.steps: case2: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
261      *                   isDragUserReject_ = true touchEvent
262      * @tc.expected: step2. result equals REJECT.
263      */
264     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
265     panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
266     panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
267     guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
268         AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
269     guestureEventHub->dragEventActuator_->isDragUserReject_ = true;
270     panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
271     EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::REJECT);
272 
273     /**
274      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
275      * @tc.steps: case3: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
276      *                   isDragUserReject_ = false touchEvent
277      * @tc.expected: step2. isDragUserReject_ = true.
278      */
279     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
280     guestureEventHub->dragEventActuator_->isDragUserReject_ = false;
281     panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
282     EXPECT_TRUE(guestureEventHub->dragEventActuator_->isDragUserReject_);
283 }
284 
285 /**
286  * @tc.name: PanPressRecognizerHandleTouchMoveEventTest002
287  * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
288  * @tc.type: FUNC
289  */
290 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest002, TestSize.Level1)
291 {
292     /**
293      * @tc.steps: step1. create and set Recognizer、TargetComponent.
294      */
295     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
296     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
297     RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anon3ec0c5700302(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 298     auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
299         return GestureJudgeResult::REJECT;};
300     auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
301     auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
302     PanDirection panDirection;
303     panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
304     panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
305     targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
306     panRecognizerPtr->targetComponent_ = targetComponent;
307     panRecognizerPtr->targetComponent_->node_ = frameNode;
308     TouchEvent touchEvent;
309     touchEvent.tiltX.emplace(1.0f);
310     touchEvent.tiltY.emplace(1.0f);
311     AxisEvent axisEvent;
312     panRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
313     panRecognizerPtr->direction_.type = PanDirection::ALL;
314     panRecognizerPtr->isFlushTouchEventsEnd_ = true;
315     panRecognizerPtr->averageDistance_ = Offset(0, -1);
316     panRecognizerPtr->distance_ = 0;
317     panRecognizerPtr->currentFingers_ = 1;
318     panRecognizerPtr->fingers_ = 1;
319 
320     /**
321      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
322      * @tc.steps: case1: gestureInfo_ is nullptr axisEvent
323      * @tc.expected: step2. result equals REJECT.
324      */
325     panRecognizerPtr->inputEventType_ = InputEventType::AXIS;
326     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
327     panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
328     EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::NONE);
329 
330     /**
331      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
332      * @tc.steps: case2: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
333      *                   isDragUserReject_ = true axisEvent
334      * @tc.expected: step2. result equals REJECT.
335      */
336     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
337     panRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
338     panRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
339     guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
340         AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
341     guestureEventHub->dragEventActuator_->isDragUserReject_ = true;
342     panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
343     EXPECT_EQ(panRecognizerPtr->disposal_, GestureDisposal::REJECT);
344 
345     /**
346      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
347      * @tc.steps: case3: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
348      *                   isDragUserReject_ = false axisEvent
349      * @tc.expected: step2. isDragUserReject_ = true.
350      */
351     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
352     guestureEventHub->dragEventActuator_->isDragUserReject_ = false;
353     panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
354     EXPECT_TRUE(guestureEventHub->dragEventActuator_->isDragUserReject_);
355 }
356 
357 class MockLongPressRecognizer : public LongPressRecognizer {
358 public:
MockLongPressRecognizer()359     MockLongPressRecognizer() : LongPressRecognizer(DURATION, FINGER_NUMBER) {}
360     MOCK_METHOD(void, HandleTouchUpEvent, (const TouchEvent&), (override));
361     MOCK_METHOD(void, HandleTouchCancelEvent, (const TouchEvent&), (override));
362 };
363 
364 /**
365  * @tc.name: PanPressRecognizerHandleTouchMoveEventTest003
366  * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
367  * @tc.type: FUNC
368  */
369 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest003, TestSize.Level1)
370 {
371     LongPressRecognizer recognizerTest(PINCH_GESTURE_DISTANCE, FINGER_NUMBER);
372     recognizerTest.fingersId_.insert(1);
373     recognizerTest.fingersId_.insert(2);
374     recognizerTest.fingersId_.insert(3);
375     recognizerTest.fingersId_.insert(4);
376     recognizerTest.fingersId_.insert(5);
377     recognizerTest.fingersId_.insert(6);
378     TouchEvent point;
379     point.type = TouchType::MOVE;
380     recognizerTest.HandleBridgeModeEvent(point);
381     SUCCEED();
382     point.type = TouchType::DOWN;
383     recognizerTest.HandleBridgeModeEvent(point);
384     SUCCEED();
385     point.sourceType = SourceType::MOUSE;
386     point.id = 4;
387     recognizerTest.HandleBridgeModeEvent(point);
388     SUCCEED();
389 
390     point.type = TouchType::UP;
391     point.id = 2;
392     MockLongPressRecognizer longPressRecoginzer;
393     longPressRecoginzer.fingersId_.clear();
394     longPressRecoginzer.fingersId_.insert(1);
395     longPressRecoginzer.fingersId_.insert(2);
396     longPressRecoginzer.fingersId_.insert(3);
397     longPressRecoginzer.fingersId_.insert(4);
398     EXPECT_CALL(longPressRecoginzer, HandleTouchUpEvent(_)).WillRepeatedly(Return());
399     longPressRecoginzer.HandleBridgeModeEvent(point);
400     SUCCEED();
401 }
402 
403 /**
404  * @tc.name: PanPressRecognizerHandleTouchMoveEventTest004
405  * @tc.desc: Test PanPressRecognizer function: HandleBridgeModeEvent
406  * @tc.type: FUNC
407  */
408 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest004, TestSize.Level1)
409 {
410     MockLongPressRecognizer longPressRecoginzer;
411     TouchEvent point;
412     point.type = TouchType::UP;
413     point.id = 8;
414     longPressRecoginzer.fingersId_.clear();
415     longPressRecoginzer.fingersId_.insert(1);
416     longPressRecoginzer.fingersId_.insert(2);
417     longPressRecoginzer.fingersId_.insert(3);
418     longPressRecoginzer.fingersId_.insert(4);
419     EXPECT_CALL(longPressRecoginzer, HandleTouchUpEvent(_)).WillRepeatedly(Return());
420     longPressRecoginzer.HandleBridgeModeEvent(point);
421     SUCCEED();
422 
423     point.type = TouchType::CANCEL;
424     longPressRecoginzer.fingersId_.clear();
425     longPressRecoginzer.fingersId_.insert(1);
426     longPressRecoginzer.fingersId_.insert(2);
427     longPressRecoginzer.fingersId_.insert(3);
428     longPressRecoginzer.fingersId_.insert(4);
429     point.id = 2;
430     EXPECT_CALL(longPressRecoginzer, HandleTouchCancelEvent(_)).WillRepeatedly(Return());
431     longPressRecoginzer.HandleBridgeModeEvent(point);
432     SUCCEED();
433 
434     point.type = TouchType::CANCEL;
435     longPressRecoginzer.fingersId_.clear();
436     longPressRecoginzer.fingersId_.insert(1);
437     longPressRecoginzer.fingersId_.insert(2);
438     longPressRecoginzer.fingersId_.insert(3);
439     longPressRecoginzer.fingersId_.insert(4);
440     point.id = 5;
441     EXPECT_CALL(longPressRecoginzer, HandleTouchCancelEvent(_)).WillRepeatedly(Return());
442     longPressRecoginzer.HandleBridgeModeEvent(point);
443     SUCCEED();
444     point.type = TouchType::PULL_UP;
445     LongPressRecognizer recognizerTest(DURATION, FINGER_NUMBER);
446     recognizerTest.HandleBridgeModeEvent(point);
447     SUCCEED();
448 }
449 
450 /**
451  * @tc.name: PanPressRecognizerHandleTouchMoveEventTest005
452  * @tc.desc: Test PanPressRecognizer function: OnRejectBridgeObj
453  * @tc.type: FUNC
454  */
455 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest005, TestSize.Level1)
456 {
457     LongPressRecognizer recognizerTest(DURATION, FINGER_NUMBER);
458     recognizerTest.OnRejectBridgeObj();
459 
460     WeakPtr<NGGestureRecognizer> bridgeObj = AceType::WeakClaim(&recognizerTest);
461     recognizerTest.bridgeObjList_.push_back(bridgeObj);
462     recognizerTest.OnRejectBridgeObj();
463     SUCCEED();
464 }
465 
466 /**
467  * @tc.name: PanPressRecognizerHandleTouchMoveEventTest006
468  * @tc.desc: Test PanPressRecognizer function: HandleBridgeModeEvent
469  * @tc.type: FUNC
470  */
471 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest006, TestSize.Level1)
472 {
473     AxisEvent event;
474     MockLongPressRecognizer longPressRecoginzer;
475     event.action = AxisAction::NONE;
476     longPressRecoginzer.HandleBridgeModeEvent(event);
477     SUCCEED();
478     event.action = AxisAction::BEGIN;
479     longPressRecoginzer.HandleBridgeModeEvent(event);
480     SUCCEED();
481     event.action = AxisAction::UPDATE;
482     longPressRecoginzer.HandleBridgeModeEvent(event);
483     SUCCEED();
484     event.action = AxisAction::END;
485     longPressRecoginzer.HandleBridgeModeEvent(event);
486     SUCCEED();
487 }
488 
489 /**
490  * @tc.name: PanPressRecognizerHandleTouchMoveEventTest007
491  * @tc.desc: Test Dump
492  * @tc.type: FUNC
493  */
494 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest007, TestSize.Level1)
495 {
496     LongPressRecognizer recognizerTest(DURATION, FINGER_NUMBER);
497     if (recognizerTest.Dump()) {
498         SUCCEED();
499     }
500 }
501 
502 /**
503  * @tc.name: PanPressRecognizerHandleTouchMoveEventTest008
504  * @tc.desc: Test PanPressRecognizer function: HandleTouchMoveEvent
505  * @tc.type: FUNC
506  */
507 HWTEST_F(GestureRecognizerTestNg, PanPressRecognizerHandleTouchMoveEventTest008, TestSize.Level1)
508 {
509     LongPressRecognizer recognizerTest(DURATION, FINGER_NUMBER);
510     RefPtr<NGGestureRecognizer> targetPtr1 = nullptr;
511     RefPtr<NGGestureRecognizer> targetPtr2 = nullptr;
512     std::list<RefPtr<NGGestureRecognizer>> responseLinkResult;
513     responseLinkResult.push_back(targetPtr1);
514     responseLinkResult.push_back(targetPtr2);
515     recognizerTest.SetResponseLinkRecognizers(responseLinkResult);
516     SUCCEED();
517 }
518 } // namespace OHOS::Ace::NG