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 constexpr float GESTURE_EVENT_PROPERTY_DEFAULT_VALUE = 0.0;
22 constexpr float GESTURE_EVENT_PROPERTY_VALUE = 10.0;
23 class PinchRecognizerTestNg : public GesturesCommonTestNg {
24 public:
25 static void SetUpTestSuite();
26 static void TearDownTestSuite();
27 };
28
SetUpTestSuite()29 void PinchRecognizerTestNg::SetUpTestSuite()
30 {
31 MockPipelineContext::SetUp();
32 }
33
TearDownTestSuite()34 void PinchRecognizerTestNg::TearDownTestSuite()
35 {
36 MockPipelineContext::TearDown();
37 }
38
funtest(GestureEvent & info)39 void funtest(GestureEvent& info) {}
40
41 /**
42 * @tc.name: PinchRecognizerTest001
43 * @tc.desc: Test PinchRecognizer function: OnAccepted OnRejected
44 * @tc.type: FUNC
45 */
46 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest001, TestSize.Level1)
47 {
48 /**
49 * @tc.steps: step1. create PinchRecognizer.
50 */
51 RefPtr<PinchRecognizer> pinchRecognizer =
52 AceType::MakeRefPtr<PinchRecognizer>(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
53
54 /**
55 * @tc.steps: step2. call OnAccepted function and compare result.
56 * @tc.expected: step2. result equals.
57 */
58 pinchRecognizer->OnAccepted();
59 EXPECT_EQ(pinchRecognizer->refereeState_, RefereeState::SUCCEED);
60
61 /**
62 * @tc.steps: step3. call OnRejected function and compare result.
63 * @tc.expected: step3. result equals.
64 */
65 pinchRecognizer->OnRejected();
66 EXPECT_EQ(pinchRecognizer->refereeState_, RefereeState::SUCCEED);
67 }
68
69 /**
70 * @tc.name: PinchRecognizerTest002
71 * @tc.desc: Test PinchRecognizer function: HandleTouchDownEvent
72 * @tc.type: FUNC
73 */
74 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest002, TestSize.Level1)
75 {
76 /**
77 * @tc.steps: step1. create PinchRecognizer.
78 */
79 RefPtr<PinchRecognizer> pinchRecognizer =
80 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
81
82 /**
83 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
84 * @tc.steps: case1: input is TouchEvent. refereeState_ is SUCCESS.
85 * @tc.expected: step2. result equals.
86 */
87 TouchEvent touchEvent;
88 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
89 pinchRecognizer->HandleTouchDownEvent(touchEvent);
90 EXPECT_EQ(static_cast<int32_t>(pinchRecognizer->touchPoints_.size()), 1);
91
92 /**
93 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
94 * @tc.steps: case2: input is TouchEvent. refereeState_ is PENDING.
95 * @tc.expected: step2. result equals.
96 */
97 pinchRecognizer->refereeState_ = RefereeState::PENDING;
98 pinchRecognizer->HandleTouchDownEvent(touchEvent);
99 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
100
101 /**
102 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
103 * @tc.steps: case3: input is TouchEvent. refereeState_ is PENDING. fingers_ > size
104 * @tc.expected: step2. result equals.
105 */
106 pinchRecognizer->refereeState_ = RefereeState::PENDING;
107 pinchRecognizer->fingers_ = FINGER_NUMBER;
108 pinchRecognizer->HandleTouchDownEvent(touchEvent);
109 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
110 EXPECT_EQ(static_cast<int32_t>(pinchRecognizer->touchPoints_.size()), 1);
111 EXPECT_EQ(pinchRecognizer->refereeState_, RefereeState::PENDING);
112 }
113
114 /**
115 * @tc.name: PinchRecognizerHandleTouchDownEventTest001
116 * @tc.desc: Test PinchRecognizer function: HandleTouchDownEvent
117 * @tc.type: FUNC
118 */
119 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchDownEventTest001, TestSize.Level1)
120 {
121 /**
122 * @tc.steps: step1. create PinchRecognizer.
123 */
124 RefPtr<PinchRecognizer> pinchRecognizer =
125 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
126
127 /**
128 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
129 * @tc.steps: case1: input is TouchEvent. refereeState_ is SUCCESS.
130 * @tc.expected: step2. result equals.
131 */
132 TouchEvent touchEvent;
133 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
134 pinchRecognizer->fingers_ = 0;
135 pinchRecognizer->HandleTouchDownEvent(touchEvent);
136 EXPECT_EQ(static_cast<int32_t>(pinchRecognizer->touchPoints_.size()), 1);
137
138 /**
139 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
140 * @tc.steps: case2: input is TouchEvent. refereeState_ is PENDING.
141 * @tc.expected: step2. result equals.
142 */
143 pinchRecognizer->refereeState_ = RefereeState::PENDING;
144 pinchRecognizer->fingers_ = 0;
145 pinchRecognizer->HandleTouchDownEvent(touchEvent);
146 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
147
148 /**
149 * @tc.steps: step2. call HandleTouchDownEvent function and compare result.
150 * @tc.steps: case3: input is TouchEvent. refereeState_ is PENDING. fingers_ > size
151 * @tc.expected: step2. result equals.
152 */
153 pinchRecognizer->refereeState_ = RefereeState::PENDING;
154 pinchRecognizer->fingers_ = 0;
155 pinchRecognizer->HandleTouchDownEvent(touchEvent);
156 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
157 EXPECT_EQ(static_cast<int32_t>(pinchRecognizer->touchPoints_.size()), 1);
158 EXPECT_EQ(pinchRecognizer->refereeState_, RefereeState::PENDING);
159 }
160
161 /**
162 * @tc.name: PinchRecognizerTest003
163 * @tc.desc: Test PinchRecognizer function: HandleMove HandleUp HandleCancel
164 * @tc.type: FUNC
165 */
166 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest003, TestSize.Level1)
167 {
168 /**
169 * @tc.steps: step1. create PinchRecognizer.
170 */
171 auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
172
173 /**
174 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
175 * @tc.steps: case1: input is TouchEvent
176 * @tc.expected: step2. result equals.
177 */
178 TouchEvent touchEvent;
179 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
180 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
181 pinchRecognizer->HandleTouchUpEvent(touchEvent);
182 pinchRecognizer->HandleTouchCancelEvent(touchEvent);
183 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
184 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
185
186 /**
187 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
188 * @tc.steps: case2: input is AxisEvent
189 * @tc.expected: step2. result equals.
190 */
191 AxisEvent axisEvent;
192 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
193 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
194 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
195 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
196
197 /**
198 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
199 * @tc.steps: case3: input is TouchEvent, isFlushTouchEventsEnd_
200 * @tc.expected: step2. result equals.
201 */
202 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
203 pinchRecognizer->isFlushTouchEventsEnd_ = true;
204 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
205 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
206 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
207
208 /**
209 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
210 * @tc.steps: case4: input is TouchEvent, refereeState is FAIL
211 * @tc.expected: step2. result equals.
212 */
213 pinchRecognizer->refereeState_ = RefereeState::FAIL;
214 pinchRecognizer->HandleTouchUpEvent(touchEvent);
215 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
216 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
217
218 /**
219 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
220 * @tc.steps: case5: input is AxisEvent
221 * @tc.expected: step2. result equals.
222 */
223 pinchRecognizer->refereeState_ = RefereeState::FAIL;
224 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
225 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
226 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
227
228 /**
229 * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
230 * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
231 * @tc.expected: step2. result equals.
232 */
233 pinchRecognizer->refereeState_ = RefereeState::FAIL;
234 pinchRecognizer->HandleTouchCancelEvent(touchEvent);
235 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
236 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
237 }
238
239 /**
240 * @tc.name: PinchRecognizerTest004
241 * @tc.desc: Test PinchRecognizer function: OnFlushTouchEvent begin end
242 * @tc.type: FUNC
243 */
244 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest004, TestSize.Level1)
245 {
246 /**
247 * @tc.steps: step1. create PinchRecognizer.
248 */
249 RefPtr<PinchRecognizer> pinchRecognizer =
250 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
251
252 /**
253 * @tc.steps: step2. call OnFlushTouchEvent function and compare result.
254 * @tc.expected: step2. result equals.
255 */
256 pinchRecognizer->OnFlushTouchEventsBegin();
257 EXPECT_EQ(pinchRecognizer->isFlushTouchEventsEnd_, false);
258 pinchRecognizer->OnFlushTouchEventsEnd();
259 EXPECT_EQ(pinchRecognizer->isFlushTouchEventsEnd_, true);
260 }
261
262 /**
263 * @tc.name: PinchRecognizerTest005
264 * @tc.desc: Test PinchRecognizer function: ComputeAverageDeviation
265 * @tc.type: FUNC
266 */
267 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest005, TestSize.Level1)
268 {
269 /**
270 * @tc.steps: step1. create PinchRecognizer.
271 */
272 RefPtr<PinchRecognizer> pinchRecognizer =
273 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
274
275 /**
276 * @tc.steps: step2. call ComputeAverageDeviation function and compare result.
277 * @tc.expected: step2. result equals.
278 */
279 TouchEvent touchEvent;
280 pinchRecognizer->touchPoints_[touchEvent.id] = touchEvent;
281 auto result = pinchRecognizer->ComputeAverageDeviation();
282 EXPECT_EQ(result, 0);
283 }
284
285 /**
286 * @tc.name: PinchRecognizerComputePinchCenterTest001
287 * @tc.desc: Test PinchRecognizer function: ComputePinchCenter
288 * @tc.type: FUNC
289 */
290 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerComputePinchCenterTest001, TestSize.Level1)
291 {
292 /**
293 * @tc.steps: step1. create PinchRecognizer.
294 */
295 RefPtr<PinchRecognizer> pinchRecognizer =
296 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
297
298 /**
299 * @tc.steps: step2. call ComputePinchCenter function and compare result.
300 * @tc.expected: step2. result equals.
301 */
302 TouchEvent touchEvent;
303 pinchRecognizer->touchPoints_[touchEvent.id] = touchEvent;
304 auto result = pinchRecognizer->ComputePinchCenter();
305 pinchRecognizer->OnFlushTouchEventsEnd();
306 EXPECT_EQ(pinchRecognizer->isFlushTouchEventsEnd_, true);
307 }
308
309 /**
310 * @tc.name: PinchRecognizerTest006
311 * @tc.desc: Test PinchRecognizer function: SendCallbackMsg
312 * @tc.type: FUNC
313 */
314 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest006, TestSize.Level1)
315 {
316 /**
317 * @tc.steps: step1. create PinchRecognizer.
318 */
319 RefPtr<PinchRecognizer> pinchRecognizer =
320 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
321
322 /**
323 * @tc.steps: step2. call SendCallbackMsg function and compare result.
324 * @tc.steps: case1: onAction is no, *onAction is no
325 * @tc.expected: step2. result equals.
326 */
327 std::unique_ptr<GestureEventFunc> onAction;
328 pinchRecognizer->SendCallbackMsg(onAction);
329 EXPECT_EQ(pinchRecognizer->touchPoints_.size(), 0);
330
331 /**
332 * @tc.steps: step2. call SendCallbackMsg function and compare result.
333 * @tc.steps: case2: onAction is yes, *onAction is no
334 * @tc.expected: step2. result equals.
335 */
336 onAction = std::make_unique<GestureEventFunc>();
337 pinchRecognizer->SendCallbackMsg(onAction);
338 EXPECT_EQ(pinchRecognizer->touchPoints_.size(), 0);
339
340 /**
341 * @tc.steps: step2. call SendCallbackMsg function and compare result.
342 * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty
343 * @tc.expected: step2. result equals.
344 */
__anoncfb3240b0102(GestureEvent) 345 onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
346 pinchRecognizer->SendCallbackMsg(onAction);
347 EXPECT_EQ(pinchRecognizer->touchPoints_.size(), 0);
348
349 /**
350 * @tc.steps: step2. call SendCallbackMsg function and compare result.
351 * @tc.steps: case4: touchEvent is not empty, have no X and Y
352 * @tc.expected: step2. result equals.
353 */
354 TouchEvent touchEvent;
355 pinchRecognizer->lastTouchEvent_ = touchEvent;
356 pinchRecognizer->SendCallbackMsg(onAction);
357 EXPECT_EQ(pinchRecognizer->touchPoints_.size(), 0);
358
359 /**
360 * @tc.steps: step2. call SendCallbackMsg function and compare result.
361 * @tc.steps: case4: touchEvent is not empty, have no X and Y
362 * @tc.expected: step2. result equals.
363 */
364 touchEvent.tiltX = 0.0f;
365 touchEvent.tiltY = 0.0f;
366 pinchRecognizer->lastTouchEvent_ = touchEvent;
367 pinchRecognizer->SendCallbackMsg(onAction);
368 EXPECT_EQ(pinchRecognizer->touchPoints_.size(), 0);
369 }
370
371 /**
372 * @tc.name: PinchRecognizerTest007
373 * @tc.desc: Test PinchRecognizer function: ReconcileFrom
374 * @tc.type: FUNC
375 */
376 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest007, TestSize.Level1)
377 {
378 /**
379 * @tc.steps: step1. create PinchRecognizer.
380 */
381 RefPtr<PinchRecognizer> pinchRecognizer =
382 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
383 RefPtr<PinchRecognizer> pinchRecognizerPtr =
384 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
385 bool result = false;
386
387 /**
388 * @tc.steps: step2. call ReconcileFrom function and compare result.
389 * @tc.steps: case1: normal case
390 * @tc.expected: step2. result equals.
391 */
392 result = pinchRecognizer->ReconcileFrom(pinchRecognizerPtr);
393 EXPECT_EQ(result, true);
394
395 /**
396 * @tc.steps: step2. call ReconcileFrom function and compare result.
397 * @tc.steps: case2: recognizerPtr is nullptr
398 * @tc.expected: step2. result equals.
399 */
400 result = pinchRecognizer->ReconcileFrom(nullptr);
401 EXPECT_EQ(result, false);
402
403 /**
404 * @tc.steps: step2. call ReconcileFrom function and compare result.
405 * @tc.steps: case3: fingers_ != curr->fingers_;
406 * @tc.expected: step2. result equals.
407 */
408 pinchRecognizer->fingers_ = 1;
409 pinchRecognizerPtr->fingers_ = 0;
410 result = pinchRecognizer->ReconcileFrom(pinchRecognizerPtr);
411 EXPECT_EQ(result, false);
412
413 /**
414 * @tc.steps: step2. call ReconcileFrom function and compare result.
415 * @tc.steps: case4: fingers_ same, distance not same
416 * @tc.expected: step2. result equals.
417 */
418 pinchRecognizer->fingers_ = pinchRecognizerPtr->fingers_;
419 pinchRecognizer->distance_ = pinchRecognizerPtr->distance_ + 1;
420 result = pinchRecognizer->ReconcileFrom(pinchRecognizerPtr);
421 EXPECT_EQ(result, false);
422
423 /**
424 * @tc.steps: step2. call ReconcileFrom function and compare result.
425 * @tc.steps: case5: fingers_ same, distance same, priorityMask not same
426 * @tc.expected: step2. result equals.
427 */
428 pinchRecognizer->fingers_ = pinchRecognizerPtr->fingers_;
429 pinchRecognizer->distance_ = pinchRecognizerPtr->distance_;
430 pinchRecognizer->priorityMask_ = GestureMask::End;
431 result = pinchRecognizer->ReconcileFrom(pinchRecognizerPtr);
432 EXPECT_EQ(result, false);
433 }
434
435 /**
436 * @tc.name: PinchRecognizerSendCallbackMsgTest001
437 * @tc.desc: Test PinchRecognizer function: SendCallbackMsg
438 * @tc.type: FUNC
439 */
440 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerSendCallbackMsgTest001, TestSize.Level1)
441 {
442 /**
443 * @tc.steps: step1. create PinchRecognizer.
444 */
445 RefPtr<PinchRecognizer> pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, -1);
446 std::unique_ptr<GestureEventFunc> onAction;
447
448 /**
449 * @tc.steps: step2. call SendCallbackMsg function and compare result.
450 * @tc.steps: case3: onAction is yes, *onAction is yes, touchEvent is empty, type is AXIS
451 * @tc.expected: step2. result equals.
452 */
__anoncfb3240b0202(GestureEvent) 453 onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
454 pinchRecognizer->SendCallbackMsg(onAction);
455 EXPECT_EQ(pinchRecognizer->touchPoints_.size(), 0);
456 }
457
458 /**
459 * @tc.name: PinchRecognizerHandleTouchMoveEventTest102
460 * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
461 * @tc.type: FUNC
462 */
463 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchMoveEventTest102, TestSize.Level1)
464 {
465 /**
466 * @tc.steps: step1. create PinchRecognizer.
467 */
468 auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
469 AxisEvent axisEvent;
470 axisEvent.pinchAxisScale = 0.0;
471
472 /**
473 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
474 * @tc.steps: case1: input is TouchEvent
475 * @tc.expected: step2. result equals.
476 */
477 TouchEvent touchEvent;
478 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
479 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
480 pinchRecognizer->HandleTouchUpEvent(touchEvent);
481 pinchRecognizer->HandleTouchCancelEvent(axisEvent);
482 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
483 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
484
485 /**
486 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
487 * @tc.steps: case2: input is AxisEvent
488 * @tc.expected: step2. result equals.
489 */
490 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
491 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
492 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
493 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
494
495 /**
496 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
497 * @tc.steps: case3: input is TouchEvent, isFlushTouchEventsEnd_
498 * @tc.expected: step2. result equals.
499 */
500 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
501 pinchRecognizer->isFlushTouchEventsEnd_ = true;
502 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
503 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
504 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
505
506 /**
507 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
508 * @tc.steps: case4: input is TouchEvent, refereeState is FAIL
509 * @tc.expected: step2. result equals.
510 */
511 pinchRecognizer->refereeState_ = RefereeState::FAIL;
512 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
513 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
514 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
515
516 /**
517 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
518 * @tc.steps: case5: input is AxisEvent
519 * @tc.expected: step2. result equals.
520 */
521 pinchRecognizer->refereeState_ = RefereeState::FAIL;
522 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
523 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
524 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
525 }
526
527 /**
528 * @tc.name: PinchGestureTest001
529 * @tc.desc: Test PinchGesture CreateRecognizer function
530 */
531 HWTEST_F(PinchRecognizerTestNg, PinchGestureTest001, TestSize.Level1)
532 {
533 /**
534 * @tc.steps: step1. create PinchGestureGesture.
535 */
536 PinchGestureModelNG pinchGestureModelNG;
537 pinchGestureModelNG.Create(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
538
539 RefPtr<GestureProcessor> gestureProcessor;
540 gestureProcessor = NG::ViewStackProcessor::GetInstance()->GetOrCreateGestureProcessor();
541 auto pinchGesture = AceType::DynamicCast<NG::PinchGesture>(gestureProcessor->TopGestureNG());
542 EXPECT_EQ(pinchGesture->distance_, PINCH_GESTURE_DISTANCE);
543 }
544
545 /**
546 * @tc.name: PinchGestureTest002
547 * @tc.desc: Test PinchGesture CreateRecognizer function
548 */
549 HWTEST_F(PinchRecognizerTestNg, PinchGestureTest002, TestSize.Level1)
550 {
551 /**
552 * @tc.steps: step1. create PinchGesture.
553 */
554 auto pinchGesture = AceType::MakeRefPtr<PinchGesture>(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
555 ASSERT_NE(pinchGesture, nullptr);
556
557 /**
558 * @tc.steps: step2. call CreateRecognizer function and compare result
559 * @tc.expect: pinchRecognizer create successfully, use the same Option as pinchGesture.
560 */
561 pinchGesture->priority_ = GesturePriority::Low;
562 pinchGesture->gestureMask_ = GestureMask::Normal;
__anoncfb3240b0302(GestureEvent& info) 563 auto onActionStart = [](GestureEvent& info) { return true; };
__anoncfb3240b0402(GestureEvent& info) 564 auto onActionUpdate = [](GestureEvent& info) { return true; };
__anoncfb3240b0502(GestureEvent& info) 565 auto onActionEnd = [](GestureEvent& info) { return true; };
__anoncfb3240b0602(GestureEvent& info) 566 auto onActionCancel = [](GestureEvent& info) { return true; };
567 pinchGesture->SetOnActionStartId(onActionStart);
568 pinchGesture->SetOnActionUpdateId(onActionUpdate);
569 pinchGesture->SetOnActionEndId(onActionEnd);
570 pinchGesture->SetOnActionCancelId(onActionCancel);
571 EXPECT_TRUE(pinchGesture->onActionStartId_);
572 EXPECT_TRUE(pinchGesture->onActionUpdateId_);
573 EXPECT_TRUE(pinchGesture->onActionEndId_);
574 EXPECT_TRUE(pinchGesture->onActionCancelId_);
575 auto pinchRecognizer = AceType::DynamicCast<PinchRecognizer>(pinchGesture->CreateRecognizer());
576 ASSERT_NE(pinchRecognizer, nullptr);
577 EXPECT_EQ(pinchRecognizer->GetPriority(), GesturePriority::Low);
578 EXPECT_EQ(pinchRecognizer->GetPriorityMask(), GestureMask::Normal);
579 EXPECT_EQ(pinchRecognizer->distance_, PINCH_GESTURE_DISTANCE);
580 }
581
582 /**
583 * @tc.name: PinchGestureCreateRecognizerTest001
584 * @tc.desc: Test PinchGesture CreateRecognizer function
585 */
586 HWTEST_F(PinchRecognizerTestNg, PinchGestureCreateRecognizerTest001, TestSize.Level1)
587 {
588 /**
589 * @tc.steps: step1. create PinchGesture.
590 */
591 auto pinchGesture = AceType::MakeRefPtr<PinchGesture>(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
592 ASSERT_NE(pinchGesture, nullptr);
593
594 /**
595 * @tc.steps: step2. call CreateRecognizer function and compare result
596 * @tc.expect: pinchRecognizer create successfully, use the same Option as pinchGesture.
597 */
598 pinchGesture->priority_ = GesturePriority::Low;
599 pinchGesture->gestureMask_ = GestureMask::Normal;
600 auto pinchRecognizer = AceType::DynamicCast<PinchRecognizer>(pinchGesture->CreateRecognizer());
601 ASSERT_NE(pinchRecognizer, nullptr);
602 EXPECT_EQ(pinchRecognizer->GetPriority(), GesturePriority::Low);
603 EXPECT_EQ(pinchRecognizer->GetPriorityMask(), GestureMask::Normal);
604 EXPECT_EQ(pinchRecognizer->distance_, PINCH_GESTURE_DISTANCE);
605 }
606
607 /**
608 * @tc.name: PinchRecognizerTest009
609 * @tc.desc: Test PinchRecognizer function: HandleTouchDownEvent
610 * @tc.type: FUNC
611 */
612 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest009, TestSize.Level1)
613 {
614 /**
615 * @tc.steps: step1. create PinchRecognizer.
616 */
617 RefPtr<PinchRecognizer> pinchRecognizer =
618 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
619 ASSERT_NE(pinchRecognizer, nullptr);
620
621 /**
622 * @tc.steps: step2. use fingers_ > MAX_PINCH_FINGERS in HandleTouchDownEvent(TouchEvent).
623 * @tc.expect: pinchRecognizer->disposal_ is not equal to GestureDisposal::REJECT.
624 */
625 TouchEvent touchEvent;
626 pinchRecognizer->fingers_ = FINGER_NUMBER_OVER_MAX;
627 pinchRecognizer->refereeState_ = RefereeState::READY;
628 pinchRecognizer->HandleTouchDownEvent(touchEvent);
629 EXPECT_NE(pinchRecognizer->disposal_, GestureDisposal::REJECT);
630
631 /**
632 * @tc.steps: step3. test with HandleTouchDownEvent(AxisEvent).
633 */
634 pinchRecognizer->fingers_ = SINGLE_FINGER_NUMBER;
635 AxisEvent axisEvent;
636
637 /**
638 * @tc.steps: step3.1. axisEvent NearZero.
639 * @tc.expect: pinchRecognizer->disposal_ is not equal to GestureDisposal::REJECT.
640 */
641 axisEvent.pinchAxisScale = 0.0;
642 pinchRecognizer->HandleTouchDownEvent(axisEvent);
643 EXPECT_NE(pinchRecognizer->disposal_, GestureDisposal::REJECT);
644
645 /**
646 * @tc.steps: step3.2. axisEvent not NearZero and IsRefereeFinished() is true.
647 * @tc.expect: pinchRecognizer->disposal_ is not equal to GestureDisposal::REJECT.
648 */
649 axisEvent.pinchAxisScale = 2.0;
650 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
651 pinchRecognizer->HandleTouchDownEvent(axisEvent);
652 EXPECT_NE(pinchRecognizer->disposal_, GestureDisposal::REJECT);
653
654 /**
655 * @tc.steps: step3.2. axisEvent with refereeState_ = RefereeState::READY.
656 * @tc.expect: pinchRecognizer->scale_ is equal to 1.0f.
657 */
658 pinchRecognizer->refereeState_ = RefereeState::READY;
659 pinchRecognizer->HandleTouchDownEvent(axisEvent);
660 EXPECT_EQ(pinchRecognizer->scale_, 1.0);
661 }
662
663 /**
664 * @tc.name: PinchRecognizerTest010
665 * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
666 * @tc.type: FUNC
667 */
668 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest010, TestSize.Level1)
669 {
670 /**
671 * @tc.steps: step1. create PinchRecognizer.
672 */
673 RefPtr<PinchRecognizer> pinchRecognizer =
674 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
675 ASSERT_NE(pinchRecognizer, nullptr);
676
677 /**
678 * @tc.steps: step2. use refereeState_ != RefereeState::SUCCEED and refereeState_ != RefereeState::FAIL.
679 * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
680 */
681 TouchEvent touchEvent;
682 pinchRecognizer->isPinchEnd_ = false;
683 pinchRecognizer->refereeState_ = RefereeState::FAIL;
684 pinchRecognizer->HandleTouchDownEvent(touchEvent);
685 pinchRecognizer->refereeState_ = RefereeState::READY;
686 pinchRecognizer->HandleTouchDownEvent(touchEvent);
687 EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::NONE);
688
689 /**
690 * @tc.steps: step3. test with HandleTouchDownEvent(AxisEvent).
691 */
692 AxisEvent axisEvent;
693 /**
694 * @tc.steps: step3.1. test with isPinchEnd_ is true.
695 */
696 pinchRecognizer->isPinchEnd_ = true;
697 pinchRecognizer->HandleTouchUpEvent(axisEvent);
698
699 /**
700 * @tc.steps: step3.2. test with refereeState_ != RefereeState::SUCCEED and refereeState_ != RefereeState::FAIL.
701 * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
702 */
703 pinchRecognizer->isPinchEnd_ = false;
704 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
705 pinchRecognizer->HandleTouchUpEvent(axisEvent);
706 EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::REJECT);
707
708 /**
709 * @tc.steps: step3.2. test with refereeState_ != RefereeState::SUCCEED.
710 * @tc.expect: pinchRecognizer->isPinchEnd_ is true.
711 */
712 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
713 pinchRecognizer->HandleTouchUpEvent(axisEvent);
714 EXPECT_EQ(pinchRecognizer->isPinchEnd_, true);
715 }
716
717 /**
718 * @tc.name: PinchRecognizerTest012
719 * @tc.desc: Test PinchRecognizer function: HandleTouchDownEvent
720 * @tc.type: FUNC
721 */
722 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest012, TestSize.Level1)
723 {
724 /**
725 * @tc.steps: step1. create PinchRecognizer.
726 */
727 RefPtr<PinchRecognizer> pinchRecognizer =
728 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
729 ASSERT_NE(pinchRecognizer, nullptr);
730 /**
731 * @tc.steps: step2. test with HandleTouchDownEvent(AxisEvent).
732 * @tc.expect: pinchRecognizer->lastAxisEvent_ is equal to axisEvent
733 * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].originalId is equal to axisEvent.originalId
734 * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].screenX is equal to axisEvent.screenX
735 * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].screenY is equal to axisEvent.screenY
736 */
737 AxisEvent axisEvent;
738 axisEvent.id = TEST_EVENT_ID;
739 axisEvent.originalId = TEST_EVENT_ID;
740 pinchRecognizer->fingers_ = FINGER_NUMBER_OVER_MAX;
741 pinchRecognizer->refereeState_ = RefereeState::READY;
742 pinchRecognizer->HandleTouchDownEvent(axisEvent);
743 EXPECT_EQ(pinchRecognizer->lastAxisEvent_.id, axisEvent.id);
744 EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].originalId, axisEvent.originalId);
745 EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].screenX, axisEvent.screenX);
746 EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].screenY, axisEvent.screenY);
747 }
748
749 /**
750 * @tc.name: PinchRecognizerTest012
751 * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
752 * @tc.type: FUNC
753 */
754 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest013, TestSize.Level1)
755 {
756 /**
757 * @tc.steps: step1. create PinchRecognizer.
758 */
759 RefPtr<PinchRecognizer> pinchRecognizer =
760 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
761 ASSERT_NE(pinchRecognizer, nullptr);
762
763 /**
764 * @tc.steps: step2. test with HandleTouchUpEvent(AxisEvent).
765 * @tc.expect: pinchRecognizer->lastAxisEvent_ is equal to axisEvent
766 */
767 AxisEvent axisEvent;
768 axisEvent.id = TEST_EVENT_ID;
769 pinchRecognizer->fingers_ = FINGER_NUMBER_OVER_MAX;
770 pinchRecognizer->refereeState_ = RefereeState::READY;
771 pinchRecognizer->HandleTouchUpEvent(axisEvent);
772 EXPECT_EQ(pinchRecognizer->lastAxisEvent_.id, axisEvent.id);
773 }
774
775 /**
776 * @tc.name: PinchRecognizerTest012
777 * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
778 * @tc.type: FUNC
779 */
780 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest014, TestSize.Level1)
781 {
782 /**
783 * @tc.steps: step1. create PinchRecognizer.
784 */
785 RefPtr<PinchRecognizer> pinchRecognizer =
786 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
787 ASSERT_NE(pinchRecognizer, nullptr);
788 /**
789 * @tc.steps: step2. test with HandleTouchMoveEvent(AxisEvent).
790 * @tc.expect: pinchRecognizer->lastAxisEvent_ is equal to axisEvent
791 * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].originalId is equal to axisEvent.originalId
792 * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].screenX is equal to axisEvent.screenX
793 * @tc.expect: pinchRecognizer->touchPoints_[axisEvent.id].screenY is equal to axisEvent.screenY
794 */
795 AxisEvent axisEvent;
796 axisEvent.id = TEST_EVENT_ID;
797 axisEvent.originalId = TEST_EVENT_ID;
798 pinchRecognizer->fingers_ = FINGER_NUMBER_OVER_MAX;
799 pinchRecognizer->refereeState_ = RefereeState::READY;
800 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
801
802 EXPECT_EQ(pinchRecognizer->lastAxisEvent_.id, axisEvent.id);
803 EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].originalId, axisEvent.originalId);
804 EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].screenX, axisEvent.screenX);
805 EXPECT_EQ(pinchRecognizer->touchPoints_[axisEvent.id].screenY, axisEvent.screenY);
806 }
807
808 /**
809 * @tc.name: PinchRecognizerHandleTouchUpEventTest001
810 * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
811 * @tc.type: FUNC
812 */
813 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchUpEventTest001, TestSize.Level1)
814 {
815 /**
816 * @tc.steps: step1. create PinchRecognizer.
817 */
818 RefPtr<PinchRecognizer> pinchRecognizer =
819 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
820 ASSERT_NE(pinchRecognizer, nullptr);
821
822 /**
823 * @tc.steps: step2. use refereeState_ != RefereeState::SUCCEED and refereeState_ != RefereeState::FAIL.
824 * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
825 */
826 TouchEvent touchEvent;
827 pinchRecognizer->isPinchEnd_ = false;
828 pinchRecognizer->refereeState_ = RefereeState::FAIL;
829 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
830 pinchRecognizer->HandleTouchDownEvent(touchEvent);
831 pinchRecognizer->refereeState_ = RefereeState::READY;
832 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
833 pinchRecognizer->HandleTouchDownEvent(touchEvent);
834 EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::NONE);
835
836 /**
837 * @tc.steps: step3. test with HandleTouchDownEvent(AxisEvent).
838 */
839 AxisEvent axisEvent;
840 /**
841 * @tc.steps: step3.1. test with isPinchEnd_ is true.
842 */
843 pinchRecognizer->isPinchEnd_ = true;
844 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
845 pinchRecognizer->HandleTouchUpEvent(axisEvent);
846
847 /**
848 * @tc.steps: step3.2. test with refereeState_ != RefereeState::SUCCEED and refereeState_ != RefereeState::FAIL.
849 * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
850 */
851 pinchRecognizer->isPinchEnd_ = false;
852 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
853 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
854 pinchRecognizer->HandleTouchUpEvent(axisEvent);
855 EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::REJECT);
856
857 /**
858 * @tc.steps: step3.2. test with refereeState_ != RefereeState::SUCCEED.
859 * @tc.expect: pinchRecognizer->isPinchEnd_ is true.
860 */
861 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
862 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
863 pinchRecognizer->HandleTouchUpEvent(axisEvent);
864 EXPECT_EQ(pinchRecognizer->isPinchEnd_, true);
865 }
866
867 /**
868 * @tc.name: PinchRecognizerHandleTouchMoveEventTest001
869 * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
870 * @tc.type: FUNC
871 */
872 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchMoveEventTest001, TestSize.Level1)
873 {
874 /**
875 * @tc.steps: step1. create PinchRecognizer.
876 */
877 RefPtr<PinchRecognizer> pinchRecognizer =
878 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
879 ASSERT_NE(pinchRecognizer, nullptr);
880
881 /**
882 * @tc.steps: step2. test HandleTouchMoveEvent(TouchEvent).
883 */
884 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
885 std::vector<TouchEvent> touchEvents;
886 for (std::size_t i = 0; i < 5; ++i) {
887 TouchEvent touchEvent;
888 touchEvent.x = 100.0 * (i + 1);
889 touchEvent.y = 100.0 * (i + 1);
890 pinchRecognizer->touchPoints_[i] = touchEvent;
891 }
892 pinchRecognizer->initialDev_ = 1.0;
893 TouchEvent touchEvent;
894 touchEvent.x = 100.0;
895 touchEvent.y = 100.0;
896
897 /**
898 * @tc.steps: step2.1. test HandleTouchMoveEvent(TouchEvent) with fabs(currentDev_ - initialDev_) >= distance_.
899 * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_.
900 */
901 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
902 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
903
904 /**
905 * @tc.steps: step2.2. test HandleTouchMoveEvent(TouchEvent) with refereeState_ == RefereeState::SUCCEED.
906 * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_
907 */
908 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
909 pinchRecognizer->initialDev_ = 2.0;
910 pinchRecognizer->OnFlushTouchEventsEnd();
911 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
912 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
913
914 /**
915 * @tc.steps: step3. test HandleTouchMoveEvent(AxisEvent).
916 */
917 AxisEvent axisEvent;
918 pinchRecognizer->isPinchEnd_ = false;
919
920 /**
921 * @tc.steps: step3.1. axisEvent NearZero.
922 * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
923 */
924 axisEvent.pinchAxisScale = 0.0;
925 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
926 auto context = PipelineContext::GetCurrentContext();
927 ASSERT_NE(context, nullptr);
928 context->eventManager_ = nullptr;
929 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
930 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
931 EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::REJECT);
932
933 /**
934 * @tc.steps: step3.2. test with refereeState_ = RefereeState::SUCCEED.
935 * @tc.expect: pinchRecognizer->refereeState_ is equal to RefereeState::READY.
936 */
937 pinchRecognizer->isPinchEnd_ = false;
938 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
939 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
940 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
941 EXPECT_EQ(pinchRecognizer->isPinchEnd_, true);
942
943 /**
944 * @tc.steps: step3.3. test with axisEvent not NearZero .
945 * @tc.expect: pinchRecognizer->scale_ is equal to axisEvent.pinchAxisScale.
946 */
947 pinchRecognizer->isPinchEnd_ = false;
948 axisEvent.pinchAxisScale = 1.0;
949 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
950 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
951 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
952 EXPECT_EQ(pinchRecognizer->scale_, axisEvent.pinchAxisScale);
953 }
954
955 /**
956 * @tc.name: PinchRecognizerHandleTouchMoveEventTest002
957 * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
958 * @tc.type: FUNC
959 */
960 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchMoveEventTest002, TestSize.Level1)
961 {
962 /**
963 * @tc.steps: step1. create PinchRecognizer.
964 */
965 RefPtr<PinchRecognizer> pinchRecognizer =
966 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
967
968 /**
969 * @tc.steps: step2. test HandleTouchMoveEvent(TouchEvent).
970 */
971 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
972 std::vector<TouchEvent> touchEvents;
973 for (std::size_t i = 0; i < 5; ++i) {
974 TouchEvent touchEvent;
975 touchEvent.x = 100.0 * (i + 1);
976 touchEvent.y = 100.0 * (i + 1);
977 pinchRecognizer->touchPoints_[i] = touchEvent;
978 }
979 pinchRecognizer->initialDev_ = 1.0;
980 TouchEvent touchEvent;
981 touchEvent.x = 100.0;
982 touchEvent.y = 100.0;
983
984 /**
985 * @tc.steps: step2.1. test HandleTouchMoveEvent(TouchEvent) with fabs(currentDev_ - initialDev_) >= distance_.
986 * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_.
987 */
988 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
989 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
990 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
991 pinchRecognizer->initialDev_ = 2.0;
992 pinchRecognizer->OnFlushTouchEventsEnd();
993
994 /**
995 * @tc.steps: step3. test HandleTouchMoveEvent(AxisEvent).
996 */
997 AxisEvent axisEvent;
998 pinchRecognizer->isPinchEnd_ = false;
999
1000 /**
1001 * @tc.steps: step3.1. axisEvent NearZero.
1002 * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
1003 */
1004 auto context = PipelineContext::GetCurrentContext();
1005 context->eventManager_ = nullptr;
1006 pinchRecognizer->isPinchEnd_ = false;
1007 axisEvent.pinchAxisScale = 1.0;
1008 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1009 pinchRecognizer->currentFingers_ = FINGER_NUMBER;
1010 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1011 pinchRecognizer->refereeState_ = RefereeState::FAIL;
1012 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1013 EXPECT_EQ(pinchRecognizer->scale_, axisEvent.pinchAxisScale);
1014
1015 axisEvent.pinchAxisScale = 0;
1016 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1017 pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1018 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1019 pinchRecognizer->HandleTouchCancelEvent(touchEvent);
1020 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1021 pinchRecognizer->currentFingers_ = pinchRecognizer->fingers_;
1022 pinchRecognizer->HandleTouchUpEvent(touchEvent);
1023 pinchRecognizer->refereeState_ = RefereeState::FAIL;
1024 pinchRecognizer->isPinchEnd_ = false;
1025 pinchRecognizer->HandleTouchUpEvent(axisEvent);
1026 EXPECT_EQ(pinchRecognizer->scale_, 1);
1027 }
1028
1029 /**
1030 * @tc.name: PinchRecognizerHandleTouchCancelEventTest001
1031 * @tc.desc: Test PinchRecognizer function: HandleTouchCancelEvent
1032 * @tc.type: FUNC
1033 */
1034 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchCancelEventTest001, TestSize.Level1)
1035 {
1036 /**
1037 * @tc.steps: step1. create PinchRecognizer.
1038 */
1039 auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1040 AxisEvent axisEvent;
1041 axisEvent.pinchAxisScale = 0.0;
1042
1043 /**
1044 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1045 * @tc.steps: case1: input is TouchEvent
1046 * @tc.expected: step2. result equals.
1047 */
1048 TouchEvent touchEvent;
1049 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1050 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1051 pinchRecognizer->HandleTouchUpEvent(touchEvent);
1052 pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1053 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1054 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1055
1056 /**
1057 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1058 * @tc.steps: case2: input is AxisEvent
1059 * @tc.expected: step2. result equals.
1060 */
1061 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1062 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1063 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1064 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1065
1066 /**
1067 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1068 * @tc.steps: case3: input is TouchEvent, isFlushTouchEventsEnd_
1069 * @tc.expected: step2. result equals.
1070 */
1071 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1072 pinchRecognizer->isFlushTouchEventsEnd_ = true;
1073 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1074 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1075 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1076
1077 /**
1078 * @tc.steps: step2. call HandleTouchUpEvent function and compare result.
1079 * @tc.steps: case4: input is TouchEvent, refereeState is FAIL
1080 * @tc.expected: step2. result equals.
1081 */
1082 pinchRecognizer->refereeState_ = RefereeState::FAIL;
1083 pinchRecognizer->HandleTouchUpEvent(touchEvent);
1084 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1085 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1086
1087 /**
1088 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1089 * @tc.steps: case5: input is AxisEvent
1090 * @tc.expected: step2. result equals.
1091 */
1092 pinchRecognizer->refereeState_ = RefereeState::FAIL;
1093 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1094 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1095 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1096
1097 /**
1098 * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1099 * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1100 * @tc.expected: step2. result equals.
1101 */
1102 pinchRecognizer->refereeState_ = RefereeState::FAIL;
1103 pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1104 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1105 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1106 }
1107
1108 /**
1109 * @tc.name: PinchRecognizerHandleTouchCancelEventTest003
1110 * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
1111 * @tc.type: FUNC
1112 */
1113 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchCancelEventTest003, TestSize.Level1)
1114 {
1115 /**
1116 * @tc.steps: step1. create PinchRecognizer.
1117 */
1118 auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1119 AxisEvent axisEvent;
1120 axisEvent.pinchAxisScale = 0.0;
1121
1122 /**
1123 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1124 * @tc.steps: case1: input is TouchEvent
1125 * @tc.expected: step2. result equals.
1126 */
1127 TouchEvent touchEvent;
1128 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1129 pinchRecognizer->currentFingers_ = pinchRecognizer->fingers_;
1130 pinchRecognizer->HandleTouchUpEvent(touchEvent);
1131 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1132
1133 /**
1134 * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1135 * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1136 * @tc.expected: step2. result equals.
1137 */
1138 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1139 pinchRecognizer->isPinchEnd_ = true;
1140 pinchRecognizer->HandleTouchUpEvent(touchEvent);
1141 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1142
1143 /**
1144 * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1145 * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1146 * @tc.expected: step2. result equals.
1147 */
1148 pinchRecognizer->refereeState_ = RefereeState::FAIL;
1149 pinchRecognizer->isPinchEnd_ = false;
1150 pinchRecognizer->HandleTouchUpEvent(touchEvent);
1151 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1152 }
1153
1154 /**
1155 * @tc.name: PinchRecognizerHandleTouchCancelEventTest002
1156 * @tc.desc: Test PinchRecognizer function: HandleTouchUpEvent
1157 * @tc.type: FUNC
1158 */
1159 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerHandleTouchCancelEventTest002, TestSize.Level1)
1160 {
1161 /**
1162 * @tc.steps: step1. create PinchRecognizer.
1163 */
1164 auto pinchRecognizer = AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1165 AxisEvent axisEvent;
1166 axisEvent.pinchAxisScale = 0.0;
1167
1168 /**
1169 * @tc.steps: step2. call HandleTouchMoveEvent function and compare result.
1170 * @tc.steps: case1: input is TouchEvent
1171 * @tc.expected: step2. result equals.
1172 */
1173 TouchEvent touchEvent;
1174 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1175 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1176 pinchRecognizer->currentFingers_ = pinchRecognizer->fingers_;
1177 pinchRecognizer->HandleTouchUpEvent(touchEvent);
1178 pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1179 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1180 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1181
1182 /**
1183 * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1184 * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1185 * @tc.expected: step2. result equals.
1186 */
1187 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1188 pinchRecognizer->isPinchEnd_ = true;
1189 pinchRecognizer->HandleTouchUpEvent(touchEvent);
1190 pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1191 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1192 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1193
1194 /**
1195 * @tc.steps: step2. call HandleTouchCancelEvent function and compare result.
1196 * @tc.steps: case6: input is TouchEvent, refereeState is FAIL
1197 * @tc.expected: step2. result equals.
1198 */
1199 pinchRecognizer->refereeState_ = RefereeState::FAIL;
1200 pinchRecognizer->isPinchEnd_ = false;
1201 pinchRecognizer->HandleTouchUpEvent(touchEvent);
1202 pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1203 EXPECT_EQ(pinchRecognizer->touchPoints_[touchEvent.id].id, touchEvent.id);
1204 EXPECT_EQ(pinchRecognizer->lastTouchEvent_.id, touchEvent.id);
1205 }
1206
1207 /**
1208 * @tc.name: PinchRecognizerTest011
1209 * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
1210 * @tc.type: FUNC
1211 */
1212 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTest011, TestSize.Level1)
1213 {
1214 /**
1215 * @tc.steps: step1. create PinchRecognizer.
1216 */
1217 RefPtr<PinchRecognizer> pinchRecognizer =
1218 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1219 ASSERT_NE(pinchRecognizer, nullptr);
1220
1221 /**
1222 * @tc.steps: step2. test HandleTouchMoveEvent(TouchEvent).
1223 */
1224 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1225 std::vector<TouchEvent> touchEvents;
1226 for (std::size_t i = 0; i < 5; ++i) {
1227 TouchEvent touchEvent;
1228 touchEvent.x = 100.0 * (i + 1);
1229 touchEvent.y = 100.0 * (i + 1);
1230 pinchRecognizer->touchPoints_[i] = touchEvent;
1231 }
1232 pinchRecognizer->initialDev_ = 1.0;
1233 TouchEvent touchEvent;
1234 touchEvent.x = 100.0;
1235 touchEvent.y = 100.0;
1236
1237 /**
1238 * @tc.steps: step2.1. test HandleTouchMoveEvent(TouchEvent) with fabs(currentDev_ - initialDev_) >= distance_.
1239 * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_.
1240 */
1241 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1242 EXPECT_EQ(pinchRecognizer->scale_, 1);
1243 EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::NONE);
1244 /**
1245 * @tc.steps: step2.2. test HandleTouchMoveEvent(TouchEvent) with refereeState_ == RefereeState::SUCCEED.
1246 * @tc.expect: scale_ = pinchRecognizer->ComputeAverageDeviation() / initialDev_
1247 */
1248 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1249 pinchRecognizer->initialDev_ = 2.0;
1250 pinchRecognizer->OnFlushTouchEventsEnd();
1251 pinchRecognizer->HandleTouchMoveEvent(touchEvent);
1252 EXPECT_EQ(pinchRecognizer->scale_, 1);
1253
1254 /**
1255 * @tc.steps: step3. test HandleTouchMoveEvent(AxisEvent).
1256 */
1257 AxisEvent axisEvent;
1258 pinchRecognizer->isPinchEnd_ = false;
1259
1260 /**
1261 * @tc.steps: step3.1. axisEvent NearZero.
1262 * @tc.expect: pinchRecognizer->disposal_ is equal to GestureDisposal::REJECT.
1263 */
1264 axisEvent.pinchAxisScale = 0.0;
1265 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1266 auto context = PipelineContext::GetCurrentContext();
1267 ASSERT_NE(context, nullptr);
1268 context->eventManager_ = nullptr;
1269 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1270 EXPECT_EQ(pinchRecognizer->disposal_, GestureDisposal::REJECT);
1271
1272 /**
1273 * @tc.steps: step3.2. test with refereeState_ = RefereeState::SUCCEED.
1274 * @tc.expect: pinchRecognizer->refereeState_ is equal to RefereeState::READY.
1275 */
1276 pinchRecognizer->isPinchEnd_ = false;
1277 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1278 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1279 EXPECT_EQ(pinchRecognizer->refereeState_, RefereeState::READY);
1280 EXPECT_EQ(pinchRecognizer->isPinchEnd_, true);
1281
1282 /**
1283 * @tc.steps: step3.3. test with axisEvent not NearZero .
1284 * @tc.expect: pinchRecognizer->scale_ is equal to axisEvent.pinchAxisScale.
1285 */
1286 pinchRecognizer->isPinchEnd_ = false;
1287 axisEvent.pinchAxisScale = 1.0;
1288 pinchRecognizer->refereeState_ = RefereeState::DETECTING;
1289 pinchRecognizer->HandleTouchMoveEvent(axisEvent);
1290 EXPECT_EQ(pinchRecognizer->scale_, axisEvent.pinchAxisScale);
1291 }
1292
1293 /**
1294 * @tc.name: PinchRecognizerPtrHandleTouchMoveEventTest002
1295 * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
1296 * @tc.type: FUNC
1297 */
1298 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerPtrHandleTouchMoveEventTest002, TestSize.Level1)
1299 {
1300 /**
1301 * @tc.steps: step1. create and set Recognizer、TargetComponent.
1302 */
1303 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1304 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1305 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<TargetComponent>();
__anoncfb3240b0702(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 1306 auto gestureJudgeFunc = [](const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) {
1307 return GestureJudgeResult::REJECT;
1308 };
1309 targetComponent->SetOnGestureJudgeBegin(gestureJudgeFunc);
1310 TouchEvent touchEvent;
1311 AxisEvent axisEvent;
1312 touchEvent.tiltX.emplace(1.0f);
1313 touchEvent.tiltY.emplace(1.0f);
1314 pinchRecognizerPtr->targetComponent_ = targetComponent;
1315 /**
1316 * @tc.steps: step2. test the function who calls TriggerGestureJudgeCallback.
1317 * @tc.expected: step2. result equals REJECT.
1318 */
1319 pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1320 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1321 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1322 pinchRecognizerPtr->fingers_ = 1;
1323 pinchRecognizerPtr->distance_ = -1;
1324 pinchRecognizerPtr->initialDev_ = 1;
1325 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
1326 EXPECT_EQ(pinchRecognizerPtr->disposal_, GestureDisposal::REJECT);
1327
1328 axisEvent.pinchAxisScale = 1.0;
1329 pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1330 pinchRecognizerPtr->isPinchEnd_ = false;
1331 pinchRecognizerPtr->HandleTouchMoveEvent(axisEvent);
1332 EXPECT_EQ(pinchRecognizerPtr->disposal_, GestureDisposal::REJECT);
1333 }
1334
1335 class MockPinchRecognizer : public PinchRecognizer {
1336 public:
MockPinchRecognizer(int32_t fingers,double distance)1337 MockPinchRecognizer(int32_t fingers, double distance) : PinchRecognizer(fingers, distance) {}
1338 MOCK_METHOD(void, BatchAdjudicate, (const RefPtr<NGGestureRecognizer>&, GestureDisposal), ());
1339 };
1340
1341 /**
1342 * @tc.name: PinchRecognizerPtrHandleTouchMoveEventTest003
1343 * @tc.desc: Test PinchRecognizer function: HandleTouchMoveEvent
1344 * @tc.type: FUNC
1345 */
1346 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerPtrHandleTouchMoveEventTest003, TestSize.Level1)
1347 {
1348 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1349 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1350 TouchEvent event;
1351 event.id = 1;
1352 pinchRecognizerPtr->fingersId_.insert(1);
1353 pinchRecognizerPtr->activeFingers_.push_back(1);
1354 pinchRecognizerPtr->activeFingers_.push_back(2);
1355 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1356 pinchRecognizerPtr->HandleTouchUpEvent(event);
1357 event.id = 3;
1358 pinchRecognizerPtr->fingersId_.insert(1);
1359 pinchRecognizerPtr->activeFingers_.push_back(1);
1360 pinchRecognizerPtr->activeFingers_.push_back(2);
1361 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1362 pinchRecognizerPtr->HandleTouchUpEvent(event);
1363 EXPECT_EQ(event.id, 3);
1364 }
1365
1366 /**
1367 * @tc.name: PinchRecognizerPtrHandleTouchMoveEventTest004
1368 * @tc.desc: Test HandleTouchCancelEvent
1369 * @tc.type: FUNC
1370 */
1371 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerPtrHandleTouchMoveEventTest004, TestSize.Level1)
1372 {
1373 MockPinchRecognizer recognizerTest(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1374 TouchEvent event;
1375 event.id = 1;
1376 recognizerTest.activeFingers_.push_back(1);
1377 recognizerTest.activeFingers_.push_back(2);
1378 recognizerTest.refereeState_ = RefereeState::SUCCEED;
1379 recognizerTest.HandleTouchCancelEvent(event);
1380 EXPECT_EQ(event.id, 1);
1381 }
1382
1383 /**
1384 * @tc.name: PinchRecognizerPtrHandleTouchMoveEventTest005
1385 * @tc.desc: Test SendCallbackMsg
1386 * @tc.type: FUNC
1387 */
1388 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerPtrHandleTouchMoveEventTest005, TestSize.Level1)
1389 {
1390 MockPinchRecognizer recognizerTest(FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1391 recognizerTest.activeFingers_.push_back(1);
1392 recognizerTest.activeFingers_.push_back(2);
1393 recognizerTest.refereeState_ = RefereeState::SUCCEED;
1394 GestureEvent info;
1395 auto callback = std::make_unique<GestureEventFunc>(funtest);
1396 recognizerTest.inputEventType_ = InputEventType::AXIS;
1397 recognizerTest.SendCallbackMsg(callback);
1398 EXPECT_EQ(recognizerTest.inputEventType_, InputEventType::AXIS);
1399 }
1400
1401 /**
1402 * @tc.name: SetOnActionCancelTest001
1403 * @tc.desc: Test SendCallbackMsg function in the HandleTouchCancelEvent with touch event input. The onActionCancel
1404 * function will return GestureEvent info.
1405 * @tc.type: FUNC
1406 */
1407 HWTEST_F(PinchRecognizerTestNg, SetOnActionCancelTest001, TestSize.Level1)
1408 {
1409 /**
1410 * @tc.steps: step1. Create PinchRecognizerTestNg.
1411 */
1412 RefPtr<PinchRecognizer> pinchRecognizer =
1413 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1414
1415 /**
1416 * @tc.steps: step2. Call SetOnActionCancel.
1417 * @tc.expected: pinchRecognizer's callback onActionCancel is not nullptr.
1418 */
1419 pinchRecognizer->deviceId_ = GESTURE_EVENT_PROPERTY_VALUE;
1420 double unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
__anoncfb3240b0802(GestureEvent& info) 1421 auto onActionCancel = [&unknownPropertyValue](GestureEvent& info) { unknownPropertyValue = info.GetDeviceId(); };
1422 pinchRecognizer->SetOnActionCancel(onActionCancel);
1423 EXPECT_NE(pinchRecognizer->onActionCancel_, nullptr);
1424
1425 /**
1426 * @tc.steps: step3. Invoke HandleTouchCancelEvent when onActionCancel_ is not null.
1427 * @tc.expected: The functions have been executed and the unknownPropertyValue has been assigned the correct
1428 * value. pinchRecognizer->refereeState_ = RefereeState::READY
1429 */
1430 TouchEvent touchEvent;
1431 pinchRecognizer->touchPoints_[touchEvent.id] = touchEvent;
1432 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1433 pinchRecognizer->activeFingers_.push_back(touchEvent.id);
1434 pinchRecognizer->fingers_ = 1;
1435 pinchRecognizer->HandleTouchCancelEvent(touchEvent);
1436 EXPECT_EQ(unknownPropertyValue, GESTURE_EVENT_PROPERTY_VALUE);
1437 EXPECT_EQ(pinchRecognizer->refereeState_, RefereeState::READY);
1438 }
1439
1440 /**
1441 * @tc.name: SetOnActionCancelTest002
1442 * @tc.desc: Test SendCallbackMsg function in the HandleTouchCancelEvent with axis event input. The onActionCancel
1443 * function will return GestureEvent info.
1444 * @tc.type: FUNC
1445 */
1446 HWTEST_F(PinchRecognizerTestNg, SetOnActionCancelTest002, TestSize.Level1)
1447 {
1448 /**
1449 * @tc.steps: step1. Create PinchRecognizerTestNg.
1450 */
1451 RefPtr<PinchRecognizer> pinchRecognizer =
1452 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1453
1454 /**
1455 * @tc.steps: step2. Call SetOnActionCancel.
1456 * @tc.expected: pinchRecognizer's callback onActionCancel is not nullptr.
1457 */
1458 pinchRecognizer->deviceId_ = GESTURE_EVENT_PROPERTY_VALUE;
1459 double unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
__anoncfb3240b0902(GestureEvent& info) 1460 auto onActionCancel = [&unknownPropertyValue](GestureEvent& info) { unknownPropertyValue = info.GetDeviceId(); };
1461 pinchRecognizer->SetOnActionCancel(onActionCancel);
1462 EXPECT_NE(pinchRecognizer->onActionCancel_, nullptr);
1463
1464 /**
1465 * @tc.steps: step3. Invoke HandleTouchCancelEvent when onActionCancel_ is not null.
1466 * @tc.expected: The functions have been executed and the unknownPropertyValue has been assigned the correct
1467 * value.
1468 */
1469 AxisEvent axisEvent;
1470 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1471 pinchRecognizer->HandleTouchCancelEvent(axisEvent);
1472 EXPECT_EQ(unknownPropertyValue, GESTURE_EVENT_PROPERTY_VALUE);
1473 }
1474
1475 /**
1476 * @tc.name: SetOnActionCancelTest003
1477 * @tc.desc: Test SendCallbackMsg function in the ReconcileFrom. The onActionCancel function will return
1478 * GestureEvent info.
1479 * @tc.type: FUNC
1480 */
1481 HWTEST_F(PinchRecognizerTestNg, SetOnActionCancelTest003, TestSize.Level1)
1482 {
1483 /**
1484 * @tc.steps: step1. Create PinchRecognizer.
1485 */
1486 RefPtr<PinchRecognizer> pinchRecognizer =
1487 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1488 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1489 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1490
1491 /**
1492 * @tc.steps: step2. Call SetOnActionCancel.
1493 * @tc.expected: pinchRecognizer's callback onActionCancel is not nullptr.
1494 */
1495 pinchRecognizer->deviceId_ = GESTURE_EVENT_PROPERTY_VALUE;
1496 double unknownPropertyValue = GESTURE_EVENT_PROPERTY_DEFAULT_VALUE;
__anoncfb3240b0a02(GestureEvent& info) 1497 auto onActionCancel = [&unknownPropertyValue](GestureEvent& info) { unknownPropertyValue = info.GetDeviceId(); };
1498 pinchRecognizer->SetOnActionCancel(onActionCancel);
1499 EXPECT_NE(pinchRecognizer->onActionCancel_, nullptr);
1500
1501 /**
1502 * @tc.steps: step3. Invoke ReconcileFrom when onActionCancel_ is not null.
1503 * @tc.expected: The functions have been executed and the unknownPropertyValue has been assigned the correct
1504 * value.
1505 */
1506 pinchRecognizer->fingers_ = 0;
1507 pinchRecognizer->refereeState_ = RefereeState::SUCCEED;
1508 auto result = pinchRecognizer->ReconcileFrom(pinchRecognizerPtr);
1509 EXPECT_EQ(unknownPropertyValue, GESTURE_EVENT_PROPERTY_VALUE);
1510 EXPECT_EQ(result, false);
1511 }
1512
1513 /**
1514 * @tc.name: PinchGestureLimitFingerTest001
1515 * @tc.desc: Test PinchGesture CreateRecognizer function
1516 */
1517 HWTEST_F(PinchRecognizerTestNg, PinchGestureLimitFingerTest001, TestSize.Level1)
1518 {
1519 /**
1520 * @tc.steps: step1. create PinchGesture.
1521 */
1522 auto pinchGesture = AceType::MakeRefPtr<PinchGesture>(FINGER_NUMBER, PINCH_GESTURE_DISTANCE, IS_LIMIT_FINGER_COUNT);
1523 ASSERT_NE(pinchGesture, nullptr);
1524 EXPECT_EQ(pinchGesture->isLimitFingerCount_, IS_LIMIT_FINGER_COUNT);
1525
1526 /**
1527 * @tc.steps: step2. call CreateRecognizer function and compare result
1528 * @tc.steps: case1: onActionId, onActionEndId, onActionCancelId not existed
1529 * @tc.expect: pinchRecognizer create successfully without the OnActionCall.
1530 */
1531 pinchGesture->priority_ = GesturePriority::Low;
1532 pinchGesture->gestureMask_ = GestureMask::Normal;
1533 auto pinchRecognizer = AceType::DynamicCast<PinchRecognizer>(pinchGesture->CreateRecognizer());
1534 ASSERT_NE(pinchRecognizer, nullptr);
1535 EXPECT_EQ(pinchRecognizer->GetPriority(), GesturePriority::Low);
1536 EXPECT_EQ(pinchRecognizer->GetPriorityMask(), GestureMask::Normal);
1537 EXPECT_EQ(pinchRecognizer->distance_, PINCH_GESTURE_DISTANCE);
1538 EXPECT_EQ(pinchRecognizer->isLimitFingerCount_, IS_LIMIT_FINGER_COUNT);
1539 }
1540
1541 /**
1542 * @tc.name: PinchGestureLimitFingerTest002
1543 * @tc.desc: Test PinchGesture CreateRecognizer function
1544 */
1545 HWTEST_F(PinchRecognizerTestNg, PinchGestureLimitFingerTest002, TestSize.Level1)
1546 {
1547 /**
1548 * @tc.steps: step1. create PinchGesture.
1549 */
1550 auto pinchGesture =
1551 AceType::MakeRefPtr<PinchGesture>(FINGER_NUMBER, PINCH_GESTURE_DISTANCE, IS_NOT_LIMIT_FINGER_COUNT);
1552 ASSERT_NE(pinchGesture, nullptr);
1553 EXPECT_EQ(pinchGesture->isLimitFingerCount_, IS_NOT_LIMIT_FINGER_COUNT);
1554
1555 /**
1556 * @tc.steps: step2. call CreateRecognizer function and compare result
1557 * @tc.steps: case1: onActionId, onActionEndId, onActionCancelId existed
1558 * @tc.expect: pinchRecognizer create successfully with the OnActionCall.
1559 */
1560 pinchGesture->priority_ = GesturePriority::Low;
1561 pinchGesture->gestureMask_ = GestureMask::Normal;
__anoncfb3240b0b02(GestureEvent& info) 1562 auto onActionStart = [](GestureEvent& info) { return true; };
__anoncfb3240b0c02(GestureEvent& info) 1563 auto onActionUpdate = [](GestureEvent& info) { return true; };
__anoncfb3240b0d02(GestureEvent& info) 1564 auto onActionEnd = [](GestureEvent& info) { return true; };
__anoncfb3240b0e02(GestureEvent& info) 1565 auto onActionCancel = [](GestureEvent& info) { return true; };
1566 pinchGesture->SetOnActionStartId(onActionStart);
1567 pinchGesture->SetOnActionUpdateId(onActionUpdate);
1568 pinchGesture->SetOnActionEndId(onActionEnd);
1569 pinchGesture->SetOnActionCancelId(onActionCancel);
1570 EXPECT_TRUE(pinchGesture->onActionStartId_);
1571 EXPECT_TRUE(pinchGesture->onActionUpdateId_);
1572 EXPECT_TRUE(pinchGesture->onActionEndId_);
1573 EXPECT_TRUE(pinchGesture->onActionCancelId_);
1574 auto pinchRecognizer = AceType::DynamicCast<PinchRecognizer>(pinchGesture->CreateRecognizer());
1575 ASSERT_NE(pinchRecognizer, nullptr);
1576 EXPECT_EQ(pinchRecognizer->GetPriority(), GesturePriority::Low);
1577 EXPECT_EQ(pinchRecognizer->GetPriorityMask(), GestureMask::Normal);
1578 EXPECT_EQ(pinchRecognizer->distance_, PINCH_GESTURE_DISTANCE);
1579 EXPECT_EQ(pinchRecognizer->isLimitFingerCount_, IS_NOT_LIMIT_FINGER_COUNT);
1580 }
1581 } // namespace OHOS::Ace::NG