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 namespace {
22 constexpr double DEFAULT_DOUBLE_50 = 50.0;
23 constexpr double DEFAULT_DOUBLE_100 = 100.0;
24
25 struct MockClickRecognizerCase {
26 int32_t fingers;
27 int32_t count;
28 Dimension distanceThreshold;
29 double moveDistance;
30 RefereeState refereeState;
31 int32_t expectedFingers;
32 int32_t expectedCount;
33 Dimension expectedDistanceThreshold;
34 RefereeState expectedRefereeState;
35 std::vector<TouchEvent> inputTouchEvents;
36 };
37 } // namespace
38
39 class ClickRecognizerTestNg : public GesturesCommonTestNg {
40 public:
41 static void SetUpTestSuite();
42 static void TearDownTestSuite();
43 };
44
SetUpTestSuite()45 void ClickRecognizerTestNg::SetUpTestSuite()
46 {
47 MockPipelineContext::SetUp();
48 }
49
TearDownTestSuite()50 void ClickRecognizerTestNg::TearDownTestSuite()
51 {
52 MockPipelineContext::TearDown();
53 }
54
55 /**
56 * @tc.name: GestureRecognizerTest001
57 * @tc.desc: Test ClickRecognizer function: OnAccepted OnRejected
58 * @tc.type: FUNC
59 */
60 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest001, TestSize.Level1)
61 {
62 /**
63 * @tc.steps: step1. create ClickRecognizer.
64 */
65 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
66
67 /**
68 * @tc.steps: step2. call OnAccepted function and compare result.
69 * @tc.steps: case1: onClick and remoteMessage is no
70 * @tc.expected: step2. result equals.
71 */
72 ClickCallback onClick;
73 clickRecognizer->onClick_ = onClick;
74 ClickCallback remoteMessage;
75 clickRecognizer->remoteMessage_ = remoteMessage;
76
77 clickRecognizer->OnAccepted();
78 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
79
80 /**
81 * @tc.steps: step2. call OnAccepted function and compare result.
82 * @tc.steps: case2: onClick and remoteMessage is yes, touchPoints is empty
83 * @tc.expected: step2. result equals.
84 */
__anonc9df6cc10202(ClickInfo) 85 onClick = [](ClickInfo) {};
86 clickRecognizer->onClick_ = onClick;
87 clickRecognizer->touchPoints_.clear();
__anonc9df6cc10302(ClickInfo) 88 remoteMessage = [](ClickInfo) {};
89 clickRecognizer->remoteMessage_ = remoteMessage;
90
91 clickRecognizer->OnAccepted();
92 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
93
94 /**
95 * @tc.steps: step2. call OnAccepted function and compare result.
96 * @tc.steps: case3: onClick and remoteMessage is yes, touchPoints is not empty
97 * @tc.expected: step2. result equals.
98 */
__anonc9df6cc10402(ClickInfo) 99 onClick = [](ClickInfo) {};
100 clickRecognizer->onClick_ = onClick;
101 clickRecognizer->touchPoints_.clear();
__anonc9df6cc10502(ClickInfo) 102 remoteMessage = [](ClickInfo) {};
103 clickRecognizer->remoteMessage_ = remoteMessage;
104 TouchEvent touchEvent;
105 clickRecognizer->touchPoints_[0] = touchEvent;
106
107 clickRecognizer->OnAccepted();
108 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
109
110 /**
111 * @tc.steps: step2. call OnAccepted function and compare result.
112 * @tc.steps: case4: onClick and remoteMessage is yes, touchPoints has tiltX and tiltY
113 * @tc.expected: step2. result equals.
114 */
__anonc9df6cc10602(ClickInfo) 115 onClick = [](ClickInfo) {};
116 clickRecognizer->onClick_ = onClick;
117 clickRecognizer->touchPoints_.clear();
__anonc9df6cc10702(ClickInfo) 118 remoteMessage = [](ClickInfo) {};
119 clickRecognizer->remoteMessage_ = remoteMessage;
120 touchEvent.tiltX = 0;
121 touchEvent.tiltY = 0;
122 clickRecognizer->touchPoints_[0] = touchEvent;
123
124 clickRecognizer->OnAccepted();
125 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
126
127 /**
128 * @tc.steps: step3. call OnRejected function and compare result.
129 * @tc.expected: step3. result equals.
130 */
131 clickRecognizer->OnRejected();
132 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::FAIL);
133 }
134
135 /**
136 * @tc.name: GestureRecognizerTest002
137 * @tc.desc: Test ClickRecognizer function: HandleTouchMoveEvent
138 * @tc.type: FUNC
139 */
140 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest002, TestSize.Level1)
141 {
142 /**
143 * @tc.steps: step1. create ClickRecognizer.
144 */
145 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
146
147 /**
148 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
149 * @tc.steps: case2: refereeState is SUCCESS,return
150 * @tc.expected: step2. result equals.
151 */
152 TouchEvent touchEvent;
153 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
154 clickRecognizer->HandleTouchMoveEvent(touchEvent);
155 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
156
157 /**
158 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
159 * @tc.steps: case1: normal case
160 * @tc.expected: step2. result equals.
161 */
162 clickRecognizer->fingers_ = FINGER_NUMBER_OVER_MAX;
163 clickRecognizer->touchPoints_.clear();
164 clickRecognizer->touchPoints_[touchEvent.id] = touchEvent;
165 clickRecognizer->HandleTouchMoveEvent(touchEvent);
166 EXPECT_EQ(clickRecognizer->disposal_, GestureDisposal::NONE);
167 }
168
169 /**
170 * @tc.name: GestureRecognizerTest003
171 * @tc.desc: Test ClickRecognizer function: ComputeFocusPoint
172 * @tc.type: FUNC
173 */
174 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest003, TestSize.Level1)
175 {
176 /**
177 * @tc.steps: step1. create ClickRecognizer.
178 */
179 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
180
181 /**
182 * @tc.steps: step2. call ComputeFocusPoint function and compare result.
183 * @tc.expected: step2. result equals.
184 */
185 TouchEvent touchEvent;
186 clickRecognizer->touchPoints_.clear();
187 clickRecognizer->touchPoints_[touchEvent.id] = touchEvent;
188 auto focusPoint = clickRecognizer->ComputeFocusPoint();
189 EXPECT_EQ(focusPoint.GetX(), 0);
190 EXPECT_EQ(focusPoint.GetY(), 0);
191 }
192
193 /**
194 * @tc.name: GestureRecognizerTest004
195 * @tc.desc: Test ClickRecognizer function: ExceedSlop
196 * @tc.type: FUNC
197 */
198 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest004, TestSize.Level1)
199 {
200 /**
201 * @tc.steps: step1. create ClickRecognizer.
202 */
203 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
204
205 /**
206 * @tc.steps: step2. call ComputeFocusPoint function and compare result.
207 * @tc.steps: case1: not enter
208 * @tc.expected: step2. result equals.
209 */
210 TouchEvent touchEvent;
211 clickRecognizer->touchPoints_.clear();
212 clickRecognizer->touchPoints_[touchEvent.id] = touchEvent;
213 auto result = clickRecognizer->ExceedSlop();
214 EXPECT_EQ(result, false);
215
216 /**
217 * @tc.steps: step2. call ComputeFocusPoint function and compare result.
218 * @tc.steps: case2: tappedCount_ > 0 && tappedCount_ < count_, distance >= TAP_SLOP
219 * @tc.expected: step2. result equals.
220 */
221 touchEvent.x = CLICK_MULTI_TAP_SLOP;
222 touchEvent.y = CLICK_MULTI_TAP_SLOP;
223 clickRecognizer->touchPoints_[touchEvent.id] = touchEvent;
224 clickRecognizer->tappedCount_ = TAPPED_COUNT;
225 clickRecognizer->count_ = COUNT;
226 result = clickRecognizer->ExceedSlop();
227 EXPECT_EQ(result, true);
228
229 /**
230 * @tc.steps: step2. call ComputeFocusPoint function and compare result.
231 * @tc.steps: case3: tappedCount_ > 0 && tappedCount_ < count_, distance < TAP_SLOP
232 * @tc.expected: step2. result equals.
233 */
234 touchEvent.x = 0;
235 touchEvent.y = 0;
236 clickRecognizer->touchPoints_[touchEvent.id] = touchEvent;
237 clickRecognizer->tappedCount_ = TAPPED_COUNT;
238 clickRecognizer->count_ = COUNT;
239 result = clickRecognizer->ExceedSlop();
240 EXPECT_EQ(result, false);
241
242 /**
243 * @tc.steps: step2. call ComputeFocusPoint function and compare result.
244 * @tc.steps: case4: tappedCount_ = count_ = 0
245 * @tc.expected: step2. result equals.
246 */
247 clickRecognizer->tappedCount_ = 0;
248 clickRecognizer->count_ = 0;
249 result = clickRecognizer->ExceedSlop();
250 EXPECT_EQ(result, false);
251 }
252
253 /**
254 * @tc.name: GestureRecognizerTest005
255 * @tc.desc: Test ClickRecognizer function: ReconcileFrom
256 * @tc.type: FUNC
257 */
258 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest005, TestSize.Level1)
259 {
260 /**
261 * @tc.steps: step1. create ClickRecognizer.
262 */
263 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
264 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
265
266 /**
267 * @tc.steps: step2. call ReconcileFrom function and compare result.
268 * @tc.steps: case1: normal case
269 * @tc.expected: step2. result equals.
270 */
271 TouchEvent touchEvent;
272 clickRecognizer->touchPoints_.clear();
273 clickRecognizer->touchPoints_[touchEvent.id] = touchEvent;
274 auto result = clickRecognizer->ReconcileFrom(clickRecognizerPtr);
275 EXPECT_EQ(result, true);
276
277 /**
278 * @tc.steps: step2. call ReconcileFrom function and compare result.
279 * @tc.steps: case2: recognizerPtr is nullptr
280 * @tc.expected: step2. result equals.
281 */
282 result = clickRecognizer->ReconcileFrom(nullptr);
283 EXPECT_EQ(result, false);
284
285 /**
286 * @tc.steps: step2. call ReconcileFrom function and compare result.
287 * @tc.steps: case3: recognizerPtr count != count
288 * @tc.expected: step2. result equals.
289 */
290 clickRecognizerPtr->count_ = 1;
291 clickRecognizer->count_ = 0;
292 result = clickRecognizer->ReconcileFrom(clickRecognizerPtr);
293 EXPECT_EQ(result, false);
294
295 /**
296 * @tc.steps: step2. call ReconcileFrom function and compare result.
297 * @tc.steps: case4: recognizerPtr count same, fingers not same
298 * @tc.expected: step2. result equals.
299 */
300 clickRecognizerPtr->count_ = clickRecognizer->count_;
301 clickRecognizerPtr->fingers_ = clickRecognizer->fingers_ + 1;
302 result = clickRecognizer->ReconcileFrom(clickRecognizerPtr);
303 EXPECT_EQ(result, false);
304
305 /**
306 * @tc.steps: step2. call ReconcileFrom function and compare result.
307 * @tc.steps: case5: recognizerPtr count same, fingers same, priorityMask not same
308 * @tc.expected: step2. result equals.
309 */
310 clickRecognizerPtr->count_ = clickRecognizer->count_;
311 clickRecognizerPtr->fingers_ = clickRecognizer->fingers_;
312 clickRecognizer->priorityMask_ = GestureMask::End;
313 result = clickRecognizer->ReconcileFrom(clickRecognizerPtr);
314 EXPECT_EQ(result, false);
315 }
316
317 /**
318 * @tc.name: GestureRecognizerTest006
319 * @tc.desc: Test ClickRecognizer function: HandleTouchDownEvent
320 * @tc.type: FUNC
321 */
322 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest006, TestSize.Level1)
323 {
324 /**
325 * @tc.steps: step1. create ClickRecognizer.
326 */
327 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
328
329 /**
330 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
331 * @tc.steps: case1: refereeState is SUCCESS,return
332 * @tc.expected: step2. result equals.
333 */
334 TouchEvent touchEvent;
335 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
336 clickRecognizer->HandleTouchDownEvent(touchEvent);
337 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
338
339 /**
340 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
341 * @tc.steps: case2: refereeState is PENDING, tappedCount_ = 1, fingers > PointsNum
342 * @tc.expected: step2. result equals.
343 */
344 clickRecognizer->refereeState_ = RefereeState::PENDING;
345 clickRecognizer->fingers_ = FINGER_NUMBER;
346 clickRecognizer->tappedCount_ = 1;
347 clickRecognizer->currentTouchPointsNum_ = 0;
348 clickRecognizer->HandleTouchDownEvent(touchEvent);
349 EXPECT_EQ(clickRecognizer->currentTouchPointsNum_, 1);
350 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
351
352 /**
353 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
354 * @tc.steps: case3: refereeState is PENDING, tappedCount_ = 1, fingers = 1
355 * @tc.expected: step2. result equals.
356 */
357 clickRecognizer->refereeState_ = RefereeState::PENDING;
358 clickRecognizer->fingers_ = 1;
359 clickRecognizer->tappedCount_ = 1;
360 clickRecognizer->currentTouchPointsNum_ = 0;
361 clickRecognizer->HandleTouchDownEvent(touchEvent);
362 EXPECT_EQ(clickRecognizer->equalsToFingers_, false);
363 }
364
365 /**
366 * @tc.name: GestureRecognizerTest007
367 * @tc.desc: Test ClickRecognizer function: HandleTouchUpEvent
368 * @tc.type: FUNC
369 */
370 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest007, TestSize.Level1)
371 {
372 /**
373 * @tc.steps: step1. create ClickRecognizer.
374 */
375 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
376
377 /**
378 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
379 * @tc.steps: case1: refereeState is SUCCESS,return
380 * @tc.expected: step2. result equals.
381 */
382 TouchEvent touchEvent;
383 clickRecognizer->currentTouchPointsNum_ = 0;
384 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
385 clickRecognizer->HandleTouchUpEvent(touchEvent);
386 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
387
388 /**
389 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
390 * @tc.steps: case2: equalsToFingers = true, currentTouchPointsNum = 1, tap != count
391 * @tc.expected: step2. result equals.
392 */
393 clickRecognizer->currentTouchPointsNum_ = 1;
394 clickRecognizer->equalsToFingers_ = true;
395 clickRecognizer->useCatchMode_ = false;
396 clickRecognizer->refereeState_ = RefereeState::PENDING;
397 clickRecognizer->fingersId_.insert(0);
398 clickRecognizer->HandleTouchUpEvent(touchEvent);
399 EXPECT_FALSE(clickRecognizer->equalsToFingers_);
400 EXPECT_EQ(clickRecognizer->currentTouchPointsNum_, 0);
401 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
402
403 /**
404 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
405 * @tc.steps: case3: equalsToFingers = true, currentTouchPointsNum = 1,
406 * @tc.steps: tap == count, useCatchMode_ = false
407 * @tc.expected: step2. result equals.
408 */
409 clickRecognizer->currentTouchPointsNum_ = 1;
410 clickRecognizer->equalsToFingers_ = true;
411 clickRecognizer->useCatchMode_ = false;
412 clickRecognizer->tappedCount_ = 0;
413 clickRecognizer->count_ = 0;
414 clickRecognizer->fingersId_.insert(0);
415 clickRecognizer->HandleTouchUpEvent(touchEvent);
416 EXPECT_FALSE(clickRecognizer->equalsToFingers_);
417 EXPECT_EQ(clickRecognizer->currentTouchPointsNum_, 0);
418 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
419
420 /**
421 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
422 * @tc.steps: case3: equalsToFingers = true, currentTouchPointsNum = fingers,
423 * @tc.expected: step2. result equals.
424 */
425 clickRecognizer->currentTouchPointsNum_ = FINGER_NUMBER;
426 clickRecognizer->fingers_ = FINGER_NUMBER;
427 clickRecognizer->equalsToFingers_ = true;
428 clickRecognizer->HandleTouchUpEvent(touchEvent);
429 EXPECT_EQ(clickRecognizer->equalsToFingers_, true);
430
431 /**
432 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
433 * @tc.steps: case4: equalsToFingers = false, currentTouchPointsNum = 1,
434 * @tc.expected: step2. result equals.
435 */
436 clickRecognizer->currentTouchPointsNum_ = 1;
437 clickRecognizer->equalsToFingers_ = false;
438 clickRecognizer->HandleTouchUpEvent(touchEvent);
439 EXPECT_EQ(clickRecognizer->equalsToFingers_, false);
440
441 /**
442 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
443 * @tc.steps: case5: equalsToFingers = false, currentTouchPointsNum = 0,
444 * @tc.expected: step2. result equals.
445 */
446 clickRecognizer->currentTouchPointsNum_ = 0;
447 clickRecognizer->equalsToFingers_ = false;
448 clickRecognizer->HandleTouchUpEvent(touchEvent);
449 EXPECT_EQ(clickRecognizer->equalsToFingers_, false);
450
451 /**
452 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
453 * @tc.steps: case6: equalsToFingers = true, currentTouchPointsNum = 1,
454 * @tc.steps: tap == count, useCatchMode_ = false
455 * @tc.expected: step2. result equals.
456 */
457 clickRecognizer->currentTouchPointsNum_ = 1;
458 clickRecognizer->equalsToFingers_ = true;
459 clickRecognizer->useCatchMode_ = false;
460 clickRecognizer->tappedCount_ = -1;
461 clickRecognizer->count_ = 0;
462 clickRecognizer->fingersId_.insert(0);
463 clickRecognizer->HandleTouchUpEvent(touchEvent);
464 EXPECT_EQ(clickRecognizer->equalsToFingers_, true);
465 EXPECT_EQ(clickRecognizer->currentTouchPointsNum_, 0);
466 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
467 }
468
469 /**
470 * @tc.name: GestureRecognizerTest008
471 * @tc.desc: Test ClickRecognizer function: HandleTouchCancelEvent
472 * @tc.type: FUNC
473 */
474 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest008, TestSize.Level1)
475 {
476 /**
477 * @tc.steps: step1. create ClickRecognizer.
478 */
479 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
480
481 /**
482 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
483 * @tc.steps: case1: refereeState is SUCCESS,return
484 * @tc.expected: step2. result equals.
485 */
486 TouchEvent touchEvent;
487 clickRecognizer->currentTouchPointsNum_ = 0;
488 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
489 clickRecognizer->HandleTouchCancelEvent(touchEvent);
490 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
491
492 clickRecognizer->refereeState_ = RefereeState::FAIL;
493 }
494
495 /**
496 * @tc.name: GestureRecognizerTest009
497 * @tc.desc: Test ClickRecognizer function: SendCallbackMsg
498 * @tc.type: FUNC
499 */
500 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest009, TestSize.Level1)
501 {
502 /**
503 * @tc.steps: step1. create ClickRecognizer.
504 */
505 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
506
507 /**
508 * @tc.steps: step2. call SendCallbackMsg function and compare result.
509 * @tc.steps: case1: onAction is no, *onAction is no
510 * @tc.expected: step2. result equals.
511 */
512 std::unique_ptr<GestureEventFunc> onAction;
513 clickRecognizer->SendCallbackMsg(onAction, GestureCallbackType::ACTION);
514 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
515
516 /**
517 * @tc.steps: step2. call SendCallbackMsg function and compare result.
518 * @tc.steps: case2: onAction is yes, *onAction is no
519 * @tc.expected: step2. result equals.
520 */
521 onAction = std::make_unique<GestureEventFunc>();
522 clickRecognizer->SendCallbackMsg(onAction, GestureCallbackType::ACTION);
523 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
524
525 /**
526 * @tc.steps: step2. call SendCallbackMsg function and compare result.
527 * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty
528 * @tc.expected: step2. result equals.
529 */
__anonc9df6cc10802(GestureEvent) 530 onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
531 clickRecognizer->SendCallbackMsg(onAction, GestureCallbackType::ACTION);
532 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
533
534 /**
535 * @tc.steps: step2. call SendCallbackMsg function and compare result.
536 * @tc.steps: case4: touchEvent is not empty, have no X and Y
537 * @tc.expected: step2. result equals.
538 */
539 TouchEvent touchEvent;
540 clickRecognizer->touchPoints_[touchEvent.id] = touchEvent;
541 clickRecognizer->SendCallbackMsg(onAction, GestureCallbackType::ACTION);
542 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 1);
543
544 /**
545 * @tc.steps: step2. call SendCallbackMsg function and compare result.
546 * @tc.steps: case4: touchEvent is not empty, have no X and Y
547 * @tc.expected: step2. result equals.
548 */
549 touchEvent.tiltX = 0.0f;
550 touchEvent.tiltY = 0.0f;
551 clickRecognizer->touchPoints_[touchEvent.id] = touchEvent;
552 clickRecognizer->SendCallbackMsg(onAction, GestureCallbackType::ACTION);
553 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 1);
554 }
555
556 /**
557 * @tc.name: GestureRecognizerTest010
558 * @tc.desc: Test ClickRecognizer function: HandleTouchDownEvent
559 * @tc.type: FUNC
560 */
561 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest010, TestSize.Level1)
562 {
563 /**
564 * @tc.steps: step1. create ClickRecognizer.
565 */
566 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
567 TouchEvent touchEvent;
568
569 /**
570 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
571 * @tc.steps: case1: event.sourceType == TOUCH
572 * @tc.expected: step2. result equals.
573 */
574 clickRecognizer->refereeState_ = RefereeState::PENDING;
575 clickRecognizer->fingers_ = FINGER_NUMBER;
576 clickRecognizer->tappedCount_ = 1;
577 clickRecognizer->currentTouchPointsNum_ = 0;
578 touchEvent.sourceType = SourceType::TOUCH;
579 clickRecognizer->HandleTouchDownEvent(touchEvent);
580 EXPECT_EQ(clickRecognizer->currentTouchPointsNum_, 1);
581 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
582
583 /**
584 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
585 * @tc.steps: case2: event.sourceType == MOUSE
586 * @tc.expected: step2. result equals.
587 */
588 touchEvent.sourceType = SourceType::MOUSE;
589 clickRecognizer->HandleTouchDownEvent(touchEvent);
590 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
591
592 /**
593 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
594 * @tc.steps: case3: event.sourceType == TOUCH_PAD
595 * @tc.expected: step2. result equals.
596 */
597 touchEvent.sourceType = SourceType::TOUCH_PAD;
598 clickRecognizer->HandleTouchDownEvent(touchEvent);
599 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
600
601 /**
602 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
603 * @tc.step4: case3: event.sourceType == OTHER
604 * @tc.expected: step2. result equals.
605 */
606 touchEvent.sourceType = SourceType::KEYBOARD;
607 clickRecognizer->HandleTouchDownEvent(touchEvent);
608 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
609 }
610
611 /*
612 * @tc.name: GestureRecognizerTest011
613 * @tc.desc: Test ClickRecognizer function: IsPointInRegion
614 * @tc.type: FUNC
615 */
616 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest011, TestSize.Level1)
617 {
618 /**
619 * @tc.steps: step1. create ClickRecognizer.
620 */
621 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
622 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
623 clickRecognizer->AttachFrameNode(frameNode);
624 clickRecognizer->responseRegionBuffer_.emplace_back(RectF(0, 0, 200, 200));
625 clickRecognizer->SetDistanceThreshold(200);
626 TouchEvent touchEvent;
627
628 /**
629 * @tc.steps: step2. call IsInResponseRegion function and compare result.
630 * @tc.steps: case1: event.sourceType == TOUCH, x == 100, y == 100
631 * @tc.expected: step2. result equals.
632 */
633 touchEvent.x = 100.0f;
634 touchEvent.y = 100.0f;
635 touchEvent.sourceType = SourceType::TOUCH;
636 auto result = clickRecognizer->IsPointInRegion(touchEvent);
637 EXPECT_EQ(result, true);
638 }
639
640 /**
641 * @tc.name: ClickRecognizerTest012
642 * @tc.desc: Test ClickRecognizer function: HandleTouchUpEvent
643 * @tc.type: FUNC
644 */
645 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest012, TestSize.Level1)
646 {
647 /**
648 * @tc.steps: step1. create ClickRecognizer.
649 */
650 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
651
652 /**
653 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
654 * @tc.steps: case1: refereeState is SUCCESS,return
655 * @tc.expected: step2. result equals.
656 */
657 TouchEvent touchEvent;
658 clickRecognizer->currentTouchPointsNum_ = 0;
659 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
660 clickRecognizer->currentFingers_ = FINGER_NUMBER;
661 clickRecognizer->HandleTouchUpEvent(touchEvent);
662 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
663
664 /**
665 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
666 * @tc.steps: case2: equalsToFingers = true, currentTouchPointsNum = 1, tap != count
667 * @tc.expected: step2. result equals.
668 */
669 clickRecognizer->currentTouchPointsNum_ = 1;
670 clickRecognizer->equalsToFingers_ = true;
671 clickRecognizer->useCatchMode_ = false;
672 clickRecognizer->refereeState_ = RefereeState::PENDING;
673 clickRecognizer->currentFingers_ = FINGER_NUMBER;
674 clickRecognizer->HandleTouchUpEvent(touchEvent);
675 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
676
677 /**
678 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
679 * @tc.steps: case3: equalsToFingers = true, currentTouchPointsNum = 1,
680 * @tc.steps: tap == count, useCatchMode_ = false
681 * @tc.expected: step2. result equals.
682 */
683 clickRecognizer->currentTouchPointsNum_ = 1;
684 clickRecognizer->equalsToFingers_ = true;
685 clickRecognizer->useCatchMode_ = false;
686 clickRecognizer->tappedCount_ = 0;
687 clickRecognizer->count_ = 0;
688 clickRecognizer->currentFingers_ = FINGER_NUMBER;
689 clickRecognizer->HandleTouchUpEvent(touchEvent);
690 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
691
692 /**
693 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
694 * @tc.steps: case3: equalsToFingers = true, currentTouchPointsNum = fingers,
695 * @tc.expected: step2. result equals.
696 */
697 clickRecognizer->currentTouchPointsNum_ = FINGER_NUMBER;
698 clickRecognizer->fingers_ = FINGER_NUMBER;
699 clickRecognizer->equalsToFingers_ = true;
700 clickRecognizer->currentFingers_ = FINGER_NUMBER;
701 clickRecognizer->HandleTouchUpEvent(touchEvent);
702 EXPECT_EQ(clickRecognizer->equalsToFingers_, true);
703
704 /**
705 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
706 * @tc.steps: case4: equalsToFingers = false, currentTouchPointsNum = 1,
707 * @tc.expected: step2. result equals.
708 */
709 clickRecognizer->currentTouchPointsNum_ = 1;
710 clickRecognizer->equalsToFingers_ = false;
711 clickRecognizer->currentFingers_ = FINGER_NUMBER;
712 clickRecognizer->HandleTouchUpEvent(touchEvent);
713 EXPECT_EQ(clickRecognizer->equalsToFingers_, false);
714
715 /**
716 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
717 * @tc.steps: case5: equalsToFingers = false, currentTouchPointsNum = 0,
718 * @tc.expected: step2. result equals.
719 */
720 clickRecognizer->currentTouchPointsNum_ = 0;
721 clickRecognizer->equalsToFingers_ = false;
722 clickRecognizer->currentFingers_ = FINGER_NUMBER;
723 clickRecognizer->HandleTouchUpEvent(touchEvent);
724 EXPECT_EQ(clickRecognizer->equalsToFingers_, false);
725
726 /**
727 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
728 * @tc.steps: case6: equalsToFingers = true, currentTouchPointsNum = 1,
729 * @tc.steps: tap == count, useCatchMode_ = false
730 * @tc.expected: step2. result equals.
731 */
732 clickRecognizer->currentTouchPointsNum_ = 1;
733 clickRecognizer->equalsToFingers_ = true;
734 clickRecognizer->useCatchMode_ = false;
735 clickRecognizer->tappedCount_ = -1;
736 clickRecognizer->count_ = 0;
737 clickRecognizer->currentFingers_ = FINGER_NUMBER;
738 clickRecognizer->HandleTouchUpEvent(touchEvent);
739 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
740 }
741
742 /**
743 * @tc.name: ClickRecognizerTest013
744 * @tc.desc: Test GestureRecognizer function: HandleEvent
745 * @tc.type: FUNC
746 */
747 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest013, TestSize.Level1)
748 {
749 /**
750 * @tc.steps: step1. create GestureRecognizer.
751 */
752 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
753 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
754 TouchEvent touchEvent;
755
756 /**
757 * @tc.steps: step2. call TouchEvent function and compare result.
758 * @tc.expected: step2. result equals.
759 */
760 touchEvent.type = TouchType::MOVE;
761 clickRecognizer->HandleEvent(touchEvent);
762 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
763
764 touchEvent.type = TouchType::DOWN;
765 clickRecognizer->HandleEvent(touchEvent);
766 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
767
768 touchEvent.type = TouchType::UP;
769 clickRecognizer->HandleEvent(touchEvent);
770 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
771
772 touchEvent.type = TouchType::CANCEL;
773 clickRecognizer->HandleEvent(touchEvent);
774 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
775
776 touchEvent.type = TouchType::UNKNOWN;
777 clickRecognizer->HandleEvent(touchEvent);
778 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
779 EXPECT_EQ(clickRecognizer->inputEventType_, InputEventType::TOUCH_SCREEN);
780
781 /**
782 * @tc.steps: step2. call AxisEvent function and compare result.
783 * @tc.expected: step2. result equals.
784 */
785 AxisEvent axisEvent;
786 axisEvent.action = AxisAction::BEGIN;
787 clickRecognizer->HandleEvent(axisEvent);
788 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
789
790 axisEvent.action = AxisAction::UPDATE;
791 clickRecognizer->HandleEvent(axisEvent);
792 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
793
794 axisEvent.action = AxisAction::END;
795 clickRecognizer->HandleEvent(axisEvent);
796 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
797
798 axisEvent.action = AxisAction::NONE;
799 clickRecognizer->HandleEvent(axisEvent);
800 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
801 EXPECT_EQ(clickRecognizer->inputEventType_, InputEventType::AXIS);
802 }
803
804 /**
805 * @tc.name: GestureRecognizerTest014
806 * @tc.desc: Test ClickRecognizer function: HandleTouchUpEvent
807 * @tc.type: FUNC
808 */
809 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTest014, TestSize.Level1)
810 {
811 /**
812 * @tc.steps: step1. create ClickRecognizer.
813 */
814 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
815 TouchEvent touchEvent;
816
817 /**
818 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
819 * @tc.steps: case7: equalsToFingers = true, currentTouchPointsNum = 1,
820 * @tc.steps: tap != count, useCatchMode_ = false, refereeState = DETECTING.
821 * @tc.expected: step2. result equals.
822 */
823 clickRecognizer->currentTouchPointsNum_ = 1;
824 clickRecognizer->equalsToFingers_ = true;
825 clickRecognizer->useCatchMode_ = false;
826 clickRecognizer->tappedCount_ = 0;
827 clickRecognizer->count_ = 1;
828 clickRecognizer->fingersId_.insert(0);
829 clickRecognizer->refereeState_ = RefereeState::DETECTING;
830 clickRecognizer->HandleTouchUpEvent(touchEvent);
831 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
832
833 /**
834 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
835 * @tc.steps: case7: equalsToFingers = false, currentTouchPointsNum = 1,
836 * @tc.steps: tap != count, useCatchMode_ = false, refereeState = DETECTING.
837 * @tc.expected: step2. result equals.
838 */
839 clickRecognizer->currentTouchPointsNum_ = 1;
840 clickRecognizer->equalsToFingers_ = true;
841 clickRecognizer->useCatchMode_ = false;
842 clickRecognizer->tappedCount_ = 0;
843 clickRecognizer->count_ = 1;
844 clickRecognizer->fingersId_.insert(0);
845 clickRecognizer->refereeState_ = RefereeState::DETECTING;
846 clickRecognizer->HandleTouchUpEvent(touchEvent);
847 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
848 }
849
850 /**
851 * @tc.name: ClickRecognizerHandleTouchUpEventTest101
852 * @tc.desc: Test ClickRecognizer function: HandleTouchUpEvent
853 * @tc.type: FUNC
854 */
855 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleTouchUpEventTest001, TestSize.Level1)
856 {
857 /**
858 * @tc.steps: step1. create ClickRecognizer.
859 */
860 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
861
862 /**
863 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
864 * @tc.steps: case1: refereeState is SUCCESS,return
865 * @tc.expected: step2. result equals.
866 */
867 TouchEvent touchEvent;
868 clickRecognizer->currentTouchPointsNum_ = 0;
869 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
870 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
871 clickRecognizer->HandleTouchUpEvent(touchEvent);
872 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
873
874 /**
875 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
876 * @tc.steps: case2: equalsToFingers = true, currentTouchPointsNum = 1, tap != count
877 * @tc.expected: step2. result equals.
878 */
879 clickRecognizer->currentTouchPointsNum_ = 1;
880 clickRecognizer->equalsToFingers_ = true;
881 clickRecognizer->useCatchMode_ = false;
882 clickRecognizer->refereeState_ = RefereeState::PENDING;
883 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
884 clickRecognizer->HandleTouchUpEvent(touchEvent);
885 EXPECT_TRUE(clickRecognizer->equalsToFingers_);
886
887 /**
888 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
889 * @tc.steps: case3: equalsToFingers = true, currentTouchPointsNum = 1,
890 * @tc.steps: tap == count, useCatchMode_ = false
891 * @tc.expected: step2. result equals.
892 */
893 clickRecognizer->currentTouchPointsNum_ = 1;
894 clickRecognizer->equalsToFingers_ = true;
895 clickRecognizer->useCatchMode_ = false;
896 clickRecognizer->tappedCount_ = 0;
897 clickRecognizer->count_ = 0;
898 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
899 clickRecognizer->HandleTouchUpEvent(touchEvent);
900 EXPECT_TRUE(clickRecognizer->equalsToFingers_);
901
902 /**
903 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
904 * @tc.steps: case3: equalsToFingers = true, currentTouchPointsNum = fingers,
905 * @tc.expected: step2. result equals.
906 */
907 clickRecognizer->currentTouchPointsNum_ = FINGER_NUMBER;
908 clickRecognizer->fingers_ = FINGER_NUMBER;
909 clickRecognizer->equalsToFingers_ = true;
910 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
911 clickRecognizer->HandleTouchUpEvent(touchEvent);
912 EXPECT_EQ(clickRecognizer->equalsToFingers_, true);
913
914 /**
915 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
916 * @tc.steps: case4: equalsToFingers = false, currentTouchPointsNum = 1,
917 * @tc.expected: step2. result equals.
918 */
919 clickRecognizer->currentTouchPointsNum_ = 1;
920 clickRecognizer->equalsToFingers_ = false;
921 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
922 clickRecognizer->HandleTouchUpEvent(touchEvent);
923 EXPECT_EQ(clickRecognizer->equalsToFingers_, false);
924
925 /**
926 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
927 * @tc.steps: case5: equalsToFingers = false, currentTouchPointsNum = 0,
928 * @tc.expected: step2. result equals.
929 */
930 clickRecognizer->currentTouchPointsNum_ = 0;
931 clickRecognizer->equalsToFingers_ = false;
932 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
933 clickRecognizer->HandleTouchUpEvent(touchEvent);
934 EXPECT_EQ(clickRecognizer->equalsToFingers_, false);
935
936 /**
937 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
938 * @tc.steps: case6: equalsToFingers = true, currentTouchPointsNum = 1,
939 * @tc.steps: tap == count, useCatchMode_ = false
940 * @tc.expected: step2. result equals.
941 */
942 clickRecognizer->currentTouchPointsNum_ = 1;
943 clickRecognizer->equalsToFingers_ = true;
944 clickRecognizer->useCatchMode_ = false;
945 clickRecognizer->tappedCount_ = -1;
946 clickRecognizer->count_ = 0;
947 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
948 clickRecognizer->HandleTouchUpEvent(touchEvent);
949 EXPECT_EQ(clickRecognizer->equalsToFingers_, true);
950 }
951
952 /**
953 * @tc.name: GestureRecognizerHandleTouchMoveEventTest001
954 * @tc.desc: Test ClickRecognizer function: HandleTouchMoveEvent
955 * @tc.type: FUNC
956 */
957 HWTEST_F(ClickRecognizerTestNg, GestureRecognizerHandleTouchMoveEventTest001, TestSize.Level1)
958 {
959 /**
960 * @tc.steps: step1. create ClickRecognizer.
961 */
962 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
963
964 /**
965 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
966 * @tc.steps: case1: refereeState is SUCCESS,return
967 * @tc.expected: step2. result equals.
968 */
969 TouchEvent touchEvent;
970 clickRecognizer->currentTouchPointsNum_ = 0;
971 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
972 clickRecognizer->currentFingers_ = FINGER_NUMBER;
973 clickRecognizer->HandleTouchMoveEvent(touchEvent);
974 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
975 }
976
977 /**
978 * @tc.name: ClickRecognizerHandleTouchUpEventTest102
979 * @tc.desc: Test ClickRecognizer function: HandleTouchUpEvent
980 * @tc.type: FUNC
981 */
982 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleTouchUpEventTest002, TestSize.Level1)
983 {
984 /**
985 * @tc.steps: step1. create ClickRecognizer.
986 */
987 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
988
989 /**
990 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
991 * @tc.steps: case1: refereeState is SUCCESS,return
992 * @tc.expected: step2. result equals.
993 */
994 TouchEvent touchEvent;
995 clickRecognizer->currentTouchPointsNum_ = 0;
996 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
997 clickRecognizer->currentFingers_ = FINGER_NUMBER;
998 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
999 clickRecognizer->HandleTouchUpEvent(touchEvent);
1000
1001 clickRecognizer->currentTouchPointsNum_ = 1;
1002 clickRecognizer->equalsToFingers_ = true;
1003 clickRecognizer->useCatchMode_ = false;
1004 clickRecognizer->refereeState_ = RefereeState::PENDING;
1005 clickRecognizer->currentFingers_ = FINGER_NUMBER;
1006 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
1007 clickRecognizer->HandleTouchUpEvent(touchEvent);
1008
1009 clickRecognizer->currentTouchPointsNum_ = 1;
1010 clickRecognizer->equalsToFingers_ = true;
1011 clickRecognizer->useCatchMode_ = false;
1012 clickRecognizer->tappedCount_ = 0;
1013 clickRecognizer->count_ = 0;
1014 clickRecognizer->currentFingers_ = FINGER_NUMBER;
1015 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
1016 clickRecognizer->HandleTouchUpEvent(touchEvent);
1017 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1018
1019 /**
1020 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
1021 * @tc.steps: case3: equalsToFingers = true, currentTouchPointsNum = fingers,
1022 * @tc.expected: step2. result equals.
1023 */
1024 clickRecognizer->currentTouchPointsNum_ = FINGER_NUMBER;
1025 clickRecognizer->fingers_ = FINGER_NUMBER;
1026 clickRecognizer->equalsToFingers_ = true;
1027 clickRecognizer->currentFingers_ = FINGER_NUMBER;
1028 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
1029
1030 clickRecognizer->currentTouchPointsNum_ = 1;
1031 clickRecognizer->equalsToFingers_ = false;
1032 clickRecognizer->currentFingers_ = FINGER_NUMBER;
1033 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
1034
1035 clickRecognizer->currentTouchPointsNum_ = 0;
1036 clickRecognizer->equalsToFingers_ = false;
1037 clickRecognizer->currentFingers_ = FINGER_NUMBER;
1038 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
1039 clickRecognizer->HandleTouchUpEvent(touchEvent);
1040 EXPECT_EQ(clickRecognizer->equalsToFingers_, false);
1041
1042 /**
1043 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
1044 * @tc.steps: case6: equalsToFingers = true, currentTouchPointsNum = 1,
1045 * @tc.steps: tap == count, useCatchMode_ = false
1046 * @tc.expected: step2. result equals.
1047 */
1048 clickRecognizer->currentTouchPointsNum_ = 1;
1049 clickRecognizer->equalsToFingers_ = true;
1050 clickRecognizer->useCatchMode_ = false;
1051 clickRecognizer->tappedCount_ = -1;
1052 clickRecognizer->count_ = 0;
1053 clickRecognizer->currentFingers_ = FINGER_NUMBER;
1054 clickRecognizer->currentTouchPointsNum_ = clickRecognizer->fingers_;
1055 clickRecognizer->HandleTouchUpEvent(touchEvent);
1056 EXPECT_EQ(clickRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1057 }
1058
1059 /**
1060 * @tc.name: GestureRecognizerHandleOverdueDeadlineTest001
1061 * @tc.desc: Test ClickRecognizer function: HandleOverdueDeadline
1062 * @tc.type: FUNC
1063 */
1064 HWTEST_F(ClickRecognizerTestNg, GestureRecognizerHandleOverdueDeadlineTest001, TestSize.Level1)
1065 {
1066 /**
1067 * @tc.steps: step1. create ClickRecognizer.
1068 */
1069 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1070
1071 /**
1072 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
1073 * @tc.steps: case1: refereeState is SUCCESS,return
1074 * @tc.expected: step2. result equals.
1075 */
1076 TouchEvent touchEvent;
1077 clickRecognizer->currentTouchPointsNum_ = FINGER_NUMBER;
1078 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
1079 clickRecognizer->currentFingers_ = FINGER_NUMBER;
1080 clickRecognizer->tappedCount_ = FINGER_NUMBER;
1081 clickRecognizer->count_ = FINGER_NUMBER;
1082 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
1083 clickRecognizer->AttachFrameNode(frameNode);
1084 clickRecognizer->HandleOverdueDeadline();
1085 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
1086 }
1087
1088 /**
1089 * @tc.name: ClickRecognizerClickRecognizerTest101
1090 * @tc.desc: Test ClickRecognizer function: ClickRecognizer
1091 * @tc.type: FUNC
1092 */
1093 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerClickRecognizerTest001, TestSize.Level1)
1094 {
1095 /**
1096 * @tc.steps: step1. create ClickRecognizer
1097 */
1098 RefPtr<ClickRecognizer> clickRecognizerPtr1 = AceType::MakeRefPtr<ClickRecognizer>(0, COUNT);
1099 EXPECT_EQ(clickRecognizerPtr1->fingers_, 1);
1100
1101 /**
1102 * @tc.steps: step1. create ClickRecognizer
1103 */
1104 RefPtr<ClickRecognizer> clickRecognizerPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER_OVER_MAX, COUNT);
1105 EXPECT_EQ(clickRecognizerPtr2->fingers_, 1);
1106
1107 /**
1108 * @tc.steps: step1. create ClickRecognizer
1109 */
1110 RefPtr<ClickRecognizer> clickRecognizerPtr3 = AceType::MakeRefPtr<ClickRecognizer>(10, COUNT);
1111 EXPECT_EQ(clickRecognizerPtr3->fingers_, 10);
1112
1113 /**
1114 * @tc.steps: step1. create ClickRecognizer
1115 */
1116 RefPtr<ClickRecognizer> clickRecognizerPtr4 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1117 EXPECT_EQ(clickRecognizerPtr4->fingers_, FINGER_NUMBER);
1118 }
1119
1120 /**
1121 * @tc.name: ClickRecognizerSendCallbackMsgTest001
1122 * @tc.desc: Test ClickRecognizer function: SendCallbackMsg
1123 * @tc.type: FUNC
1124 */
1125 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerSendCallbackMsgTest001, TestSize.Level1)
1126 {
1127 /**
1128 * @tc.steps: step1. Create clickRecognizer.
1129 */
1130 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(SINGLE_FINGER_NUMBER, TAPPED_COUNT);
1131 std::unique_ptr<GestureEventFunc> onAction;
1132
1133 /**
1134 * @tc.steps: step2. call SendCallbackMsg function and compare result.
1135 * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty, type is AXIS
1136 * @tc.expected: step2. result equals.
1137 */
__anonc9df6cc10902(GestureEvent) 1138 onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
1139 clickRecognizer->SendCallbackMsg(onAction, GestureCallbackType::ACTION);
1140 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
1141 }
1142
1143 /**
1144 * @tc.name: ClickRecognizerHandleTouchMoveEventTest002
1145 * @tc.desc: Test ClickRecognizer function: HandleTouchMoveEvent
1146 * @tc.type: FUNC
1147 */
1148 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleTouchMoveEventTest002, TestSize.Level1)
1149 {
1150 /**
1151 * @tc.steps: step1. create ClickRecognizer.
1152 */
1153 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1154
1155 /**
1156 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1157 * @tc.steps: case2: refereeState is SUCCESS,return
1158 * @tc.expected: step2. result equals.
1159 */
1160 TouchEvent touchEvent;
1161 clickRecognizer->refereeState_ = RefereeState::PENDING;
1162 clickRecognizer->currentFingers_ = clickRecognizer->fingers_;
1163 clickRecognizer->HandleTouchMoveEvent(touchEvent);
1164 EXPECT_EQ(clickRecognizer->touchPoints_.size(), 0);
1165 }
1166
1167 /**
1168 * @tc.name: ClickRecognizerHandleTouchDownEventTest003
1169 * @tc.desc: Test ClickRecognizer function: HandleTouchDownEvent
1170 * @tc.type: FUNC
1171 */
1172 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleTouchDownEventTest003, TestSize.Level1)
1173 {
1174 /**
1175 * @tc.steps: step1. create ClickRecognizer.
1176 */
1177 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1178
1179 TouchEvent touchEvent;
1180 touchEvent.x = 100.0;
1181 touchEvent.y = 100.0;
1182 touchEvent.sourceType = SourceType::MOUSE;
1183
1184 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1185 clickRecognizerPtr->fingers_ = 0;
1186 clickRecognizerPtr->HandleTouchDownEvent(touchEvent);
1187 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::PENDING);
1188 }
1189
1190 /**
1191 * @tc.name: ClickRecognizerHandleOverdueDeadlineTest001
1192 * @tc.desc: Test HandleOverdueDeadline in ClickRecognizer
1193 */
1194 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleOverdueDeadlineTest001, TestSize.Level1)
1195 {
1196 /**
1197 * @tc.steps: step1. create clickRecognizerPtr.
1198 */
1199 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1200 TouchEvent touchEvent;
1201
1202 /**
1203 * @tc.steps: step2. set HandleOverdueDeadline function.
1204 */
1205 clickRecognizerPtr->currentTouchPointsNum_ = clickRecognizerPtr->fingers_ - 1;
1206 clickRecognizerPtr->HandleOverdueDeadline();
1207 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::FAIL);
1208
1209 /**
1210 * @tc.steps: step2. set HandleOverdueDeadline function.
1211 */
1212 clickRecognizerPtr->currentTouchPointsNum_ = clickRecognizerPtr->fingers_;
1213 clickRecognizerPtr->tappedCount_ = clickRecognizerPtr->count_ - 1;
1214 clickRecognizerPtr->HandleOverdueDeadline();
1215 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::FAIL);
1216 }
1217
1218 /**
1219 * @tc.name: ClickRecognizerExceedSlopTest001
1220 * @tc.desc: Test ExceedSlop in ClickRecognizer
1221 */
1222 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerExceedSlopTest001, TestSize.Level1)
1223 {
1224 /**
1225 * @tc.steps: step1. create clickRecognizerPtr.
1226 */
1227 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1228 TouchEvent touchEvent;
1229
1230 clickRecognizerPtr->tappedCount_ = -1;
1231 clickRecognizerPtr->ExceedSlop();
1232 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::READY);
1233 clickRecognizerPtr->tappedCount_ = 1;
1234 clickRecognizerPtr->count_ = 0;
1235 clickRecognizerPtr->ExceedSlop();
1236 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::READY);
1237 clickRecognizerPtr->tappedCount_ = 1;
1238 clickRecognizerPtr->count_ = 2;
1239 clickRecognizerPtr->ExceedSlop();
1240 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::READY);
1241 }
1242
1243 /**
1244 * @tc.name: ClickRecognizerHandleTouchCancelEventTest001
1245 * @tc.desc: Test HandleTouchCancelEvent in ClickRecognizer
1246 */
1247 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleTouchCancelEventTest001, TestSize.Level1)
1248 {
1249 /**
1250 * @tc.steps: step1. create clickRecognizerPtr.
1251 */
1252 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1253 TouchEvent touchEvent;
1254
1255 clickRecognizerPtr->refereeState_ = RefereeState::PENDING;
1256 clickRecognizerPtr->HandleTouchCancelEvent(touchEvent);
1257 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::FAIL);
1258 }
1259
1260 /**
1261 * @tc.name: ClickRecognizerHandleOverdueDeadlineTest002
1262 * @tc.desc: Test HandleOverdueDeadline in ClickRecognizer
1263 */
1264 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleOverdueDeadlineTest002, TestSize.Level1)
1265 {
1266 /**
1267 * @tc.steps: step1. create clickRecognizerPtr.
1268 */
1269 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1270 TouchEvent touchEvent;
1271
1272 /**
1273 * @tc.steps: step2. set HandleOverdueDeadline function.
1274 */
1275 clickRecognizerPtr->currentTouchPointsNum_ = clickRecognizerPtr->fingers_ - 1;
1276 clickRecognizerPtr->HandleOverdueDeadline();
1277 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::FAIL);
1278
1279 /**
1280 * @tc.steps: step2. set HandleOverdueDeadline function.
1281 */
1282 clickRecognizerPtr->currentTouchPointsNum_ = clickRecognizerPtr->fingers_;
1283 clickRecognizerPtr->tappedCount_ = clickRecognizerPtr->count_ - 1;
1284 clickRecognizerPtr->HandleOverdueDeadline();
1285 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::FAIL);
1286 }
1287
1288 /**
1289 * @tc.name: ClickRecognizerHandleOverdueDeadlineTest012
1290 * @tc.desc: Test HandleOverdueDeadline in ClickRecognizer
1291 */
1292 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleOverdueDeadlineTest012, TestSize.Level1)
1293 {
1294 /**
1295 * @tc.steps: step1. create clickRecognizerPtr.
1296 */
1297 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1298
1299 /**
1300 * @tc.steps: step2. set HandleOverdueDeadline function.
1301 */
1302 clickRecognizerPtr->AttachFrameNode(nullptr);
1303
1304 PointF f1 = PointF(1.0, 0.0);
1305 NGGestureRecognizer::Transform(f1, clickRecognizerPtr->GetAttachedNode());
1306 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::READY);
1307 }
1308
1309 /**
1310 * @tc.name: ClickRecognizerHandleOverdueDeadlineTest013
1311 * @tc.desc: Test HandleOverdueDeadline in ClickRecognizer
1312 */
1313 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleOverdueDeadlineTest013, TestSize.Level1)
1314 {
1315 /**
1316 * @tc.steps: step1. create clickRecognizerPtr.
1317 */
1318 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1319
1320 /**
1321 * @tc.steps: step2. set HandleOverdueDeadline function.
1322 */
1323 clickRecognizerPtr->AttachFrameNode(nullptr);
1324
1325 PointF f1 = PointF(1.0, 0.0);
1326 NGGestureRecognizer::Transform(f1, clickRecognizerPtr->GetAttachedNode());
1327 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::READY);
1328 }
1329
1330 /**
1331 * @tc.name: ClickRecognizerHandleOverdueDeadlineTest014
1332 * @tc.desc: Test HandleOverdueDeadline in ClickRecognizer
1333 */
1334 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleOverdueDeadlineTest014, TestSize.Level1)
1335 {
1336 /**
1337 * @tc.steps: step1. create clickRecognizerPtr.
1338 */
1339 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1340
1341 /**
1342 * @tc.steps: step2. set HandleOverdueDeadline function.
1343 */
1344 clickRecognizerPtr->AttachFrameNode(nullptr);
1345
1346 PointF f1 = PointF(1.0, 0.0);
1347 NGGestureRecognizer::Transform(f1, clickRecognizerPtr->GetAttachedNode());
1348 EXPECT_EQ(clickRecognizerPtr->refereeState_, RefereeState::READY);
1349 }
1350
1351 /**
1352 * @tc.name: GestureAccessibilityEventTest001
1353 * @tc.desc: Test SetOnAccessibility in ClickRecognizer
1354 */
1355 HWTEST_F(ClickRecognizerTestNg, GestureAccessibilityEventTest001, TestSize.Level1)
1356 {
1357 /**
1358 * @tc.steps: step1. Create clickRecognizer.
1359 */
1360 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(SINGLE_FINGER_NUMBER, TAPPED_COUNT);
1361
1362 /**
1363 * @tc.steps: step2. set callback function.
1364 */
__anonc9df6cc10a02(AccessibilityEventType eventType) 1365 auto onAccessibilityEvent = [](AccessibilityEventType eventType) {};
1366 clickRecognizer->SetOnAccessibility(onAccessibilityEvent);
1367 ASSERT_NE(clickRecognizer->onAccessibilityEventFunc_, nullptr);
1368
1369 /**
1370 * @tc.steps: step3. call callback function.
1371 * @tc.expected: refereeState_ is SUCCEED.
1372 */
1373 clickRecognizer->OnAccepted();
1374 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED);
1375 }
1376
1377 /**
1378 * @tc.name: ClickRecognizerHandleTouchUpEvent001
1379 * @tc.desc: Test ClickRecognizer function: HandleTouchUpEvent
1380 * @tc.type: FUNC
1381 */
1382 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleTouchUpEvent001, TestSize.Level1)
1383 {
1384 /**
1385 * @tc.steps: step1. create and set Recognizer、TargetComponent.
1386 */
1387 RefPtr<ClickRecognizer> clickRecognizerPtr = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1388 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
1389 DimensionRect area;
1390 DimensionOffset origin;
1391 EventTarget target = { "", "", area, origin };
__anonc9df6cc10b02(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1392 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
1393 return GestureJudgeResult::REJECT;
1394 };
1395 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
1396 TouchEvent touchEvent;
1397 touchEvent.tiltX.emplace(1.0f);
1398 touchEvent.tiltY.emplace(1.0f);
1399 clickRecognizerPtr->targetComponent_ = targetComponent;
1400 /**
1401 * @tc.steps: step2. test the function who calls TriggerGestureJudgeCallback.
1402 * @tc.expected: step2. result equals REJECT.
1403 */
1404 clickRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1405 clickRecognizerPtr->currentTouchPointsNum_ = 1;
1406 clickRecognizerPtr->equalsToFingers_ = true;
1407 clickRecognizerPtr->useCatchMode_ = true;
1408 clickRecognizerPtr->tappedCount_ = -1;
1409 clickRecognizerPtr->count_ = 0;
1410 clickRecognizerPtr->fingersId_.insert(0);
1411 clickRecognizerPtr->SetIsSystemGesture(false);
1412 clickRecognizerPtr->gestureInfo_->SetTag("test");
1413 clickRecognizerPtr->HandleTouchUpEvent(touchEvent);
1414 EXPECT_EQ(clickRecognizerPtr->disposal_, GestureDisposal::REJECT);
1415 }
1416
1417 /**
1418 * @tc.name: ClickRecognizerHandleTouchUpEvent002
1419 * @tc.desc: Test ClickRecognizer function: HandleTouchUpEvent
1420 * @tc.type: FUNC
1421 */
1422 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerHandleTouchUpEvent002, TestSize.Level1)
1423 {
1424 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1425 clickRecognizer->refereeState_ = RefereeState::SUCCEED;
1426 clickRecognizer->currentFingers_ = 0;
1427 clickRecognizer->CleanRecognizerState();
1428 clickRecognizer->refereeState_ = RefereeState::FAIL;
1429 clickRecognizer->currentFingers_ = 0;
1430 clickRecognizer->CleanRecognizerState();
1431 clickRecognizer->refereeState_ = RefereeState::DETECTING;
1432 clickRecognizer->currentFingers_ = 0;
1433 clickRecognizer->CleanRecognizerState();
1434 clickRecognizer->refereeState_ = RefereeState::SUCCEED_BLOCKED;
1435 clickRecognizer->currentFingers_ = 0;
1436 clickRecognizer->CleanRecognizerState();
1437 clickRecognizer->refereeState_ = RefereeState::DETECTING;
1438 clickRecognizer->currentFingers_ = 1;
1439 clickRecognizer->CleanRecognizerState();
1440 clickRecognizer->refereeState_ = RefereeState::SUCCEED_BLOCKED;
1441 clickRecognizer->currentFingers_ = 1;
1442 clickRecognizer->CleanRecognizerState();
1443 EXPECT_EQ(clickRecognizer->refereeState_, RefereeState::SUCCEED_BLOCKED);
1444 }
1445
1446 /**
1447 * @tc.name: ClickEventRecordTest001
1448 * @tc.desc: test RecordClickEventIfNeed.
1449 * @tc.type: FUNC
1450 */
1451 HWTEST_F(ClickRecognizerTestNg, ClickEventRecordTest001, TestSize.Level1)
1452 {
1453 int32_t componentIndex = static_cast<int32_t>(Recorder::EventCategory::CATEGORY_COMPONENT);
1454 int32_t rectIndex = static_cast<int32_t>(Recorder::EventCategory::CATEGORY_RECT);
1455 Recorder::EventRecorder::Get().eventSwitch_[componentIndex] = true;
1456 Recorder::EventRecorder::Get().eventSwitch_[rectIndex] = true;
1457 Recorder::EventRecorder::Get().globalSwitch_[componentIndex] = true;
1458 Recorder::EventRecorder::Get().globalSwitch_[rectIndex] = true;
1459 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1460 GestureEvent info = GestureEvent();
1461 clickRecognizer->RecordClickEventIfNeed(info);
1462 EXPECT_TRUE(clickRecognizer->GetAttachedNode().Upgrade() == nullptr);
1463 }
1464
1465 /**
1466 * @tc.name: TapGestureLimit001
1467 * @tc.desc: Test TapGesture with isFingerCountLimited
1468 */
1469
1470 HWTEST_F(ClickRecognizerTestNg, TapGestureLimit001, TestSize.Level1)
1471 {
1472 /**
1473 * @tc.steps: step1. create TapGestureGesture.
1474 */
1475 TapGestureModelNG tapGestureModelNG;
1476 tapGestureModelNG.Create(COUNT, FINGER_NUMBER, 10, IS_LIMIT_FINGER_COUNT);
1477
1478 RefPtr<GestureProcessor> gestureProcessor;
1479 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
1480 auto tapGestureNG = AceType::DynamicCast<NG::TapGesture>(gestureProcessor->TopGestureNG());
1481 EXPECT_EQ(tapGestureNG->isLimitFingerCount_, IS_LIMIT_FINGER_COUNT);
1482
1483 TapGesture tapGesture = TapGesture(COUNT, FINGER_NUMBER, 10, IS_LIMIT_FINGER_COUNT);
1484 EXPECT_EQ(tapGesture.isLimitFingerCount_, IS_LIMIT_FINGER_COUNT);
1485
1486 /**
1487 * @tc.steps: step2. call CreateRecognizer function and compare result
1488 * @tc.steps: case1: compare isLimitFingerCount_
1489 */
1490 tapGesture.priority_ = GesturePriority::Low;
1491 tapGesture.gestureMask_ = GestureMask::Normal;
1492 auto tapRecognizer = AceType::DynamicCast<ClickRecognizer>(tapGesture.CreateRecognizer());
1493 EXPECT_EQ(tapRecognizer->isLimitFingerCount_, IS_LIMIT_FINGER_COUNT);
1494 }
1495
1496 /**
1497 * @tc.name: TapGestureLimit002
1498 * @tc.desc: Test TapGesture with isFingerCountLimited
1499 */
1500
1501 HWTEST_F(ClickRecognizerTestNg, TapGestureLimit002, TestSize.Level1)
1502 {
1503 /**
1504 * @tc.steps: step1. create TapGestureGesture.
1505 */
1506 TapGestureModelNG tapGestureModelNG;
1507 tapGestureModelNG.Create(COUNT, FINGER_NUMBER, 10, IS_NOT_LIMIT_FINGER_COUNT);
1508
1509 RefPtr<GestureProcessor> gestureProcessor;
1510 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
1511 auto tapGestureNG = AceType::DynamicCast<NG::TapGesture>(gestureProcessor->TopGestureNG());
1512 EXPECT_EQ(tapGestureNG->isLimitFingerCount_, IS_NOT_LIMIT_FINGER_COUNT);
1513
1514 TapGesture tapGesture = TapGesture(COUNT, FINGER_NUMBER, 10, IS_NOT_LIMIT_FINGER_COUNT);
1515 EXPECT_EQ(tapGesture.isLimitFingerCount_, IS_NOT_LIMIT_FINGER_COUNT);
1516
1517 /**
1518 * @tc.steps: step2. call CreateRecognizer function and compare result
1519 * @tc.steps: case1: compare isLimitFingerCount_
1520 */
1521 tapGesture.priority_ = GesturePriority::Low;
1522 tapGesture.gestureMask_ = GestureMask::Normal;
1523 auto tapRecognizer = AceType::DynamicCast<ClickRecognizer>(tapGesture.CreateRecognizer());
1524 EXPECT_EQ(tapRecognizer->isLimitFingerCount_, IS_NOT_LIMIT_FINGER_COUNT);
1525 }
1526
1527 /**
1528 * @tc.name: HandleTouchUpEventTest001
1529 * @tc.desc: Test HandleTouchUpEvent
1530 */
1531 HWTEST_F(ClickRecognizerTestNg, HandleTouchUpEventTest001, TestSize.Level1)
1532 {
1533 /**
1534 * @tc.steps: step1. create ClickRecognizer.
1535 */
1536 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1537
1538 /**
1539 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
1540 * @tc.steps: case1: refereeState is READY.
1541 * @tc.expected: step2. result equals.
1542 */
1543 TouchEvent touchEvent;
1544 clickRecognizer->currentTouchPointsNum_ = 1;
1545 clickRecognizer->equalsToFingers_ = true;
1546 clickRecognizer->HandleTouchUpEvent(touchEvent);
1547 EXPECT_EQ(clickRecognizer->disposal_, GestureDisposal::PENDING);
1548
1549 /**
1550 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
1551 * @tc.steps: case2: touchEvent.sourceType is SourceType::MOUSE.
1552 * @tc.expected: step2. result equals.
1553 */
1554 touchEvent.sourceType = SourceType::MOUSE;
1555 clickRecognizer->HandleTouchUpEvent(touchEvent);
1556 EXPECT_EQ(clickRecognizer->disposal_, GestureDisposal::PENDING);
1557
1558 /**
1559 * @tc.steps: step3. call AboutToAddToPendingRecognizers function and compare result.
1560 * @tc.steps: case1: refereeState is PENDING_BLOCKED.
1561 * @tc.expected: step3. result equals.
1562 */
1563 clickRecognizer->refereeState_ = RefereeState::PENDING_BLOCKED;
1564 clickRecognizer->AboutToAddToPendingRecognizers(touchEvent);
1565 EXPECT_EQ(clickRecognizer->disposal_, GestureDisposal::PENDING);
1566
1567 /**
1568 * @tc.steps: step3. call AboutToAddToPendingRecognizers function and compare result.
1569 * @tc.steps: case2: refereeState is PENDING.
1570 * @tc.expected: step3. result equals.
1571 */
1572 clickRecognizer->refereeState_ = RefereeState::PENDING;
1573 clickRecognizer->AboutToAddToPendingRecognizers(touchEvent);
1574 EXPECT_EQ(clickRecognizer->disposal_, GestureDisposal::PENDING);
1575 }
1576
1577 /*
1578 * @tc.name: IsPointInRegionTest001
1579 * @tc.desc: Test IsPointInRegion
1580 * @tc.type: FUNC
1581 */
1582 HWTEST_F(ClickRecognizerTestNg, IsPointInRegionTest001, TestSize.Level1)
1583 {
1584 /**
1585 * @tc.steps: step1. create ClickRecognizer.
1586 */
1587 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT, 0);
1588 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
1589 TouchEvent touchEvent;
1590 double distanceThreshold = 1.0;
1591
1592 /**
1593 * @tc.steps: step2. call IsPointInRegion function and compare result.
1594 * @tc.steps: case1: distanceThreshold is 1.0.
1595 * @tc.expected: step2. result equals.
1596 */
1597 touchEvent.SetScreenX(DEFAULT_DOUBLE_100);
1598 touchEvent.SetScreenY(DEFAULT_DOUBLE_100);
1599 clickRecognizer->SetDistanceThreshold(distanceThreshold);
1600 bool result = clickRecognizer->IsPointInRegion(touchEvent);
1601 EXPECT_FALSE(result);
1602 EXPECT_EQ(clickRecognizer->disposal_, GestureDisposal::REJECT);
1603
1604 /**
1605 * @tc.steps: step2. call IsPointInRegion function and compare result.
1606 * @tc.steps: case2: distanceThreshold is 0.0.
1607 * @tc.expected: step2. result equals.
1608 */
1609 distanceThreshold = 0.0;
1610 clickRecognizer->SetDistanceThreshold(distanceThreshold);
1611 clickRecognizer->AttachFrameNode(frameNode);
1612 result = clickRecognizer->IsPointInRegion(touchEvent);
1613 EXPECT_FALSE(result);
1614 }
1615
1616 /*
1617 * @tc.name: GetClickInfoTest001
1618 * @tc.desc: Test GetClickInfo
1619 * @tc.type: FUNC
1620 */
1621 HWTEST_F(ClickRecognizerTestNg, GetClickInfoTest001, TestSize.Level1)
1622 {
1623 /**
1624 * @tc.steps: step1. create ClickRecognizer.
1625 */
1626 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1627 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
1628 TouchEvent touchEvent;
1629
1630 /**
1631 * @tc.steps: step2. call GetClickInfo function and compare result.
1632 * @tc.steps: case: rollAngle has value.
1633 * @tc.expected: step2. result equals.
1634 */
1635 touchEvent.rollAngle = 0;
1636 clickRecognizer->AttachFrameNode(frameNode);
1637 clickRecognizer->touchPoints_[0] = touchEvent;
1638 ClickInfo result = clickRecognizer->GetClickInfo();
1639 EXPECT_EQ(result.GetPatternName(), "myButton");
1640 EXPECT_EQ(result.GetRollAngle(), 0);
1641 }
1642
1643 /*
1644 * @tc.name: IsFormRenderClickRejectedTest001
1645 * @tc.desc: Test IsFormRenderClickRejected
1646 * @tc.type: FUNC
1647 */
1648 HWTEST_F(ClickRecognizerTestNg, IsFormRenderClickRejectedTest001, TestSize.Level1)
1649 {
1650 /**
1651 * @tc.steps: step1. create ClickRecognizer.
1652 */
1653 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1654 TouchEvent touchEvent;
1655 TouchEvent testTouchEvent;
1656
1657 /**
1658 * @tc.steps: step2. call IsFormRenderClickRejected function and compare result.
1659 * @tc.steps: case1: touchEvent is default.
1660 * @tc.expected: step2. result is false.
1661 */
1662 bool result = clickRecognizer->IsFormRenderClickRejected(touchEvent);
1663 EXPECT_FALSE(result);
1664
1665 /**
1666 * @tc.steps: step2. call IsFormRenderClickRejected function and compare result.
1667 * @tc.steps: case2: touchEvent is not default.
1668 * @tc.expected: step2. result is true.
1669 */
1670 touchEvent.SetScreenX(DEFAULT_DOUBLE_100);
1671 touchEvent.SetScreenY(DEFAULT_DOUBLE_100);
1672 testTouchEvent.SetScreenX(DEFAULT_DOUBLE_50);
1673 testTouchEvent.SetScreenY(DEFAULT_DOUBLE_50);
1674 clickRecognizer->touchPoints_[0] = testTouchEvent;
1675 result = clickRecognizer->IsFormRenderClickRejected(touchEvent);
1676 EXPECT_TRUE(result);
1677 }
1678
1679 /*
1680 * @tc.name: GetGestureEventInfoTest001
1681 * @tc.desc: Test GetGestureEventInfo
1682 * @tc.type: FUNC
1683 */
1684 HWTEST_F(ClickRecognizerTestNg, GetGestureEventInfoTest001, TestSize.Level1)
1685 {
1686 /**
1687 * @tc.steps: step1. create ClickRecognizer.
1688 */
1689 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1690 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
1691 TouchEvent touchEvent;
1692
1693 /**
1694 * @tc.steps: step2. call GetGestureEventInfo function and compare result.
1695 * @tc.steps: case: touchEvent is not default.
1696 * @tc.expected: step2. result equals.
1697 */
1698 touchEvent.sourceType = SourceType::MOUSE;
1699 touchEvent.SetTiltX(0);
1700 touchEvent.SetTiltY(0);
1701 touchEvent.rollAngle = 0;
1702 touchEvent.convertInfo.first = UIInputEventType::AXIS;
1703 touchEvent.convertInfo.second = UIInputEventType::TOUCH;
1704 clickRecognizer->AttachFrameNode(frameNode);
1705 clickRecognizer->touchPoints_[0] = touchEvent;
1706 GestureEvent result = clickRecognizer->GetGestureEventInfo();
1707 EXPECT_EQ(result.GetPatternName(), "myButton");
1708 EXPECT_EQ(result.GetTiltX(), 0);
1709 EXPECT_EQ(result.GetTiltY(), 0);
1710 EXPECT_EQ(result.GetRollAngle(), 0);
1711 EXPECT_EQ(result.GetOriginUIInputEventType(), UIInputEventType::AXIS);
1712 EXPECT_EQ(result.GetCurrentUIInputEventType(), UIInputEventType::TOUCH);
1713 }
1714
1715 /**
1716 * @tc.name: TriggerGestureJudgeCallbackTest001
1717 * @tc.desc: Test TriggerGestureJudgeCallback
1718 * @tc.type: FUNC
1719 */
1720 HWTEST_F(ClickRecognizerTestNg, TriggerGestureJudgeCallbackTest001, TestSize.Level1)
1721 {
1722 /**
1723 * @tc.steps: step1. create ClickRecognizer.
1724 */
1725 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
1726 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anonc9df6cc10c02(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1727 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
1728 return GestureJudgeResult::REJECT;
1729 };
1730 auto func = [](const std::shared_ptr<BaseGestureEvent>& info, const RefPtr<NGGestureRecognizer>& current,
__anonc9df6cc10d02(const std::shared_ptr<BaseGestureEvent>& info, const RefPtr<NGGestureRecognizer>& current, const std::list<RefPtr<NGGestureRecognizer>>& others) 1731 const std::list<RefPtr<NGGestureRecognizer>>& others) { return GestureJudgeResult::REJECT; };
1732 TouchEvent touchEvent;
1733
1734 /**
1735 * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
1736 * @tc.steps: case1: targetComponent is default.
1737 * @tc.expected: step2. result equals.
1738 */
1739 touchEvent.rollAngle = 0;
1740 clickRecognizer->touchPoints_[0] = touchEvent;
1741 clickRecognizer->targetComponent_ = targetComponent;
1742 GestureJudgeResult result = clickRecognizer->TriggerGestureJudgeCallback();
1743 EXPECT_EQ(result, GestureJudgeResult::CONTINUE);
1744
1745 /**
1746 * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
1747 * @tc.steps: case2: gestureRecognizerJudgeFunc is not null.
1748 * @tc.expected: step2. result equals.
1749 */
1750 targetComponent->SetOnGestureRecognizerJudgeBegin(func);
1751 result = clickRecognizer->TriggerGestureJudgeCallback();
1752 EXPECT_EQ(result, GestureJudgeResult::REJECT);
1753
1754 /**
1755 * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
1756 * @tc.steps: case3: sysJudge_ is not null.
1757 * @tc.expected: step2. result equals.
1758 */
1759 clickRecognizer->sysJudge_ = gestureJudgeFunc;
1760 result = clickRecognizer->TriggerGestureJudgeCallback();
1761 EXPECT_EQ(result, GestureJudgeResult::REJECT);
1762 }
1763
1764 /**
1765 * @tc.name: TriggerGestureJudgeCallbackTest003
1766 * @tc.desc: Test TriggerGestureJudgeCallback
1767 * @tc.type: FUNC
1768 */
1769 HWTEST_F(ClickRecognizerTestNg, TriggerGestureJudgeCallbackTest003, TestSize.Level1)
1770 {
1771 /**
1772 * @tc.steps: step1. create ClickRecognizer.
1773 */
1774 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(2, COUNT, 0, true);
1775 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anonc9df6cc10e02(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1776 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
1777 return GestureJudgeResult::REJECT;
1778 };
1779 auto func = [](const std::shared_ptr<BaseGestureEvent>& info, const RefPtr<NGGestureRecognizer>& current,
__anonc9df6cc10f02(const std::shared_ptr<BaseGestureEvent>& info, const RefPtr<NGGestureRecognizer>& current, const std::list<RefPtr<NGGestureRecognizer>>& others) 1780 const std::list<RefPtr<NGGestureRecognizer>>& others) { return GestureJudgeResult::REJECT; };
1781 TouchEvent touchEvent;
1782
1783 /**
1784 * @tc.steps: step2. call TriggerGestureJudgeCallback function and compare result.
1785 * @tc.steps: case1: targetComponent is default.
1786 * @tc.expected: step2. result equals.
1787 */
1788
1789 targetComponent->SetOnGestureRecognizerJudgeBegin(func);
1790 touchEvent.rollAngle = 0;
1791 clickRecognizer->touchPoints_[0] = touchEvent;
1792 clickRecognizer->touchPoints_[1] = touchEvent;
1793 clickRecognizer->touchPoints_[2] = touchEvent;
1794 clickRecognizer->targetComponent_ = targetComponent;
1795 clickRecognizer->TriggerClickAccepted(touchEvent);
1796 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
1797 EXPECT_EQ(clickRecognizer->disposal_, GestureDisposal::REJECT);
1798 }
1799
1800 /**
1801 * @tc.name: OnAcceptedTest001
1802 * @tc.desc: Test OnAccepted
1803 */
1804 HWTEST_F(ClickRecognizerTestNg, OnAcceptedTest001, TestSize.Level1)
1805 {
1806 /**
1807 * @tc.steps: step1. Create clickRecognizer.
1808 */
1809 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, TAPPED_COUNT);
1810
1811 /**
1812 * @tc.steps: step2. call OnAccepted function and compare result.
1813 * @tc.expected: result equals.
1814 */
1815 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1816 clickRecognizer->firstInputTime_ = timeStape;
1817 clickRecognizer->OnAccepted();
1818 EXPECT_FALSE(clickRecognizer->firstInputTime_.has_value());
1819 }
1820
1821 /**
1822 * @tc.name: UpdateInfoWithDownEventTest001
1823 * @tc.desc: Test UpdateInfoWithDownEvent
1824 */
1825 HWTEST_F(ClickRecognizerTestNg, UpdateInfoWithDownEventTest001, TestSize.Level1)
1826 {
1827 /**
1828 * @tc.steps: step1. Create clickRecognizer.
1829 */
1830 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, TAPPED_COUNT);
1831 auto frameNode = FrameNode::CreateFrameNode("myButton", 0, AceType::MakeRefPtr<Pattern>());
1832 TouchEvent touchEvent;
1833
1834 /**
1835 * @tc.steps: step2. call UpdateInfoWithDownEvent function and compare result.
1836 * @tc.expected: result equals.
1837 */
1838 clickRecognizer->AttachFrameNode(frameNode);
1839 clickRecognizer->UpdateInfoWithDownEvent(touchEvent);
1840 EXPECT_FALSE(clickRecognizer->equalsToFingers_);
1841 }
1842
1843
1844 /**
1845 * @tc.name: ClickRecognizerBasicInfoTest001
1846 * @tc.desc: Test case basic input info check.
1847 * @tc.type: FUNC
1848 */
1849 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerBasicInfoTest001, TestSize.Level1)
1850 {
1851 /**
1852 * @tc.steps: step1. Create basic info testCases.
1853 * @tc.expected: set clickRecognizer basic info correct.
1854 */
1855 const std::vector<MockClickRecognizerCase> mockClickRecognizerCases = {
1856 {1, 1, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 1, 1,
1857 Dimension(std::numeric_limits<double>::infinity()), RefereeState::READY, {}},
1858 {-1, 1, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 1, 1,
1859 Dimension(std::numeric_limits<double>::infinity()), RefereeState::READY, {}},
1860 {1, -1, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 1, -1,
1861 Dimension(std::numeric_limits<double>::infinity()), RefereeState::READY, {}},
1862 {1, 1, Dimension(-1), 1, RefereeState::READY, 1, 1,
1863 Dimension(std::numeric_limits<double>::infinity()), RefereeState::READY, {}}
1864 };
1865 for (auto i = 0; i < mockClickRecognizerCases.size(); i++) {
1866 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(
1867 mockClickRecognizerCases[i].fingers, mockClickRecognizerCases[i].count,
1868 mockClickRecognizerCases[i].distanceThreshold);
1869 clickRecognizer->refereeState_ = mockClickRecognizerCases[i].refereeState;
1870 EXPECT_EQ(clickRecognizer->fingers_, mockClickRecognizerCases[i].expectedFingers);
1871 EXPECT_EQ(clickRecognizer->count_, mockClickRecognizerCases[i].expectedCount);
1872 EXPECT_EQ(clickRecognizer->distanceThreshold_.ConvertToPx(),
1873 mockClickRecognizerCases[i].expectedDistanceThreshold.ConvertToPx());
1874 EXPECT_EQ(clickRecognizer->refereeState_, mockClickRecognizerCases[i].expectedRefereeState);
1875 }
1876 }
1877
1878 /**
1879 * @tc.name: ClickRecognizerInjectEventsTest001
1880 * @tc.desc: Test case inject events.
1881 * @tc.type: FUNC
1882 */
1883 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerInjectEventsTest001, TestSize.Level1)
1884 {
1885 /**
1886 * @tc.steps: step1. Create basic info testCases.
1887 * @tc.expected: set clickRecognizer basic info correct.
1888 */
1889 TouchEvent downEvent = TouchEvent();
1890 downEvent.type = TouchType::DOWN;
1891 TouchEvent upEvent = TouchEvent();
1892 upEvent.type = TouchType::UP;
1893
1894 const std::vector<MockClickRecognizerCase> mockClickRecognizerCases = {
1895 {1, 1, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 1, 1,
1896 Dimension(std::numeric_limits<double>::infinity()), RefereeState::SUCCEED, {downEvent, upEvent}},
1897 {-1, 1, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 1, 1,
1898 Dimension(std::numeric_limits<double>::infinity()), RefereeState::SUCCEED, {downEvent, upEvent}},
1899 {1, -1, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 1, -1,
1900 Dimension(std::numeric_limits<double>::infinity()), RefereeState::PENDING, {downEvent, upEvent}},
1901 {1, 1, Dimension(-1), 1, RefereeState::READY, 1, 1,
1902 Dimension(std::numeric_limits<double>::infinity()), RefereeState::SUCCEED, {downEvent, upEvent}},
1903 {1, 2, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 1, 2,
1904 Dimension(std::numeric_limits<double>::infinity()), RefereeState::PENDING, {downEvent, upEvent}},
1905 {1, 2, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 1, 2,
1906 Dimension(std::numeric_limits<double>::infinity()), RefereeState::SUCCEED,
1907 {downEvent, upEvent, downEvent, upEvent}},
1908 };
1909 for (auto i = 0; i < mockClickRecognizerCases.size(); i++) {
1910 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(
1911 mockClickRecognizerCases[i].fingers, mockClickRecognizerCases[i].count,
1912 mockClickRecognizerCases[i].distanceThreshold);
1913 clickRecognizer->refereeState_ = mockClickRecognizerCases[i].refereeState;
1914 for (auto j = 0; j < mockClickRecognizerCases[i].inputTouchEvents.size(); j++) {
1915 clickRecognizer->ProcessTouchEvent(mockClickRecognizerCases[i].inputTouchEvents[j]);
1916 }
1917 EXPECT_EQ(clickRecognizer->fingers_, mockClickRecognizerCases[i].expectedFingers);
1918 EXPECT_EQ(clickRecognizer->count_, mockClickRecognizerCases[i].expectedCount);
1919 EXPECT_EQ(clickRecognizer->distanceThreshold_.ConvertToPx(),
1920 mockClickRecognizerCases[i].expectedDistanceThreshold.ConvertToPx());
1921 EXPECT_EQ(clickRecognizer->refereeState_, mockClickRecognizerCases[i].expectedRefereeState);
1922 }
1923 }
1924
1925 /**
1926 * @tc.name: ClickRecognizerInjectEventsTest002
1927 * @tc.desc: Test case inject events.
1928 * @tc.type: FUNC
1929 */
1930 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerInjectEventsTest002, TestSize.Level1)
1931 {
1932 /**
1933 * @tc.steps: step1. Create basic info testCases.
1934 * @tc.expected: set clickRecognizer basic info correct.
1935 */
1936 TouchEvent downEventFinger0 = TouchEvent();
1937 TouchEvent downEventFinger1 = TouchEvent();
1938 downEventFinger0.type = TouchType::DOWN;
1939 downEventFinger1.type = TouchType::DOWN;
1940 downEventFinger0.id = 0;
1941 downEventFinger1.id = 1;
1942
1943 TouchEvent upEventFinger0 = TouchEvent();
1944 TouchEvent upEventFinger1 = TouchEvent();
1945 upEventFinger0.type = TouchType::UP;
1946 upEventFinger1.type = TouchType::UP;
1947 upEventFinger0.id = 0;
1948 upEventFinger1.id = 1;
1949
1950 const std::vector<MockClickRecognizerCase> mockClickRecognizerCases = {
1951 {2, 1, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 2, 1,
1952 Dimension(std::numeric_limits<double>::infinity()), RefereeState::FAIL,
1953 {downEventFinger0, upEventFinger0}},
1954 {2, -1, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 2, -1,
1955 Dimension(std::numeric_limits<double>::infinity()), RefereeState::FAIL,
1956 {downEventFinger0, upEventFinger0}},
1957 {2, 1, Dimension(-1), 1, RefereeState::READY, 2, 1,
1958 Dimension(std::numeric_limits<double>::infinity()), RefereeState::FAIL,
1959 {downEventFinger0, upEventFinger0}},
1960 {2, 2, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 2, 2,
1961 Dimension(std::numeric_limits<double>::infinity()), RefereeState::FAIL,
1962 {downEventFinger0, upEventFinger0}},
1963 {2, 2, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 2, 2,
1964 Dimension(std::numeric_limits<double>::infinity()), RefereeState::FAIL,
1965 {downEventFinger0, upEventFinger0, downEventFinger0, upEventFinger0}},
1966 {2, 1, Dimension(std::numeric_limits<double>::infinity()), 1, RefereeState::READY, 2, 1,
1967 Dimension(std::numeric_limits<double>::infinity()), RefereeState::SUCCEED,
1968 {downEventFinger0, downEventFinger1, upEventFinger0, upEventFinger1}},
1969 };
1970 for (auto i = 0; i < mockClickRecognizerCases.size(); i++) {
1971 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(
1972 mockClickRecognizerCases[i].fingers, mockClickRecognizerCases[i].count,
1973 mockClickRecognizerCases[i].distanceThreshold);
1974 clickRecognizer->refereeState_ = mockClickRecognizerCases[i].refereeState;
1975 for (auto j = 0; j < mockClickRecognizerCases[i].inputTouchEvents.size(); j++) {
1976 clickRecognizer->ProcessTouchEvent(mockClickRecognizerCases[i].inputTouchEvents[j]);
1977 }
1978 EXPECT_EQ(clickRecognizer->fingers_, mockClickRecognizerCases[i].expectedFingers);
1979 EXPECT_EQ(clickRecognizer->count_, mockClickRecognizerCases[i].expectedCount);
1980 EXPECT_EQ(clickRecognizer->distanceThreshold_.ConvertToPx(),
1981 mockClickRecognizerCases[i].expectedDistanceThreshold.ConvertToPx());
1982 EXPECT_EQ(clickRecognizer->refereeState_, mockClickRecognizerCases[i].expectedRefereeState);
1983 }
1984 }
1985
1986 /**
1987 * @tc.name: ClickRecognizerTypeTest001
1988 * @tc.desc: Test ClickRecognizer Type function: ClickRecognizerTypeTest001
1989 * @tc.type: FUNC
1990 */
1991 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTypeTest001, TestSize.Level1)
1992 {
1993 /**
1994 * @tc.steps: step1. Create clickRecognizer.
1995 */
1996 GestureEvent info = GestureEvent();
1997 /**
1998 * @tc.steps: step2. call SetGestureTypeName
1999 * @tc.expected: result equals.
2000 */
2001 info.SetGestureTypeName(GestureTypeName::TAP_GESTURE);
2002 EXPECT_EQ(info.GetGestureTypeName(), GestureTypeName::TAP_GESTURE);
2003 }
2004
2005 /**
2006 * @tc.name: ClickRecognizerTypeTest002
2007 * @tc.desc: Test ClickRecognizerType
2008 */
2009 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTypeTest002, TestSize.Level1)
2010 {
2011 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, TAPPED_COUNT);
2012 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
2013 clickRecognizer->AttachFrameNode(frameNode);
2014 clickRecognizer->SetRecognizerType(GestureTypeName::CLICK);
2015 GestureEvent info = GestureEvent();
2016 clickRecognizer->HandleReports(info, GestureCallbackType::START);
2017 EXPECT_EQ(clickRecognizer->GetRecognizerType(), GestureTypeName::CLICK);
2018 }
2019
2020 /**
2021 * @tc.name: ClickRecognizerTypeTest003
2022 * @tc.desc: Test ClickRecognizerType
2023 */
2024 HWTEST_F(ClickRecognizerTestNg, ClickRecognizerTypeTest003, TestSize.Level1)
2025 {
2026 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, TAPPED_COUNT);
2027 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
2028 clickRecognizer->AttachFrameNode(frameNode);
2029 clickRecognizer->SetRecognizerType(GestureTypeName::TAP_GESTURE);
2030 GestureEvent info = GestureEvent();
2031 clickRecognizer->HandleReports(info, GestureCallbackType::START);
2032 EXPECT_EQ(clickRecognizer->GetRecognizerType(), GestureTypeName::TAP_GESTURE);
2033 }
2034
2035 /**
2036 * @tc.name: TriggerGestureJudgeCallbackTest002
2037 * @tc.desc: Test TriggerGestureJudgeCallback
2038 * @tc.type: FUNC
2039 */
2040 HWTEST_F(ClickRecognizerTestNg, TriggerGestureJudgeCallbackTest002, TestSize.Level1)
2041 {
2042 RefPtr<ClickRecognizer> clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
2043 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
2044 clickRecognizer->inputEventType_ = InputEventType::KEYBOARD;
2045 clickRecognizer->deviceId_ = 1;
2046
2047 auto func = [](const std::shared_ptr<BaseGestureEvent>& info, const RefPtr<NGGestureRecognizer>& current,
__anonc9df6cc11002(const std::shared_ptr<BaseGestureEvent>& info, const RefPtr<NGGestureRecognizer>& current, const std::list<RefPtr<NGGestureRecognizer>>& others) 2048 const std::list<RefPtr<NGGestureRecognizer>>& others) {
2049 EXPECT_EQ(info->rawInputEventType_, InputEventType::KEYBOARD);
2050 EXPECT_EQ(info->rawInputDeviceId_, 1);
2051 return GestureJudgeResult::REJECT;
2052 };
2053 TouchEvent touchEvent;
2054 touchEvent.rollAngle = 0;
2055 clickRecognizer->touchPoints_[0] = touchEvent;
2056 clickRecognizer->targetComponent_ = targetComponent;
2057 targetComponent->SetOnGestureRecognizerJudgeBegin(func);
2058 clickRecognizer->TriggerGestureJudgeCallback();
2059 }
2060
2061 /**
2062 * @tc.name: ResetStatusInHandleOverdueDeadlineTest001
2063 * @tc.desc: Test ResetStatusInHandleOverdueDeadline
2064 * @tc.type: FUNC
2065 */
2066 HWTEST_F(ClickRecognizerTestNg, ResetStatusInHandleOverdueDeadlineTest001, TestSize.Level1)
2067 {
2068 /**
2069 * @tc.steps: step1. Create clickRecognizer and SetResponseLinkRecognizers.
2070 */
2071 RefPtr<ClickRecognizer> triggerClickRecognizer = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
2072 std::list<RefPtr<NGGestureRecognizer>> responseLinkResult;
2073 responseLinkResult.push_back(triggerClickRecognizer);
2074 RefPtr<NGGestureRecognizer> targetPtr1 = nullptr;
2075 responseLinkResult.push_back(targetPtr1);
2076 RefPtr<NGGestureRecognizer> targetPtr2 = AceType::MakeRefPtr<ClickRecognizer>(FINGER_NUMBER, COUNT);
2077 responseLinkResult.push_back(targetPtr2);
2078 triggerClickRecognizer->SetResponseLinkRecognizers(responseLinkResult);
2079 targetPtr2->SetResponseLinkRecognizers(responseLinkResult);
2080
2081 /**
2082 * @tc.steps: step2. Do ResetStatusInHandleOverdueDeadline.
2083 * @tc.expected: responseLinkRecognizer_ is empty().
2084 */
2085 auto eventManager = AceType::MakeRefPtr<EventManager>();
2086 ASSERT_NE(eventManager, nullptr);
2087 auto context = PipelineContext::GetCurrentContext();
2088 ASSERT_NE(context, nullptr);
2089 context->eventManager_ = eventManager;
2090 triggerClickRecognizer->ResetStatusInHandleOverdueDeadline();
2091 EXPECT_EQ(triggerClickRecognizer->responseLinkRecognizer_.size(), 0);
2092 EXPECT_EQ(targetPtr2->responseLinkRecognizer_.size(), 0);
2093
2094 /**
2095 * @tc.steps: step3. Do ResetStatusInHandleOverdueDeadline with not QueryAllDone.
2096 * @tc.expected: responseLinkRecognizer_ is same as before.
2097 */
2098 RefPtr<GestureScope> gestureScope = AceType::MakeRefPtr<GestureScope>(0);
2099 ASSERT_NE(gestureScope, nullptr);
2100 triggerClickRecognizer->refereeState_ = RefereeState::PENDING;
2101 gestureScope->recognizers_.insert(gestureScope->recognizers_.end(), triggerClickRecognizer);
2102 ASSERT_NE(context->eventManager_, nullptr);
2103 ASSERT_NE(context->eventManager_->refereeNG_, nullptr);
2104 context->eventManager_->refereeNG_->gestureScopes_.insert(std::make_pair(0, gestureScope));
2105 targetPtr2->SetResponseLinkRecognizers(responseLinkResult);
2106 triggerClickRecognizer->ResetStatusInHandleOverdueDeadline();
2107 EXPECT_EQ(targetPtr2->responseLinkRecognizer_.size(), 3);
2108 }
2109 } // namespace OHOS::Ace::NG