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 PinchRecognizerTestNg : public GesturesCommonTestNg {
22 public:
23     static void SetUpTestSuite();
24     static void TearDownTestSuite();
25 };
26 
SetUpTestSuite()27 void PinchRecognizerTestNg::SetUpTestSuite()
28 {
29     MockPipelineContext::SetUp();
30 }
31 
TearDownTestSuite()32 void PinchRecognizerTestNg::TearDownTestSuite()
33 {
34     MockPipelineContext::TearDown();
35 }
36 
funtest(GestureEvent & info)37 void funtest(GestureEvent& info) {}
38 
39 /**
40  * @tc.name: PinchRecognizerTest001
41  * @tc.desc: Test PinchRecognizer function: OnAccepted OnRejected
42  * @tc.type: FUNC
43  */
44 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest001, TestSize.Level1)
45 {
46     /**
47      * @tc.steps: step1. create PinchRecognizer.
48      */
49     PinchRecognizer pinchRecognizer = PinchRecognizer(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
50 
51     /**
52      * @tc.steps: step2. call OnAccepted function and compare result.
53      * @tc.expected: step2. result equals.
54      */
55     pinchRecognizer.OnAccepted();
56     EXPECT_EQ(pinchRecognizer.refereeState_, RefereeState::SUCCEED);
57 
58     /**
59      * @tc.steps: step3. call OnRejected function and compare result.
60      * @tc.expected: step3. result equals.
61      */
62     pinchRecognizer.OnRejected();
63     EXPECT_EQ(pinchRecognizer.refereeState_, RefereeState::SUCCEED);
64 }
65 
66 /**
67  * @tc.name: PinchRecognizerTest002
68  * @tc.desc: Test PinchRecognizer function: HandleTouchDownEvent
69  * @tc.type: FUNC
70  */
71 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest002, TestSize.Level1)
72 {
73     /**
74      * @tc.steps: step1. create PinchRecognizer.
75      */
76     PinchRecognizer pinchRecognizer = PinchRecognizer(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
77 
78     /**
79      * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
80      * @tc.steps: case1: input is TouchEvent. refereeState_ is SUCCESS.
81      * @tc.expected: step2. result equals.
82      */
83     TouchEvent touchEvent;
84     pinchRecognizer.refereeState_ = RefereeState::SUCCEED;
85     pinchRecognizer.HandleTouchDownEvent(touchEvent);
86     EXPECT_EQ(static_cast<int32_t>(pinchRecognizer.touchPoints_.size()), 1);
87 
88     /**
89      * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
90      * @tc.steps: case2: input is TouchEvent. refereeState_ is PENDING.
91      * @tc.expected: step2. result equals.
92      */
93     pinchRecognizer.refereeState_ = RefereeState::PENDING;
94     pinchRecognizer.HandleTouchDownEvent(touchEvent);
95     EXPECT_EQ(pinchRecognizer.touchPoints_[touchEvent.id].id, touchEvent.id);
96 
97     /**
98      * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
99      * @tc.steps: case3: input is TouchEvent. refereeState_ is PENDING. fingers_ > size
100      * @tc.expected: step2. result equals.
101      */
102     pinchRecognizer.refereeState_ = RefereeState::PENDING;
103     pinchRecognizer.fingers_ = FINGER_NUMBER;
104     pinchRecognizer.HandleTouchDownEvent(touchEvent);
105     EXPECT_EQ(pinchRecognizer.touchPoints_[touchEvent.id].id, touchEvent.id);
106     EXPECT_EQ(static_cast<int32_t>(pinchRecognizer.touchPoints_.size()), 1);
107     EXPECT_EQ(pinchRecognizer.refereeState_, RefereeState::PENDING);
108 }
109 
110 /**
111  * @tc.name: PinchRecognizerHandleTouchDownEventTest001
112  * @tc.desc: Test PinchRecognizer function: HandleTouchDownEvent
113  * @tc.type: FUNC
114  */
115 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchDownEventTest001, TestSize.Level1)
116 {
117     /**
118      * @tc.steps: step1. create PinchRecognizer.
119      */
120     PinchRecognizer pinchRecognizer = PinchRecognizer(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
121 
122     /**
123      * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
124      * @tc.steps: case1: input is TouchEvent. refereeState_ is SUCCESS.
125      * @tc.expected: step2. result equals.
126      */
127     TouchEvent touchEvent;
128     pinchRecognizer.refereeState_ = RefereeState::SUCCEED;
129     pinchRecognizer.fingers_ = 0;
130     pinchRecognizer.HandleTouchDownEvent(touchEvent);
131     EXPECT_EQ(static_cast<int32_t>(pinchRecognizer.touchPoints_.size()), 1);
132 
133     /**
134      * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
135      * @tc.steps: case2: input is TouchEvent. refereeState_ is PENDING.
136      * @tc.expected: step2. result equals.
137      */
138     pinchRecognizer.refereeState_ = RefereeState::PENDING;
139     pinchRecognizer.fingers_ = 0;
140     pinchRecognizer.HandleTouchDownEvent(touchEvent);
141     EXPECT_EQ(pinchRecognizer.touchPoints_[touchEvent.id].id, touchEvent.id);
142 
143     /**
144      * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
145      * @tc.steps: case3: input is TouchEvent. refereeState_ is PENDING. fingers_ > size
146      * @tc.expected: step2. result equals.
147      */
148     pinchRecognizer.refereeState_ = RefereeState::PENDING;
149     pinchRecognizer.fingers_ = 0;
150     pinchRecognizer.HandleTouchDownEvent(touchEvent);
151     EXPECT_EQ(pinchRecognizer.touchPoints_[touchEvent.id].id, touchEvent.id);
152     EXPECT_EQ(static_cast<int32_t>(pinchRecognizer.touchPoints_.size()), 1);
153     EXPECT_EQ(pinchRecognizer.refereeState_, RefereeState::PENDING);
154 }
155 
156 /**
157  * @tc.name: PinchRecognizerTest003
158  * @tc.desc: Test PinchRecognizer function: HandleMove HandleUp HandleCancel
159  * @tc.type: FUNC
160  */
161 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest003, TestSize.Level1)
162 {
163     /**
164      * @tc.steps: step1. create PinchRecognizer.
165      */
166     auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
167 
168     /**
169      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
170      * @tc.steps: case1: input is TouchEvent
171      * @tc.expected: step2. result equals.
172      */
173     TouchEvent touchEvent;
174     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
175     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
176     pinchRecognizer->HandleTouchUpEvent(touchEvent);
177     pinchRecognizer->HandleTouchCancelEvent(touchEvent);
178     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
179     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
180 
181     /**
182      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
183      * @tc.steps: case2: input is AxisEvent
184      * @tc.expected: step2. result equals.
185      */
186     AxisEvent axisEvent;
187     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
188     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
189     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
190     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
191 
192     /**
193      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
194      * @tc.steps: case3: input is TouchEvent, isFlushTouchEventsEnd_
195      * @tc.expected: step2. result equals.
196      */
197     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
198     pinchRecognizer->isFlushTouchEventsEnd_ = true;
199     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
200     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
201     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
202 
203     /**
204      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
205      * @tc.steps: case4: input is TouchEvent, refereeState is FAIL
206      * @tc.expected: step2. result equals.
207      */
208     pinchRecognizer->refereeState_ = RefereeState::FAIL;
209     pinchRecognizer->HandleTouchUpEvent(touchEvent);
210     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
211     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
212 
213     /**
214      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
215      * @tc.steps: case5: input is AxisEvent
216      * @tc.expected: step2. result equals.
217      */
218     pinchRecognizer->refereeState_ = RefereeState::FAIL;
219     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
220     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
221     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
222 
223     /**
224      * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
225      * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
226      * @tc.expected: step2. result equals.
227      */
228     pinchRecognizer->refereeState_ = RefereeState::FAIL;
229     pinchRecognizer->HandleTouchCancelEvent(touchEvent);
230     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
231     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
232 }
233 
234 /**
235  * @tc.name: PinchRecognizerTest004
236  * @tc.desc: Test PinchRecognizer function: OnFlushTouchEvent begin end
237  * @tc.type: FUNC
238  */
239 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest004, TestSize.Level1)
240 {
241     /**
242      * @tc.steps: step1. create PinchRecognizer.
243      */
244     PinchRecognizer pinchRecognizer = PinchRecognizer(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
245 
246     /**
247      * @tc.steps: step2. call OnFlushTouchEvent function and compare result.
248      * @tc.expected: step2. result equals.
249      */
250     pinchRecognizer.OnFlushTouchEventsBegin();
251     EXPECT_EQ(pinchRecognizer.isFlushTouchEventsEnd_, false);
252     pinchRecognizer.OnFlushTouchEventsEnd();
253     EXPECT_EQ(pinchRecognizer.isFlushTouchEventsEnd_, true);
254 }
255 
256 /**
257  * @tc.name: PinchRecognizerTest005
258  * @tc.desc: Test PinchRecognizer function: ComputeAverageDeviation
259  * @tc.type: FUNC
260  */
261 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest005, TestSize.Level1)
262 {
263     /**
264      * @tc.steps: step1. create PinchRecognizer.
265      */
266     PinchRecognizer pinchRecognizer = PinchRecognizer(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
267 
268     /**
269      * @tc.steps: step2. call ComputeAverageDeviation function and compare result.
270      * @tc.expected: step2. result equals.
271      */
272     TouchEvent touchEvent;
273     pinchRecognizer.touchPoints_[touchEvent.id] = touchEvent;
274     auto result = pinchRecognizer.ComputeAverageDeviation();
275     EXPECT_EQ(result, 0);
276 }
277 
278 /**
279  * @tc.name: PinchRecognizerComputePinchCenterTest001
280  * @tc.desc: Test PinchRecognizer function: ComputePinchCenter
281  * @tc.type: FUNC
282  */
283 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerComputePinchCenterTest001, TestSize.Level1)
284 {
285     /**
286      * @tc.steps: step1. create PinchRecognizer.
287      */
288     PinchRecognizer pinchRecognizer = PinchRecognizer(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
289 
290     /**
291      * @tc.steps: step2. call ComputePinchCenter function and compare result.
292      * @tc.expected: step2. result equals.
293      */
294     TouchEvent touchEvent;
295     pinchRecognizer.touchPoints_[touchEvent.id] = touchEvent;
296     auto result = pinchRecognizer.ComputePinchCenter();
297     pinchRecognizer.OnFlushTouchEventsEnd();
298     EXPECT_EQ(pinchRecognizer.isFlushTouchEventsEnd_, true);
299 }
300 
301 /**
302  * @tc.name: PinchRecognizerTest006
303  * @tc.desc: Test PinchRecognizer function: SendCallbackMsg
304  * @tc.type: FUNC
305  */
306 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest006, TestSize.Level1)
307 {
308     /**
309      * @tc.steps: step1. create PinchRecognizer.
310      */
311     PinchRecognizer pinchRecognizer = PinchRecognizer(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
312 
313     /**
314      * @tc.steps: step2. call SendCallbackMsg function and compare result.
315      * @tc.steps: case1: onAction is no, *onAction is no
316      * @tc.expected: step2. result equals.
317      */
318     std::unique_ptr<GestureEventFunc> onAction;
319     pinchRecognizer.SendCallbackMsg(onAction);
320     EXPECT_EQ(pinchRecognizer.touchPoints_.size(), 0);
321 
322     /**
323      * @tc.steps: step2. call SendCallbackMsg function and compare result.
324      * @tc.steps: case2: onAction is yes, *onAction is no
325      * @tc.expected: step2. result equals.
326      */
327     onAction = std::make_unique<GestureEventFunc>();
328     pinchRecognizer.SendCallbackMsg(onAction);
329     EXPECT_EQ(pinchRecognizer.touchPoints_.size(), 0);
330 
331     /**
332      * @tc.steps: step2. call SendCallbackMsg function and compare result.
333      * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty
334      * @tc.expected: step2. result equals.
335      */
__anon1d59c4030102(GestureEvent) 336     onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
337     pinchRecognizer.SendCallbackMsg(onAction);
338     EXPECT_EQ(pinchRecognizer.touchPoints_.size(), 0);
339 
340     /**
341      * @tc.steps: step2. call SendCallbackMsg function and compare result.
342      * @tc.steps: case4: touchEvent is not empty, have no X and Y
343      * @tc.expected: step2. result equals.
344      */
345     TouchEvent touchEvent;
346     pinchRecognizer.lastTouchEvent_ = touchEvent;
347     pinchRecognizer.SendCallbackMsg(onAction);
348     EXPECT_EQ(pinchRecognizer.touchPoints_.size(), 0);
349 
350     /**
351      * @tc.steps: step2. call SendCallbackMsg function and compare result.
352      * @tc.steps: case4: touchEvent is not empty, have no X and Y
353      * @tc.expected: step2. result equals.
354      */
355     touchEvent.tiltX = 0.0f;
356     touchEvent.tiltY = 0.0f;
357     pinchRecognizer.lastTouchEvent_ = touchEvent;
358     pinchRecognizer.SendCallbackMsg(onAction);
359     EXPECT_EQ(pinchRecognizer.touchPoints_.size(), 0);
360 }
361 
362 /**
363  * @tc.name: PinchRecognizerTest007
364  * @tc.desc: Test PinchRecognizer function: ReconcileFrom
365  * @tc.type: FUNC
366  */
367 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest007, TestSize.Level1)
368 {
369     /**
370      * @tc.steps: step1. create PinchRecognizer.
371      */
372     PinchRecognizer pinchRecognizer = PinchRecognizer(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
373     RefPtr<PinchRecognizer> pinchRecognizerPtr =
374         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
375     bool result = false;
376 
377     /**
378      * @tc.steps: step2. call ReconcileFrom function and compare result.
379      * @tc.steps: case1: normal case
380      * @tc.expected: step2. result equals.
381      */
382     result = pinchRecognizer.ReconcileFrom(pinchRecognizerPtr);
383     EXPECT_EQ(result, true);
384 
385     /**
386      * @tc.steps: step2. call ReconcileFrom function and compare result.
387      * @tc.steps: case2: recognizerPtr is nullptr
388      * @tc.expected: step2. result equals.
389      */
390     result = pinchRecognizer.ReconcileFrom(nullptr);
391     EXPECT_EQ(result, false);
392 
393     /**
394      * @tc.steps: step2. call ReconcileFrom function and compare result.
395      * @tc.steps: case3: fingers_ != curr->fingers_;
396      * @tc.expected: step2. result equals.
397      */
398     pinchRecognizer.fingers_ = 1;
399     pinchRecognizerPtr->fingers_ = 0;
400     result = pinchRecognizer.ReconcileFrom(pinchRecognizerPtr);
401     EXPECT_EQ(result, false);
402 
403     /**
404      * @tc.steps: step2. call ReconcileFrom function and compare result.
405      * @tc.steps: case4: fingers_ same, distance not same
406      * @tc.expected: step2. result equals.
407      */
408     pinchRecognizer.fingers_ = pinchRecognizerPtr->fingers_;
409     pinchRecognizer.distance_ = pinchRecognizerPtr->distance_ + 1;
410     result = pinchRecognizer.ReconcileFrom(pinchRecognizerPtr);
411     EXPECT_EQ(result, false);
412 
413     /**
414      * @tc.steps: step2. call ReconcileFrom function and compare result.
415      * @tc.steps: case5: fingers_ same, distance same, priorityMask not same
416      * @tc.expected: step2. result equals.
417      */
418     pinchRecognizer.fingers_ = pinchRecognizerPtr->fingers_;
419     pinchRecognizer.distance_ = pinchRecognizerPtr->distance_;
420     pinchRecognizer.priorityMask_ = GestureMask::End;
421     result = pinchRecognizer.ReconcileFrom(pinchRecognizerPtr);
422     EXPECT_EQ(result, false);
423 }
424 
425 /**
426  * @tc.name: PinchRecognizerSendCallbackMsgTest001
427  * @tc.desc: Test PinchRecognizer function: SendCallbackMsg
428  * @tc.type: FUNC
429  */
430 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerSendCallbackMsgTest001, TestSize.Level1)
431 {
432     /**
433      * @tc.steps: step1. create PinchRecognizer.
434      */
435     PinchRecognizer pinchRecognizer = PinchRecognizer(SINGLE_FINGER_NUMBER, -1);
436     std::unique_ptr<GestureEventFunc> onAction;
437 
438     /**
439      * @tc.steps: step2. call SendCallbackMsg function and compare result.
440      * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty, type is AXIS
441      * @tc.expected: step2. result equals.
442      */
__anon1d59c4030202(GestureEvent) 443     onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
444     pinchRecognizer.SendCallbackMsg(onAction);
445     EXPECT_EQ(pinchRecognizer.touchPoints_.size(), 0);
446 }
447 
448 /**
449  * @tc.name: PinchRecognizerHandleTouchMoveEventTest102
450  * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
451  * @tc.type: FUNC
452  */
453 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchMoveEventTest102, TestSize.Level1)
454 {
455     /**
456      * @tc.steps: step1. create PinchRecognizer.
457      */
458     auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
459     AxisEvent axisEvent;
460     axisEvent.pinchAxisScale = 0.0;
461 
462     /**
463      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
464      * @tc.steps: case1: input is TouchEvent
465      * @tc.expected: step2. result equals.
466      */
467     TouchEvent touchEvent;
468     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
469     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
470     pinchRecognizer->HandleTouchUpEvent(touchEvent);
471     pinchRecognizer->HandleTouchCancelEvent(axisEvent);
472     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
473     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
474 
475     /**
476      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
477      * @tc.steps: case2: input is AxisEvent
478      * @tc.expected: step2. result equals.
479      */
480     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
481     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
482     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
483     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
484 
485     /**
486      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
487      * @tc.steps: case3: input is TouchEvent, isFlushTouchEventsEnd_
488      * @tc.expected: step2. result equals.
489      */
490     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
491     pinchRecognizer->isFlushTouchEventsEnd_ = true;
492     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
493     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
494     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
495 
496     /**
497      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
498      * @tc.steps: case4: input is TouchEvent, refereeState is FAIL
499      * @tc.expected: step2. result equals.
500      */
501     pinchRecognizer->refereeState_ = RefereeState::FAIL;
502     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
503     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
504     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
505 
506     /**
507      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
508      * @tc.steps: case5: input is AxisEvent
509      * @tc.expected: step2. result equals.
510      */
511     pinchRecognizer->refereeState_ = RefereeState::FAIL;
512     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
513     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
514     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
515 }
516 
517 /**
518  * @tc.name: PinchGestureTest001
519  * @tc.desc: Test PinchGesture CreateRecognizer function
520  */
521 HWTEST_F(PinchRecognizerTestNg, PinchGestureTest001, TestSize.Level1)
522 {
523     /**
524      * @tc.steps: step1. create PinchGestureGesture.
525      */
526     PinchGestureModelNG pinchGestureModelNG;
527     pinchGestureModelNG.Create(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
528 
529     RefPtr<GestureProcessor> gestureProcessor;
530     gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
531     auto pinchGesture = AceType::DynamicCast<NG::PinchGesture>(gestureProcessor->TopGestureNG());
532     EXPECT_EQ(pinchGesture->distance_, PINCH_GESTURE_DISTANCE);
533 }
534 
535 /**
536  * @tc.name: PinchGestureTest002
537  * @tc.desc: Test PinchGesture CreateRecognizer function
538  */
539 HWTEST_F(PinchRecognizerTestNg, PinchGestureTest002, TestSize.Level1)
540 {
541     /**
542      * @tc.steps: step1. create PinchGesture.
543      */
544     auto pinchGesture = AceType::MakeRefPtr<PinchGesture>(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
545     ASSERT_NE(pinchGesture, nullptr);
546 
547     /**
548      * @tc.steps: step2. call CreateRecognizer function and compare result
549      * @tc.expect: pinchRecognizer create successfully, use the same Option as pinchGesture.
550      */
551     pinchGesture->priority_ = GesturePriority::Low;
552     pinchGesture->gestureMask_ = GestureMask::Normal;
__anon1d59c4030302(GestureEvent& info) 553     auto onActionStart = [](GestureEvent& info) { return true; };
__anon1d59c4030402(GestureEvent& info) 554     auto onActionUpdate = [](GestureEvent& info) { return true; };
__anon1d59c4030502(GestureEvent& info) 555     auto onActionEnd = [](GestureEvent& info) { return true; };
__anon1d59c4030602() 556     auto onActionCancel = []() { return true; };
557     pinchGesture->SetOnActionStartId(onActionStart);
558     pinchGesture->SetOnActionUpdateId(onActionUpdate);
559     pinchGesture->SetOnActionEndId(onActionEnd);
560     pinchGesture->SetOnActionCancelId(onActionCancel);
561     EXPECT_TRUE(pinchGesture->onActionStartId_);
562     EXPECT_TRUE(pinchGesture->onActionUpdateId_);
563     EXPECT_TRUE(pinchGesture->onActionEndId_);
564     EXPECT_TRUE(pinchGesture->onActionCancelId_);
565     auto pinchRecognizer = AceType::DynamicCast<PinchRecognizer>(pinchGesture->CreateRecognizer());
566     ASSERT_NE(pinchRecognizer, nullptr);
567     EXPECT_EQ(pinchRecognizer->GetPriority(), GesturePriority::Low);
568     EXPECT_EQ(pinchRecognizer->GetPriorityMask(), GestureMask::Normal);
569     EXPECT_EQ(pinchRecognizer->distance_, PINCH_GESTURE_DISTANCE);
570 }
571 
572 /**
573  * @tc.name: PinchGestureCreateRecognizerTest001
574  * @tc.desc: Test PinchGesture CreateRecognizer function
575  */
576 HWTEST_F(PinchRecognizerTestNg, PinchGestureCreateRecognizerTest001, TestSize.Level1)
577 {
578     /**
579      * @tc.steps: step1. create PinchGesture.
580      */
581     auto pinchGesture = AceType::MakeRefPtr<PinchGesture>(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
582     ASSERT_NE(pinchGesture, nullptr);
583 
584     /**
585      * @tc.steps: step2. call CreateRecognizer function and compare result
586      * @tc.expect: pinchRecognizer create successfully, use the same Option as pinchGesture.
587      */
588     pinchGesture->priority_ = GesturePriority::Low;
589     pinchGesture->gestureMask_ = GestureMask::Normal;
590     auto pinchRecognizer = AceType::DynamicCast<PinchRecognizer>(pinchGesture->CreateRecognizer());
591     ASSERT_NE(pinchRecognizer, nullptr);
592     EXPECT_EQ(pinchRecognizer->GetPriority(), GesturePriority::Low);
593     EXPECT_EQ(pinchRecognizer->GetPriorityMask(), GestureMask::Normal);
594     EXPECT_EQ(pinchRecognizer->distance_, PINCH_GESTURE_DISTANCE);
595 }
596 
597 /**
598  * @tc.name: PinchRecognizerTest009
599  * @tc.desc: Test PinchRecognizer function: HandleTouchDownEvent
600  * @tc.type: FUNC
601  */
602 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest009, TestSize.Level1)
603 {
604     /**
605      * @tc.steps: step1. create PinchRecognizer.
606      */
607     RefPtr<PinchRecognizer> pinchRecognizer =
608         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
609     ASSERT_NE(pinchRecognizer, nullptr);
610 
611     /**
612      * @tc.steps: step2. use fingers_ > MAX_PINCH_FINGERS in HandleTouchDownEvent(TouchEvent).
613      * @tc.expect: pinchRecognizer->disposal_ is not equal to GestureDisposal::REJECT.
614      */
615     TouchEvent touchEvent;
616     pinchRecognizer->fingers_ = FINGER_NUMBER_OVER_MAX;
617     pinchRecognizer->refereeState_ = RefereeState::READY;
618     pinchRecognizer->HandleTouchDownEvent(touchEvent);
619     EXPECT_NE(pinchRecognizer->disposal_, GestureDisposal::REJECT);
620 
621     /**
622      * @tc.steps: step3. test with HandleTouchDownEvent(AxisEvent).
623      */
624     pinchRecognizer->fingers_ = SINGLE_FINGER_NUMBER;
625     AxisEvent axisEvent;
626 
627     /**
628      * @tc.steps: step3.1. axisEvent NearZero.
629      * @tc.expect: pinchRecognizer.disposal_ is not equal to GestureDisposal::REJECT.
630      */
631     axisEvent.pinchAxisScale = 0.0;
632     pinchRecognizer->HandleTouchDownEvent(axisEvent);
633     EXPECT_NE(pinchRecognizer->disposal_, GestureDisposal::REJECT);
634 
635     /**
636      * @tc.steps: step3.2. axisEvent not NearZero and IsRefereeFinished() is true.
637      * @tc.expect: pinchRecognizer->disposal_ is not equal to GestureDisposal::REJECT.
638      */
639     axisEvent.pinchAxisScale = 2.0;
640     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
641     pinchRecognizer->HandleTouchDownEvent(axisEvent);
642     EXPECT_NE(pinchRecognizer->disposal_, GestureDisposal::REJECT);
643 
644     /**
645      * @tc.steps: step3.2. axisEvent with refereeState_ = RefereeState::READY.
646      * @tc.expect: pinchRecognizer->scale_ is equal to 1.0f.
647      */
648     pinchRecognizer->refereeState_ = RefereeState::READY;
649     pinchRecognizer->HandleTouchDownEvent(axisEvent);
650     EXPECT_EQ(pinchRecognizer->scale_, 1.0);
651 }
652 
653 /**
654  * @tc.name: PinchRecognizerTest010
655  * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
656  * @tc.type: FUNC
657  */
658 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest010, TestSize.Level1)
659 {
660     /**
661      * @tc.steps: step1. create PinchRecognizer.
662      */
663     RefPtr<PinchRecognizer> pinchRecognizer =
664         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
665     ASSERT_NE(pinchRecognizer, nullptr);
666 
667     /**
668      * @tc.steps: step2. use refereeState_ != RefereeState::SUCCEED and refereeState_ != RefereeState::FAIL.
669      * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
670      */
671     TouchEvent touchEvent;
672     pinchRecognizer->isPinchEnd_ = false;
673     pinchRecognizer->refereeState_ = RefereeState::FAIL;
674     pinchRecognizer->HandleTouchDownEvent(touchEvent);
675     pinchRecognizer->refereeState_ = RefereeState::READY;
676     pinchRecognizer->HandleTouchDownEvent(touchEvent);
677     EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::NONE);
678 
679     /**
680      * @tc.steps: step3. test with HandleTouchDownEvent(AxisEvent).
681      */
682     AxisEvent axisEvent;
683     /**
684      * @tc.steps: step3.1. test with isPinchEnd_ is true.
685      */
686     pinchRecognizer->isPinchEnd_ = true;
687     pinchRecognizer->HandleTouchUpEvent(axisEvent);
688 
689     /**
690      * @tc.steps: step3.2. test with refereeState_ != RefereeState::SUCCEED and refereeState_ != RefereeState::FAIL.
691      * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
692      */
693     pinchRecognizer->isPinchEnd_ = false;
694     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
695     pinchRecognizer->HandleTouchUpEvent(axisEvent);
696     EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::REJECT);
697 
698     /**
699      * @tc.steps: step3.2. test with refereeState_ != RefereeState::SUCCEED.
700      * @tc.expect: pinchRecognizer->isPinchEnd_ is true.
701      */
702     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
703     pinchRecognizer->HandleTouchUpEvent(axisEvent);
704     EXPECT_EQ(pinchRecognizer->isPinchEnd_, true);
705 }
706 
707 /**
708  * @tc.name: PinchRecognizerTest012
709  * @tc.desc: Test PinchRecognizer function: HandleTouchDownEvent
710  * @tc.type: FUNC
711  */
712 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest012, TestSize.Level1)
713 {
714     /**
715      * @tc.steps: step1. create PinchRecognizer.
716      */
717     RefPtr<PinchRecognizer> pinchRecognizer =
718         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
719     ASSERT_NE(pinchRecognizer, nullptr);
720     /**
721      * @tc.steps: step2. test with HandleTouchDownEvent(AxisEvent).
722      * @tc.expect: pinchRecognizer->lastAxisEvent_ is equal to axisEvent
723      * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].originalId is equal to axisEvent.originalId
724      * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].screenX is equal to axisEvent.screenX
725      * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].screenY is equal to axisEvent.screenY
726      */
727     AxisEvent axisEvent;
728     axisEvent.id = TEST_EVENT_ID;
729     axisEvent.originalId = TEST_EVENT_ID;
730     pinchRecognizer->fingers_ = FINGER_NUMBER_OVER_MAX;
731     pinchRecognizer->refereeState_ = RefereeState::READY;
732     pinchRecognizer->HandleTouchDownEvent(axisEvent);
733     EXPECT_EQ(pinchRecognizer->lastAxisEvent_.id, axisEvent.id);
734     EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].originalId, axisEvent.originalId);
735     EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].screenX, axisEvent.screenX);
736     EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].screenY, axisEvent.screenY);
737 }
738 
739 /**
740  * @tc.name: PinchRecognizerTest012
741  * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
742  * @tc.type: FUNC
743  */
744 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest013, TestSize.Level1)
745 {
746     /**
747      * @tc.steps: step1. create PinchRecognizer.
748      */
749     RefPtr<PinchRecognizer> pinchRecognizer =
750         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
751     ASSERT_NE(pinchRecognizer, nullptr);
752 
753     /**
754      * @tc.steps: step2. test with HandleTouchUpEvent(AxisEvent).
755      * @tc.expect: pinchRecognizer->lastAxisEvent_ is equal to axisEvent
756      */
757     AxisEvent axisEvent;
758     axisEvent.id = TEST_EVENT_ID;
759     pinchRecognizer->fingers_ = FINGER_NUMBER_OVER_MAX;
760     pinchRecognizer->refereeState_ = RefereeState::READY;
761     pinchRecognizer->HandleTouchUpEvent(axisEvent);
762     EXPECT_EQ(pinchRecognizer->lastAxisEvent_.id, axisEvent.id);
763 }
764 
765 /**
766  * @tc.name: PinchRecognizerTest012
767  * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
768  * @tc.type: FUNC
769  */
770 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest014, TestSize.Level1)
771 {
772     /**
773      * @tc.steps: step1. create PinchRecognizer.
774      */
775     RefPtr<PinchRecognizer> pinchRecognizer =
776         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
777     ASSERT_NE(pinchRecognizer, nullptr);
778     /**
779      * @tc.steps: step2. test with HandleTouchMoveEvent(AxisEvent).
780      * @tc.expect: pinchRecognizer->lastAxisEvent_ is equal to axisEvent
781      * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].originalId is equal to axisEvent.originalId
782      * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].screenX is equal to axisEvent.screenX
783      * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].screenY is equal to axisEvent.screenY
784      */
785     AxisEvent axisEvent;
786     axisEvent.id = TEST_EVENT_ID;
787     axisEvent.originalId = TEST_EVENT_ID;
788     pinchRecognizer->fingers_ = FINGER_NUMBER_OVER_MAX;
789     pinchRecognizer->refereeState_ = RefereeState::READY;
790     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
791 
792     EXPECT_EQ(pinchRecognizer->lastAxisEvent_.id, axisEvent.id);
793     EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].originalId, axisEvent.originalId);
794     EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].screenX, axisEvent.screenX);
795     EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].screenY, axisEvent.screenY);
796 }
797 
798 /**
799  * @tc.name: PinchRecognizerHandleTouchUpEventTest001
800  * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
801  * @tc.type: FUNC
802  */
803 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchUpEventTest001, TestSize.Level1)
804 {
805     /**
806      * @tc.steps: step1. create PinchRecognizer.
807      */
808     RefPtr<PinchRecognizer> pinchRecognizer =
809         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
810     ASSERT_NE(pinchRecognizer, nullptr);
811 
812     /**
813      * @tc.steps: step2. use refereeState_ != RefereeState::SUCCEED and refereeState_ != RefereeState::FAIL.
814      * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
815      */
816     TouchEvent touchEvent;
817     pinchRecognizer->isPinchEnd_ = false;
818     pinchRecognizer->refereeState_ = RefereeState::FAIL;
819     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
820     pinchRecognizer->HandleTouchDownEvent(touchEvent);
821     pinchRecognizer->refereeState_ = RefereeState::READY;
822     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
823     pinchRecognizer->HandleTouchDownEvent(touchEvent);
824     EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::NONE);
825 
826     /**
827      * @tc.steps: step3. test with HandleTouchDownEvent(AxisEvent).
828      */
829     AxisEvent axisEvent;
830     /**
831      * @tc.steps: step3.1. test with isPinchEnd_ is true.
832      */
833     pinchRecognizer->isPinchEnd_ = true;
834     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
835     pinchRecognizer->HandleTouchUpEvent(axisEvent);
836 
837     /**
838      * @tc.steps: step3.2. test with refereeState_ != RefereeState::SUCCEED and refereeState_ != RefereeState::FAIL.
839      * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
840      */
841     pinchRecognizer->isPinchEnd_ = false;
842     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
843     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
844     pinchRecognizer->HandleTouchUpEvent(axisEvent);
845     EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::REJECT);
846 
847     /**
848      * @tc.steps: step3.2. test with refereeState_ != RefereeState::SUCCEED.
849      * @tc.expect: pinchRecognizer->isPinchEnd_ is true.
850      */
851     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
852     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
853     pinchRecognizer->HandleTouchUpEvent(axisEvent);
854     EXPECT_EQ(pinchRecognizer->isPinchEnd_, true);
855 }
856 
857 /**
858  * @tc.name: PinchRecognizerHandleTouchMoveEventTest001
859  * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
860  * @tc.type: FUNC
861  */
862 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchMoveEventTest001, TestSize.Level1)
863 {
864     /**
865      * @tc.steps: step1. create PinchRecognizer.
866      */
867     RefPtr<PinchRecognizer> pinchRecognizer =
868         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
869     ASSERT_NE(pinchRecognizer, nullptr);
870 
871     /**
872      * @tc.steps: step2. test HandleTouchMoveEvent(TouchEvent).
873      */
874     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
875     std::vector<TouchEvent> touchEvents;
876     for (std::size_t i = 0; i < 5; ++i) {
877         TouchEvent touchEvent;
878         touchEvent.x = 100.0 * (i + 1);
879         touchEvent.y = 100.0 * (i + 1);
880         pinchRecognizer->touchPoints_[i] = touchEvent;
881     }
882     pinchRecognizer->initialDev_ = 1.0;
883     TouchEvent touchEvent;
884     touchEvent.x = 100.0;
885     touchEvent.y = 100.0;
886 
887     /**
888      * @tc.steps: step2.1. test HandleTouchMoveEvent(TouchEvent) with fabs(currentDev_ - initialDev_) >= distance_.
889      * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_.
890      */
891     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
892     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
893 
894     /**
895      * @tc.steps: step2.2. test HandleTouchMoveEvent(TouchEvent) with refereeState_ == RefereeState::SUCCEED.
896      * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_
897      */
898     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
899     pinchRecognizer->initialDev_ = 2.0;
900     pinchRecognizer->OnFlushTouchEventsEnd();
901     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
902     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
903 
904     /**
905      * @tc.steps: step3. test HandleTouchMoveEvent(AxisEvent).
906      */
907     AxisEvent axisEvent;
908     pinchRecognizer->isPinchEnd_ = false;
909 
910     /**
911      * @tc.steps: step3.1. axisEvent NearZero.
912      * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
913      */
914     axisEvent.pinchAxisScale = 0.0;
915     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
916     auto context = PipelineContext::GetCurrentContext();
917     ASSERT_NE(context, nullptr);
918     context->eventManager_ = nullptr;
919     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
920     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
921     EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::REJECT);
922 
923     /**
924      * @tc.steps: step3.2. test with refereeState_ = RefereeState::SUCCEED.
925      * @tc.expect: pinchRecognizer->refereeState_ is equal to RefereeState::READY.
926      */
927     pinchRecognizer->isPinchEnd_ = false;
928     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
929     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
930     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
931     EXPECT_EQ(pinchRecognizer->isPinchEnd_, true);
932 
933     /**
934      * @tc.steps: step3.3. test with axisEvent not NearZero .
935      * @tc.expect: pinchRecognizer->scale_ is equal to axisEvent.pinchAxisScale.
936      */
937     pinchRecognizer->isPinchEnd_ = false;
938     axisEvent.pinchAxisScale = 1.0;
939     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
940     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
941     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
942     EXPECT_EQ(pinchRecognizer->scale_, axisEvent.pinchAxisScale);
943 }
944 
945 /**
946  * @tc.name: PinchRecognizerHandleTouchMoveEventTest002
947  * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
948  * @tc.type: FUNC
949  */
950 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchMoveEventTest002, TestSize.Level1)
951 {
952     /**
953      * @tc.steps: step1. create PinchRecognizer.
954      */
955     RefPtr<PinchRecognizer> pinchRecognizer =
956         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
957 
958     /**
959      * @tc.steps: step2. test HandleTouchMoveEvent(TouchEvent).
960      */
961     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
962     std::vector<TouchEvent> touchEvents;
963     for (std::size_t i = 0; i < 5; ++i) {
964         TouchEvent touchEvent;
965         touchEvent.x = 100.0 * (i + 1);
966         touchEvent.y = 100.0 * (i + 1);
967         pinchRecognizer->touchPoints_[i] = touchEvent;
968     }
969     pinchRecognizer->initialDev_ = 1.0;
970     TouchEvent touchEvent;
971     touchEvent.x = 100.0;
972     touchEvent.y = 100.0;
973 
974     /**
975      * @tc.steps: step2.1. test HandleTouchMoveEvent(TouchEvent) with fabs(currentDev_ - initialDev_) >= distance_.
976      * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_.
977      */
978     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
979     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
980     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
981     pinchRecognizer->initialDev_ = 2.0;
982     pinchRecognizer->OnFlushTouchEventsEnd();
983 
984     /**
985      * @tc.steps: step3. test HandleTouchMoveEvent(AxisEvent).
986      */
987     AxisEvent axisEvent;
988     pinchRecognizer->isPinchEnd_ = false;
989 
990     /**
991      * @tc.steps: step3.1. axisEvent NearZero.
992      * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
993      */
994     auto context = PipelineContext::GetCurrentContext();
995     context->eventManager_ = nullptr;
996     pinchRecognizer->isPinchEnd_ = false;
997     axisEvent.pinchAxisScale = 1.0;
998     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
999     pinchRecognizer->currentFingers_ = FINGER_NUMBER;
1000     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1001     pinchRecognizer->refereeState_ = RefereeState::FAIL;
1002     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1003     EXPECT_EQ(pinchRecognizer->scale_, axisEvent.pinchAxisScale);
1004 
1005     axisEvent.pinchAxisScale = 0;
1006     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1007     pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1008     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1009     pinchRecognizer->HandleTouchCancelEvent(touchEvent);
1010     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1011     pinchRecognizer->currentFingers_ = pinchRecognizer->fingers_;
1012     pinchRecognizer->HandleTouchUpEvent(touchEvent);
1013     pinchRecognizer->refereeState_ = RefereeState::FAIL;
1014     pinchRecognizer->isPinchEnd_ = false;
1015     pinchRecognizer->HandleTouchUpEvent(axisEvent);
1016     EXPECT_EQ(pinchRecognizer->scale_, 1);
1017 }
1018 
1019 /**
1020  * @tc.name: PinchRecognizerHandleTouchCancelEventTest001
1021  * @tc.desc: Test PinchRecognizer function: HandleTouchCancelEvent
1022  * @tc.type: FUNC
1023  */
1024 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchCancelEventTest001, TestSize.Level1)
1025 {
1026     /**
1027      * @tc.steps: step1. create PinchRecognizer.
1028      */
1029     auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1030     AxisEvent axisEvent;
1031     axisEvent.pinchAxisScale = 0.0;
1032 
1033     /**
1034      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1035      * @tc.steps: case1: input is TouchEvent
1036      * @tc.expected: step2. result equals.
1037      */
1038     TouchEvent touchEvent;
1039     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1040     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1041     pinchRecognizer->HandleTouchUpEvent(touchEvent);
1042     pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1043     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1044     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1045 
1046     /**
1047      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1048      * @tc.steps: case2: input is AxisEvent
1049      * @tc.expected: step2. result equals.
1050      */
1051     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1052     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1053     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1054     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1055 
1056     /**
1057      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1058      * @tc.steps: case3: input is TouchEvent, isFlushTouchEventsEnd_
1059      * @tc.expected: step2. result equals.
1060      */
1061     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1062     pinchRecognizer->isFlushTouchEventsEnd_ = true;
1063     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1064     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1065     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1066 
1067     /**
1068      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
1069      * @tc.steps: case4: input is TouchEvent, refereeState is FAIL
1070      * @tc.expected: step2. result equals.
1071      */
1072     pinchRecognizer->refereeState_ = RefereeState::FAIL;
1073     pinchRecognizer->HandleTouchUpEvent(touchEvent);
1074     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1075     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1076 
1077     /**
1078      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1079      * @tc.steps: case5: input is AxisEvent
1080      * @tc.expected: step2. result equals.
1081      */
1082     pinchRecognizer->refereeState_ = RefereeState::FAIL;
1083     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1084     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1085     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1086 
1087     /**
1088      * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1089      * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1090      * @tc.expected: step2. result equals.
1091      */
1092     pinchRecognizer->refereeState_ = RefereeState::FAIL;
1093     pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1094     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1095     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1096 }
1097 
1098 /**
1099  * @tc.name: PinchRecognizerHandleTouchCancelEventTest003
1100  * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
1101  * @tc.type: FUNC
1102  */
1103 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchCancelEventTest003, TestSize.Level1)
1104 {
1105     /**
1106      * @tc.steps: step1. create PinchRecognizer.
1107      */
1108     auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1109     AxisEvent axisEvent;
1110     axisEvent.pinchAxisScale = 0.0;
1111 
1112     /**
1113      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1114      * @tc.steps: case1: input is TouchEvent
1115      * @tc.expected: step2. result equals.
1116      */
1117     TouchEvent touchEvent;
1118     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1119     pinchRecognizer->currentFingers_ = pinchRecognizer->fingers_;
1120     pinchRecognizer->HandleTouchUpEvent(touchEvent);
1121     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1122 
1123     /**
1124      * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1125      * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1126      * @tc.expected: step2. result equals.
1127      */
1128     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1129     pinchRecognizer->isPinchEnd_ = true;
1130     pinchRecognizer->HandleTouchUpEvent(touchEvent);
1131     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1132 
1133     /**
1134      * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1135      * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1136      * @tc.expected: step2. result equals.
1137      */
1138     pinchRecognizer->refereeState_ = RefereeState::FAIL;
1139     pinchRecognizer->isPinchEnd_ = false;
1140     pinchRecognizer->HandleTouchUpEvent(touchEvent);
1141     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1142 }
1143 
1144 /**
1145  * @tc.name: PinchRecognizerHandleTouchCancelEventTest002
1146  * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
1147  * @tc.type: FUNC
1148  */
1149 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchCancelEventTest002, TestSize.Level1)
1150 {
1151     /**
1152      * @tc.steps: step1. create PinchRecognizer.
1153      */
1154     auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1155     AxisEvent axisEvent;
1156     axisEvent.pinchAxisScale = 0.0;
1157 
1158     /**
1159      * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1160      * @tc.steps: case1: input is TouchEvent
1161      * @tc.expected: step2. result equals.
1162      */
1163     TouchEvent touchEvent;
1164     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1165     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1166     pinchRecognizer->currentFingers_ = pinchRecognizer->fingers_;
1167     pinchRecognizer->HandleTouchUpEvent(touchEvent);
1168     pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1169     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1170     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1171 
1172     /**
1173      * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1174      * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1175      * @tc.expected: step2. result equals.
1176      */
1177     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1178     pinchRecognizer->isPinchEnd_ = true;
1179     pinchRecognizer->HandleTouchUpEvent(touchEvent);
1180     pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1181     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1182     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1183 
1184     /**
1185      * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1186      * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1187      * @tc.expected: step2. result equals.
1188      */
1189     pinchRecognizer->refereeState_ = RefereeState::FAIL;
1190     pinchRecognizer->isPinchEnd_ = false;
1191     pinchRecognizer->HandleTouchUpEvent(touchEvent);
1192     pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1193     EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1194     EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1195 }
1196 
1197 /**
1198  * @tc.name: PinchRecognizerTest011
1199  * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
1200  * @tc.type: FUNC
1201  */
1202 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest011, TestSize.Level1)
1203 {
1204     /**
1205      * @tc.steps: step1. create PinchRecognizer.
1206      */
1207     RefPtr<PinchRecognizer> pinchRecognizer =
1208         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1209     ASSERT_NE(pinchRecognizer, nullptr);
1210 
1211     /**
1212      * @tc.steps: step2. test HandleTouchMoveEvent(TouchEvent).
1213      */
1214     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1215     std::vector<TouchEvent> touchEvents;
1216     for (std::size_t i = 0; i < 5; ++i) {
1217         TouchEvent touchEvent;
1218         touchEvent.x = 100.0 * (i + 1);
1219         touchEvent.y = 100.0 * (i + 1);
1220         pinchRecognizer->touchPoints_[i] = touchEvent;
1221     }
1222     pinchRecognizer->initialDev_ = 1.0;
1223     TouchEvent touchEvent;
1224     touchEvent.x = 100.0;
1225     touchEvent.y = 100.0;
1226 
1227     /**
1228      * @tc.steps: step2.1. test HandleTouchMoveEvent(TouchEvent) with fabs(currentDev_ - initialDev_) >= distance_.
1229      * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_.
1230      */
1231     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1232     EXPECT_EQ(pinchRecognizer->scale_, 1);
1233     EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::NONE);
1234     /**
1235      * @tc.steps: step2.2. test HandleTouchMoveEvent(TouchEvent) with refereeState_ == RefereeState::SUCCEED.
1236      * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_
1237      */
1238     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1239     pinchRecognizer->initialDev_ = 2.0;
1240     pinchRecognizer->OnFlushTouchEventsEnd();
1241     pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1242     EXPECT_EQ(pinchRecognizer->scale_, 1);
1243 
1244     /**
1245      * @tc.steps: step3. test HandleTouchMoveEvent(AxisEvent).
1246      */
1247     AxisEvent axisEvent;
1248     pinchRecognizer->isPinchEnd_ = false;
1249 
1250     /**
1251      * @tc.steps: step3.1. axisEvent NearZero.
1252      * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
1253      */
1254     axisEvent.pinchAxisScale = 0.0;
1255     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1256     auto context = PipelineContext::GetCurrentContext();
1257     ASSERT_NE(context, nullptr);
1258     context->eventManager_ = nullptr;
1259     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1260     EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::REJECT);
1261 
1262     /**
1263      * @tc.steps: step3.2. test with refereeState_ = RefereeState::SUCCEED.
1264      * @tc.expect: pinchRecognizer->refereeState_ is equal to RefereeState::READY.
1265      */
1266     pinchRecognizer->isPinchEnd_ = false;
1267     pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1268     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1269     EXPECT_EQ(pinchRecognizer->refereeState_, RefereeState::READY);
1270     EXPECT_EQ(pinchRecognizer->isPinchEnd_, true);
1271 
1272     /**
1273      * @tc.steps: step3.3. test with axisEvent not NearZero .
1274      * @tc.expect: pinchRecognizer->scale_ is equal to axisEvent.pinchAxisScale.
1275      */
1276     pinchRecognizer->isPinchEnd_ = false;
1277     axisEvent.pinchAxisScale = 1.0;
1278     pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1279     pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1280     EXPECT_EQ(pinchRecognizer->scale_, axisEvent.pinchAxisScale);
1281 }
1282 
1283 /**
1284  * @tc.name: PinchRecognizerPtrHandleTouchMoveEventTest002
1285  * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
1286  * @tc.type: FUNC
1287  */
1288 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerPtrHandleTouchMoveEventTest002, TestSize.Level1)
1289 {
1290     /**
1291      * @tc.steps: step1. create and set Recognizer、TargetComponent.
1292      */
1293     RefPtr<PinchRecognizer> pinchRecognizerPtr =
1294         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1295     RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anon1d59c4030702(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1296     auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
1297         return GestureJudgeResult::REJECT;
1298     };
1299     targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
1300     TouchEvent touchEvent;
1301     AxisEvent axisEvent;
1302     touchEvent.tiltX.emplace(1.0f);
1303     touchEvent.tiltY.emplace(1.0f);
1304     pinchRecognizerPtr->targetComponent_ = targetComponent;
1305     /**
1306      * @tc.steps: step2. test the function who calls TriggerGestureJudgeCallback.
1307      * @tc.expected: step2. result equals REJECT.
1308      */
1309     pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1310     pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1311     pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1312     pinchRecognizerPtr->fingers_ = 1;
1313     pinchRecognizerPtr->distance_ = -1;
1314     pinchRecognizerPtr->initialDev_ = 1;
1315     pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
1316     EXPECT_EQ(pinchRecognizerPtr->disposal_, GestureDisposal::REJECT);
1317 
1318     axisEvent.pinchAxisScale = 1.0;
1319     pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1320     pinchRecognizerPtr->isPinchEnd_ = false;
1321     pinchRecognizerPtr->HandleTouchMoveEvent(axisEvent);
1322     EXPECT_EQ(pinchRecognizerPtr->disposal_, GestureDisposal::REJECT);
1323 }
1324 
1325 class MockPinchRecognizer : public PinchRecognizer {
1326 public:
MockPinchRecognizer(int32_t fingers,double distance)1327     MockPinchRecognizer(int32_t fingers, double distance) : PinchRecognizer(fingers, distance) {}
1328     MOCK_METHOD(void, BatchAdjudicate, (const RefPtr<NGGestureRecognizer>&, GestureDisposal), ());
1329 };
1330 
1331 /**
1332  * @tc.name: PinchRecognizerPtrHandleTouchMoveEventTest003
1333  * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
1334  * @tc.type: FUNC
1335  */
1336 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerPtrHandleTouchMoveEventTest003, TestSize.Level1)
1337 {
1338     RefPtr<PinchRecognizer> pinchRecognizerPtr =
1339         AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1340     TouchEvent event;
1341     event.id = 1;
1342     pinchRecognizerPtr->fingersId_.insert(1);
1343     pinchRecognizerPtr->activeFingers_.push_back(1);
1344     pinchRecognizerPtr->activeFingers_.push_back(2);
1345     pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1346     pinchRecognizerPtr->HandleTouchUpEvent(event);
1347     SUCCEED();
1348     event.id = 3;
1349     pinchRecognizerPtr->fingersId_.insert(1);
1350     pinchRecognizerPtr->activeFingers_.push_back(1);
1351     pinchRecognizerPtr->activeFingers_.push_back(2);
1352     pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1353     pinchRecognizerPtr->HandleTouchUpEvent(event);
1354     SUCCEED();
1355 }
1356 
1357 /**
1358  * @tc.name: PinchRecognizerPtrHandleTouchMoveEventTest004
1359  * @tc.desc: Test HandleTouchCancelEvent
1360  * @tc.type: FUNC
1361  */
1362 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerPtrHandleTouchMoveEventTest004, TestSize.Level1)
1363 {
1364     MockPinchRecognizer recognizerTest(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1365     TouchEvent event;
1366     event.id = 1;
1367     recognizerTest.activeFingers_.push_back(1);
1368     recognizerTest.activeFingers_.push_back(2);
1369     recognizerTest.refereeState_ = RefereeState::SUCCEED;
1370     recognizerTest.HandleTouchCancelEvent(event);
1371     SUCCEED();
1372 }
1373 
1374 /**
1375  * @tc.name: PinchRecognizerPtrHandleTouchMoveEventTest005
1376  * @tc.desc: Test SendCallbackMsg
1377  * @tc.type: FUNC
1378  */
1379 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerPtrHandleTouchMoveEventTest005, TestSize.Level1)
1380 {
1381     MockPinchRecognizer recognizerTest(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1382     recognizerTest.activeFingers_.push_back(1);
1383     recognizerTest.activeFingers_.push_back(2);
1384     recognizerTest.refereeState_ = RefereeState::SUCCEED;
1385     GestureEvent info;
1386     auto callback = std::make_unique<GestureEventFunc>(funtest);
1387     recognizerTest.inputEventType_ = InputEventType::AXIS;
1388     recognizerTest.SendCallbackMsg(callback);
1389     SUCCEED();
1390 }
1391 } // namespace OHOS::Ace::NG