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