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 LongPressRecognizerTestNg : public GesturesCommonTestNg {
22 public:
23     static void SetUpTestSuite();
24     static void TearDownTestSuite();
25 };
26 
SetUpTestSuite()27 void LongPressRecognizerTestNg::SetUpTestSuite()
28 {
29     MockPipelineContext::SetUp();
30 }
31 
TearDownTestSuite()32 void LongPressRecognizerTestNg::TearDownTestSuite()
33 {
34     MockPipelineContext::TearDown();
35 }
36 
37 /**
38  * @tc.name: LongPressRecognizerTest001
39  * @tc.desc: Test LongPressRecognizer function: OnAccepted OnRejected
40  * @tc.type: FUNC
41  */
42 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTest001, TestSize.Level1)
43 {
44     /**
45      * @tc.steps: step1. create LongPressRecognizer.
46      */
47     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
48     OnLongPress onLongPress;
49     TouchEvent touchEvent;
50 
51     /**
52      * @tc.steps: step2. call OnAccepted function and compare result.
53      * @tc.steps: case1: !onLongPress, !empty, repeat
54      * @tc.expected: step2. result equals.
55      */
56     longPressRecognizer.touchPoints_[touchEvent.id] = touchEvent;
57     longPressRecognizer.repeat_ = true;
58     longPressRecognizer.OnAccepted();
59     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
60 
61     /**
62      * @tc.steps: step2. call OnAccepted function and compare result.
63      * @tc.steps: case2: !onLongPress, empty, !repeat
64      * @tc.expected: step2. result equals.
65      */
66     longPressRecognizer.touchPoints_.clear();
67     longPressRecognizer.repeat_ = false;
68     longPressRecognizer.OnAccepted();
69     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
70 
71     /**
72      * @tc.steps: step2. call OnAccepted function and compare result.
73      * @tc.steps: case3: onLongPress, empty, !repeat
74      * @tc.expected: step2. result equals.
75      */
__anon876fb52d0102(LongPressInfo) 76     onLongPress = [](LongPressInfo) {};
77     longPressRecognizer.onLongPress_ = onLongPress;
78     longPressRecognizer.touchPoints_.clear();
79     longPressRecognizer.repeat_ = false;
80     longPressRecognizer.OnAccepted();
81     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
82 
83     /**
84      * @tc.steps: step2. call OnAccepted function and compare result.
85      * @tc.steps: case4: onLongPress, !empty, !repeat
86      * @tc.expected: step2. result equals.
87      */
88     longPressRecognizer.touchPoints_.clear();
89     longPressRecognizer.touchPoints_[touchEvent.id] = touchEvent;
90     longPressRecognizer.repeat_ = false;
91     longPressRecognizer.OnAccepted();
92     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
93 
94     /**
95      * @tc.steps: step3. call OnRejected function and compare result.
96      * @tc.expected: step3. result equals.
97      */
98     longPressRecognizer.OnRejected();
99     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
100 }
101 
102 /**
103  * @tc.name: LongPressRecognizerTest002
104  * @tc.desc: Test LongPressRecognizer function: HandleTouchMoveEvent
105  * @tc.type: FUNC
106  */
107 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTest002, TestSize.Level1)
108 {
109     /**
110      * @tc.steps: step1. create LongPressRecognizer.
111      */
112     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
113 
114     /**
115      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
116      * @tc.steps: case1: referee is not SUCCEED
117      * @tc.expected: step2. result equals.
118      */
119     TouchEvent touchEvent;
120     longPressRecognizer.touchPoints_[touchEvent.id] = touchEvent;
121     longPressRecognizer.HandleTouchMoveEvent(touchEvent);
122     EXPECT_EQ(longPressRecognizer.time_, touchEvent.time);
123 
124     /**
125      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
126      * @tc.steps: case2: referee is SUCCEED
127      * @tc.expected: step2. result equals.
128      */
129     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
130     longPressRecognizer.HandleTouchMoveEvent(touchEvent);
131     EXPECT_EQ(longPressRecognizer.time_, touchEvent.time);
132 
133     /**
134      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
135      * @tc.steps: case2: referee is SUCCEED
136      * @tc.expected: step2. result equals.
137      */
138     longPressRecognizer.currentFingers_ = longPressRecognizer.fingers_;
139     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
140     longPressRecognizer.HandleTouchMoveEvent(touchEvent);
141     EXPECT_EQ(longPressRecognizer.time_, touchEvent.time);
142 }
143 
144 /**
145  * @tc.name: LongPressRecognizerTest003
146  * @tc.desc: Test LongPressRecognizer function: HandleTouchDownEvent
147  * @tc.type: FUNC
148  */
149 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTest003, TestSize.Level1)
150 {
151     /**
152      * @tc.steps: step1. create LongPressRecognizer.
153      */
154     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
155 
156     /**
157      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
158      * @tc.steps: case1: pointsCount == fingers, useCatchMode_ is true
159      * @tc.expected: step2. result equals.
160      */
161     TouchEvent touchEvent;
162     longPressRecognizer.HandleTouchDownEvent(touchEvent);
163     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 1);
164 
165     /**
166      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
167      * @tc.steps: case2: pointsCount == fingers, useCatchMode_ is true
168      * @tc.expected: step2. result equals.
169      */
170     touchEvent.sourceType = SourceType::MOUSE;
171     longPressRecognizer.isForDrag_ = true;
172     longPressRecognizer.touchPoints_[touchEvent.id] = touchEvent;
173     longPressRecognizer.fingers_ = 1;
174     longPressRecognizer.useCatchMode_ = true;
175     longPressRecognizer.HandleTouchDownEvent(touchEvent);
176     EXPECT_EQ(longPressRecognizer.globalPoint_.GetX(), touchEvent.x);
177     EXPECT_EQ(longPressRecognizer.globalPoint_.GetY(), touchEvent.y);
178     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::READY);
179 
180     /**
181      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
182      * @tc.steps: case3: pointsCount == fingers, useCatchMode_ is false
183      * @tc.expected: step2. result equals.
184      */
185     longPressRecognizer.useCatchMode_ = false;
186     longPressRecognizer.HandleTouchDownEvent(touchEvent);
187     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::READY);
188 
189     /**
190      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
191      * @tc.steps: case4: referee is SUCCEED
192      * @tc.expected: step2. result equals.
193      */
194     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
195     longPressRecognizer.HandleTouchDownEvent(touchEvent);
196     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 1);
197 
198     /**
199      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
200      * @tc.steps: case5: change SourceType to KEYBOARD
201      * @tc.expected: step2. result equals.
202      */
203     longPressRecognizer.refereeState_ = RefereeState::PENDING;
204     touchEvent.sourceType = SourceType::KEYBOARD;
205     longPressRecognizer.HandleTouchDownEvent(touchEvent);
206     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 1);
207 
208     /**
209      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
210      * @tc.steps: case6: change isForDrag
211      * @tc.expected: step2. result equals.
212      */
213     longPressRecognizer.isForDrag_ = !longPressRecognizer.isForDrag_;
214     longPressRecognizer.HandleTouchDownEvent(touchEvent);
215     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 1);
216 
217     /**
218      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
219      * @tc.steps: case7: change isDisableMouseLeft_
220      * @tc.expected: step2. result equals.
221      */
222     longPressRecognizer.isDisableMouseLeft_ = !longPressRecognizer.isDisableMouseLeft_;
223     longPressRecognizer.HandleTouchDownEvent(touchEvent);
224     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 1);
225 }
226 
227 /**
228  * @tc.name: LongPressRecognizerTest004
229  * @tc.desc: Test LongPressRecognizer function: HandleTouchCancelEvent UpEvent
230  * @tc.type: FUNC
231  */
232 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTest004, TestSize.Level1)
233 {
234     /**
235      * @tc.steps: step1. create LongPressRecognizer.
236      */
237     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
238 
239     /**
240      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
241      * @tc.steps: refereeState == RefereeState::SUCCEED
242      * @tc.expected: step2. result equals.
243      */
244     TouchEvent touchEvent;
245     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
246     longPressRecognizer.HandleTouchUpEvent(touchEvent);
247     longPressRecognizer.HandleTouchCancelEvent(touchEvent);
248     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 0);
249 
250     /**
251      * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
252      * @tc.steps: refereeState == RefereeState::SUCCEED
253      * @tc.expected: step2. result equals.
254      */
255     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
256     longPressRecognizer.currentFingers_ = longPressRecognizer.fingers_;
257     longPressRecognizer.HandleTouchUpEvent(touchEvent);
258     longPressRecognizer.HandleTouchCancelEvent(touchEvent);
259     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 0);
260 }
261 
262 /**
263  * @tc.name: LongPressRecognizerDoRepeatTest001
264  * @tc.desc: Test LongPressRecognizer function: DoRepeat
265  * @tc.type: FUNC
266  */
267 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerDoRepeatTest001, TestSize.Level1)
268 {
269     /**
270      * @tc.steps: step1. create LongPressRecognizer.
271      */
272     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
273 
274     /**
275      * @tc.steps: step2. call DoRepeat
276      * @tc.steps: refereeState == RefereeState::SUCCEED
277      * @tc.expected: step2. result equals.
278      */
279     TouchEvent touchEvent;
280     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
281     longPressRecognizer.fingers_ = 0;
282     longPressRecognizer.DoRepeat();
283     longPressRecognizer.HandleTouchCancelEvent(touchEvent);
284     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 0);
285 
286     /**
287      * @tc.steps: step2. call DoRepeat
288      * @tc.steps: refereeState == RefereeState::SUCCEED
289      * @tc.expected: step2. result equals.
290      */
291     longPressRecognizer.refereeState_ = RefereeState::DETECTING;
292     longPressRecognizer.currentFingers_ = longPressRecognizer.fingers_;
293     longPressRecognizer.fingers_ = 0;
294     longPressRecognizer.DoRepeat();
295     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 0);
296 }
297 
298 /**
299  * @tc.name: LongPressRecognizerTest005
300  * @tc.desc: Test LongPressRecognizer function: SendCallbackMsg
301  * @tc.type: FUNC
302  */
303 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTest005, TestSize.Level1)
304 {
305     /**
306      * @tc.steps: step1. create LongPressRecognizer.
307      */
308     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
309     bool isRepeat = false;
310 
311     /**
312      * @tc.steps: step2. call SendCallbackMsg function and compare result.
313      * @tc.steps: case1: onAction is no, *onAction is no
314      * @tc.expected: step2. result equals.
315      */
316     std::unique_ptr<GestureEventFunc> onAction;
317     longPressRecognizer.SendCallbackMsg(onAction, isRepeat);
318     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 0);
319 
320     /**
321      * @tc.steps: step2. call SendCallbackMsg function and compare result.
322      * @tc.steps: case2: onAction is yes, *onAction is no
323      * @tc.expected: step2. result equals.
324      */
325     onAction = std::make_unique<GestureEventFunc>();
326     longPressRecognizer.SendCallbackMsg(onAction, isRepeat);
327     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 0);
328 
329     /**
330      * @tc.steps: step2. call SendCallbackMsg function and compare result.
331      * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty
332      * @tc.expected: step2. result equals.
333      */
__anon876fb52d0202(GestureEvent) 334     onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
335     longPressRecognizer.SendCallbackMsg(onAction, isRepeat);
336     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 0);
337 
338     /**
339      * @tc.steps: step2. call SendCallbackMsg function and compare result.
340      * @tc.steps: case4: touchEvent is not empty, have no X and Y
341      * @tc.expected: step2. result equals.
342      */
343     TouchEvent touchEvent;
344     longPressRecognizer.touchPoints_[touchEvent.id] = touchEvent;
345     longPressRecognizer.SendCallbackMsg(onAction, isRepeat);
346     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 1);
347 
348     /**
349      * @tc.steps: step2. call SendCallbackMsg function and compare result.
350      * @tc.steps: case4: touchEvent is not empty, have no X and Y
351      * @tc.expected: step2. result equals.
352      */
353     touchEvent.tiltX = 0.0f;
354     touchEvent.tiltY = 0.0f;
355     longPressRecognizer.touchPoints_[touchEvent.id] = touchEvent;
356     longPressRecognizer.SendCallbackMsg(onAction, isRepeat);
357     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 1);
358 }
359 
360 /**
361  * @tc.name: LongPressRecognizerTest006
362  * @tc.desc: Test LongPressRecognizer function: ReconcileFrom
363  * @tc.type: FUNC
364  */
365 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTest006, TestSize.Level1)
366 {
367     /**
368      * @tc.steps: step1. create LongPressRecognizer.
369      */
370     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
371     RefPtr<LongPressRecognizer> longPressRecognizerPtr =
372         AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION, FINGER_NUMBER, false);
373 
374     /**
375      * @tc.steps: step2. call ReconcileFrom function and compare result.
376      * @tc.steps: case1: normal case
377      * @tc.expected: step2. result equals.
378      */
379     auto result = longPressRecognizer.ReconcileFrom(longPressRecognizerPtr);
380     EXPECT_EQ(result, true);
381 
382     /**
383      * @tc.steps: step2. call ReconcileFrom function and compare result.
384      * @tc.steps: case2: recognizerPtr is nullptr
385      * @tc.expected: step2. result equals.
386      */
387     result = longPressRecognizer.ReconcileFrom(nullptr);
388     EXPECT_EQ(result, false);
389 
390     /**
391      * @tc.steps: step2. call ReconcileFrom function and compare result.
392      * @tc.steps: case3: recognizerPtr, duration not same
393      * @tc.expected: step2. result equals.
394      */
395     longPressRecognizer.duration_ = 0;
396     result = longPressRecognizer.ReconcileFrom(longPressRecognizerPtr);
397     EXPECT_EQ(result, false);
398 
399     /**
400      * @tc.steps: step2. call ReconcileFrom function and compare result.
401      * @tc.steps: case4: recognizerPtr, duration same, fingers not same
402      * @tc.expected: step2. result equals.
403      */
404     longPressRecognizer.duration_ = longPressRecognizerPtr->duration_;
405     longPressRecognizer.fingers_ = longPressRecognizerPtr->fingers_ + 1;
406     result = longPressRecognizer.ReconcileFrom(longPressRecognizerPtr);
407     EXPECT_EQ(result, false);
408 
409     /**
410      * @tc.steps: step2. call ReconcileFrom function and compare result.
411      * @tc.steps: case5: recognizerPtr, fingers same, repeat not same
412      * @tc.expected: step2. result equals.
413      */
414     longPressRecognizer.fingers_ = longPressRecognizerPtr->fingers_;
415     longPressRecognizer.repeat_ = !longPressRecognizerPtr->repeat_;
416     result = longPressRecognizer.ReconcileFrom(longPressRecognizerPtr);
417     EXPECT_EQ(result, false);
418 
419     /**
420      * @tc.steps: step2. call ReconcileFrom function and compare result.
421      * @tc.steps: case5: recognizerPtr, repeat same, priorityMask not same
422      * @tc.expected: step2. result equals.
423      */
424     longPressRecognizer.repeat_ = longPressRecognizerPtr->repeat_;
425     longPressRecognizer.priorityMask_ = GestureMask::End;
426     result = longPressRecognizer.ReconcileFrom(longPressRecognizerPtr);
427     EXPECT_EQ(result, false);
428 }
429 
430 /**
431  * @tc.name: LongPressRecognizerTestGetLongPressActionFunc001
432  * @tc.desc: Test LongPressRecognizer function: GetLongPressActionFunc
433  * @tc.type: FUNC
434  */
435 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTestGetLongPressActionFunc001, TestSize.Level1)
436 {
437     /**
438      * @tc.steps: step1. create LongPressRecognizer.
439      */
440     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
441     bool isCatchMode = false;
442 
443     /**
444      * @tc.steps: step2. call GetLongPressActionFunc function and compare result.
445      * @tc.steps: case1: normal case
446      * @tc.expected: step2. result equals.
447      */
448     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
449     auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
450     longPressRecognizer.AttachFrameNode(frameNode);
451     longPressRecognizer.HandleOverdueDeadline(isCatchMode);
452     longPressRecognizer.DoRepeat();
453     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
454     auto result = longPressRecognizer.GetLongPressActionFunc();
455 }
456 
457 /**
458  * @tc.name: LongPressRecognizerTestGetLongPressActionFunc003
459  * @tc.desc: Test LongPressRecognizer function: GetLongPressActionFunc
460  * @tc.type: FUNC
461  */
462 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTestGetLongPressActionFunc003, TestSize.Level1)
463 {
464     /**
465      * @tc.steps: step1. create LongPressRecognizer.
466      */
467     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
468     bool isCatchMode = false;
469 
470     /**
471      * @tc.steps: step2. call GetLongPressActionFunc function and compare result.
472      * @tc.steps: case1: normal case
473      * @tc.expected: step2. result equals.
474      */
475     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
476     auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
477     longPressRecognizer.AttachFrameNode(frameNode);
478     longPressRecognizer.HandleOverdueDeadline(isCatchMode);
479     longPressRecognizer.DoRepeat();
480     GestureEventFunc click;
481     GestureEvent info;
482     click = longPressRecognizer.GetLongPressActionFunc();
483     click(info);
484     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
485 }
486 
487 /**
488  * @tc.name: LongPressRecognizerTestGetLongPressActionFunc004
489  * @tc.desc: Test LongPressRecognizer function: GetLongPressActionFunc
490  * @tc.type: FUNC
491  */
492 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTestGetLongPressActionFunc004, TestSize.Level1)
493 {
494     /**
495      * @tc.steps: step1. create LongPressRecognizer.
496      */
497     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
498     bool isCatchMode = false;
499 
500     /**
501      * @tc.steps: step2. call GetLongPressActionFunc function and compare result.
502      * @tc.steps: case1: normal case
503      * @tc.expected: step2. result equals.
504      */
505     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
506     auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
507     longPressRecognizer.AttachFrameNode(frameNode);
508     longPressRecognizer.HandleOverdueDeadline(isCatchMode);
509     longPressRecognizer.DoRepeat();
510     GestureEventFunc click;
511     GestureEvent info;
__anon876fb52d0302(GestureEvent& info) 512     auto onActionStart = [](GestureEvent& info) { return true; };
__anon876fb52d0402(GestureEvent& info) 513     auto onActionUpdate = [](GestureEvent& info) { return true; };
__anon876fb52d0502(GestureEvent& info) 514     auto onActionEnd = [](GestureEvent& info) { return true; };
515     longPressRecognizer.SetOnActionUpdate(onActionUpdate);
516     longPressRecognizer.SetOnAction(onActionStart);
517     longPressRecognizer.SetOnActionEnd(onActionEnd);
518     click = longPressRecognizer.GetLongPressActionFunc();
519     click(info);
520     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
521 }
522 
523 /**
524  * @tc.name: LongPressRecognizerTestGetLongPressActionFunc002
525  * @tc.desc: Test LongPressRecognizer function: GetLongPressActionFunc
526  * @tc.type: FUNC
527  */
528 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTestGetLongPressActionFunc002, TestSize.Level1)
529 {
530     /**
531      * @tc.steps: step1. create LongPressRecognizer.
532      */
533     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
534     bool isCatchMode = false;
535 
536     /**
537      * @tc.steps: step2. call GetLongPressActionFunc function and compare result.
538      * @tc.steps: case1: normal case
539      * @tc.expected: step2. result equals.
540      */
541     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
542     longPressRecognizer.fingers_ = SINGLE_FINGER_NUMBER;
543     auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
544     longPressRecognizer.AttachFrameNode(frameNode);
545     longPressRecognizer.HandleOverdueDeadline(isCatchMode);
546     longPressRecognizer.DoRepeat();
547     auto result = longPressRecognizer.GetLongPressActionFunc();
548     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
549 
550     /**
551      * @tc.steps: step2. call GetLongPressActionFunc function and compare result.
552      * @tc.steps: case1: normal case
553      * @tc.expected: step2. result equals.
554      */
555     longPressRecognizer.refereeState_ = RefereeState::DETECTING;
556     longPressRecognizer.fingers_ = SINGLE_FINGER_NUMBER;
557     longPressRecognizer.HandleOverdueDeadline(isCatchMode);
558     longPressRecognizer.DoRepeat();
559     result = longPressRecognizer.GetLongPressActionFunc();
560     EXPECT_NE(longPressRecognizer.refereeState_, RefereeState::DETECTING);
561 }
562 
563 /**
564  * @tc.name: LongPressRecognizerConvertPxToVpTest001
565  * @tc.desc: Test LongPressRecognizer function: ConvertPxToVp
566  * @tc.type: FUNC
567  */
568 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerConvertPxToVpTest001, TestSize.Level1)
569 {
570     /**
571      * @tc.steps: step1. create LongPressRecognizer.
572      */
573     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
574 
575     /**
576      * @tc.steps: step2. call ConvertPxToVp function and compare result.
577      * @tc.steps: case1: normal case
578      * @tc.expected: step2. result equals.
579      */
580     double result = longPressRecognizer.ConvertPxToVp(0.0);
581     EXPECT_EQ(result, 0.0);
582 }
583 
584 /**
585  * @tc.name: LongPressRecognizerTest007
586  * @tc.desc: Test LongPressRecognizer function: HandleOverdueDeadline  DoRepeat
587  * @tc.type: FUNC
588  */
589 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTest007, TestSize.Level1)
590 {
591     /**
592      * @tc.steps: step1. create LongPressRecognizer.
593      */
594     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
595     bool isCatchMode = false;
596 
597     /**
598      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
599      * @tc.steps: case1: refereeState is SUCCESS, return
600      * @tc.expected: step2. result equals.
601      */
602     longPressRecognizer.refereeState_ = RefereeState::SUCCEED;
603     auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
604     longPressRecognizer.AttachFrameNode(frameNode);
605     longPressRecognizer.HandleOverdueDeadline(isCatchMode);
606     longPressRecognizer.DoRepeat();
607     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
608 
609     /**
610      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
611      * @tc.steps: case1: refereeState is DETECTING, isCatchMode is false
612      * @tc.expected: step2. result equals.
613      */
614     longPressRecognizer.refereeState_ = RefereeState::DETECTING;
615     longPressRecognizer.HandleOverdueDeadline(isCatchMode);
616     longPressRecognizer.DoRepeat();
617     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
618 }
619 
620 /**
621  * @tc.name: LongPressRecognizerSendCallbackMsgTest001
622  * @tc.desc: Test LongPressRecognizer function: SendCallbackMsg
623  * @tc.type: FUNC
624  */
625 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerSendCallbackMsgTest001, TestSize.Level1)
626 {
627     /**
628      * @tc.steps: step1. Create longPressRecognizer.
629      */
630     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
631     std::unique_ptr<GestureEventFunc> onAction;
632 
633     /**
634      * @tc.steps: step2. call SendCallbackMsg function and compare result.
635      * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty, type is AXIS
636      * @tc.expected: step2. result equals.
637      */
__anon876fb52d0602(GestureEvent) 638     onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
639     longPressRecognizer.SendCallbackMsg(onAction, true);
640     EXPECT_EQ(longPressRecognizer.touchPoints_.size(), 0);
641 }
642 
643 /**
644  * @tc.name: LongPressGestureTest001
645  * @tc.desc: Test LongPressGesture CreateRecognizer function
646  */
647 HWTEST_F(LongPressRecognizerTestNg, LongPressGestureTest001, TestSize.Level1)
648 {
649     /**
650      * @tc.steps: step1. create LongPressGesture.
651      */
652     LongPressGestureModelNG longPressGestureModelNG;
653     longPressGestureModelNG.Create(FINGER_NUMBER, false, LONG_PRESS_DURATION);
654 
655     RefPtr<GestureProcessor> gestureProcessor;
656     gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
657     auto longPressGestureNG = AceType::DynamicCast<NG::LongPressGesture>(gestureProcessor->TopGestureNG());
658     EXPECT_EQ(longPressGestureNG->duration_, LONG_PRESS_DURATION);
659 
660     LongPressGesture longPressGesture = LongPressGesture(FINGER_NUMBER, false, LONG_PRESS_DURATION, false, false);
661     EXPECT_EQ(longPressGesture.repeat_, false);
662     EXPECT_EQ(longPressGesture.duration_, LONG_PRESS_DURATION);
663     EXPECT_EQ(longPressGesture.isForDrag_, false);
664     EXPECT_EQ(longPressGesture.isDisableMouseLeft_, false);
665 
666     /**
667      * @tc.steps: step2. call CreateRecognizer function and compare result
668      * @tc.steps: case1: onActionId, onActionEndId, onActionCancelId not existed
669      */
670     auto longPressRecognizer = AceType::DynamicCast<LongPressRecognizer>(longPressGesture.CreateRecognizer());
671     EXPECT_NE(longPressRecognizer, nullptr);
672     EXPECT_EQ(longPressRecognizer->repeat_, false);
673     EXPECT_EQ(longPressRecognizer->duration_, LONG_PRESS_DURATION);
674     EXPECT_EQ(longPressRecognizer->isForDrag_, false);
675     EXPECT_EQ(longPressRecognizer->isDisableMouseLeft_, false);
676 
677     /**
678      * @tc.steps: step2. call CreateRecognizer function and compare result
679      * @tc.steps: case2: onActionId, onActionEndId, onActionCancelId existed
680      */
681     std::unique_ptr<GestureEventFunc> onActionId;
682     std::unique_ptr<GestureEventFunc> onActionEndId;
683     std::unique_ptr<GestureEventNoParameter> onActionCancelId;
684     longPressGesture.onActionId_ = std::move(onActionId);
685     longPressGesture.onActionEndId_ = std::move(onActionEndId);
686     longPressGesture.onActionCancelId_ = std::move(onActionCancelId);
687     longPressRecognizer = AceType::DynamicCast<LongPressRecognizer>(longPressGesture.CreateRecognizer());
688     EXPECT_NE(longPressRecognizer, nullptr);
689     EXPECT_EQ(longPressRecognizer->repeat_, false);
690     EXPECT_EQ(longPressRecognizer->duration_, LONG_PRESS_DURATION);
691     EXPECT_EQ(longPressRecognizer->isForDrag_, false);
692     EXPECT_EQ(longPressRecognizer->isDisableMouseLeft_, false);
693 }
694 
695 /**
696  * @tc.name: LongPressGestureCreateRecognizerTest001
697  * @tc.desc: Test LongPressGesture CreateRecognizer function
698  */
699 HWTEST_F(LongPressRecognizerTestNg, LongPressGestureCreateRecognizerTest001, TestSize.Level1)
700 {
701     /**
702      * @tc.steps: step1. create LongPressGesture.
703      */
704     LongPressGestureModelNG longPressGestureModelNG;
705     longPressGestureModelNG.Create(FINGER_NUMBER, false, LONG_PRESS_DURATION);
706 
707     RefPtr<GestureProcessor> gestureProcessor;
708     gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
709     auto longPressGestureNG = AceType::DynamicCast<NG::LongPressGesture>(gestureProcessor->TopGestureNG());
710     EXPECT_EQ(longPressGestureNG->duration_, LONG_PRESS_DURATION);
711 
712     LongPressGesture longPressGesture = LongPressGesture(FINGER_NUMBER, false, LONG_PRESS_DURATION, false, false);
713     EXPECT_EQ(longPressGesture.repeat_, false);
714     EXPECT_EQ(longPressGesture.duration_, LONG_PRESS_DURATION);
715     EXPECT_EQ(longPressGesture.isForDrag_, false);
716     EXPECT_EQ(longPressGesture.isDisableMouseLeft_, false);
717 
718     /**
719      * @tc.steps: step2. call CreateRecognizer function and compare result
720      * @tc.steps: case1: onActionId, onActionEndId, onActionCancelId not existed
721      */
722     longPressGesture.fingers_ = FINGER_NUMBER_OVER_MAX;
723     longPressGesture.duration_ = 0;
724     auto longPressRecognizer = AceType::DynamicCast<LongPressRecognizer>(longPressGesture.CreateRecognizer());
725     EXPECT_NE(longPressRecognizer, nullptr);
726 
727     /**
728      * @tc.steps: step2. call CreateRecognizer function and compare result
729      * @tc.steps: case1: onActionId, onActionEndId, onActionCancelId not existed
730      */
731     longPressGesture.fingers_ = 0;
732     longPressGesture.duration_ = 0;
733     longPressRecognizer = AceType::DynamicCast<LongPressRecognizer>(longPressGesture.CreateRecognizer());
734     EXPECT_NE(longPressRecognizer, nullptr);
735 }
736 
737 
738 /**
739  * @tc.name: LongPressGestureCreateRecognizerTest002
740  * @tc.desc: Test LongPressGesture CreateRecognizer function
741  */
742 HWTEST_F(LongPressRecognizerTestNg, LongPressGestureCreateRecognizerTest002, TestSize.Level1)
743 {
744     /**
745      * @tc.steps: step1. create LongPressGesture.
746      */
747     LongPressGestureModelNG longPressGestureModelNG;
748     longPressGestureModelNG.Create(FINGER_NUMBER, false, LONG_PRESS_DURATION);
749 
750     RefPtr<GestureProcessor> gestureProcessor;
751     gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
752     auto longPressGestureNG = AceType::DynamicCast<NG::LongPressGesture>(gestureProcessor->TopGestureNG());
753     EXPECT_EQ(longPressGestureNG->duration_, LONG_PRESS_DURATION);
754 
755     LongPressGesture longPressGesture = LongPressGesture(FINGER_NUMBER, false, LONG_PRESS_DURATION, false, false);
756     EXPECT_EQ(longPressGesture.repeat_, false);
757     EXPECT_EQ(longPressGesture.duration_, LONG_PRESS_DURATION);
758     EXPECT_EQ(longPressGesture.isForDrag_, false);
759     EXPECT_EQ(longPressGesture.isDisableMouseLeft_, false);
760 
761     /**
762      * @tc.steps: step2. call CreateRecognizer function and compare result
763      * @tc.steps: case1: onActionId, onActionEndId, onActionCancelId not existed
764      */
765     longPressGesture.fingers_ = FINGER_NUMBER_OVER_MAX;
766     longPressGesture.duration_ = 0;
__anon876fb52d0702(GestureEvent& info) 767     auto onActionStart = [](GestureEvent& info) { return true; };
__anon876fb52d0802(GestureEvent& info) 768     auto onActionEnd = [](GestureEvent& info) { return true; };
__anon876fb52d0902() 769     auto onActionCancel = []() { return true; };
770     longPressGesture.SetOnActionId(onActionStart);
771     longPressGesture.SetOnActionEndId(onActionEnd);
772     longPressGesture.SetOnActionCancelId(onActionCancel);
773     auto longPressRecognizer = AceType::DynamicCast<LongPressRecognizer>(longPressGesture.CreateRecognizer());
774     EXPECT_NE(longPressRecognizer, nullptr);
775 
776     /**
777      * @tc.steps: step2. call CreateRecognizer function and compare result
778      * @tc.steps: case1: onActionId, onActionEndId, onActionCancelId not existed
779      */
780     longPressGesture.fingers_ = 0;
781     longPressGesture.duration_ = 0;
782     longPressRecognizer = AceType::DynamicCast<LongPressRecognizer>(longPressGesture.CreateRecognizer());
783     EXPECT_NE(longPressRecognizer, nullptr);
784 }
785 
786 /**
787  * @tc.name: LongPressRecognizerHandleTouchUpEventTest009
788  * @tc.desc: Test LongPressRecognizer function: HandleTouchUpEvent
789  * @tc.type: FUNC
790  */
791 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerHandleTouchUpEventTest009, TestSize.Level1)
792 {
793     /**
794      * @tc.steps: step1. create PinchRecognizer.
795      */
796     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
797         FINGER_NUMBER, false);
798     TouchEvent touchEvent;
799     touchEvent.x = 100.0;
800     touchEvent.y = 100.0;
801 
802     longPressRecognizer->refereeState_ = RefereeState::DETECTING;
803     longPressRecognizer->currentFingers_ = longPressRecognizer->fingers_;
804     longPressRecognizer->HandleTouchUpEvent(touchEvent);
805     EXPECT_EQ(longPressRecognizer->repeat_, false);
806 }
807 
808 /**
809  * @tc.name: LongPressRecognizerHandleTouchCancelEventTest001
810  * @tc.desc: Test LongPressRecognizer function: HandleTouchCancelEvent
811  * @tc.type: FUNC
812  */
813 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerHandleTouchCancelEventTest001, TestSize.Level1)
814 {
815     /**
816      * @tc.steps: step1. create LongPressRecognizer.
817      */
818     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
819         FINGER_NUMBER, false);
820     TouchEvent touchEvent;
821     touchEvent.x = 100.0;
822     touchEvent.y = 100.0;
823 
824     longPressRecognizer->refereeState_ = RefereeState::DETECTING;
825     longPressRecognizer->currentFingers_ = longPressRecognizer->fingers_;
826     longPressRecognizer->HandleTouchCancelEvent(touchEvent);
827     EXPECT_EQ(longPressRecognizer->repeat_, false);
828 }
829 
830 /**
831  * @tc.name: LongPressRecognizerHandleTouchDownEventTest001
832  * @tc.desc: Test LongPressRecognizer function: HandleTouchDownEvent
833  * @tc.type: FUNC
834  */
835 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerHandleTouchDownEventTest001, TestSize.Level1)
836 {
837     /**
838      * @tc.steps: step1. create LongPressRecognizer.
839      */
840     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
841         FINGER_NUMBER, false);
842     TouchEvent touchEvent;
843     touchEvent.x = 100.0;
844     touchEvent.y = 100.0;
845     touchEvent.sourceType = SourceType::MOUSE;
846 
847     longPressRecognizer->refereeState_ = RefereeState::DETECTING;
848     longPressRecognizer->isDisableMouseLeft_ = true;
849     longPressRecognizer->currentFingers_ = longPressRecognizer->fingers_;
850     longPressRecognizer->HandleTouchDownEvent(touchEvent);
851     EXPECT_EQ(longPressRecognizer->repeat_, false);
852 }
853 
854 /**
855  * @tc.name: LongPressRecognizerHandleTouchMoveEventTest001
856  * @tc.desc: Test LongPressRecognizer function: HandleTouchMoveEvent
857  * @tc.type: FUNC
858  */
859 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerHandleTouchMoveEventTest001, TestSize.Level1)
860 {
861     /**
862      * @tc.steps: step1. create LongPressRecognizer.
863      */
864     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
865         FINGER_NUMBER, false);
866     TouchEvent touchEvent;
867     touchEvent.x = 100.0;
868     touchEvent.y = 100.0;
869     touchEvent.sourceType = SourceType::MOUSE;
870 
871     longPressRecognizer->refereeState_ = RefereeState::DETECTING;
872     longPressRecognizer->isDisableMouseLeft_ = true;
873     longPressRecognizer->currentFingers_ = longPressRecognizer->fingers_;
874     longPressRecognizer->isForDrag_ = true;
875     longPressRecognizer->HandleTouchMoveEvent(touchEvent);
876     EXPECT_EQ(longPressRecognizer->repeat_, false);
877 
878     longPressRecognizer->refereeState_ = RefereeState::DETECTING;
879     longPressRecognizer->isDisableMouseLeft_ = false;
880     longPressRecognizer->currentFingers_ = longPressRecognizer->fingers_;
881     longPressRecognizer->isForDrag_ = false;
882     longPressRecognizer->HandleTouchMoveEvent(touchEvent);
883     EXPECT_EQ(longPressRecognizer->repeat_, false);
884 }
885 
886 /**
887  * @tc.name: LongPressRecognizerHandleOverdueDeadlineTest001
888  * @tc.desc: Test LongPressRecognizer function: HandleOverdueDeadline
889  * @tc.type: FUNC
890  */
891 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerHandleOverdueDeadlineTest001, TestSize.Level1)
892 {
893     /**
894      * @tc.steps: step1. create LongPressRecognizer.
895      */
896     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
897         FINGER_NUMBER, false);
898     TouchEvent touchEvent;
899     touchEvent.x = 100.0;
900     touchEvent.y = 100.0;
901     touchEvent.sourceType = SourceType::MOUSE;
902 
903     longPressRecognizer->refereeState_ = RefereeState::DETECTING;
904     longPressRecognizer->HandleOverdueDeadline(true);
905     EXPECT_EQ(longPressRecognizer->repeat_, false);
906 }
907 
908 /**
909  * @tc.name: LongPressRecognizerThumbnailTimerTest001
910  * @tc.desc: Test ThumbnailTimer in LongPressRecognizer
911  */
912 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerThumbnailTimerTest001, TestSize.Level1)
913 {
914     /**
915      * @tc.steps: step1. create LongPressRecognizer.
916      */
917     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
918         FINGER_NUMBER, false);
919 
920     /**
921      * @tc.steps: step2. set callback function.
922      */
__anon876fb52d0a02(Offset offset) 923     auto callback = [](Offset offset) {};
924     longPressRecognizer->callback_ = callback;
925     longPressRecognizer->ThumbnailTimer(0);
926     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::READY);
927 }
928 
929 /**
930  * @tc.name: LongPressRecognizerTestGetLongPressActionFunc005
931  * @tc.desc: Test LongPressRecognizer function: GetLongPressActionFunc
932  * @tc.type: FUNC
933  */
934 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTestGetLongPressActionFunc005, TestSize.Level1)
935 {
936     /**
937      * @tc.steps: step1. create LongPressRecognizer.
938      */
939     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
940         FINGER_NUMBER, false);
941     bool isCatchMode = false;
942     longPressRecognizer->refereeState_ = RefereeState::SUCCEED;
943     longPressRecognizer->HandleOverdueDeadline(isCatchMode);
944     longPressRecognizer->DoRepeat();
945     GestureEventFunc click;
946     GestureEvent info;
947 
948     /**
949      * @tc.steps: step2. call GetLongPressActionFunc function and compare result.
950      * @tc.steps: case1: normal case
951      * @tc.expected: step2. result equals.
952      */
953     click = longPressRecognizer->GetLongPressActionFunc();
954     click(info);
955     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::SUCCEED);
956 
__anon876fb52d0b02(GestureEvent& info) 957     auto onActionStart = [](GestureEvent& info) { return true; };
__anon876fb52d0c02(GestureEvent& info) 958     auto onActionUpdate = [](GestureEvent& info) { return true; };
__anon876fb52d0d02(GestureEvent& info) 959     auto onActionEnd = [](GestureEvent& info) { return true; };
960     longPressRecognizer->SetOnActionUpdate(onActionUpdate);
961     longPressRecognizer->SetOnAction(onActionStart);
962     longPressRecognizer->SetOnActionEnd(onActionEnd);
963     click = longPressRecognizer->GetLongPressActionFunc();
964     click(info);
965     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::SUCCEED);
966 }
967 
968 /**
969  * @tc.name: LongPressRecognizerTestGetLongPressActionFunc006
970  * @tc.desc: Test LongPressRecognizer function: GetLongPressActionFunc
971  * @tc.type: FUNC
972  */
973 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTestGetLongPressActionFunc006, TestSize.Level1)
974 {
975     /**
976      * @tc.steps: step1. create LongPressRecognizer.
977      */
978     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
979         FINGER_NUMBER, false);
980     GestureEventFunc click;
981     GestureEvent info;
982 
983     /**
984      * @tc.steps: step2. call GetLongPressActionFunc function and compare result.
985      * @tc.steps: case1: normal case
986      * @tc.expected: step2. result equals.
987      */
988     click = longPressRecognizer->GetLongPressActionFunc();
989     click(info);
990     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::READY);
991 
__anon876fb52d0e02(GestureEvent& info) 992     auto onActionStart = [](GestureEvent& info) { return true; };
__anon876fb52d0f02(GestureEvent& info) 993     auto onActionUpdate = [](GestureEvent& info) { return true; };
__anon876fb52d1002(GestureEvent& info) 994     auto onActionEnd = [](GestureEvent& info) { return true; };
995     longPressRecognizer->SetOnActionUpdate(onActionUpdate);
996     longPressRecognizer->SetOnAction(onActionStart);
997     longPressRecognizer->SetOnActionEnd(onActionEnd);
998     click = longPressRecognizer->GetLongPressActionFunc();
999     click(info);
1000     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::READY);
1001 }
1002 
1003 /**
1004  * @tc.name: LongPressRecognizerHandleTouchUpEventTest001
1005  * @tc.desc: Test HandleTouchUpEvent in LongPressRecognizer
1006  */
1007 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerHandleTouchUpEventTest001, TestSize.Level1)
1008 {
1009     /**
1010      * @tc.steps: step1. create LongPressRecognizer.
1011      */
1012     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
1013         FINGER_NUMBER, false);
1014     TouchEvent touchEvent;
1015 
1016     /**
1017      * @tc.steps: step2. set callback function.
1018      */
1019     longPressRecognizer->refereeState_ = RefereeState::SUCCEED;
1020     longPressRecognizer->currentFingers_ = longPressRecognizer->fingers_ + 1;
__anon876fb52d1102(Offset offset) 1021     auto callback = [](Offset offset) {};
1022     longPressRecognizer->callback_ = callback;
1023     longPressRecognizer->HandleTouchUpEvent(touchEvent);
1024     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::SUCCEED);
1025 }
1026 
1027 /**
1028  * @tc.name: LongPressRecognizerThumbnailTimerTest002
1029  * @tc.desc: Test ThumbnailTimer in LongPressRecognizer
1030  */
1031 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerThumbnailTimerTest002, TestSize.Level1)
1032 {
1033     /**
1034      * @tc.steps: step1. create LongPressRecognizer.
1035      */
1036     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
1037         FINGER_NUMBER, false);
1038 
1039     /**
1040      * @tc.steps: step2. set callback function.
1041      */
__anon876fb52d1202(Offset offset) 1042     auto callback = [](Offset offset) {};
1043     longPressRecognizer->callback_ = callback;
1044     longPressRecognizer->ThumbnailTimer(0);
1045     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::READY);
1046 }
1047 
1048 /**
1049  * @tc.name: LongPressRecognizerTestGetLongPressActionFunc008
1050  * @tc.desc: Test LongPressRecognizer function: GetLongPressActionFunc
1051  * @tc.type: FUNC
1052  */
1053 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTestGetLongPressActionFunc008, TestSize.Level1)
1054 {
1055     /**
1056      * @tc.steps: step1. create LongPressRecognizer.
1057      */
1058     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
1059         FINGER_NUMBER, false);
1060     bool isCatchMode = false;
1061     longPressRecognizer->refereeState_ = RefereeState::SUCCEED;
1062     longPressRecognizer->HandleOverdueDeadline(isCatchMode);
1063     longPressRecognizer->DoRepeat();
1064     GestureEventFunc click;
1065     GestureEvent info;
1066 
1067     /**
1068      * @tc.steps: step2. call GetLongPressActionFunc function and compare result.
1069      * @tc.steps: case1: normal case
1070      * @tc.expected: step2. result equals.
1071      */
1072     click = longPressRecognizer->GetLongPressActionFunc();
1073     click(info);
1074     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::SUCCEED);
1075 
__anon876fb52d1302(GestureEvent& info) 1076     auto onActionStart = [](GestureEvent& info) { return true; };
__anon876fb52d1402(GestureEvent& info) 1077     auto onActionUpdate = [](GestureEvent& info) { return true; };
__anon876fb52d1502(GestureEvent& info) 1078     auto onActionEnd = [](GestureEvent& info) { return true; };
1079     longPressRecognizer->SetOnActionUpdate(onActionUpdate);
1080     longPressRecognizer->SetOnAction(onActionStart);
1081     longPressRecognizer->SetOnActionEnd(onActionEnd);
1082     click = longPressRecognizer->GetLongPressActionFunc();
1083     click(info);
1084     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::SUCCEED);
1085 }
1086 
1087 /**
1088  * @tc.name: LongPressRecognizerTestGetLongPressActionFunc009
1089  * @tc.desc: Test LongPressRecognizer function: GetLongPressActionFunc
1090  * @tc.type: FUNC
1091  */
1092 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerTestGetLongPressActionFunc009, TestSize.Level1)
1093 {
1094     /**
1095      * @tc.steps: step1. create LongPressRecognizer.
1096      */
1097     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
1098         FINGER_NUMBER, false);
1099     GestureEventFunc click;
1100     GestureEvent info;
1101 
1102     /**
1103      * @tc.steps: step2. call GetLongPressActionFunc function and compare result.
1104      * @tc.steps: case1: normal case
1105      * @tc.expected: step2. result equals.
1106      */
1107     click = longPressRecognizer->GetLongPressActionFunc();
1108     click(info);
1109     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::READY);
1110 
__anon876fb52d1602(GestureEvent& info) 1111     auto onActionStart = [](GestureEvent& info) { return true; };
__anon876fb52d1702(GestureEvent& info) 1112     auto onActionUpdate = [](GestureEvent& info) { return true; };
__anon876fb52d1802(GestureEvent& info) 1113     auto onActionEnd = [](GestureEvent& info) { return true; };
1114     longPressRecognizer->SetOnActionUpdate(onActionUpdate);
1115     longPressRecognizer->SetOnAction(onActionStart);
1116     longPressRecognizer->SetOnActionEnd(onActionEnd);
1117     click = longPressRecognizer->GetLongPressActionFunc();
1118     click(info);
1119     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::READY);
1120 }
1121 
1122 /**
1123  * @tc.name: LongPressRecognizerHandleTouchUpEventTest002
1124  * @tc.desc: Test HandleTouchUpEvent in LongPressRecognizer
1125  */
1126 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerHandleTouchUpEventTest002, TestSize.Level1)
1127 {
1128     /**
1129      * @tc.steps: step1. create LongPressRecognizer.
1130      */
1131     RefPtr<LongPressRecognizer> longPressRecognizer =AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
1132         FINGER_NUMBER, false);
1133     TouchEvent touchEvent;
1134 
1135     /**
1136      * @tc.steps: step2. set callback function.
1137      */
1138     longPressRecognizer->refereeState_ = RefereeState::SUCCEED;
1139     longPressRecognizer->currentFingers_ = longPressRecognizer->fingers_ + 1;
__anon876fb52d1902(Offset offset) 1140     auto callback = [](Offset offset) {};
1141     longPressRecognizer->callback_ = callback;
1142     longPressRecognizer->HandleTouchUpEvent(touchEvent);
1143     EXPECT_EQ(longPressRecognizer->refereeState_, RefereeState::SUCCEED);
1144 }
1145 
1146 /**
1147  * @tc.name: GestureAccessibilityEventTest002
1148  * @tc.desc: Test SetOnAccessibility in LongPressRecognizer
1149  */
1150 HWTEST_F(LongPressRecognizerTestNg, GestureAccessibilityEventTest002, TestSize.Level1)
1151 {
1152     /**
1153      * @tc.steps: step1. Create longPressRecognizer.
1154      */
1155     LongPressRecognizer longPressRecognizer = LongPressRecognizer(LONG_PRESS_DURATION, FINGER_NUMBER, false);
1156 
1157     /**
1158      * @tc.steps: step2. set callback function.
1159      */
__anon876fb52d1a02(AccessibilityEventType eventType) 1160     auto onAccessibilityEvent = [](AccessibilityEventType eventType) {};
1161     longPressRecognizer.SetOnAccessibility(onAccessibilityEvent);
1162     ASSERT_NE(longPressRecognizer.onAccessibilityEventFunc_, nullptr);
1163 
1164     /**
1165      * @tc.steps: step3. call callback function.
1166      * @tc.expected: refereeState_ is SUCCEED.
1167      */
1168     longPressRecognizer.OnAccepted();
1169     EXPECT_EQ(longPressRecognizer.refereeState_, RefereeState::SUCCEED);
1170 }
1171 
1172 /**
1173  * @tc.name: LongPressRecognizerHandleOverdueDeadlineTest002
1174  * @tc.desc: Test LongPressRecognizer function: HandleOverdueDeadline
1175  * @tc.type: FUNC
1176  */
1177 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerHandleOverdueDeadlineTest002, TestSize.Level1)
1178 {
1179     /**
1180      * @tc.steps: step1. create Recognizer、TargetComponent.
1181      */
1182     RefPtr<LongPressRecognizer> longPressRecognizerPtr = AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
1183         FINGER_NUMBER, false);
1184     RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anon876fb52d1b02(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1185     auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
1186         return GestureJudgeResult::REJECT;};
1187     auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
1188     auto guestureEventHub = frameNode->GetOrCreateGestureEventHub();
1189     PanDirection panDirection;
1190     targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
1191     longPressRecognizerPtr->targetComponent_ = targetComponent;
1192     longPressRecognizerPtr->targetComponent_->node_ = frameNode;
1193     TouchEvent touchEvent;
1194     touchEvent.tiltX.emplace(1.0f);
1195     touchEvent.tiltY.emplace(1.0f);
1196     longPressRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1197     /**
1198      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
1199      * @tc.steps: case1: gestureInfo_ is nullptr
1200      * @tc.expected: step2. result equals REJECT.
1201      */
1202     longPressRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1203     longPressRecognizerPtr->HandleOverdueDeadline(true);
1204     EXPECT_EQ(longPressRecognizerPtr->disposal_, GestureDisposal::REJECT);
1205 
1206     /**
1207      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
1208      * @tc.steps: case2: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
1209      *                   isDragUserReject_ = true
1210      * @tc.expected: step2. result equals REJECT.
1211      */
1212     longPressRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1213     longPressRecognizerPtr->gestureInfo_ = AceType::MakeRefPtr<GestureInfo>();
1214     longPressRecognizerPtr->gestureInfo_->type_ = GestureTypeName::DRAG;
1215     guestureEventHub->dragEventActuator_ = AceType::MakeRefPtr<DragEventActuator>(
1216         AceType::WeakClaim(AceType::RawPtr(guestureEventHub)), panDirection, 1, 50.0f);
1217     guestureEventHub->dragEventActuator_->isDragUserReject_ = true;
1218     longPressRecognizerPtr->HandleOverdueDeadline(true);
1219     EXPECT_EQ(longPressRecognizerPtr->disposal_, GestureDisposal::REJECT);
1220 
1221     /**
1222      * @tc.steps: step2. call HandleOverdueDeadline function and compare result.
1223      * @tc.steps: case3: gestureInfo_ is not nullptr, gestureInfo_->type_ = DRAG
1224      *                   isDragUserReject_ = false
1225      * @tc.expected: step2. isDragUserReject_ = true.
1226      */
1227     longPressRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1228     guestureEventHub->dragEventActuator_->isDragUserReject_ = false;
1229     longPressRecognizerPtr->HandleOverdueDeadline(true);
1230     EXPECT_TRUE(guestureEventHub->dragEventActuator_->isDragUserReject_);
1231 }
1232 
1233 /**
1234  * @tc.name: LongPressRecognizerLongPressRecognizerTest
1235  * @tc.desc: Test LongPressRecognizer function: LongPressRecognizer
1236  * @tc.type: FUNC
1237  */
1238 HWTEST_F(LongPressRecognizerTestNg, LongPressRecognizerLongPressRecognizerTest, TestSize.Level1)
1239 {
1240     /**
1241      * @tc.steps: step1. create Recognizer、TargetComponent.
1242      */
1243     LongPressRecognizer longPressRecognizer1 = LongPressRecognizer(100, 9, false, false, false);
1244     LongPressRecognizer longPressRecognizer2 = LongPressRecognizer(100, 11, false, false, false);
1245     LongPressRecognizer longPressRecognizer3 = LongPressRecognizer(0, 10, false, false, false);
1246     EXPECT_EQ(longPressRecognizer1.fingers_, 9);
1247     EXPECT_EQ(longPressRecognizer2.fingers_, 1);
1248     EXPECT_EQ(longPressRecognizer3.duration_, 500);
1249 }
1250 
1251 /**
1252  * @tc.name: DeadlineTimerTest
1253  * @tc.desc: Test LongPressRecognizer function: DeadlineTimer
1254  * @tc.type: FUNC
1255  */
1256 HWTEST_F(LongPressRecognizerTestNg, DeadlineTimerTest, TestSize.Level1)
1257 {
1258     /**
1259      * @tc.steps: step1. create Recognizer、TargetComponent.
1260      */
1261     RefPtr<LongPressRecognizer> longPressRecognizerPtr = AceType::MakeRefPtr<LongPressRecognizer>(LONG_PRESS_DURATION,
1262         FINGER_NUMBER, false);
1263     longPressRecognizerPtr->DeadlineTimer(1, true);
1264     ASSERT_NE(longPressRecognizerPtr, nullptr);
1265 }
1266 } // namespace OHOS::Ace::NG