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 SwipeRecognizerTestNg : public GesturesCommonTestNg {
22 public:
23     static void SetUpTestSuite();
24     static void TearDownTestSuite();
25 };
26 
SetUpTestSuite()27 void SwipeRecognizerTestNg::SetUpTestSuite()
28 {
29     MockPipelineContext::SetUp();
30 }
31 
TearDownTestSuite()32 void SwipeRecognizerTestNg::TearDownTestSuite()
33 {
34     MockPipelineContext::TearDown();
35 }
36 
37 /**
38  * @tc.name: SwipeRecognizerTest001
39  * @tc.desc: Test SwipeRecognizer function: OnAccepted OnRejected
40  * @tc.type: FUNC
41  */
42 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest001, TestSize.Level1)
43 {
44     /**
45      * @tc.steps: step1. create SwipeRecognizer.
46      */
47     SwipeDirection swipeDirection;
48     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
49 
50     /**
51      * @tc.steps: step2. call OnAccepted function and compare result.
52      * @tc.expected: step2. result equals.
53      */
54     swipeRecognizer.OnAccepted();
55     EXPECT_EQ(swipeRecognizer.refereeState_, RefereeState::SUCCEED);
56 
57     /**
58      * @tc.steps: step3. call OnRejected function and compare result.
59      * @tc.expected: step3. result equals.
60      */
61     swipeRecognizer.OnRejected();
62     EXPECT_EQ(swipeRecognizer.refereeState_, RefereeState::FAIL);
63 }
64 
65 /**
66  * @tc.name: SwipeRecognizerTest002
67  * @tc.desc: Test SwipeRecognizer function: HandleTouchDown
68  * @tc.type: FUNC
69  */
70 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest002, TestSize.Level1)
71 {
72     /**
73      * @tc.steps: step1. create SwipeRecognizer.
74      */
75     SwipeDirection swipeDirection;
76     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
77 
78     /**
79      * @tc.steps: step2. call HandleTouchDown function
80      * @tc.expected: step2. result equals.
81      */
82     TouchEvent touchEvent;
83     swipeRecognizer.fingers_ = 1;
84     swipeRecognizer.HandleTouchDownEvent(touchEvent);
85     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
86     EXPECT_EQ(swipeRecognizer.refereeState_, RefereeState::DETECTING);
87 
88     AxisEvent axisEvent;
89     swipeRecognizer.HandleTouchDownEvent(axisEvent);
90     EXPECT_EQ(swipeRecognizer.axisOffset_.GetX(), 0.0);
91     EXPECT_EQ(swipeRecognizer.axisOffset_.GetY(), 0.0);
92     EXPECT_EQ(swipeRecognizer.refereeState_, RefereeState::DETECTING);
93 }
94 
95 /**
96  * @tc.name: SwipeRecognizerTest003
97  * @tc.desc: Test SwipeRecognizer function: HandleTouchUp
98  * @tc.type: FUNC
99  */
100 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest003, TestSize.Level1)
101 {
102     /**
103      * @tc.steps: step1. create SwipeRecognizer.
104      */
105     SwipeDirection swipeDirection;
106     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
107 
108     /**
109      * @tc.steps: step2. call HandleTouchUp function
110      * @tc.expected: step2. result equals.
111      */
112     TouchEvent touchEvent;
113     swipeRecognizer.refereeState_ = RefereeState::FAIL;
114     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
115     swipeRecognizer.HandleTouchUpEvent(touchEvent);
116     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), touchEvent.x);
117     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), touchEvent.y);
118     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
119 
120     AxisEvent axisEvent;
121     swipeRecognizer.refereeState_ = RefereeState::FAIL;
122     swipeRecognizer.HandleTouchUpEvent(touchEvent);
123     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), axisEvent.x);
124     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), axisEvent.y);
125 }
126 
127 /**
128  * @tc.name: SwipeRecognizerHandleTouchUpEventTest001
129  * @tc.desc: Test SwipeRecognizer function: HandleTouchUpEvent
130  * @tc.type: FUNC
131  */
132 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchUpEventTest001, TestSize.Level1)
133 {
134     /**
135      * @tc.steps: step1. create SwipeRecognizer.
136      */
137     SwipeDirection swipeDirection;
138     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
139 
140     /**
141      * @tc.steps: step2. call HandleTouchUpEvent function
142      * @tc.expected: step2. result equals.
143      */
144     TouchEvent touchEvent;
145     swipeRecognizer.refereeState_ = RefereeState::FAIL;
146     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
147     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
148     swipeRecognizer.HandleTouchUpEvent(touchEvent);
149     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), touchEvent.x);
150     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), touchEvent.y);
151     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
152 
153     swipeRecognizer.refereeState_ = RefereeState::FAIL;
154     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
155     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
156     swipeRecognizer.HandleTouchUpEvent(touchEvent);
157     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), touchEvent.x);
158     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), touchEvent.y);
159     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
160 }
161 
162 /**
163  * @tc.name: SwipeRecognizerHandleTouchUpEventTest002
164  * @tc.desc: Test SwipeRecognizer function: HandleTouchUp
165  * @tc.type: FUNC
166  */
167 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchUpEventTest002, TestSize.Level1)
168 {
169     /**
170      * @tc.steps: step1. create SwipeRecognizer.
171      */
172     SwipeDirection swipeDirection;
173     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
174 
175     /**
176      * @tc.steps: step2. call HandleTouchUp function
177      * @tc.expected: step2. result equals.
178      */
179     AxisEvent axisEvent;
180     swipeRecognizer.refereeState_ = RefereeState::FAIL;
181     swipeRecognizer.HandleTouchUpEvent(axisEvent);
182     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), axisEvent.x);
183     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), axisEvent.y);
184 
185     swipeRecognizer.refereeState_ = RefereeState::FAIL;
186     swipeRecognizer.HandleTouchUpEvent(axisEvent);
187     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), axisEvent.x);
188     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), axisEvent.y);
189 }
190 
191 /**
192  * @tc.name: SwipeRecognizerHandleTouchCancelEventTest001
193  * @tc.desc: Test SwipeRecognizer function: HandleTouchCancelEvent
194  * @tc.type: FUNC
195  */
196 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchCancelEventTest001, TestSize.Level1)
197 {
198     /**
199      * @tc.steps: step1. create SwipeRecognizer.
200      */
201     SwipeDirection swipeDirection;
202     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
203 
204     /**
205      * @tc.steps: step2. call HandleTouchUp function
206      * @tc.expected: step2. result equals.
207      */
208     AxisEvent axisEvent;
209     swipeRecognizer.refereeState_ = RefereeState::FAIL;
210     swipeRecognizer.HandleTouchCancelEvent(axisEvent);
211     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), axisEvent.x);
212     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), axisEvent.y);
213 }
214 
215 /**
216  * @tc.name: SwipeRecognizerSendCallbackMsgTest001
217  * @tc.desc: Test SwipeRecognizer function: SendCallbackMsg
218  * @tc.type: FUNC
219  */
220 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerSendCallbackMsgTest001, TestSize.Level1)
221 {
222     /**
223      * @tc.steps: step1. create SwipeRecognizer.
224      */
225     SwipeDirection swipeDirection;
226     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
227 
228     /**
229      * @tc.steps: step2. call SendCallbackMsg function and compare result.
230      * @tc.steps: case1: onAction is no, *onAction is no
231      * @tc.expected: step2. result equals.
232      */
233     std::unique_ptr<GestureEventFunc> onAction;
234     swipeRecognizer.SendCallbackMsg(onAction);
235     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 0);
236 
237     /**
238      * @tc.steps: step2. call SendCallbackMsg function and compare result.
239      * @tc.steps: case2: onAction is yes, *onAction is no
240      * @tc.expected: step2. result equals.
241      */
242     onAction = std::make_unique<GestureEventFunc>();
243     swipeRecognizer.SendCallbackMsg(onAction);
244     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 0);
245 
246     /**
247      * @tc.steps: step2. call SendCallbackMsg function and compare result.
248      * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty
249      * @tc.expected: step2. result equals.
250      */
__anon1a9f5a790102(GestureEvent) 251     onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
252     swipeRecognizer.SendCallbackMsg(onAction);
253     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 0);
254 
255     /**
256      * @tc.steps: step2. call SendCallbackMsg function and compare result.
257      * @tc.steps: case4: touchEvent is not empty, have no X and Y
258      * @tc.expected: step2. result equals.
259      */
260     TouchEvent touchEvent;
261     swipeRecognizer.touchPoints_[touchEvent.id] = touchEvent;
262     swipeRecognizer.SendCallbackMsg(onAction);
263     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 1);
264 
265     /**
266      * @tc.steps: step2. call SendCallbackMsg function and compare result.
267      * @tc.steps: case4: touchEvent is not empty, have no X and Y
268      * @tc.expected: step2. result equals.
269      */
270     touchEvent.tiltX = 0.0f;
271     touchEvent.tiltY = 0.0f;
272     swipeRecognizer.touchPoints_[touchEvent.id] = touchEvent;
273     swipeRecognizer.SendCallbackMsg(onAction);
274     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 1);
275 }
276 
277 /**
278  * @tc.name: SwipeRecognizerSendCallbackMsgTest002
279  * @tc.desc: Test SwipeRecognizer function: SendCallbackMsg
280  * @tc.type: FUNC
281  */
282 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerSendCallbackMsgTest002, TestSize.Level1)
283 {
284     /**
285      * @tc.steps: step1. create SwipeRecognizer.
286      */
287     SwipeDirection swipeDirection;
288     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
289     std::unique_ptr<GestureEventFunc> onAction;
290 
291     /**
292      * @tc.steps: step2. call SendCallbackMsg function and compare result.
293      * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty
294      * @tc.expected: step2. result equals.
295      */
__anon1a9f5a790202(GestureEvent) 296     onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
297     swipeRecognizer.deviceType_ = SourceType::MOUSE;
298     swipeRecognizer.SendCallbackMsg(onAction);
299     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 0);
300 
301     /**
302      * @tc.steps: step2. call SendCallbackMsg function and compare result.
303      * @tc.steps: case4: touchEvent is not empty, have no X and Y
304      * @tc.expected: step2. result equals.
305      */
306     TouchEvent touchEvent;
307     swipeRecognizer.prevAngle_ = std::make_optional(VERTICAL_ANGLE);
308     swipeRecognizer.touchPoints_[touchEvent.id] = touchEvent;
309     swipeRecognizer.SendCallbackMsg(onAction);
310     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 1);
311 
312     /**
313      * @tc.steps: step2. call SendCallbackMsg function and compare result.
314      * @tc.steps: case4: touchEvent is not empty, have no X and Y
315      * @tc.expected: step2. result equals.
316      */
317     touchEvent.tiltX = 0.0f;
318     touchEvent.tiltY = 0.0f;
319     TouchEvent touchEvent1;
320     swipeRecognizer.deviceType_ = SourceType::MOUSE;
321     swipeRecognizer.lastTouchEvent_ = touchEvent1;
322     swipeRecognizer.lastTouchEvent_.tiltX = std::make_optional(0.0f);
323     swipeRecognizer.lastTouchEvent_.tiltY = std::make_optional(0.0f);
324     swipeRecognizer.touchPoints_[touchEvent.id] = touchEvent;
325     swipeRecognizer.SendCallbackMsg(onAction);
326     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 1);
327 }
328 
329 /**
330  * @tc.name: SwipeRecognizerHandleTouchMoveEventTest001
331  * @tc.desc: Test SwipeRecognizer function: HandleTouchMove
332  * @tc.type: FUNC
333  */
334 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchMoveEventTest001, TestSize.Level1)
335 {
336     /**
337      * @tc.steps: step1. create SwipeRecognizer.
338      */
339     SwipeDirection swipeDirection;
340     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
341 
342     /**
343      * @tc.steps: step2. call HandleTouchMove function
344      * @tc.expected: step2. result equals.
345      */
346     AxisEvent axisEvent;
347     swipeRecognizer.refereeState_ = RefereeState::FAIL;
348     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
349     swipeRecognizer.HandleTouchMoveEvent(axisEvent);
350     EXPECT_EQ(swipeRecognizer.axisOffset_.GetX(), 0);
351     EXPECT_EQ(swipeRecognizer.axisOffset_.GetY(), 0);
352 }
353 
354 /**
355  * @tc.name: SwipeRecognizerTest004
356  * @tc.desc: Test SwipeRecognizer function: HandleTouchMove
357  * @tc.type: FUNC
358  */
359 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest004, TestSize.Level1)
360 {
361     /**
362      * @tc.steps: step1. create SwipeRecognizer.
363      */
364     SwipeDirection swipeDirection;
365     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
366 
367     /**
368      * @tc.steps: step2. call HandleTouchMove function
369      * @tc.expected: step2. result equals.
370      */
371     TouchEvent touchEvent;
372     touchEvent.x = 0;
373     touchEvent.y = 1;
374     swipeRecognizer.refereeState_ = RefereeState::FAIL;
375     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
376     swipeRecognizer.HandleTouchMoveEvent(touchEvent);
377     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), 0);
378     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), 0);
379     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
380 
381     swipeRecognizer.refereeState_ = RefereeState::DETECTING;
382     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
383     swipeRecognizer.HandleTouchMoveEvent(touchEvent);
384     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), touchEvent.x);
385     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), 0);
386     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
387 
388     AxisEvent axisEvent;
389     swipeRecognizer.refereeState_ = RefereeState::DETECTING;
390     swipeRecognizer.HandleTouchMoveEvent(axisEvent);
391     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), axisEvent.x);
392     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), axisEvent.y);
393     EXPECT_EQ(swipeRecognizer.axisOffset_.GetX(), 0);
394     EXPECT_EQ(swipeRecognizer.axisOffset_.GetY(), 0);
395 }
396 
397 /**
398  * @tc.name: SwipeRecognizerTest005
399  * @tc.desc: Test SwipeRecognizer function: CheckAngle
400  * @tc.type: FUNC
401  */
402 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest005, TestSize.Level1)
403 {
404     /**
405      * @tc.steps: step1. create SwipeRecognizer.
406      */
407     SwipeDirection swipeDirection;
408     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
409 
410     /**
411      * @tc.steps: step2. call CheckAngle function
412      * @tc.steps: case1: prevAngle has value, prevAngle - angle > 45
413      * @tc.expected: step2. result equals.
414      */
415     swipeRecognizer.prevAngle_ = std::make_optional(VERTICAL_ANGLE);
416     auto result = swipeRecognizer.CheckAngle(0);
417     EXPECT_EQ(result, false);
418 
419     /**
420      * @tc.steps: step2. call CheckAngle function
421      * @tc.steps: case2: prevAngle has value, prevAngle - angle < 45
422      * @tc.expected: step2. result equals.
423      */
424     swipeRecognizer.prevAngle_ = std::make_optional(VERTICAL_ANGLE);
425     result = swipeRecognizer.CheckAngle(VERTICAL_ANGLE);
426     EXPECT_EQ(result, true);
427 
428     /**
429      * @tc.steps: step2. call CheckAngle function
430      * @tc.steps: case2: prevAngle has no value, direction is HORIZONTAL, angle > 45
431      * @tc.expected: step2. result equals.
432      */
433     swipeRecognizer.prevAngle_ = std::optional<double>();
434     swipeRecognizer.direction_.type = SwipeDirection::HORIZONTAL;
435     result = swipeRecognizer.CheckAngle(VERTICAL_ANGLE);
436     EXPECT_EQ(result, false);
437 
438     /**
439      * @tc.steps: step2. call CheckAngle function
440      * @tc.steps: case3: prevAngle has no value, direction is HORIZONTAL, angle < 45
441      * @tc.expected: step2. result equals.
442      */
443     swipeRecognizer.prevAngle_ = std::optional<double>();
444     swipeRecognizer.direction_.type = SwipeDirection::HORIZONTAL;
445     result = swipeRecognizer.CheckAngle(0);
446     EXPECT_EQ(result, true);
447 
448     /**
449      * @tc.steps: step2. call CheckAngle function
450      * @tc.steps: case4: prevAngle has no value, direction is VERTICAL, angle > 135
451      * @tc.expected: step2. result equals.
452      */
453     swipeRecognizer.prevAngle_ = std::make_optional(VERTICAL_ANGLE);
454     swipeRecognizer.direction_.type = SwipeDirection::VERTICAL;
455     result = swipeRecognizer.CheckAngle(HORIZONTAL_ANGLE);
456     EXPECT_EQ(result, false);
457 
458     /**
459      * @tc.steps: step2. call CheckAngle function
460      * @tc.steps: case5: prevAngle has no value, direction is VERTICAL, angle < 135
461      * @tc.expected: step2. result equals.
462      */
463     swipeRecognizer.prevAngle_ = std::make_optional(VERTICAL_ANGLE);
464     swipeRecognizer.direction_.type = SwipeDirection::VERTICAL;
465     result = swipeRecognizer.CheckAngle(VERTICAL_ANGLE);
466     EXPECT_EQ(result, true);
467 }
468 
469 /**
470  * @tc.name: SwipeRecognizerHandleTouchMoveEventTest002
471  * @tc.desc: Test SwipeRecognizer function: HandleTouchMove
472  * @tc.type: FUNC
473  */
474 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchMoveEventTest002, TestSize.Level1)
475 {
476     /**
477      * @tc.steps: step1. create SwipeRecognizer.
478      */
479     SwipeDirection swipeDirection;
480     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
481 
482     /**
483      * @tc.steps: step2. call HandleTouchMove function
484      * @tc.expected: step2. result equals.
485      */
486     TouchEvent touchEvent;
487     touchEvent.x = 0;
488     touchEvent.y = 1;
489     swipeRecognizer.refereeState_ = RefereeState::FAIL;
490     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
491     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
492     swipeRecognizer.HandleTouchMoveEvent(touchEvent);
493     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), 0);
494     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), 0);
495     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
496 
497     swipeRecognizer.refereeState_ = RefereeState::DETECTING;
498     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
499     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
500     swipeRecognizer.HandleTouchMoveEvent(touchEvent);
501     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
502 
503     AxisEvent axisEvent;
504     swipeRecognizer.refereeState_ = RefereeState::FAIL;
505     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
506     swipeRecognizer.HandleTouchMoveEvent(axisEvent);
507     EXPECT_EQ(swipeRecognizer.axisOffset_.GetX(), 0);
508     EXPECT_EQ(swipeRecognizer.axisOffset_.GetY(), 0);
509 }
510 
511 /**
512  * @tc.name: SwipeRecognizerHandleTouchMoveEventTest003
513  * @tc.desc: Test SwipeRecognizer function: HandleTouchMove
514  * @tc.type: FUNC
515  */
516 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchMoveEventTest003, TestSize.Level1)
517 {
518     /**
519      * @tc.steps: step1. create SwipeRecognizer.
520      */
521     SwipeDirection swipeDirection;
522     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
523 
524     /**
525      * @tc.steps: step2. call HandleTouchMove function
526      * @tc.expected: step2. result equals.
527      */
528     TouchEvent touchEvent;
529     touchEvent.x = 0;
530     touchEvent.y = -1;
531     swipeRecognizer.refereeState_ = RefereeState::FAIL;
532     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
533     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
534     swipeRecognizer.HandleTouchMoveEvent(touchEvent);
535     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), 0);
536     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), 0);
537     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
538 
539     swipeRecognizer.refereeState_ = RefereeState::DETECTING;
540     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
541     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
542     swipeRecognizer.HandleTouchMoveEvent(touchEvent);
543     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
544 
545     AxisEvent axisEvent;
546     swipeRecognizer.refereeState_ = RefereeState::FAIL;
547     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
548     swipeRecognizer.HandleTouchMoveEvent(axisEvent);
549     EXPECT_EQ(swipeRecognizer.axisOffset_.GetX(), 0);
550     EXPECT_EQ(swipeRecognizer.axisOffset_.GetY(), 0);
551 }
552 
553 /**
554  * @tc.name: SwipeRecognizerHandleTouchMoveEventTest004
555  * @tc.desc: Test SwipeRecognizer function: HandleTouchMove
556  * @tc.type: FUNC
557  */
558 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchMoveEventTest004, TestSize.Level1)
559 {
560     /**
561      * @tc.steps: step1. create SwipeRecognizer.
562      */
563     SwipeDirection swipeDirection;
564     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
565 
566     /**
567      * @tc.steps: step2. call HandleTouchMove function
568      * @tc.expected: step2. result equals.
569      */
570     TouchEvent touchEvent;
571     touchEvent.x = -1;
572     touchEvent.y = -1;
573     swipeRecognizer.refereeState_ = RefereeState::FAIL;
574     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
575     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
576     swipeRecognizer.HandleTouchMoveEvent(touchEvent);
577     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
578 
579     swipeRecognizer.refereeState_ = RefereeState::DETECTING;
580     swipeRecognizer.downEvents_[touchEvent.id] = touchEvent;
581     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
582     swipeRecognizer.HandleTouchMoveEvent(touchEvent);
583     EXPECT_EQ(swipeRecognizer.lastTouchEvent_.id, touchEvent.id);
584 
585     AxisEvent axisEvent;
586     swipeRecognizer.refereeState_ = RefereeState::FAIL;
587     swipeRecognizer.currentFingers_ = swipeRecognizer.fingers_;
588     swipeRecognizer.HandleTouchMoveEvent(axisEvent);
589     EXPECT_EQ(swipeRecognizer.axisOffset_.GetX(), 0);
590     EXPECT_EQ(swipeRecognizer.axisOffset_.GetY(), 0);
591 }
592 
593 /**
594  * @tc.name: SwipeRecognizerTest006
595  * @tc.desc: Test SwipeRecognizer function: OnResetStatus
596  * @tc.type: FUNC
597  */
598 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest006, TestSize.Level1)
599 {
600     /**
601      * @tc.steps: step1. create SwipeRecognizer.
602      */
603     SwipeDirection swipeDirection;
604     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
605 
606     /**
607      * @tc.steps: step2. call OnResetStatus function
608      * @tc.expected: step2. result equals.
609      */
610     swipeRecognizer.OnResetStatus();
611     EXPECT_EQ(swipeRecognizer.axisOffset_.GetX(), 0.0);
612     EXPECT_EQ(swipeRecognizer.axisOffset_.GetY(), 0.0);
613     EXPECT_EQ(swipeRecognizer.resultSpeed_, 0.0);
614     EXPECT_EQ(swipeRecognizer.globalPoint_.GetX(), 0.0);
615     EXPECT_EQ(swipeRecognizer.globalPoint_.GetY(), 0.0);
616 }
617 
618 /**
619  * @tc.name: SwipeRecognizerTest007
620  * @tc.desc: Test SwipeRecognizer function: ReconcileFrom
621  * @tc.type: FUNC
622  */
623 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest007, TestSize.Level1)
624 {
625     /**
626      * @tc.steps: step1. create SwipeRecognizer.
627      */
628     SwipeDirection swipeDirection;
629     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
630     RefPtr<SwipeRecognizer> swipeRecognizerPtr =
631         AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
632 
633     /**
634      * @tc.steps: step2. call ReconcileFrom function
635      * @tc.steps: case1: input is nullptr
636      * @tc.expected: step2. result equals.
637      */
638     auto result = swipeRecognizer.ReconcileFrom(nullptr);
639     EXPECT_EQ(result, false);
640 
641     /**
642      * @tc.steps: step2. call ReconcileFrom function
643      * @tc.steps: case2: input is same
644      * @tc.expected: step2. result equals.
645      */
646     result = swipeRecognizer.ReconcileFrom(swipeRecognizerPtr);
647     EXPECT_EQ(result, true);
648 
649     /**
650      * @tc.steps: step2. call ReconcileFrom function
651      * @tc.steps: case3: curr->fingers != fingers
652      * @tc.expected: step2. result equals.
653      */
654     swipeRecognizer.fingers_ = swipeRecognizerPtr->fingers_ + 1;
655     result = swipeRecognizer.ReconcileFrom(swipeRecognizerPtr);
656     EXPECT_EQ(result, false);
657 
658     /**
659      * @tc.steps: step2. call ReconcileFrom function
660      * @tc.steps: case4: curr->fingers = fingers, direction type not same
661      * @tc.expected: step2. result equals.
662      */
663     swipeRecognizer.fingers_ = swipeRecognizerPtr->fingers_;
664     swipeRecognizer.direction_.type = SwipeDirection::HORIZONTAL;
665     result = swipeRecognizer.ReconcileFrom(swipeRecognizerPtr);
666     EXPECT_EQ(result, false);
667 
668     /**
669      * @tc.steps: step2. call ReconcileFrom function
670      * @tc.steps: case5:direction type is same, speed is not same
671      * @tc.expected: step2. result equals.
672      */
673     swipeRecognizer.fingers_ = swipeRecognizerPtr->fingers_;
674     swipeRecognizer.direction_.type = swipeRecognizerPtr->direction_.type;
675     swipeRecognizer.speed_ = 1;
676     result = swipeRecognizer.ReconcileFrom(swipeRecognizerPtr);
677     EXPECT_EQ(result, false);
678 }
679 
680 /**
681  * @tc.name: SwipeRecognizerTest008
682  * @tc.desc: Test SwipeRecognizer function: HandleTouchCancelEvent
683  * @tc.type: FUNC
684  */
685 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest008, TestSize.Level1)
686 {
687     /**
688      * @tc.steps: step1. create SwipeRecognizer.
689      */
690     SwipeDirection swipeDirection;
691     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
692 
693     /**
694      * @tc.steps: step2. call HandleTouchCancelEvent function
695      * @tc.expected: step2. result equals.
696      */
697     swipeRecognizer.refereeState_ = RefereeState::SUCCEED;
698     TouchEvent touchEvent;
699     swipeRecognizer.HandleTouchCancelEvent(touchEvent);
700     EXPECT_EQ(swipeRecognizer.refereeState_, RefereeState::SUCCEED);
701 }
702 
703 /**
704  * @tc.name: SwipeRecognizerTest009
705  * @tc.desc: Test SwipeRecognizer function: SendCallbackMsg
706  * @tc.type: FUNC
707  */
708 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest009, TestSize.Level1)
709 {
710     /**
711      * @tc.steps: step1. create SwipeRecognizer.
712      */
713     SwipeDirection swipeDirection;
714     SwipeRecognizer swipeRecognizer = SwipeRecognizer(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
715 
716     /**
717      * @tc.steps: step2. call SendCallbackMsg function and compare result.
718      * @tc.steps: case1: callback is null
719      * @tc.expected: step2. result equals.
720      */
721     swipeRecognizer.SendCallbackMsg(nullptr);
722     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 0);
723 
724     /**
725      * @tc.steps: step2. call SendCallbackMsg function and compare result.
726      * @tc.steps: case2: callback is ptr, have no tiltX and tileY
727      * @tc.expected: step2. result equals.
728      */
729     std::unique_ptr<GestureEventFunc> onAction;
730     TouchEvent touchEvent1;
731     swipeRecognizer.deviceType_ = SourceType::MOUSE;
732     swipeRecognizer.lastTouchEvent_ = touchEvent1;
733     swipeRecognizer.SendCallbackMsg(onAction);
734     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 0);
735 
736     /**
737      * @tc.steps: step2. call SendCallbackMsg function and compare result.
738      * @tc.steps: case3: callback is ptr, have tiltX and no tileY
739      * @tc.expected: step2. result equals.
740      */
741     TouchEvent touchEvent2;
742     touchEvent2.tiltX = 0;
743     swipeRecognizer.deviceType_ = SourceType::TOUCH;
744     swipeRecognizer.lastTouchEvent_ = touchEvent2;
745     swipeRecognizer.SendCallbackMsg(onAction);
746     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 0);
747 
748     /**
749      * @tc.steps: step2. call SendCallbackMsg function and compare result.
750      * @tc.steps: case4: callback is ptr, have tiltX and tileY
751      * @tc.expected: step2. result equals.
752      */
753     TouchEvent touchEvent3;
754     touchEvent3.tiltX = 0;
755     touchEvent3.tiltY = 0;
756     swipeRecognizer.deviceType_ = SourceType::TOUCH;
757     swipeRecognizer.lastTouchEvent_ = touchEvent3;
758     swipeRecognizer.prevAngle_ = std::make_optional(0);
759     swipeRecognizer.SendCallbackMsg(onAction);
760     EXPECT_EQ(swipeRecognizer.touchPoints_.size(), 0);
761 }
762 
763 /**
764  * @tc.name: SwipeRecognizerTest010
765  * @tc.desc: Test SwipeRecognizer function: HandleTouchDownEvent
766  * @tc.type: FUNC
767  */
768 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest010, TestSize.Level1)
769 {
770     /**
771      * @tc.steps: step1. create SwipeRecognizer.
772      */
773     SwipeDirection swipeDirection;
774     RefPtr<SwipeRecognizer> swipeRecognizer = AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER,
775         swipeDirection, SWIPE_SPEED);
776     ASSERT_NE(swipeRecognizer, nullptr);
777     /**
778      * @tc.steps: step3. test with HandleTouchDownEvent(AxisEvent).
779      * @tc.expect: swipeRecognizer->lastAxisEvent_ is equal to axisEvent
780      * @tc.expect: swipeRecognizer->touchPoints_[axisEvent.id].originalId is equal to axisEvent.originalId
781      * @tc.expect: swipeRecognizer->touchPoints_[axisEvent.id].screenX is equal to axisEvent.screenX
782      * @tc.expect: swipeRecognizer->touchPoints_[axisEvent.id].screenY is equal to axisEvent.screenY
783      */
784     AxisEvent axisEvent;
785     axisEvent.id = TEST_EVENT_ID;
786     axisEvent.originalId = TEST_EVENT_ID;
787 
788     swipeRecognizer->refereeState_ = RefereeState::SUCCEED;
789     swipeRecognizer->fingers_ = FINGER_NUMBER;
790     swipeRecognizer->direction_.type = SwipeDirection::HORIZONTAL;
791     swipeRecognizer->HandleTouchDownEvent(axisEvent);
792     EXPECT_EQ(swipeRecognizer->lastAxisEvent_.id, axisEvent.id);
793     EXPECT_EQ(swipeRecognizer->touchPoints_[axisEvent.id].originalId, axisEvent.originalId);
794     EXPECT_EQ(swipeRecognizer->touchPoints_[axisEvent.id].screenX, axisEvent.screenX);
795     EXPECT_EQ(swipeRecognizer->touchPoints_[axisEvent.id].screenY, axisEvent.screenY);
796 }
797 
798 /**
799  * @tc.name: SwipeRecognizerTest011
800  * @tc.desc: Test SwipeRecognizer function: HandleTouchUpEvent
801  * @tc.type: FUNC
802  */
803 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerTest011, TestSize.Level1)
804 {
805     /**
806      * @tc.steps: step1. create SwipeRecognizer.
807      */
808     SwipeDirection swipeDirection;
809     RefPtr<SwipeRecognizer> swipeRecognizer = AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER,
810         swipeDirection, SWIPE_SPEED);
811     ASSERT_NE(swipeRecognizer, nullptr);
812 
813     /**
814      * @tc.steps: step3. test with HandleTouchUpEvent(AxisEvent).
815      * @tc.expect: swipeRecognizer->lastAxisEvent_ is equal to axisEvent
816      */
817     AxisEvent axisEvent;
818     axisEvent.id = TEST_EVENT_ID;
819     swipeRecognizer->refereeState_ = RefereeState::SUCCEED;
820     swipeRecognizer->HandleTouchUpEvent(axisEvent);
821     EXPECT_EQ(swipeRecognizer->lastAxisEvent_.id, axisEvent.id);
822 }
823 
824 /**
825  * @tc.name: SwipeGestureTest001
826  * @tc.desc: Test SwipeGesture CreateRecognizer function
827  */
828 HWTEST_F(SwipeRecognizerTestNg, SwipeGestureTest001, TestSize.Level1)
829 {
830     /**
831      * @tc.steps: step1. create SwipeGesture.
832      */
833     int32_t fingersNum = DEFAULT_PAN_FINGER;
834     double speedNum = DEFAULT_SLIDE_SPEED;
835     SwipeDirection slideDirection;
836     SwipeGestureModelNG swipeGestureModelNG;
837     swipeGestureModelNG.Create(fingersNum, slideDirection, speedNum);
838 
839     RefPtr<GestureProcessor> gestureProcessor;
840     gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
841     auto swipeGestureNG = AceType::DynamicCast<NG::SwipeRecognizer>(gestureProcessor->TopGestureNG());
842 
843     SwipeGesture swipeGesture = SwipeGesture(fingersNum, slideDirection, speedNum);
844     EXPECT_EQ(swipeGesture.speed_, DEFAULT_SLIDE_SPEED);
845 
846     /**
847      * @tc.steps: step2. call CreateRecognizer function and compare result
848      * @tc.steps: case1: onActionId, onActionEndId, onActionCancelId not existed
849      */
850     auto swipeRecognizer = AceType::DynamicCast<SwipeRecognizer>(swipeGesture.CreateRecognizer());
851     EXPECT_EQ(swipeGesture.speed_, DEFAULT_SLIDE_SPEED);
852 
853     /**
854      * @tc.steps: step2. call CreateRecognizer function and compare result
855      * @tc.steps: case2: onActionId, onActionEndId, onActionCancelId existed
856      */
857     std::unique_ptr<GestureEventFunc> onActionId;
858     std::unique_ptr<GestureEventFunc> onActionEndId;
859     std::unique_ptr<GestureEventNoParameter> onActionCancelId;
860     swipeGesture.onActionId_ = std::move(onActionId);
861     swipeGesture.onActionEndId_ = std::move(onActionEndId);
862     swipeGesture.onActionCancelId_ = std::move(onActionCancelId);
863     swipeRecognizer = AceType::DynamicCast<SwipeRecognizer>(swipeGesture.CreateRecognizer());
864     EXPECT_EQ(swipeGesture.speed_, DEFAULT_SLIDE_SPEED);
865 }
866 
867 /**
868  * @tc.name: SwipeGestureCreateRecognizerTest001
869  * @tc.desc: Test SwipeGesture CreateRecognizer function
870  */
871 HWTEST_F(SwipeRecognizerTestNg, SwipeGestureCreateRecognizerTest001, TestSize.Level1)
872 {
873     /**
874      * @tc.steps: step1. create SwipeGesture.
875      */
876     int32_t fingersNum = DEFAULT_PAN_FINGER;
877     double speedNum = DEFAULT_SLIDE_SPEED;
878     SwipeDirection slideDirection;
879     SwipeGestureModelNG swipeGestureModelNG;
880     swipeGestureModelNG.Create(fingersNum, slideDirection, speedNum);
881 
882     RefPtr<GestureProcessor> gestureProcessor;
883     gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
884     auto swipeGestureNG = AceType::DynamicCast<NG::SwipeRecognizer>(gestureProcessor->TopGestureNG());
885 
886     SwipeGesture swipeGesture = SwipeGesture(fingersNum, slideDirection, speedNum);
887     EXPECT_EQ(swipeGesture.speed_, DEFAULT_SLIDE_SPEED);
888 
889     /**
890      * @tc.steps: step2. call CreateRecognizer function and compare result
891      * @tc.steps: case1: onActionId, onActionEndId, onActionCancelId not existed
892      */
893     auto swipeRecognizer = AceType::DynamicCast<SwipeRecognizer>(swipeGesture.CreateRecognizer());
894     EXPECT_EQ(swipeGesture.speed_, DEFAULT_SLIDE_SPEED);
895 
896     /**
897      * @tc.steps: step2. call CreateRecognizer function and compare result
898      * @tc.steps: case2: onActionId, onActionEndId, onActionCancelId existed
899      */
900     std::unique_ptr<GestureEventFunc> onActionId;
901     std::unique_ptr<GestureEventFunc> onActionEndId;
902     std::unique_ptr<GestureEventNoParameter> onActionCancelId;
903     swipeGesture.onActionId_ = std::move(onActionId);
904     swipeGesture.onActionEndId_ = std::move(onActionEndId);
905     swipeGesture.onActionCancelId_ = std::move(onActionCancelId);
__anon1a9f5a790302(GestureEvent& info) 906     auto onActionStart = [](GestureEvent& info) { return true; };
907     swipeGesture.SetOnActionId(onActionStart);
908     swipeRecognizer = AceType::DynamicCast<SwipeRecognizer>(swipeGesture.CreateRecognizer());
909     EXPECT_EQ(swipeGesture.speed_, DEFAULT_SLIDE_SPEED);
910 }
911 
912 /**
913  * @tc.name: SwipeRecognizerHandleTouchDownEventTest001
914  * @tc.desc: Test SwipeRecognizer function: HandleTouchDownEvent
915  * @tc.type: FUNC
916  */
917 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchDownEventTest001, TestSize.Level1)
918 {
919     /**
920      * @tc.steps: step1. create LongPressRecognizer.
921      */
922     SwipeDirection swipeDirection;
923     RefPtr<SwipeRecognizer> swipeRecognizer = AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER,
924         swipeDirection, SWIPE_SPEED);
925     TouchEvent touchEvent;
926     touchEvent.x = 100.0;
927     touchEvent.y = 100.0;
928     touchEvent.sourceType = SourceType::MOUSE;
929 
930     swipeRecognizer->refereeState_ = RefereeState::DETECTING;
931     swipeRecognizer->fingers_ = 11;
932     swipeRecognizer->direction_.type = SwipeDirection::NONE;
933     swipeRecognizer->HandleTouchDownEvent(touchEvent);
934     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
935 
936     swipeRecognizer->refereeState_ = RefereeState::DETECTING;
937     swipeRecognizer->fingers_ = FINGER_NUMBER;
938     swipeRecognizer->direction_.type = SwipeDirection::NONE;
939     swipeRecognizer->HandleTouchDownEvent(touchEvent);
940     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
941 }
942 
943 /**
944  * @tc.name: SwipeRecognizerHandleTouchDownEventTest002
945  * @tc.desc: Test SwipeRecognizer function: HandleTouchDownEvent
946  * @tc.type: FUNC
947  */
948 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchDownEventTest002, TestSize.Level1)
949 {
950     /**
951      * @tc.steps: step1. create SwipeRecognizer.
952      */
953     SwipeDirection swipeDirection;
954     RefPtr<SwipeRecognizer> swipeRecognizer = AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER,
955         swipeDirection, SWIPE_SPEED);
956     TouchEvent touchEvent;
957     touchEvent.x = 100.0;
958     touchEvent.y = 100.0;
959     touchEvent.sourceType = SourceType::MOUSE;
960 
961     AxisEvent axisEvent;
962     swipeRecognizer->refereeState_ = RefereeState::DETECTING;
963     swipeRecognizer->fingers_ = 11;
964     swipeRecognizer->direction_.type = SwipeDirection::NONE;
965     swipeRecognizer->HandleTouchDownEvent(axisEvent);
966     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
967 
968     swipeRecognizer->refereeState_ = RefereeState::DETECTING;
969     swipeRecognizer->fingers_ = FINGER_NUMBER;
970     swipeRecognizer->direction_.type = SwipeDirection::NONE;
971     swipeRecognizer->HandleTouchDownEvent(axisEvent);
972     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
973 }
974 
975 /**
976  * @tc.name: SwipeRecognizerHandleTouchUpEventTest003
977  * @tc.desc: Test SwipeRecognizer function: HandleTouchUpEvent
978  * @tc.type: FUNC
979  */
980 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchUpEventTest003, TestSize.Level1)
981 {
982     /**
983      * @tc.steps: step1. create SwipeRecognizer.
984      */
985     SwipeDirection swipeDirection;
986     RefPtr<SwipeRecognizer> swipeRecognizer = AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER,
987         swipeDirection, SWIPE_SPEED);
988     TouchEvent touchEvent;
989     touchEvent.x = 100.0;
990     touchEvent.y = 100.0;
991     touchEvent.sourceType = SourceType::MOUSE;
992 
993     swipeRecognizer->refereeState_ = RefereeState::SUCCEED;
994     swipeRecognizer->fingers_ = 11;
995     swipeRecognizer->direction_.type = SwipeDirection::NONE;
996     swipeRecognizer->HandleTouchDownEvent(touchEvent);
997     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
998 }
999 
1000 
1001 /**
1002  * @tc.name: SwipeRecognizerHandleTouchUpEventTest006
1003  * @tc.desc: Test SwipeRecognizer function: HandleTouchUpEvent
1004  * @tc.type: FUNC
1005  */
1006 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchUpEventTest006, TestSize.Level1)
1007 {
1008     /**
1009      * @tc.steps: step1. create SwipeRecognizer.
1010      */
1011     SwipeDirection swipeDirection;
1012     RefPtr<SwipeRecognizer> swipeRecognizer = AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER,
1013         swipeDirection, SWIPE_SPEED);
1014     TouchEvent touchEvent;
1015     touchEvent.x = 100.0;
1016     touchEvent.y = 100.0;
1017     touchEvent.sourceType = SourceType::MOUSE;
1018     swipeRecognizer->OnResetStatus();
1019     touchEvent.time = swipeRecognizer->touchDownTime_;
1020 
1021     swipeRecognizer->refereeState_ = RefereeState::SUCCEED;
1022     swipeRecognizer->HandleTouchUpEvent(touchEvent);
1023     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), touchEvent.x);
1024 
1025     swipeRecognizer->refereeState_ = RefereeState::DETECTING;
1026     swipeRecognizer->HandleTouchUpEvent(touchEvent);
1027     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), touchEvent.x);
1028 
1029     swipeRecognizer->refereeState_ = RefereeState::READY;
1030     swipeRecognizer->HandleTouchUpEvent(touchEvent);
1031     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), touchEvent.x);
1032 
1033     swipeRecognizer->refereeState_ = RefereeState::PENDING;
1034     swipeRecognizer->HandleTouchUpEvent(touchEvent);
1035     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), touchEvent.x);
1036 
1037     swipeRecognizer->refereeState_ = RefereeState::PENDING_BLOCKED;
1038     swipeRecognizer->HandleTouchUpEvent(touchEvent);
1039     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), touchEvent.x);
1040 
1041     swipeRecognizer->refereeState_ = RefereeState::SUCCEED_BLOCKED;
1042     swipeRecognizer->HandleTouchUpEvent(touchEvent);
1043     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), touchEvent.x);
1044 
1045     swipeRecognizer->refereeState_ = RefereeState::FAIL;
1046     swipeRecognizer->HandleTouchUpEvent(touchEvent);
1047     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), touchEvent.x);
1048 }
1049 
1050 /**
1051  * @tc.name: SwipeRecognizerHandleTouchUpEventTest005
1052  * @tc.desc: Test SwipeRecognizer function: HandleTouchUpEvent
1053  * @tc.type: FUNC
1054  */
1055 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchUpEventTest005, TestSize.Level1)
1056 {
1057     /**
1058      * @tc.steps: step1. create SwipeRecognizer.
1059      */
1060     SwipeDirection swipeDirection;
1061     RefPtr<SwipeRecognizer> swipeRecognizer = AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER,
1062         swipeDirection, SWIPE_SPEED);
1063     TouchEvent touchEvent;
1064     touchEvent.x = 100.0;
1065     touchEvent.y = 100.0;
1066     touchEvent.sourceType = SourceType::MOUSE;
1067 
1068     AxisEvent axisEvent;
1069     swipeRecognizer->refereeState_ = RefereeState::SUCCEED;
1070     swipeRecognizer->HandleTouchUpEvent(axisEvent);
1071     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1072 
1073     swipeRecognizer->refereeState_ = RefereeState::DETECTING;
1074     swipeRecognizer->HandleTouchUpEvent(axisEvent);
1075     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1076 
1077     swipeRecognizer->refereeState_ = RefereeState::READY;
1078     swipeRecognizer->HandleTouchUpEvent(axisEvent);
1079     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1080 
1081     swipeRecognizer->refereeState_ = RefereeState::PENDING;
1082     swipeRecognizer->HandleTouchUpEvent(axisEvent);
1083     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1084 
1085     swipeRecognizer->refereeState_ = RefereeState::PENDING_BLOCKED;
1086     swipeRecognizer->HandleTouchUpEvent(axisEvent);
1087     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1088 
1089     swipeRecognizer->refereeState_ = RefereeState::SUCCEED_BLOCKED;
1090     swipeRecognizer->HandleTouchUpEvent(axisEvent);
1091     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1092 
1093     swipeRecognizer->refereeState_ = RefereeState::FAIL;
1094     swipeRecognizer->HandleTouchUpEvent(axisEvent);
1095     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1096 }
1097 
1098 /**
1099  * @tc.name: SwipeRecognizerHandleTouchCancelEventTest005
1100  * @tc.desc: Test SwipeRecognizer function: HandleTouchCancelEvent
1101  * @tc.type: FUNC
1102  */
1103 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerHandleTouchCancelEventTest005, TestSize.Level1)
1104 {
1105     /**
1106      * @tc.steps: step1. create SwipeRecognizer.
1107      */
1108     SwipeDirection swipeDirection;
1109     RefPtr<SwipeRecognizer> swipeRecognizer = AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER,
1110         swipeDirection, SWIPE_SPEED);
1111     TouchEvent touchEvent;
1112     touchEvent.x = 100.0;
1113     touchEvent.y = 100.0;
1114     touchEvent.sourceType = SourceType::MOUSE;
1115 
1116     swipeRecognizer->refereeState_ = RefereeState::SUCCEED;
1117     swipeRecognizer->HandleTouchCancelEvent(touchEvent);
1118     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1119 
1120     swipeRecognizer->refereeState_ = RefereeState::DETECTING;
1121     swipeRecognizer->HandleTouchCancelEvent(touchEvent);
1122     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1123 
1124     swipeRecognizer->refereeState_ = RefereeState::READY;
1125     swipeRecognizer->HandleTouchCancelEvent(touchEvent);
1126     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1127 
1128     swipeRecognizer->refereeState_ = RefereeState::PENDING;
1129     swipeRecognizer->HandleTouchCancelEvent(touchEvent);
1130     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1131 
1132     swipeRecognizer->refereeState_ = RefereeState::PENDING_BLOCKED;
1133     swipeRecognizer->HandleTouchCancelEvent(touchEvent);
1134     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1135 
1136     swipeRecognizer->refereeState_ = RefereeState::SUCCEED_BLOCKED;
1137     swipeRecognizer->HandleTouchCancelEvent(touchEvent);
1138     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1139 
1140     swipeRecognizer->refereeState_ = RefereeState::FAIL;
1141     swipeRecognizer->HandleTouchCancelEvent(touchEvent);
1142     EXPECT_EQ(swipeRecognizer->globalPoint_.GetX(), 0);
1143 }
1144 
1145 /**
1146  * @tc.name: SwipeRecognizerPtrHandleTouchUpEventTest001
1147  * @tc.desc: Test SwipeRecognizer function: HandleTouchUpEvent
1148  * @tc.type: FUNC
1149  */
1150 HWTEST_F(SwipeRecognizerTestNg, SwipeRecognizerPtrHandleTouchUpEventTest001, TestSize.Level1)
1151 {
1152     /**
1153      * @tc.steps: step1. create and set Recognizer、TargetComponent.
1154      */
1155     SwipeDirection swipeDirection;
1156     RefPtr<SwipeRecognizer> swipeRecognizerPtr =
1157         AceType::MakeRefPtr<SwipeRecognizer>(SINGLE_FINGER_NUMBER, swipeDirection, SWIPE_SPEED);
1158     RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
1159     DimensionRect area;
1160     DimensionOffset origin;
1161     EventTarget target = {"", "", area, origin};
__anon1a9f5a790402(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1162     auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
1163         return GestureJudgeResult::REJECT;};
1164     targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
1165     TouchEvent touchEvent;
1166     AxisEvent axisEvent;
1167     touchEvent.tiltX.emplace(1.0f);
1168     touchEvent.tiltY.emplace(1.0f);
1169     swipeRecognizerPtr->targetComponent_ = targetComponent;
1170     /**
1171      * @tc.steps: step2. test the function who calls TriggerGestureJudgeCallback.
1172      * @tc.expected: step2. result equals REJECT.
1173      */
1174     swipeRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1175     swipeRecognizerPtr->speed_ = -1;
1176     swipeRecognizerPtr->fingers_ = 1;
1177     swipeRecognizerPtr->HandleTouchUpEvent(touchEvent);
1178     EXPECT_EQ(swipeRecognizerPtr->disposal_, GestureDisposal::REJECT);
1179 
1180     swipeRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1181     swipeRecognizerPtr->deviceType_ = SourceType::MOUSE;
1182     swipeRecognizerPtr->HandleTouchUpEvent(axisEvent);
1183     EXPECT_EQ(swipeRecognizerPtr->disposal_, GestureDisposal::REJECT);
1184 }
1185 } // namespace OHOS::Ace::NG