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