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