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 #include "test/unittest/core/gestures/gestures_common_test_ng.h"
16 
17 using namespace testing;
18 using namespace testing::ext;
19 
20 namespace OHOS::Ace::NG {
21 class PanRecognizerTestNg : public GesturesCommonTestNg {
22 public:
23     static void SetUpTestSuite();
24     static void TearDownTestSuite();
25 };
26 
SetUpTestSuite()27 void PanRecognizerTestNg::SetUpTestSuite()
28 {
29     MockPipelineContext::SetUp();
30 }
31 
TearDownTestSuite()32 void PanRecognizerTestNg::TearDownTestSuite()
33 {
34     MockPipelineContext::TearDown();
35 }
36 
37 /**
38  * @tc.name: PanRecognizerTest001
39  * @tc.desc: Test PanRecognizer function: OnAccepted OnRejected
40  * @tc.type: FUNC
41  */
42 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest001, TestSize.Level1)
43 {
44     /**
45      * @tc.steps: step1. create PanRecognizer.
46      */
47     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
48     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
49 
50     /**
51      * @tc.steps: step2. call OnAccepted function and compare result.
52      * @tc.expected: step2. result equals.
53      */
54     panRecognizer.OnAccepted();
55     EXPECT_EQ(panRecognizer.refereeState_, RefereeState::SUCCEED);
56 
57     /**
58      * @tc.steps: step3. call OnRejected function and compare result.
59      * @tc.expected: step3. result equals.
60      */
61     panRecognizer.OnRejected();
62     EXPECT_EQ(panRecognizer.refereeState_, RefereeState::SUCCEED);
63 }
64 
65 /**
66  * @tc.name: PanRecognizerPanRecognizerTest001
67  * @tc.desc: Test PanRecognizer function PanRecognizer
68  * @tc.type: FUNC
69  */
70 HWTEST_F(PanRecognizerTestNg, PanRecognizerPanRecognizerTest001, TestSize.Level1)
71 {
72     PanDirection panDirection;
73     panDirection.type = PanDirection::VERTICAL;
74     PanRecognizer panRecognizer = PanRecognizer(FINGER_NUMBER_OVER_MAX, panDirection, 0.0);
75     EXPECT_NE(panRecognizer.refereeState_, RefereeState::FAIL);
76     panDirection.type = PanDirection::NONE;
77     PanRecognizer panRecognizer1 = PanRecognizer(FINGER_NUMBER_OVER_MAX, panDirection, 0.0);
78     EXPECT_NE(panRecognizer1.refereeState_, RefereeState::FAIL);
79     panDirection.type = PanDirection::LEFT;
80     PanRecognizer panRecognizer2 = PanRecognizer(FINGER_NUMBER, panDirection, 0.0);
81     EXPECT_NE(panRecognizer2.refereeState_, RefereeState::FAIL);
82     panDirection.type = PanDirection::RIGHT;
83     PanRecognizer panRecognizer3 = PanRecognizer(FINGER_NUMBER, panDirection, 0.0);
84     EXPECT_NE(panRecognizer3.refereeState_, RefereeState::FAIL);
85     panDirection.type = PanDirection::HORIZONTAL;
86     PanRecognizer panRecognizer4 = PanRecognizer(FINGER_NUMBER, panDirection, 0.0);
87     EXPECT_NE(panRecognizer4.refereeState_, RefereeState::FAIL);
88     panDirection.type = PanDirection::UP;
89     PanRecognizer panRecognizer5 = PanRecognizer(0, panDirection, 0.0);
90     EXPECT_NE(panRecognizer5.refereeState_, RefereeState::FAIL);
91     panDirection.type = PanDirection::DOWN;
92     PanRecognizer panRecognizer6 = PanRecognizer(0, panDirection, 0.0);
93     EXPECT_NE(panRecognizer6.refereeState_, RefereeState::FAIL);
94     panDirection.type = PanDirection::VERTICAL;
95     PanRecognizer panRecognizer7 = PanRecognizer(0, panDirection, 0.0);
96     EXPECT_NE(panRecognizer7.refereeState_, RefereeState::FAIL);
97     panDirection.type = PanDirection::ALL;
98     PanRecognizer panRecognizer8 = PanRecognizer(0, panDirection, 0.0);
99     EXPECT_NE(panRecognizer8.refereeState_, RefereeState::FAIL);
100 }
101 
102 /**
103  * @tc.name: PanRecognizerPanRecognizerTest002
104  * @tc.desc: Test PanRecognizer function PanRecognizer
105  * @tc.type: FUNC
106  */
107 HWTEST_F(PanRecognizerTestNg, PanRecognizerPanRecognizerTest002, TestSize.Level1)
108 {
109     /**
110      * @tc.steps: step1. create PanRecognizer.
111      */
112     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
113     PanDirection panDirection;
114     panGestureOption->fingers_ = FINGER_NUMBER_OVER_MAX;
115     panDirection.type = PanDirection::VERTICAL;
116     panGestureOption->SetDirection(panDirection);
117     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
118     EXPECT_NE(panRecognizer.refereeState_, RefereeState::SUCCEED);
119     panGestureOption->fingers_ = FINGER_NUMBER;
120     panDirection.type = PanDirection::NONE;
121     panGestureOption->SetDirection(panDirection);
122     PanRecognizer panRecognizer1 = PanRecognizer(panGestureOption);
123     EXPECT_NE(panRecognizer1.refereeState_, RefereeState::SUCCEED);
124     panGestureOption->fingers_ = FINGER_NUMBER_OVER_MAX;
125     panDirection.type = PanDirection::LEFT;
126     panGestureOption->SetDirection(panDirection);
127     PanRecognizer panRecognizer2 = PanRecognizer(panGestureOption);
128     EXPECT_NE(panRecognizer2.refereeState_, RefereeState::SUCCEED);
129     panGestureOption->fingers_ = FINGER_NUMBER;
130     panDirection.type = PanDirection::RIGHT;
131     panGestureOption->SetDirection(panDirection);
132     PanRecognizer panRecognizer3 = PanRecognizer(panGestureOption);
133     EXPECT_NE(panRecognizer3.refereeState_, RefereeState::SUCCEED);
134     panGestureOption->fingers_ = FINGER_NUMBER_OVER_MAX;
135     panDirection.type = PanDirection::HORIZONTAL;
136     panGestureOption->SetDirection(panDirection);
137     PanRecognizer panRecognizer4 = PanRecognizer(panGestureOption);
138     EXPECT_NE(panRecognizer4.refereeState_, RefereeState::SUCCEED);
139     panGestureOption->fingers_ = 0;
140     panDirection.type = PanDirection::UP;
141     panGestureOption->SetDirection(panDirection);
142     PanRecognizer panRecognizer5 = PanRecognizer(panGestureOption);
143     EXPECT_NE(panRecognizer5.refereeState_, RefereeState::SUCCEED);
144     panGestureOption->fingers_ = 0;
145     panDirection.type = PanDirection::DOWN;
146     panGestureOption->SetDirection(panDirection);
147     PanRecognizer panRecognizer6 = PanRecognizer(panGestureOption);
148     EXPECT_NE(panRecognizer6.refereeState_, RefereeState::SUCCEED);
149     panGestureOption->fingers_ = 0;
150     panDirection.type = PanDirection::DOWN;
151     panGestureOption->SetDirection(panDirection);
152     PanRecognizer panRecognizer7 = PanRecognizer(panGestureOption);
153     EXPECT_NE(panRecognizer7.refereeState_, RefereeState::SUCCEED);
154     panGestureOption->fingers_ = 0;
155     panDirection.type = PanDirection::ALL;
156     panGestureOption->SetDirection(panDirection);
157     PanRecognizer panRecognizer8 = PanRecognizer(panGestureOption);
158     EXPECT_NE(panRecognizer8.refereeState_, RefereeState::SUCCEED);
159 }
160 
161 /**
162  * @tc.name: PanRecognizerTest002
163  * @tc.desc: Test PanRecognizer function: HandleTouchDownEvent
164  * @tc.type: FUNC
165  */
166 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest002, TestSize.Level1)
167 {
168     /**
169      * @tc.steps: step1. create PanRecognizer.
170      */
171     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
172     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
173 
174     /**
175      * @tc.steps: step2. call HandleTouchDown function and compare result.
176      * @tc.steps: case1: call TouchEvent, refereeState is SUCCEED, return
177      * @tc.expected: step2. result equals.
178      */
179     TouchEvent touchEvent;
180     panRecognizer.refereeState_ = RefereeState::SUCCEED;
181     panRecognizer.HandleTouchDownEvent(touchEvent);
182     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
183 
184     /**
185      * @tc.steps: step2. call HandleTouchDown function and compare result.
186      * @tc.steps: case2: call TouchEvent, normal case
187      * @tc.expected: step2. result equals.
188      */
189     panRecognizer.refereeState_ = RefereeState::PENDING;
190     panRecognizer.HandleTouchDownEvent(touchEvent);
191     EXPECT_EQ(panRecognizer.deviceId_, touchEvent.deviceId);
192     EXPECT_EQ(panRecognizer.deviceType_, touchEvent.sourceType);
193 
194     /**
195      * @tc.steps: step2. call HandleTouchDown function and compare result.
196      * @tc.steps: case3: call TouchEvent, set fingerNum != fingers_
197      * @tc.expected: step2. result equals.
198      */
199     panRecognizer.fingers_ = FINGER_NUMBER;
200     panRecognizer.HandleTouchDownEvent(touchEvent);
201     EXPECT_EQ(panRecognizer.refereeState_, RefereeState::PENDING);
202 
203     /**
204      * @tc.steps: step2. call HandleTouchDown function and compare result.
205      * @tc.steps: case4: call TouchEvent, set fingerNum = fingers_
206      * @tc.expected: step2. result equals.
207      */
208     panRecognizer.fingers_ = 1;
209     panRecognizer.HandleTouchDownEvent(touchEvent);
210     EXPECT_EQ(panRecognizer.refereeState_, RefereeState::PENDING);
211 
212     /**
213      * @tc.steps: step2. call HandleTouchDown function and compare result.
214      * @tc.steps: case4: call AxisEvent, refereeState is SUCCEED, return
215      * @tc.expected: step2. result equals.
216      */
217     AxisEvent axisEvent;
218     panRecognizer.refereeState_ = RefereeState::SUCCEED;
219     panRecognizer.touchPoints_.clear();
220     panRecognizer.HandleTouchDownEvent(axisEvent);
221     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
222 
223     /**
224      * @tc.steps: step2. call HandleTouchDown function and compare result.
225      * @tc.steps: case5: call AxisEvent, refereeState is PENDING, normal case
226      * @tc.expected: step2. result equals.
227      */
228     panRecognizer.refereeState_ = RefereeState::PENDING;
229     panRecognizer.HandleTouchDownEvent(axisEvent);
230     EXPECT_EQ(panRecognizer.deviceId_, axisEvent.deviceId);
231     EXPECT_EQ(panRecognizer.deviceType_, axisEvent.sourceType);
232     EXPECT_EQ(panRecognizer.refereeState_, RefereeState::DETECTING);
233 }
234 
235 /**
236  * @tc.name: PanRecognizerHandleTouchDownEventTest001
237  * @tc.desc: Test PanRecognizer function: HandleTouchDownEvent
238  * @tc.type: FUNC
239  */
240 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchDownEventTest001, TestSize.Level1)
241 {
242     /**
243      * @tc.steps: step1. create PanRecognizer.
244      */
245     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
246     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
247 
248     /**
249      * @tc.steps: step2. call HandleTouchDown function and compare result.
250      * @tc.steps: case1: call TouchEvent, refereeState is SUCCEED, return
251      * @tc.expected: step2. result equals.
252      */
253     TouchEvent touchEvent;
254     touchEvent.sourceType = SourceType::MOUSE;
255     panRecognizer.fingers_ = 1;
256     panRecognizer.refereeState_ = RefereeState::SUCCEED;
257     panRecognizer.HandleTouchDownEvent(touchEvent);
258     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
259 
260     /**
261      * @tc.steps: step2. call HandleTouchDown function and compare result.
262      * @tc.steps: case2: call TouchEvent, normal case
263      * @tc.expected: step2. result equals.
264      */
265     panRecognizer.refereeState_ = RefereeState::PENDING;
266     panRecognizer.HandleTouchDownEvent(touchEvent);
267     EXPECT_EQ(panRecognizer.deviceId_, touchEvent.deviceId);
268     EXPECT_EQ(panRecognizer.deviceType_, touchEvent.sourceType);
269 
270     /**
271      * @tc.steps: step2. call HandleTouchDown function and compare result.
272      * @tc.steps: case3: call TouchEvent, set fingerNum != fingers_
273      * @tc.expected: step2. result equals.
274      */
275     panRecognizer.fingers_ = FINGER_NUMBER;
276     panRecognizer.HandleTouchDownEvent(touchEvent);
277     EXPECT_EQ(panRecognizer.refereeState_, RefereeState::PENDING);
278 
279     /**
280      * @tc.steps: step2. call HandleTouchDown function and compare result.
281      * @tc.steps: case4: call TouchEvent, set fingerNum = fingers_
282      * @tc.expected: step2. result equals.
283      */
284     panRecognizer.fingers_ = 1;
285     panRecognizer.HandleTouchDownEvent(touchEvent);
286     EXPECT_EQ(panRecognizer.refereeState_, RefereeState::PENDING);
287 
288     /**
289      * @tc.steps: step2. call HandleTouchDown function and compare result.
290      * @tc.steps: case4: call AxisEvent, refereeState is SUCCEED, return
291      * @tc.expected: step2. result equals.
292      */
293     AxisEvent axisEvent;
294     panRecognizer.refereeState_ = RefereeState::SUCCEED;
295     panRecognizer.touchPoints_.clear();
296     panRecognizer.HandleTouchDownEvent(axisEvent);
297     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
298 
299     /**
300      * @tc.steps: step2. call HandleTouchDown function and compare result.
301      * @tc.steps: case5: call AxisEvent, refereeState is PENDING, normal case
302      * @tc.expected: step2. result equals.
303      */
304     panRecognizer.refereeState_ = RefereeState::PENDING;
305     panRecognizer.HandleTouchDownEvent(axisEvent);
306     EXPECT_EQ(panRecognizer.deviceId_, axisEvent.deviceId);
307     EXPECT_EQ(panRecognizer.deviceType_, axisEvent.sourceType);
308     EXPECT_EQ(panRecognizer.refereeState_, RefereeState::DETECTING);
309 }
310 
311 /**
312  * @tc.name: PanRecognizerTest003
313  * @tc.desc: Test PanRecognizer function: HandleTouchUpEvent
314  * @tc.type: FUNC
315  */
316 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest003, TestSize.Level1)
317 {
318     /**
319      * @tc.steps: step1. create PanRecognizer.
320      */
321     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
322     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
323 
324     /**
325      * @tc.steps: step2. call HandleTouchUp function and compare result.
326      * @tc.steps: case1: refereeState is SUCCEED
327      * @tc.expected: step2. result equals.
328      */
329     TouchEvent touchEvent;
330     panRecognizer.refereeState_ = RefereeState::SUCCEED;
331     panRecognizer.HandleTouchUpEvent(touchEvent);
332     EXPECT_EQ(panRecognizer.globalPoint_.GetX(), touchEvent.x);
333     EXPECT_EQ(panRecognizer.globalPoint_.GetY(), touchEvent.y);
334     EXPECT_EQ(panRecognizer.lastTouchEvent_.id, touchEvent.id);
335 
336     /**
337      * @tc.steps: step2. call HandleTouchUp function and compare result.
338      * @tc.steps: case2: refereeState is SUCCEED, size > 1
339      * @tc.expected: step2. result equals.
340      */
341     panRecognizer.touchPoints_[0] = touchEvent;
342     panRecognizer.touchPoints_[1] = touchEvent;
343     panRecognizer.HandleTouchUpEvent(touchEvent);
344     EXPECT_EQ(panRecognizer.globalPoint_.GetX(), touchEvent.x);
345     EXPECT_EQ(panRecognizer.globalPoint_.GetY(), touchEvent.y);
346     EXPECT_EQ(panRecognizer.lastTouchEvent_.id, touchEvent.id);
347 
348     /**
349      * @tc.steps: step2. call HandleTouchUp function and compare result.
350      * @tc.steps: case3: refereeState is FAIL
351      * @tc.expected: step2. result equals.
352      */
353     panRecognizer.refereeState_ = RefereeState::FAIL;
354     EXPECT_EQ(panRecognizer.globalPoint_.GetX(), touchEvent.x);
355     EXPECT_EQ(panRecognizer.globalPoint_.GetY(), touchEvent.y);
356     EXPECT_EQ(panRecognizer.lastTouchEvent_.id, touchEvent.id);
357 
358     /**
359      * @tc.steps: step3. call HandleTouchUp function and compare result.
360      * @tc.steps: case1: refereeState is SUCCEED
361      * @tc.expected: step2. result equals.
362      */
363     AxisEvent axisEvent;
364     panRecognizer.refereeState_ = RefereeState::SUCCEED;
365     panRecognizer.HandleTouchUpEvent(axisEvent);
366     EXPECT_EQ(panRecognizer.globalPoint_.GetX(), axisEvent.x);
367     EXPECT_EQ(panRecognizer.globalPoint_.GetY(), axisEvent.y);
368 
369     /**
370      * @tc.steps: step3. call HandleTouchUp function and compare result.
371      * @tc.steps: case2: refereeState is FAIL
372      * @tc.expected: step2. result equals.
373      */
374     panRecognizer.refereeState_ = RefereeState::FAIL;
375     panRecognizer.HandleTouchUpEvent(axisEvent);
376     EXPECT_EQ(panRecognizer.globalPoint_.GetX(), axisEvent.x);
377     EXPECT_EQ(panRecognizer.globalPoint_.GetY(), axisEvent.y);
378 }
379 
380 /**
381  * @tc.name: PanRecognizerHandleTouchUpEventTest001
382  * @tc.desc: Test PanRecognizer function: HandleTouchUpEvent
383  * @tc.type: FUNC
384  */
385 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchUpEventTest001, TestSize.Level1)
386 {
387     /**
388      * @tc.steps: step1. create PanRecognizer.
389      */
390     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
391     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
392 
393     /**
394      * @tc.steps: step2. call HandleTouchUp function and compare result.
395      * @tc.steps: case1: refereeState is SUCCEED
396      * @tc.expected: step2. result equals.
397      */
398     TouchEvent touchEvent;
399     panRecognizer.refereeState_ = RefereeState::SUCCEED;
400     panRecognizer.currentFingers_ = panRecognizer.fingers_;
401     panRecognizer.HandleTouchUpEvent(touchEvent);
402     EXPECT_EQ(panRecognizer.globalPoint_.GetX(), touchEvent.x);
403     EXPECT_EQ(panRecognizer.globalPoint_.GetY(), touchEvent.y);
404     EXPECT_EQ(panRecognizer.lastTouchEvent_.id, touchEvent.id);
405 
406     /**
407      * @tc.steps: step2. call HandleTouchUp function and compare result.
408      * @tc.steps: case2: refereeState is SUCCEED, size > 1
409      * @tc.expected: step2. result equals.
410      */
411     panRecognizer.touchPoints_[0] = touchEvent;
412     panRecognizer.touchPoints_[1] = touchEvent;
413     panRecognizer.currentFingers_ = panRecognizer.fingers_;
414     panRecognizer.refereeState_ = RefereeState::FAIL;
415     panRecognizer.HandleTouchUpEvent(touchEvent);
416     EXPECT_EQ(panRecognizer.globalPoint_.GetX(), touchEvent.x);
417     EXPECT_EQ(panRecognizer.globalPoint_.GetY(), touchEvent.y);
418     EXPECT_EQ(panRecognizer.lastTouchEvent_.id, touchEvent.id);
419 }
420 
421 /**
422  * @tc.name: PanRecognizerHandleTouchMoveEventTest001
423  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent
424  * @tc.type: FUNC
425  */
426 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchMoveEventTest001, TestSize.Level1)
427 {
428     /**
429      * @tc.steps: step1. create PanRecognizer.
430      */
431     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
432     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
433 
434     /**
435      * @tc.steps: step2. call HandleTouchUp function and compare result.
436      * @tc.steps: case1: direction.type is VERTICAL
437      * @tc.expected: step2. result equals.
438      */
439     TouchEvent touchEvent;
440     panRecognizer.refereeState_ = RefereeState::SUCCEED;
441     panRecognizer.touchPoints_[touchEvent.id] = touchEvent;
442     panRecognizer.direction_.type = PanDirection::VERTICAL;
443     panRecognizer.isFlushTouchEventsEnd_ = true;
444     panRecognizer.currentFingers_ = panRecognizer.fingers_;
445     panRecognizer.HandleTouchMoveEvent(touchEvent);
446     EXPECT_EQ(panRecognizer.globalPoint_.GetX(), touchEvent.x);
447     EXPECT_EQ(panRecognizer.globalPoint_.GetY(), touchEvent.y);
448     EXPECT_EQ(panRecognizer.delta_.GetX(), 0);
449     EXPECT_EQ(panRecognizer.delta_.GetY(), 0);
450     EXPECT_EQ(panRecognizer.averageDistance_.GetX(), 0);
451 
452     /**
453      * @tc.steps: step2. call HandleTouchUp function and compare result.
454      * @tc.steps: case2: direction.type is HORIZONTAL
455      * @tc.expected: step2. result equals.
456      */
457     panRecognizer.direction_.type = PanDirection::HORIZONTAL;
458     panRecognizer.currentFingers_ = panRecognizer.fingers_;
459     panRecognizer.HandleTouchMoveEvent(touchEvent);
460     EXPECT_EQ(panRecognizer.averageDistance_.GetY(), 0);
461 
462     /**
463      * @tc.steps: step2. call HandleTouchUp function and compare result.
464      * @tc.steps: case3: isFlushTouchEventsEnd_ is false
465      * @tc.expected: step2. result equals.
466      */
467     panRecognizer.isFlushTouchEventsEnd_ = false;
468     panRecognizer.currentFingers_ = panRecognizer.fingers_;
469     panRecognizer.HandleTouchMoveEvent(touchEvent);
470     EXPECT_EQ(panRecognizer.averageDistance_.GetY(), 0);
471 
472     /**
473      * @tc.steps: step2. call HandleTouchUp function and compare result.
474      * @tc.steps: case3: isFlushTouchEventsEnd_ is true
475      * @tc.expected: step2. result equals.
476      */
477     panRecognizer.isFlushTouchEventsEnd_ = true;
478     panRecognizer.currentFingers_ = panRecognizer.fingers_;
479     panRecognizer.HandleTouchMoveEvent(touchEvent);
480     EXPECT_EQ(panRecognizer.averageDistance_.GetY(), 0);
481 }
482 
483 /**
484  * @tc.name: PanRecognizerTest004
485  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent
486  * @tc.type: FUNC
487  */
488 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest004, TestSize.Level1)
489 {
490     /**
491      * @tc.steps: step1. create PanRecognizer.
492      */
493     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
494     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
495 
496     /**
497      * @tc.steps: step2. call HandleTouchUp function and compare result.
498      * @tc.steps: case1: direction.type is VERTICAL
499      * @tc.expected: step2. result equals.
500      */
501     TouchEvent touchEvent;
502     panRecognizer.refereeState_ = RefereeState::SUCCEED;
503     panRecognizer.touchPoints_[touchEvent.id] = touchEvent;
504     panRecognizer.direction_.type = PanDirection::VERTICAL;
505     panRecognizer.isFlushTouchEventsEnd_ = true;
506     panRecognizer.HandleTouchMoveEvent(touchEvent);
507     EXPECT_EQ(panRecognizer.globalPoint_.GetX(), touchEvent.x);
508     EXPECT_EQ(panRecognizer.globalPoint_.GetY(), touchEvent.y);
509     EXPECT_EQ(panRecognizer.delta_.GetX(), 0);
510     EXPECT_EQ(panRecognizer.delta_.GetY(), 0);
511     EXPECT_EQ(panRecognizer.averageDistance_.GetX(), 0);
512 
513     /**
514      * @tc.steps: step2. call HandleTouchUp function and compare result.
515      * @tc.steps: case2: direction.type is HORIZONTAL
516      * @tc.expected: step2. result equals.
517      */
518     panRecognizer.direction_.type = PanDirection::HORIZONTAL;
519     panRecognizer.HandleTouchMoveEvent(touchEvent);
520     EXPECT_EQ(panRecognizer.averageDistance_.GetY(), 0);
521 
522     /**
523      * @tc.steps: step2. call HandleTouchUp function and compare result.
524      * @tc.steps: case3: isFlushTouchEventsEnd_ is false
525      * @tc.expected: step2. result equals.
526      */
527     panRecognizer.isFlushTouchEventsEnd_ = false;
528     panRecognizer.HandleTouchMoveEvent(touchEvent);
529     EXPECT_EQ(panRecognizer.averageDistance_.GetY(), 0);
530 }
531 
532 /**
533  * @tc.name: PanRecognizerTest005
534  * @tc.desc: Test PanRecognizer function: OnFlushTouchEvents begin end
535  * @tc.type: FUNC
536  */
537 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest005, TestSize.Level1)
538 {
539     /**
540      * @tc.steps: step1. create PanRecognizer.
541      */
542     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
543     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
544 
545     /**
546      * @tc.steps: step2. call HandleTouchUp function and compare result.
547      * @tc.expected: step2. result equals.
548      */
549     panRecognizer.OnFlushTouchEventsBegin();
550     EXPECT_EQ(panRecognizer.isFlushTouchEventsEnd_, false);
551     panRecognizer.OnFlushTouchEventsEnd();
552     EXPECT_EQ(panRecognizer.isFlushTouchEventsEnd_, true);
553 }
554 
555 /**
556  * @tc.name: PanRecognizerTest006
557  * @tc.desc: Test PanRecognizer function: IsPanGestureAccept
558  * @tc.type: FUNC
559  */
560 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest006, TestSize.Level1)
561 {
562     /**
563      * @tc.steps: step1. create PanRecognizer.
564      */
565     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
566     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
567 
568     /**
569      * @tc.steps: step2. case1: PanDirection::ALL, fabs(offset) >= distance_.
570      * @tc.expected: step2. return ACCEPT.
571      */
572     PanRecognizer::GestureAcceptResult result;
573     panRecognizer.direction_.type = PanDirection::ALL;
574     panRecognizer.distance_ = 0;
575     result = panRecognizer.IsPanGestureAccept();
576     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::ACCEPT);
577 
578     /**
579      * @tc.steps: step2. case2: PanDirection::ALL, fabs(offset) < distance_.
580      * @tc.expected: step2. return DETECTING.
581      */
582     panRecognizer.direction_.type = PanDirection::ALL;
583     panRecognizer.distance_ = 1;
584     result = panRecognizer.IsPanGestureAccept();
585     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
586 
587     /**
588      * @tc.steps: step2. case3: GetX > GetY, GetX < distance, PanDirection::HORIZONTAL.
589      * @tc.expected: step2. return DETECTING.
590      */
591     panRecognizer.direction_.type = PanDirection::HORIZONTAL;
592     panRecognizer.averageDistance_ = Offset(0, -1);
593     panRecognizer.distance_ = 1;
594     result = panRecognizer.IsPanGestureAccept();
595     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
596 
597     /**
598      * @tc.steps: step2. case4: GetX > GetY, GetX > 0, GetX > distance_, PanDirection::LEFT.
599      * @tc.expected: step2. return REJECT.
600      */
601     panRecognizer.direction_.type = PanDirection::LEFT;
602     panRecognizer.averageDistance_ = Offset(1, 0);
603     panRecognizer.distance_ = 0;
604     result = panRecognizer.IsPanGestureAccept();
605     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::REJECT);
606 
607     /**
608      * @tc.steps: step2. case5: GetX > GetY, GetX > 0, GetX > distance_, PanDirection::VERTICAL.
609      * @tc.expected: step2. return REJECT.
610      */
611     panRecognizer.direction_.type = PanDirection::VERTICAL;
612     panRecognizer.averageDistance_ = Offset(1, 0);
613     panRecognizer.distance_ = 0;
614     result = panRecognizer.IsPanGestureAccept();
615     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
616 
617     /**
618      * @tc.steps: step2. case6: GetX > GetY, GetX = distance_ = 0, PanDirection::VERTICAL.
619      * @tc.expected: step2. return ACCEPT.
620      */
621     panRecognizer.direction_.type = PanDirection::VERTICAL;
622     panRecognizer.averageDistance_ = Offset(0, -1);
623     panRecognizer.distance_ = 0;
624     result = panRecognizer.IsPanGestureAccept();
625     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::ACCEPT);
626 }
627 
628 /**
629  * @tc.name: PanRecognizerTest007
630  * @tc.desc: Test PanRecognizer function: IsPanGestureAccept
631  * @tc.type: FUNC
632  */
633 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest007, TestSize.Level1)
634 {
635     /**
636      * @tc.steps: step1. create PanRecognizer.
637      */
638     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
639     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
640 
641     /**
642      * @tc.steps: step2. case7: GetX <= GetY, GetY < distance_, PanDirection::VERTICAL.
643      * @tc.expected: step2. return DETECTING.
644      */
645     PanRecognizer::GestureAcceptResult result;
646     panRecognizer.direction_.type = PanDirection::VERTICAL;
647     panRecognizer.averageDistance_ = Offset(-1, 0);
648     panRecognizer.distance_ = 1;
649     result = panRecognizer.IsPanGestureAccept();
650     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
651 
652     /**
653      * @tc.steps: step2. case8: GetX <= GetY, GetY > distance_, GetY < 0, PanDirection::DOWN.
654      * @tc.expected: step2. return ACCEPT.
655      */
656     panRecognizer.direction_.type = PanDirection::DOWN;
657     panRecognizer.averageDistance_ = Offset(-1, 1);
658     panRecognizer.touchPointsDistance_[0] = Offset(-1, 1);
659     panRecognizer.distance_ = 0;
660     result = panRecognizer.IsPanGestureAccept();
661     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::ACCEPT);
662 
663     /**
664      * @tc.steps: step2. case9: GetX <= GetY, GetY > distance_, GetY > 0, PanDirection::UP.
665      * @tc.expected: step2. return REJECT.
666      */
667     panRecognizer.direction_.type = PanDirection::UP;
668     panRecognizer.averageDistance_ = Offset(-1, 1);
669     panRecognizer.distance_ = 0;
670     result = panRecognizer.IsPanGestureAccept();
671     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::REJECT);
672 
673     /**
674      * @tc.steps: step2. case10: GetX <= GetY, GetY = distance_ = 0, PanDirection::UP.
675      * @tc.expected: step2. return DETECTING.
676      */
677     panRecognizer.direction_.type = PanDirection::UP;
678     panRecognizer.averageDistance_ = Offset(-1, 0);
679     panRecognizer.distance_ = 0;
680     result = panRecognizer.IsPanGestureAccept();
681     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
682 }
683 
684 /**
685  * @tc.name: PanRecognizerTest008
686  * @tc.desc: Test PanRecognizer function: HandleTouchCancelEvent
687  * @tc.type: FUNC
688  */
689 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest008, TestSize.Level1)
690 {
691     /**
692      * @tc.steps: step1. create PanRecognizer.
693      */
694     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
695     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
696 
697     /**
698      * @tc.steps: step2. call HandleTouchCancel function and compare result.
699      * @tc.steps: case1: Touch, refereeState is SUCCEED
700      * @tc.expected: step2. result equals.
701      */
702     TouchEvent touchEvent;
703     panRecognizer.refereeState_ = RefereeState::SUCCEED;
704     panRecognizer.HandleTouchCancelEvent(touchEvent);
705     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
706 
707     /**
708      * @tc.steps: step2. call HandleTouchCancel function and compare result.
709      * @tc.steps: case2: Touch, refereeState is FAIL
710      * @tc.expected: step2. result equals.
711      */
712     panRecognizer.refereeState_ = RefereeState::FAIL;
713     panRecognizer.HandleTouchCancelEvent(touchEvent);
714     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
715 
716     /**
717      * @tc.steps: step3. call HandleTouchCancel function and compare result.
718      * @tc.steps: case1: Axis, refereeState is SUCCEED
719      * @tc.expected: step2. result equals.
720      */
721     AxisEvent axisEvent;
722     panRecognizer.refereeState_ = RefereeState::SUCCEED;
723     panRecognizer.HandleTouchCancelEvent(axisEvent);
724     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
725 
726     /**
727      * @tc.steps: step3. call HandleTouchCancel function and compare result.
728      * @tc.steps: case2: Axis, refereeState is FAIL
729      * @tc.expected: step2. result equals.
730      */
731     panRecognizer.refereeState_ = RefereeState::FAIL;
732     panRecognizer.HandleTouchCancelEvent(axisEvent);
733     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
734 }
735 
736 /**
737  * @tc.name: PanRecognizerTest009
738  * @tc.desc: Test PanRecognizer function: SendCallbackMsg
739  * @tc.type: FUNC
740  */
741 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest009, TestSize.Level1)
742 {
743     /**
744      * @tc.steps: step1. create PanRecognizer.
745      */
746     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
747     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
748 
749     /**
750      * @tc.steps: step2. call SendCallbackMsg function and compare result.
751      * @tc.steps: case1: onAction is no, *onAction is no
752      * @tc.expected: step2. result equals.
753      */
754     std::unique_ptr<GestureEventFunc> onAction;
755     panRecognizer.SendCallbackMsg(onAction);
756     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
757 
758     /**
759      * @tc.steps: step2. call SendCallbackMsg function and compare result.
760      * @tc.steps: case2: onAction is yes, *onAction is no
761      * @tc.expected: step2. result equals.
762      */
763     onAction = std::make_unique<GestureEventFunc>();
764     panRecognizer.SendCallbackMsg(onAction);
765     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
766 
767     /**
768      * @tc.steps: step2. call SendCallbackMsg function and compare result.
769      * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty, type is AXIS
770      * @tc.expected: step2. result equals.
771      */
__anon668e8bf00102(GestureEvent) 772     onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
773     panRecognizer.inputEventType_ = InputEventType::AXIS;
774     panRecognizer.SendCallbackMsg(onAction);
775     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
776 
777     /**
778      * @tc.steps: step2. call SendCallbackMsg function and compare result.
779      * @tc.steps: case4: touchEvent is not empty, have no X and Y, type is not AXIS
780      * @tc.expected: step2. result equals.
781      */
782     TouchEvent touchEvent;
783     panRecognizer.lastTouchEvent_ = touchEvent;
784     panRecognizer.SendCallbackMsg(onAction);
785     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
786 
787     /**
788      * @tc.steps: step2. call SendCallbackMsg function and compare result.
789      * @tc.steps: case4: touchEvent is not empty, have no X and Y
790      * @tc.expected: step2. result equals.
791      */
792     touchEvent.tiltX = 0.0f;
793     touchEvent.tiltY = 0.0f;
794     panRecognizer.lastTouchEvent_ = touchEvent;
795     panRecognizer.SendCallbackMsg(onAction);
796     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
797 }
798 
799 /**
800  * @tc.name: PanRecognizerSendCallbackMsgTest002
801  * @tc.desc: Test PanRecognizer function: SendCallbackMsg
802  * @tc.type: FUNC
803  */
804 HWTEST_F(PanRecognizerTestNg, PanRecognizerSendCallbackMsgTest002, TestSize.Level1)
805 {
806     /**
807      * @tc.steps: step1. create PanRecognizer.
808      */
809     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
810     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
811 
812     /**
813      * @tc.steps: step2. SendCallbackMsg
814      * @tc.expected: step2. result equals.
815      */
816     TouchEvent touchEvent;
817     panRecognizer.refereeState_ = RefereeState::SUCCEED;
818     panRecognizer.HandleTouchDownEvent(touchEvent);
819     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
820     std::unique_ptr<GestureEventFunc> onAction;
821     panRecognizer.SendCallbackMsg(onAction);
822     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
823 }
824 
825 /**
826  * @tc.name: PanRecognizerSendCallbackMsgTest001
827  * @tc.desc: Test PanRecognizer function: SendCallbackMsg
828  * @tc.type: FUNC
829  */
830 HWTEST_F(PanRecognizerTestNg, PanRecognizerSendCallbackMsgTest001, TestSize.Level1)
831 {
832     /**
833      * @tc.steps: step1. create PanRecognizer.
834      */
835     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
836     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
837 
838     /**
839      * @tc.steps: step2. call SendCallbackMsg function and compare result.
840      * @tc.steps: case1: onAction is no, *onAction is no
841      * @tc.expected: step2. result equals.
842      */
843     std::unique_ptr<GestureEventFunc> onAction = std::make_unique<GestureEventFunc>();
844     panRecognizer.inputEventType_ = InputEventType::TOUCH_SCREEN;
845     panRecognizer.SendCallbackMsg(onAction);
846     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
847 }
848 
849 /**
850  * @tc.name: PanRecognizerTest010
851  * @tc.desc: Test PanRecognizer function: ReconcileFrom
852  * @tc.type: FUNC
853  */
854 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest010, TestSize.Level1)
855 {
856     /**
857      * @tc.steps: step1. create PanRecognizer.
858      */
859     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
860     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
861     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
862 
863     /**
864      * @tc.steps: step2. call ReconcileFrom function
865      * @tc.steps: case1: recognizer is nullptr
866      * @tc.expected: step2. result equals.
867      */
868     auto result = panRecognizer.ReconcileFrom(nullptr);
869     EXPECT_EQ(result, false);
870 
871     /**
872      * @tc.steps: step2. call ReconcileFrom function
873      * @tc.steps: case2: recognizer is normal
874      * @tc.expected: step2. result equals.
875      */
876     result = panRecognizer.ReconcileFrom(panRecognizerPtr);
877     EXPECT_EQ(result, true);
878 
879     /**
880      * @tc.steps: step2. call ReconcileFrom function
881      * @tc.steps: case3: fingers not same
882      * @tc.expected: step2. result equals.
883      */
884     panRecognizer.fingers_ = panRecognizerPtr->fingers_ + 1;
885     result = panRecognizer.ReconcileFrom(panRecognizerPtr);
886     EXPECT_EQ(result, false);
887 
888     /**
889      * @tc.steps: step2. call ReconcileFrom function
890      * @tc.steps: case4: fingers not same, priority not same
891      * @tc.expected: step2. result equals.
892      */
893     panRecognizer.priorityMask_ = GestureMask::End;
894     result = panRecognizer.ReconcileFrom(panRecognizerPtr);
895     EXPECT_EQ(result, false);
896 
897     /**
898      * @tc.steps: step2. call ReconcileFrom function
899      * @tc.steps: case4: fingers same, priority not same
900      * @tc.expected: step2. result equals.
901      */
902     panRecognizer.fingers_ = panRecognizerPtr->fingers_;
903     result = panRecognizer.ReconcileFrom(panRecognizerPtr);
904     EXPECT_EQ(result, false);
905 }
906 
907 /**
908  * @tc.name: PanRecognizerTest012
909  * @tc.desc: Test PanRecognizer function: ChangeFingers
910  * @tc.type: FUNC
911  */
912 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest012, TestSize.Level1)
913 {
914     /**
915      * @tc.steps: step1. create PanRecognizer.
916      */
917     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
918     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
919 
920     /**
921      * @tc.steps: step2. call ChangeFingers function
922      * @tc.steps: case1: fingers not same
923      * @tc.expected: step2. result equals.
924      */
925     panRecognizer.fingers_ = 0;
926     panRecognizer.ChangeFingers(1);
927     EXPECT_EQ(panRecognizer.newFingers_, 1);
928 
929     /**
930      * @tc.steps: step2. call ChangeFingers function
931      * @tc.steps: case1: fingers not same
932      * @tc.expected: step2. result equals.
933      */
934     panRecognizer.fingers_ = 1;
935     panRecognizer.ChangeFingers(1);
936     EXPECT_EQ(panRecognizer.newFingers_, 1);
937 }
938 
939 /**
940  * @tc.name: PanRecognizerTest013
941  * @tc.desc: Test PanRecognizer function: ChangeDirection
942  * @tc.type: FUNC
943  */
944 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest013, TestSize.Level1)
945 {
946     /**
947      * @tc.steps: step1. create PanRecognizer.
948      */
949     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
950     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
951 
952     /**
953      * @tc.steps: step2. call ChangeDirection function
954      * @tc.steps: case1: type not same
955      * @tc.expected: step2. result equals.
956      */
957     PanDirection panDirection;
958     panDirection.type = PanDirection::VERTICAL;
959     panRecognizer.direction_.type = PanDirection::HORIZONTAL;
960     panRecognizer.ChangeDirection(panDirection);
961     EXPECT_EQ(panRecognizer.direction_.type, PanDirection::VERTICAL);
962     EXPECT_EQ(panRecognizer.newDirection_.type, PanDirection::VERTICAL);
963 
964     /**
965      * @tc.steps: step2. call ChangeDirection function
966      * @tc.steps: case2: type same
967      * @tc.expected: step2. result equals.
968      */
969     panDirection.type = PanDirection::VERTICAL;
970     panRecognizer.direction_.type = PanDirection::VERTICAL;
971     panRecognizer.ChangeDirection(panDirection);
972     EXPECT_EQ(panRecognizer.direction_.type, PanDirection::VERTICAL);
973     EXPECT_EQ(panRecognizer.newDirection_.type, PanDirection::VERTICAL);
974 }
975 
976 /**
977  * @tc.name: PanRecognizerTest014
978  * @tc.desc: Test PanRecognizer function: ChangeDistance
979  * @tc.type: FUNC
980  */
981 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest014, TestSize.Level1)
982 {
983     /**
984      * @tc.steps: step1. create PanRecognizer.
985      */
986     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
987     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
988 
989     /**
990      * @tc.steps: step2. call ChangeDistance function
991      * @tc.steps: case1: distance not same, refereeState is READY
992      * @tc.expected: step2. result equals.
993      */
994     panRecognizer.distance_ = 0;
995     panRecognizer.ChangeDistance(1);
996     panRecognizer.refereeState_ = RefereeState::READY;
997     EXPECT_EQ(panRecognizer.distance_, 1);
998     EXPECT_EQ(panRecognizer.newDistance_, 1);
999 
1000     /**
1001      * @tc.steps: step2. call ChangeDistance function
1002      * @tc.steps: case2: distance not same, refereeState is DETECTING
1003      * @tc.expected: step2. result equals.
1004      */
1005     panRecognizer.distance_ = 0;
1006     panRecognizer.ChangeDistance(1);
1007     panRecognizer.refereeState_ = RefereeState::DETECTING;
1008     EXPECT_EQ(panRecognizer.distance_, 1);
1009     EXPECT_EQ(panRecognizer.newDistance_, 1);
1010 
1011     /**
1012      * @tc.steps: step2. call ChangeDistance function
1013      * @tc.steps: case3: distance not same, refereeState is FAIL
1014      * @tc.expected: step2. result equals.
1015      */
1016     panRecognizer.distance_ = 0;
1017     panRecognizer.ChangeDistance(1);
1018     panRecognizer.refereeState_ = RefereeState::FAIL;
1019     EXPECT_EQ(panRecognizer.distance_, 1);
1020     EXPECT_EQ(panRecognizer.newDistance_, 1);
1021 
1022     /**
1023      * @tc.steps: step2. call ChangeDistance function
1024      * @tc.steps: case4: distance same
1025      * @tc.expected: step2. result equals.
1026      */
1027     panRecognizer.distance_ = 0;
1028     panRecognizer.ChangeDistance(0);
1029     panRecognizer.refereeState_ = RefereeState::FAIL;
1030     EXPECT_EQ(panRecognizer.distance_, 0);
1031     EXPECT_EQ(panRecognizer.newDistance_, 1);
1032 }
1033 
1034 /**
1035  * @tc.name: PanRecognizerChangeDistanceTest001
1036  * @tc.desc: Test PanRecognizer function: ChangeDistance
1037  * @tc.type: FUNC
1038  */
1039 HWTEST_F(PanRecognizerTestNg, PanRecognizerChangeDistanceTest001, TestSize.Level1)
1040 {
1041     /**
1042      * @tc.steps: step1. create PanRecognizer.
1043      */
1044     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1045     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
1046 
1047     /**
1048      * @tc.steps: step2. call ChangeDistance function
1049      * @tc.steps: case1: distance not same, refereeState is READY
1050      * @tc.expected: step2. result equals.
1051      */
1052     panRecognizer.distance_ = 0;
1053     panRecognizer.refereeState_ = RefereeState::READY;
1054     panRecognizer.ChangeDistance(1);
1055     EXPECT_EQ(panRecognizer.distance_, 1);
1056     EXPECT_EQ(panRecognizer.newDistance_, 1);
1057 
1058     /**
1059      * @tc.steps: step2. call ChangeDistance function
1060      * @tc.steps: case2: distance not same, refereeState is DETECTING
1061      * @tc.expected: step2. result equals.
1062      */
1063     panRecognizer.distance_ = 0;
1064     panRecognizer.refereeState_ = RefereeState::DETECTING;
1065     panRecognizer.ChangeDistance(1);
1066     EXPECT_EQ(panRecognizer.distance_, 1);
1067     EXPECT_EQ(panRecognizer.newDistance_, 1);
1068 
1069     /**
1070      * @tc.steps: step2. call ChangeDistance function
1071      * @tc.steps: case3: distance not same, refereeState is FAIL
1072      * @tc.expected: step2. result equals.
1073      */
1074     panRecognizer.distance_ = 0;
1075     panRecognizer.refereeState_ = RefereeState::FAIL;
1076     panRecognizer.ChangeDistance(1);
1077     EXPECT_EQ(panRecognizer.newDistance_, 1);
1078 
1079     /**
1080      * @tc.steps: step2. call ChangeDistance function
1081      * @tc.steps: case4: distance same
1082      * @tc.expected: step2. result equals.
1083      */
1084     panRecognizer.distance_ = 0;
1085     panRecognizer.refereeState_ = RefereeState::FAIL;
1086     panRecognizer.ChangeDistance(1);
1087     EXPECT_EQ(panRecognizer.distance_, 0);
1088     EXPECT_EQ(panRecognizer.newDistance_, 1);
1089 }
1090 
1091 /**
1092  * @tc.name: PanRecognizerTest015
1093  * @tc.desc: Test PanRecognizer function: GetMainAxisDelta
1094  * @tc.type: FUNC
1095  */
1096 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest015, TestSize.Level1)
1097 {
1098     /**
1099      * @tc.steps: step1. create PanRecognizer.
1100      */
1101     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1102     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
1103 
1104     /**
1105      * @tc.steps: step2. call ChangeDistance function
1106      * @tc.steps: case1: directionType is ALL
1107      * @tc.expected: step2. result equals.
1108      */
1109     PanDirection panDirection;
1110     panRecognizer.direction_ = panDirection;
1111     panRecognizer.direction_.type = PanDirection::ALL;
1112     auto result = panRecognizer.GetMainAxisDelta();
1113     EXPECT_EQ(result, 0);
1114 
1115     /**
1116      * @tc.steps: step2. call ChangeDistance function
1117      * @tc.steps: case2: directionType is HORIZONTAL
1118      * @tc.expected: step2. result equals.
1119      */
1120     panRecognizer.direction_.type = PanDirection::HORIZONTAL;
1121     result = panRecognizer.GetMainAxisDelta();
1122     EXPECT_EQ(result, 0);
1123 
1124     /**
1125      * @tc.steps: step2. call ChangeDistance function
1126      * @tc.steps: case3: directionType is VERTICAL
1127      * @tc.expected: step2. result equals.
1128      */
1129     panRecognizer.direction_.type = PanDirection::VERTICAL;
1130     result = panRecognizer.GetMainAxisDelta();
1131     EXPECT_EQ(result, 0);
1132 
1133     /**
1134      * @tc.steps: step2. call ChangeDistance function
1135      * @tc.steps: case4: directionType is LEFT
1136      * @tc.expected: step2. result equals.
1137      */
1138     panRecognizer.direction_.type = PanDirection::LEFT;
1139     result = panRecognizer.GetMainAxisDelta();
1140     EXPECT_EQ(result, 0);
1141 }
1142 
1143 /**
1144  * @tc.name: PanRecognizerTest016
1145  * @tc.desc: Test PanRecognizer function: PanRecognizer
1146  * @tc.type: FUNC
1147  */
1148 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest016, TestSize.Level1)
1149 {
1150     /**
1151      * @tc.steps: step1. create PanRecognizer.
1152      */
1153     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1154 
1155     /**
1156      * @tc.steps: step2. call PanRecognizer function
1157      * @tc.steps: case1: 0 <= direction.type <= 15
1158      * @tc.expected: step2. result equals.
1159      */
1160     PanRecognizer panRecognizer1 = PanRecognizer(panGestureOption);
1161     EXPECT_EQ(panRecognizer1.direction_.type, PanDirection::ALL);
1162 
1163     /**
1164      * @tc.steps: step2. call PanRecognizer function
1165      * @tc.steps: case1: 0 > direction.type
1166      * @tc.expected: step2. result equals.
1167      */
1168     panGestureOption->direction_.type = -1;
1169     PanRecognizer panRecognizer2 = PanRecognizer(panGestureOption);
1170     EXPECT_EQ(panRecognizer2.direction_.type, PanDirection::ALL);
1171 
1172     /**
1173      * @tc.steps: step2. call PanRecognizer function
1174      * @tc.steps: case1: 0 > direction.type
1175      * @tc.expected: step2. result equals.
1176      */
1177     panGestureOption->direction_.type = PanDirection::ALL + 1;
1178     PanRecognizer panRecognizer3 = PanRecognizer(panGestureOption);
1179     EXPECT_EQ(panRecognizer3.direction_.type, PanDirection::ALL);
1180 }
1181 
1182 /**
1183  * @tc.name: PanRecognizerTest017
1184  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent(AxisEvent)
1185  * @tc.type: FUNC
1186  */
1187 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest017, TestSize.Level1)
1188 {
1189     /**
1190      * @tc.steps: step1. create PanRecognizer.
1191      */
1192     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1193     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
1194     AxisEvent axisEvent;
1195 
1196     /**
1197      * @tc.steps: step2. call HandleTouchMove function and compare result.
1198      * @tc.steps: case1: fingers_ is 0, return
1199      * @tc.expected: step2. result equals.
1200      */
1201     panRecognizer.fingers_ = 0;
1202     panRecognizer.HandleTouchMoveEvent(axisEvent);
1203     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
1204 
1205     /**
1206      * @tc.steps: step2. call HandleTouchMove function and compare result.
1207      * @tc.steps: case2: fingers_ is 1, direction is VERTICAL, refereeState is SUCCEED
1208      * @tc.expected: step2. result equals.
1209      */
1210     panRecognizer.fingers_ = 1;
1211     panRecognizer.direction_.type = PanDirection::VERTICAL;
1212     panRecognizer.refereeState_ = RefereeState::SUCCEED;
1213     panRecognizer.HandleTouchMoveEvent(axisEvent);
1214     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
1215     EXPECT_EQ(panRecognizer.delta_.GetX(), 0);
1216     EXPECT_EQ(panRecognizer.delta_.GetY(), 0);
1217 
1218     /**
1219      * @tc.steps: step2. call HandleTouchMove function and compare result.
1220      * @tc.steps: case3: fingers_ is 1, direction is HORIZONTAL, refereeState is SUCCEED
1221      * @tc.steps: case3: event.horizontalAxis = 0
1222      * @tc.expected: step2. result equals.
1223      */
1224     panRecognizer.direction_.type = PanDirection::HORIZONTAL;
1225     panRecognizer.refereeState_ = RefereeState::SUCCEED;
1226     axisEvent.horizontalAxis = 0;
1227     panRecognizer.HandleTouchMoveEvent(axisEvent);
1228     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
1229     EXPECT_EQ(panRecognizer.delta_.GetX(), 0);
1230     EXPECT_EQ(panRecognizer.delta_.GetY(), 0);
1231 
1232     /**
1233      * @tc.steps: step2. call HandleTouchMove function and compare result.
1234      * @tc.steps: case3: fingers_ is 1, direction is HORIZONTAL, refereeState is PENDING
1235      * @tc.steps: case3: event.horizontalAxis != 0
1236      * @tc.expected: step2. result equals.
1237      */
1238     panRecognizer.direction_.type = PanDirection::HORIZONTAL;
1239     panRecognizer.refereeState_ = RefereeState::PENDING;
1240     axisEvent.horizontalAxis = 1;
1241     panRecognizer.HandleTouchMoveEvent(axisEvent);
1242     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
1243 }
1244 
1245 /**
1246  * @tc.name: PanRecognizerTest018
1247  * @tc.desc: Test PanRecognizer function: HandleTouchDownEvent
1248  * @tc.type: FUNC
1249  */
1250 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest018, TestSize.Level1)
1251 {
1252     /**
1253      * @tc.steps: step1. create PanRecognizer.
1254      */
1255     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1256     RefPtr<PanRecognizer> panRecognizer = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1257     ASSERT_NE(panRecognizer, nullptr);
1258 
1259     /**
1260      * @tc.steps: step2. test with HandleTouchDownEvent(AxisEvent).
1261      * @tc.expect: panRecognizer->lastAxisEvent_ is equal to axisEvent
1262      * @tc.expect: panRecognizer->touchPoints_[axisEvent.id].originalId is equal to axisEvent.originalId
1263      * @tc.expect: panRecognizer->touchPoints_[axisEvent.id].screenX is equal to axisEvent.screenX
1264      * @tc.expect: panRecognizer->touchPoints_[axisEvent.id].screenY is equal to axisEvent.screenY
1265      */
1266     AxisEvent axisEvent;
1267     axisEvent.id = TEST_EVENT_ID;
1268     axisEvent.originalId = TEST_EVENT_ID;
1269     axisEvent.isRotationEvent = false;
1270     panRecognizer->refereeState_ = RefereeState::SUCCEED;
1271     panRecognizer->fingers_ = SINGLE_FINGER_NUMBER;
1272     panRecognizer->direction_.type = PanDirection::HORIZONTAL;
1273     panRecognizer->HandleTouchDownEvent(axisEvent);
1274     EXPECT_EQ(panRecognizer->lastAxisEvent_.id, axisEvent.id);
1275     EXPECT_EQ(panRecognizer->touchPoints_[axisEvent.id].originalId, axisEvent.originalId);
1276     EXPECT_EQ(panRecognizer->touchPoints_[axisEvent.id].screenX, axisEvent.screenX);
1277     EXPECT_EQ(panRecognizer->touchPoints_[axisEvent.id].screenY, axisEvent.screenY);
1278 }
1279 
1280 /**
1281  * @tc.name: PanRecognizerTest019
1282  * @tc.desc: Test PanRecognizer function: HandleTouchUpEvent
1283  * @tc.type: FUNC
1284  */
1285 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest019, TestSize.Level1)
1286 {
1287     /**
1288      * @tc.steps: step1. create PanRecognizer.
1289      */
1290     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1291     RefPtr<PanRecognizer> panRecognizer = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1292     ASSERT_NE(panRecognizer, nullptr);
1293 
1294     /**
1295      * @tc.steps: step2. test with HandleTouchUpEvent(AxisEvent).
1296      * @tc.expect: panRecognizer->lastAxisEvent_ is equal to axisEvent
1297      */
1298     AxisEvent axisEvent;
1299     axisEvent.id = TEST_EVENT_ID;
1300     axisEvent.isRotationEvent = false;
1301     panRecognizer->refereeState_ = RefereeState::SUCCEED;
1302     panRecognizer->HandleTouchUpEvent(axisEvent);
1303     EXPECT_EQ(panRecognizer->lastAxisEvent_.id, axisEvent.id);
1304 }
1305 
1306 /**
1307  * @tc.name: PanRecognizerTest020
1308  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent
1309  * @tc.type: FUNC
1310  */
1311 HWTEST_F(PanRecognizerTestNg, PanRecognizerTest020, TestSize.Level1)
1312 {
1313     /**
1314      * @tc.steps: step1. create PanRecognizer.
1315      */
1316     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1317     RefPtr<PanRecognizer> panRecognizer = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1318     ASSERT_NE(panRecognizer, nullptr);
1319 
1320     /**
1321      * @tc.steps: step2. test with HandleTouchMoveEvent(AxisEvent).
1322      * @tc.expect: panRecognizer->lastAxisEvent_ is equal to axisEvent
1323      */
1324     AxisEvent axisEvent;
1325     axisEvent.id = TEST_EVENT_ID;
1326     axisEvent.isRotationEvent = false;
1327     panRecognizer->refereeState_ = RefereeState::SUCCEED;
1328     panRecognizer->fingers_ = SINGLE_FINGER_NUMBER;
1329     panRecognizer->HandleTouchMoveEvent(axisEvent);
1330     EXPECT_EQ(panRecognizer->lastAxisEvent_.id, axisEvent.id);
1331 }
1332 
1333 /**
1334  * @tc.name: PanRecognizerSendCallbackMsgTest003
1335  * @tc.desc: Test PanRecognizer function: SendCallbackMsg
1336  * @tc.type: FUNC
1337  */
1338 HWTEST_F(PanRecognizerTestNg, PanRecognizerSendCallbackMsgTest003, TestSize.Level1)
1339 {
1340     /**
1341      * @tc.steps: step1. create PanRecognizer.
1342      */
1343     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1344     PanRecognizer panRecognizer = PanRecognizer(panGestureOption);
1345     std::unique_ptr<GestureEventFunc> onAction;
1346 
1347     /**
1348      * @tc.steps: step2. call SendCallbackMsg function and compare result.
1349      * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty, type is AXIS
1350      * @tc.expected: step2. result equals.
1351      */
__anon668e8bf00202(GestureEvent) 1352     onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
1353     panRecognizer.inputEventType_ = InputEventType::AXIS;
1354     panRecognizer.SendCallbackMsg(onAction);
1355     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
1356 
1357     /**
1358      * @tc.steps: step2. call SendCallbackMsg function and compare result.
1359      * @tc.steps: case4: touchEvent is not empty, have no X and Y, type is not AXIS
1360      * @tc.expected: step2. result equals.
1361      */
1362     TouchEvent touchEvent;
1363     panRecognizer.lastTouchEvent_ = touchEvent;
1364     panRecognizer.inputEventType_ = InputEventType::AXIS;
1365     panRecognizer.SendCallbackMsg(onAction);
1366     EXPECT_EQ(panRecognizer.touchPoints_.size(), 0);
1367 
1368     /**
1369      * @tc.steps: step2. call SendCallbackMsg function and compare result.
1370      * @tc.steps: case4: touchEvent is not empty, have no X and Y
1371      * @tc.expected: step2. result equals.
1372      */
1373     touchEvent.tiltX = 0.0f;
1374     touchEvent.tiltY = 0.0f;
1375     panRecognizer.lastTouchEvent_ = touchEvent;
1376     panRecognizer.touchPoints_[touchEvent.id] = touchEvent;
1377     panRecognizer.inputEventType_ = InputEventType::AXIS;
1378     panRecognizer.SendCallbackMsg(onAction);
1379     EXPECT_EQ(panRecognizer.touchPoints_.size(), 1);
1380 }
1381 
1382 /*
1383  * @tc.name: PanGestureTest001
1384  * @tc.desc: Test PanGesture CreateRecognizer function
1385  */
1386 HWTEST_F(PanRecognizerTestNg, PanGestureTest001, TestSize.Level1)
1387 {
1388     /**
1389      * @tc.steps: step1. create PanGesture.
1390      */
1391     auto panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1392     auto panGesture = AceType::MakeRefPtr<PanGesture>(panGestureOption);
1393     ASSERT_NE(panGesture, nullptr);
1394     EXPECT_EQ(panGesture->panGestureOption_->fingers_, panGestureOption->fingers_);
1395 
1396     /**
1397      * @tc.steps: step2. call CreateRecognizer function and compare result.
1398      * @tc.expect: panRecognizer create successfully, use the same Option as panGesture.
1399      */
1400     panGesture->priority_ = GesturePriority::Low;
1401     panGesture->gestureMask_ = GestureMask::Normal;
1402     auto panRecognizer = AceType::DynamicCast<PanRecognizer>(panGesture->CreateRecognizer());
1403     ASSERT_NE(panRecognizer, nullptr);
1404     EXPECT_EQ(panRecognizer->GetPriority(), GesturePriority::Low);
1405     EXPECT_EQ(panRecognizer->GetPriorityMask(), GestureMask::Normal);
1406     EXPECT_EQ(panRecognizer->distance_, DEFAULT_PAN_DISTANCE.ConvertToPx());
1407 }
1408 
1409 /**
1410  * @tc.name: PanGestureTest002
1411  * @tc.desc: Test PanGesture CreateRecognizer function
1412  */
1413 HWTEST_F(PanRecognizerTestNg, PanGestureTest002, TestSize.Level1)
1414 {
1415     /**
1416      * @tc.steps: step1. create PanGesture.
1417      */
1418     PanDirection panDirection;
1419     panDirection.type = PanDirection::RIGHT;
1420     auto panGesture = AceType::MakeRefPtr<PanGesture>(SINGLE_FINGER_NUMBER, panDirection, PAN_DISTANCE);
1421     ASSERT_NE(panGesture, nullptr);
1422     EXPECT_EQ(panGesture->fingers_, SINGLE_FINGER_NUMBER);
1423 
1424     /**
1425      * @tc.steps: step2. create onActionStart, onActionUpdate, onActionEnd, onActionCancel for PanRecognizer.
1426      * @tc.expect: panRecognizer create successfully with the OnActionCall.
1427      */
1428     panGesture->priority_ = GesturePriority::Low;
1429     panGesture->gestureMask_ = GestureMask::Normal;
__anon668e8bf00302(GestureEvent& info) 1430     auto onActionStart = [](GestureEvent& info) { return true; };
__anon668e8bf00402(GestureEvent& info) 1431     auto onActionUpdate = [](GestureEvent& info) { return true; };
__anon668e8bf00502(GestureEvent& info) 1432     auto onActionEnd = [](GestureEvent& info) { return true; };
__anon668e8bf00602() 1433     auto onActionCancel = []() { return true; };
1434     panGesture->SetOnActionStartId(onActionStart);
1435     panGesture->SetOnActionUpdateId(onActionUpdate);
1436     panGesture->SetOnActionEndId(onActionEnd);
1437     panGesture->SetOnActionCancelId(onActionCancel);
1438     EXPECT_TRUE(panGesture->onActionStartId_);
1439     EXPECT_TRUE(panGesture->onActionUpdateId_);
1440     EXPECT_TRUE(panGesture->onActionEndId_);
1441     EXPECT_TRUE(panGesture->onActionCancelId_);
1442 
1443     auto panRecognizer = AceType::DynamicCast<PanRecognizer>(panGesture->CreateRecognizer());
1444     ASSERT_NE(panRecognizer, nullptr);
1445     EXPECT_EQ(panRecognizer->GetPriority(), GesturePriority::Low);
1446     EXPECT_EQ(panRecognizer->GetPriorityMask(), GestureMask::Normal);
1447 }
1448 
1449 /**
1450  * @tc.name: PanRecognizerHandleTouchDownEventTest003
1451  * @tc.desc: Test PanRecognizer function: HandleTouchDownEvent
1452  * @tc.type: FUNC
1453  */
1454 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchDownEventTest003, TestSize.Level1)
1455 {
1456     /**
1457      * @tc.steps: step1. create PanRecognizer.
1458      */
1459     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1460     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1461     TouchEvent touchEvent;
1462     touchEvent.x = 100.0;
1463     touchEvent.y = 100.0;
1464     touchEvent.sourceType = SourceType::MOUSE;
1465 
1466     panRecognizerPtr->direction_.type = PanDirection::NONE;
1467     panRecognizerPtr->isAllowMouse_ = false;
1468     panRecognizerPtr->HandleTouchDownEvent(touchEvent);
1469     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1470 }
1471 
1472 
1473 /**
1474  * @tc.name: PanRecognizerHandleTouchCancelEventTest003
1475  * @tc.desc: Test PanRecognizer function: HandleTouchCancelEvent
1476  * @tc.type: FUNC
1477  */
1478 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchCancelEventTest003, TestSize.Level1)
1479 {
1480     /**
1481      * @tc.steps: step1. create PanRecognizer.
1482      */
1483     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1484     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1485     TouchEvent touchEvent;
1486     touchEvent.x = 100.0;
1487     touchEvent.y = 100.0;
1488     touchEvent.sourceType = SourceType::MOUSE;
1489     AxisEvent axisEvent;
1490 
1491     panRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
1492     panRecognizerPtr->HandleTouchCancelEvent(touchEvent);
1493     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1494 
1495     panRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
1496     panRecognizerPtr->HandleTouchCancelEvent(axisEvent);
1497     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1498 }
1499 
1500 /**
1501  * @tc.name: PanRecognizerOnRejectedTest001
1502  * @tc.desc: Test PanRecognizer function: OnRejected
1503  * @tc.type: FUNC
1504  */
1505 HWTEST_F(PanRecognizerTestNg, PanRecognizerOnRejectedTest001, TestSize.Level1)
1506 {
1507     /**
1508      * @tc.steps: step1. create PanRecognizer.
1509      */
1510     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1511     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1512 
1513     panRecognizerPtr->refereeState_ = RefereeState::PENDING_BLOCKED;
1514     panRecognizerPtr->OnRejected();
1515     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1516 }
1517 
1518 /**
1519  * @tc.name: PanRecognizerHandleTouchDownEventTest004
1520  * @tc.desc: Test PanRecognizer function: HandleTouchDownEvent
1521  * @tc.type: FUNC
1522  */
1523 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchDownEventTest004, TestSize.Level1)
1524 {
1525     /**
1526      * @tc.steps: step1. create PanRecognizer.
1527      */
1528     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1529     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1530     TouchEvent touchEvent;
1531     touchEvent.x = 100.0;
1532     touchEvent.y = 100.0;
1533     touchEvent.sourceType = SourceType::MOUSE;
1534 
1535     panRecognizerPtr->newDirection_.type = PanDirection::NONE;
1536     panRecognizerPtr->isAllowMouse_ = false;
1537     panRecognizerPtr->HandleTouchDownEvent(touchEvent);
1538     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1539 }
1540 
1541 /**
1542  * @tc.name: PanRecognizerHandleTouchDownEventTest005
1543  * @tc.desc: Test PanRecognizer function: HandleTouchDownEvent
1544  * @tc.type: FUNC
1545  */
1546 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchDownEventTest005, TestSize.Level1)
1547 {
1548     /**
1549      * @tc.steps: step1. create PanRecognizer.
1550      */
1551     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1552     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1553     TouchEvent touchEvent;
1554     touchEvent.x = 100.0;
1555     touchEvent.y = 100.0;
1556     touchEvent.sourceType = SourceType::MOUSE;
1557     AxisEvent axisEvent;
1558 
1559     panRecognizerPtr->newDirection_.type = PanDirection::NONE;
1560     panRecognizerPtr->newFingers_ = 1;
1561     panRecognizerPtr->isAllowMouse_ = false;
1562     panRecognizerPtr->HandleTouchDownEvent(axisEvent);
1563     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1564 
1565     panRecognizerPtr->newDirection_.type = PanDirection::NONE;
1566     panRecognizerPtr->newFingers_ = FINGER_NUMBER;
1567     panRecognizerPtr->isAllowMouse_ = false;
1568     panRecognizerPtr->HandleTouchDownEvent(axisEvent);
1569     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1570 }
1571 
1572 /**
1573  * @tc.name: PanRecognizerHandleTouchMoveEventTest005
1574  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent
1575  * @tc.type: FUNC
1576  */
1577 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchMoveEventTest005, TestSize.Level1)
1578 {
1579     /**
1580      * @tc.steps: step1. create PanRecognizer.
1581      */
1582     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1583     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1584     TouchEvent touchEvent;
1585     touchEvent.x = 100.0;
1586     touchEvent.y = 100.0;
1587     touchEvent.sourceType = SourceType::MOUSE;
1588 
1589     panRecognizerPtr->fingers_ = 11;
1590     panRecognizerPtr->currentFingers_ = panRecognizerPtr->fingers_;
1591     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1592     panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
1593     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1594 
1595     panRecognizerPtr->fingers_ = 0;
1596     panRecognizerPtr->currentFingers_ = panRecognizerPtr->fingers_;
1597     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1598     panRecognizerPtr->HandleTouchMoveEvent(touchEvent);
1599     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), touchEvent.x);
1600 }
1601 
1602 /**
1603  * @tc.name: PanRecognizerHandleTouchMoveEventTest006
1604  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent
1605  * @tc.type: FUNC
1606  */
1607 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchMoveEventTest006, TestSize.Level1)
1608 {
1609     /**
1610      * @tc.steps: step1. create PanRecognizer.
1611      */
1612     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1613     RefPtr<PanRecognizer> panRecognizer = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1614     TouchEvent touchEvent;
1615     touchEvent.x = 100.0;
1616     touchEvent.y = 100.0;
1617 
1618     /**
1619      * @tc.steps: step2. case1: PanDirection::ALL, fabs(offset) >= distance_.
1620      * @tc.expected: step2. return ACCEPT.
1621      */
1622     PanRecognizer::GestureAcceptResult result;
1623     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1624     panRecognizer->refereeState_ = RefereeState::DETECTING;
1625     panRecognizer->direction_.type = PanDirection::ALL;
1626     panRecognizer->distance_ = 0;
1627     result = panRecognizer->IsPanGestureAccept();
1628     panRecognizer->HandleTouchMoveEvent(touchEvent);
1629     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::ACCEPT);
1630 
1631     /**
1632      * @tc.steps: step2. case2: PanDirection::ALL, fabs(offset) < distance_.
1633      * @tc.expected: step2. return DETECTING.
1634      */
1635     panRecognizer->direction_.type = PanDirection::ALL;
1636     panRecognizer->distance_ = 1;
1637     result = panRecognizer->IsPanGestureAccept();
1638     panRecognizer->HandleTouchMoveEvent(touchEvent);
1639     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
1640 
1641     /**
1642      * @tc.steps: step2. case3: GetX > GetY, GetX < distance, PanDirection::HORIZONTAL.
1643      * @tc.expected: step2. return DETECTING.
1644      */
1645     panRecognizer->direction_.type = PanDirection::HORIZONTAL;
1646     panRecognizer->averageDistance_ = Offset(0, -1);
1647     panRecognizer->distance_ = 1;
1648     result = panRecognizer->IsPanGestureAccept();
1649     panRecognizer->HandleTouchMoveEvent(touchEvent);
1650     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
1651 
1652     /**
1653      * @tc.steps: step2. case4: GetX > GetY, GetX > 0, GetX > distance_, PanDirection::LEFT.
1654      * @tc.expected: step2. return REJECT.
1655      */
1656     panRecognizer->direction_.type = PanDirection::LEFT;
1657     panRecognizer->averageDistance_ = Offset(1, 0);
1658     panRecognizer->distance_ = 0;
1659     result = panRecognizer->IsPanGestureAccept();
1660     panRecognizer->HandleTouchMoveEvent(touchEvent);
1661     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::REJECT);
1662 
1663     /**
1664      * @tc.steps: step2. case5: GetX > GetY, GetX > 0, GetX > distance_, PanDirection::VERTICAL.
1665      * @tc.expected: step2. return REJECT.
1666      */
1667     panRecognizer->direction_.type = PanDirection::VERTICAL;
1668     panRecognizer->averageDistance_ = Offset(1, 0);
1669     panRecognizer->distance_ = 0;
1670     result = panRecognizer->IsPanGestureAccept();
1671     panRecognizer->HandleTouchMoveEvent(touchEvent);
1672     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
1673 
1674     /**
1675      * @tc.steps: step2. case6: GetX > GetY, GetX = distance_ = 0, PanDirection::VERTICAL.
1676      * @tc.expected: step2. return ACCEPT.
1677      */
1678     panRecognizer->direction_.type = PanDirection::VERTICAL;
1679     panRecognizer->averageDistance_ = Offset(0, -1);
1680     panRecognizer->distance_ = 0;
1681     result = panRecognizer->IsPanGestureAccept();
1682     panRecognizer->HandleTouchMoveEvent(touchEvent);
1683     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::ACCEPT);
1684 }
1685 
1686 /**
1687  * @tc.name: PanRecognizerHandleTouchMoveEventTest007
1688  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent
1689  * @tc.type: FUNC
1690  */
1691 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchMoveEventTest007, TestSize.Level1)
1692 {
1693     /**
1694      * @tc.steps: step1. create PanRecognizer.
1695      */
1696     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1697     RefPtr<PanRecognizer> panRecognizer = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1698     TouchEvent touchEvent;
1699 
1700     /**
1701      * @tc.steps: step2. case1: PanDirection::ALL, fabs(offset) >= distance_.
1702      * @tc.expected: step2. return ACCEPT.
1703      */
1704     PanRecognizer::GestureAcceptResult result;
1705     panRecognizer->direction_.type = PanDirection::ALL;
1706     panRecognizer->distance_ = 0;
1707     result = panRecognizer->IsPanGestureAccept();
1708     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1709     panRecognizer->refereeState_ = RefereeState::DETECTING;
1710     panRecognizer->HandleTouchMoveEvent(touchEvent);
1711     panRecognizer->direction_.type = PanDirection::ALL;
1712     panRecognizer->distance_ = 1;
1713     result = panRecognizer->IsPanGestureAccept();
1714     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1715     panRecognizer->refereeState_ = RefereeState::DETECTING;
1716     panRecognizer->HandleTouchMoveEvent(touchEvent);
1717     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
1718 
1719     /**
1720      * @tc.steps: step2. case3: GetX > GetY, GetX < distance, PanDirection::HORIZONTAL.
1721      * @tc.expected: step2. return DETECTING.
1722      */
1723     panRecognizer->direction_.type = PanDirection::HORIZONTAL;
1724     panRecognizer->averageDistance_ = Offset(0, -1);
1725     panRecognizer->distance_ = 1;
1726     result = panRecognizer->IsPanGestureAccept();
1727     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1728     panRecognizer->refereeState_ = RefereeState::DETECTING;
1729     panRecognizer->HandleTouchMoveEvent(touchEvent);
1730     panRecognizer->direction_.type = PanDirection::LEFT;
1731     panRecognizer->averageDistance_ = Offset(1, 0);
1732     panRecognizer->distance_ = 0;
1733     result = panRecognizer->IsPanGestureAccept();
1734     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1735     panRecognizer->refereeState_ = RefereeState::DETECTING;
1736     panRecognizer->HandleTouchMoveEvent(touchEvent);
1737     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::REJECT);
1738 
1739     /**
1740      * @tc.steps: step2. case5: GetX > GetY, GetX > 0, GetX > distance_, PanDirection::VERTICAL.
1741      * @tc.expected: step2. return REJECT.
1742      */
1743     panRecognizer->direction_.type = PanDirection::VERTICAL;
1744     panRecognizer->averageDistance_ = Offset(1, 0);
1745     panRecognizer->distance_ = 0;
1746     result = panRecognizer->IsPanGestureAccept();
1747     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1748     panRecognizer->refereeState_ = RefereeState::DETECTING;
1749     panRecognizer->HandleTouchMoveEvent(touchEvent);
1750     panRecognizer->direction_.type = PanDirection::VERTICAL;
1751     panRecognizer->averageDistance_ = Offset(0, -1);
1752     panRecognizer->distance_ = 0;
1753     result = panRecognizer->IsPanGestureAccept();
1754     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1755     panRecognizer->refereeState_ = RefereeState::DETECTING;
1756     panRecognizer->HandleTouchMoveEvent(touchEvent);
1757     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::ACCEPT);
1758 }
1759 
1760 /**
1761  * @tc.name: PanRecognizerHandleTouchMoveEventTest008
1762  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent
1763  * @tc.type: FUNC
1764  */
1765 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchMoveEventTest008, TestSize.Level1)
1766 {
1767     /**
1768      * @tc.steps: step1. create PanRecognizer.
1769      */
1770     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1771     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1772     AxisEvent axisEvent;
1773 
1774     panRecognizerPtr->fingers_ = 11;
1775     panRecognizerPtr->currentFingers_ = panRecognizerPtr->fingers_;
1776     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1777     panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
1778     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1779 
1780     panRecognizerPtr->fingers_ = 0;
1781     panRecognizerPtr->currentFingers_ = panRecognizerPtr->fingers_;
1782     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1783     panRecognizerPtr->HandleTouchMoveEvent(axisEvent);
1784     EXPECT_EQ(panRecognizerPtr->globalPoint_.GetX(), 0);
1785 }
1786 
1787 /**
1788  * @tc.name: PanRecognizerHandleTouchMoveEventTest009
1789  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent
1790  * @tc.type: FUNC
1791  */
1792 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchMoveEventTest009, TestSize.Level1)
1793 {
1794     /**
1795      * @tc.steps: step1. create PanRecognizer.
1796      */
1797     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1798     RefPtr<PanRecognizer> panRecognizer = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1799     AxisEvent axisEvent;
1800 
1801     /**
1802      * @tc.steps: step2. case1: PanDirection::ALL, fabs(offset) >= distance_.
1803      * @tc.expected: step2. return ACCEPT.
1804      */
1805     PanRecognizer::GestureAcceptResult result;
1806     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1807     panRecognizer->refereeState_ = RefereeState::DETECTING;
1808     panRecognizer->direction_.type = PanDirection::ALL;
1809     panRecognizer->distance_ = 0;
1810     result = panRecognizer->IsPanGestureAccept();
1811     panRecognizer->HandleTouchMoveEvent(axisEvent);
1812     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::ACCEPT);
1813 
1814     /**
1815      * @tc.steps: step2. case2: PanDirection::ALL, fabs(offset) < distance_.
1816      * @tc.expected: step2. return DETECTING.
1817      */
1818     panRecognizer->direction_.type = PanDirection::ALL;
1819     panRecognizer->distance_ = 1;
1820     result = panRecognizer->IsPanGestureAccept();
1821     panRecognizer->HandleTouchMoveEvent(axisEvent);
1822     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
1823 
1824     /**
1825      * @tc.steps: step2. case3: GetX > GetY, GetX < distance, PanDirection::HORIZONTAL.
1826      * @tc.expected: step2. return DETECTING.
1827      */
1828     panRecognizer->direction_.type = PanDirection::HORIZONTAL;
1829     panRecognizer->averageDistance_ = Offset(0, -1);
1830     panRecognizer->distance_ = 1;
1831     result = panRecognizer->IsPanGestureAccept();
1832     panRecognizer->HandleTouchMoveEvent(axisEvent);
1833     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
1834 
1835     /**
1836      * @tc.steps: step2. case4: GetX > GetY, GetX > 0, GetX > distance_, PanDirection::LEFT.
1837      * @tc.expected: step2. return REJECT.
1838      */
1839     panRecognizer->direction_.type = PanDirection::LEFT;
1840     panRecognizer->averageDistance_ = Offset(1, 0);
1841     panRecognizer->distance_ = 0;
1842     result = panRecognizer->IsPanGestureAccept();
1843     panRecognizer->HandleTouchMoveEvent(axisEvent);
1844     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::REJECT);
1845 
1846     /**
1847      * @tc.steps: step2. case5: GetX > GetY, GetX > 0, GetX > distance_, PanDirection::VERTICAL.
1848      * @tc.expected: step2. return REJECT.
1849      */
1850     panRecognizer->direction_.type = PanDirection::VERTICAL;
1851     panRecognizer->averageDistance_ = Offset(1, 0);
1852     panRecognizer->distance_ = 0;
1853     result = panRecognizer->IsPanGestureAccept();
1854     panRecognizer->HandleTouchMoveEvent(axisEvent);
1855     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
1856 
1857     /**
1858      * @tc.steps: step2. case6: GetX > GetY, GetX = distance_ = 0, PanDirection::VERTICAL.
1859      * @tc.expected: step2. return ACCEPT.
1860      */
1861     panRecognizer->direction_.type = PanDirection::VERTICAL;
1862     panRecognizer->averageDistance_ = Offset(0, -1);
1863     panRecognizer->distance_ = 0;
1864     result = panRecognizer->IsPanGestureAccept();
1865     panRecognizer->HandleTouchMoveEvent(axisEvent);
1866     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::ACCEPT);
1867 }
1868 
1869 /**
1870  * @tc.name: PanRecognizerHandleTouchMoveEventTest010
1871  * @tc.desc: Test PanRecognizer function: HandleTouchMoveEvent
1872  * @tc.type: FUNC
1873  */
1874 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchMoveEventTest010, TestSize.Level1)
1875 {
1876     /**
1877      * @tc.steps: step1. create PanRecognizer.
1878      */
1879     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1880     RefPtr<PanRecognizer> panRecognizer = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1881     AxisEvent axisEvent;
1882 
1883     /**
1884      * @tc.steps: step2. case1: PanDirection::ALL, fabs(offset) >= distance_.
1885      * @tc.expected: step2. return ACCEPT.
1886      */
1887     PanRecognizer::GestureAcceptResult result;
1888     panRecognizer->direction_.type = PanDirection::ALL;
1889     panRecognizer->distance_ = 0;
1890     result = panRecognizer->IsPanGestureAccept();
1891     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1892     panRecognizer->refereeState_ = RefereeState::DETECTING;
1893     panRecognizer->HandleTouchMoveEvent(axisEvent);
1894     panRecognizer->direction_.type = PanDirection::ALL;
1895     panRecognizer->distance_ = 1;
1896     result = panRecognizer->IsPanGestureAccept();
1897     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1898     panRecognizer->refereeState_ = RefereeState::DETECTING;
1899     panRecognizer->HandleTouchMoveEvent(axisEvent);
1900     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::DETECTING);
1901 
1902     /**
1903      * @tc.steps: step2. case3: GetX > GetY, GetX < distance, PanDirection::HORIZONTAL.
1904      * @tc.expected: step2. return DETECTING.
1905      */
1906     panRecognizer->direction_.type = PanDirection::HORIZONTAL;
1907     panRecognizer->averageDistance_ = Offset(0, -1);
1908     panRecognizer->distance_ = 1;
1909     result = panRecognizer->IsPanGestureAccept();
1910     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1911     panRecognizer->refereeState_ = RefereeState::DETECTING;
1912     panRecognizer->HandleTouchMoveEvent(axisEvent);
1913     panRecognizer->direction_.type = PanDirection::LEFT;
1914     panRecognizer->averageDistance_ = Offset(1, 0);
1915     panRecognizer->distance_ = 0;
1916     result = panRecognizer->IsPanGestureAccept();
1917     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1918     panRecognizer->refereeState_ = RefereeState::DETECTING;
1919     panRecognizer->HandleTouchMoveEvent(axisEvent);
1920     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::REJECT);
1921 
1922     /**
1923      * @tc.steps: step2. case5: GetX > GetY, GetX > 0, GetX > distance_, PanDirection::VERTICAL.
1924      * @tc.expected: step2. return REJECT.
1925      */
1926     panRecognizer->direction_.type = PanDirection::VERTICAL;
1927     panRecognizer->averageDistance_ = Offset(1, 0);
1928     panRecognizer->distance_ = 0;
1929     result = panRecognizer->IsPanGestureAccept();
1930     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1931     panRecognizer->refereeState_ = RefereeState::DETECTING;
1932     panRecognizer->HandleTouchMoveEvent(axisEvent);
1933     panRecognizer->direction_.type = PanDirection::VERTICAL;
1934     panRecognizer->averageDistance_ = Offset(0, -1);
1935     panRecognizer->distance_ = 0;
1936     result = panRecognizer->IsPanGestureAccept();
1937     panRecognizer->currentFingers_ = panRecognizer->fingers_;
1938     panRecognizer->refereeState_ = RefereeState::DETECTING;
1939     panRecognizer->HandleTouchMoveEvent(axisEvent);
1940     EXPECT_EQ(result, PanRecognizer::GestureAcceptResult::ACCEPT);
1941 }
1942 
1943 /**
1944  * @tc.name: PanRecognizerHandleTouchUpEvent002
1945  * @tc.desc: Test HandleTouchUpEvent in PanRecognizer
1946  */
1947 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchUpEvent002, TestSize.Level1)
1948 {
1949     /**
1950      * @tc.steps: step1. create PanRecognizer.
1951      */
1952     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1953     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1954     TouchEvent touchEvent;
1955 
1956     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1957     panRecognizerPtr->fingers_ = 0;
1958     panRecognizerPtr->isForDrag_ = true;
1959     panRecognizerPtr->currentFingers_ = panRecognizerPtr->fingers_;
1960     panRecognizerPtr->HandleTouchUpEvent(touchEvent);
1961     EXPECT_EQ(panRecognizerPtr->refereeState_, RefereeState::FAIL);
1962 
1963     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1964     panRecognizerPtr->fingers_ = 0;
1965     panRecognizerPtr->isForDrag_ = false;
1966     panRecognizerPtr->currentFingers_ = panRecognizerPtr->fingers_;
1967     panRecognizerPtr->HandleTouchUpEvent(touchEvent);
1968     EXPECT_EQ(panRecognizerPtr->refereeState_, RefereeState::FAIL);
1969 }
1970 
1971 /**
1972  * @tc.name: PanRecognizerHandleTouchUpEvent005
1973  * @tc.desc: Test HandleTouchUpEvent in PanRecognizer
1974  */
1975 HWTEST_F(PanRecognizerTestNg, PanRecognizerHandleTouchUpEvent005, TestSize.Level1)
1976 {
1977     /**
1978      * @tc.steps: step1. create PanRecognizer.
1979      */
1980     RefPtr<PanGestureOption> panGestureOption = AceType::MakeRefPtr<PanGestureOption>();
1981     RefPtr<PanRecognizer> panRecognizerPtr = AceType::MakeRefPtr<PanRecognizer>(panGestureOption);
1982     AxisEvent axisEvent;
1983 
1984     panRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1985     panRecognizerPtr->HandleTouchUpEvent(axisEvent);
1986     EXPECT_EQ(panRecognizerPtr->refereeState_, RefereeState::FAIL);
1987 }
1988 } // namespace OHOS::Ace::NG