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, GestureCallbackType::ACTION);
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, GestureCallbackType::ACTION);
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 */
__anonb05139ed0102(GestureEvent) 345 onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
346 pinchRecognizer->SendCallbackMsg(onAction, GestureCallbackType::ACTION);
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, GestureCallbackType::ACTION);
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, GestureCallbackType::ACTION);
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 */
__anonb05139ed0202(GestureEvent) 453 onAction = std::make_unique<GestureEventFunc>([](GestureEvent) {});
454 pinchRecognizer->SendCallbackMsg(onAction, GestureCallbackType::ACTION);
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;
__anonb05139ed0302(GestureEvent& info) 563 auto onActionStart = [](GestureEvent& info) { return true; };
__anonb05139ed0402(GestureEvent& info) 564 auto onActionUpdate = [](GestureEvent& info) { return true; };
__anonb05139ed0502(GestureEvent& info) 565 auto onActionEnd = [](GestureEvent& info) { return true; };
__anonb05139ed0602(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>();
__anonb05139ed0702(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, GestureCallbackType::ACTION);
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;
__anonb05139ed0802(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;
__anonb05139ed0902(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;
__anonb05139ed0a02(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;
__anonb05139ed0b02(GestureEvent& info) 1562 auto onActionStart = [](GestureEvent& info) { return true; };
__anonb05139ed0c02(GestureEvent& info) 1563 auto onActionUpdate = [](GestureEvent& info) { return true; };
__anonb05139ed0d02(GestureEvent& info) 1564 auto onActionEnd = [](GestureEvent& info) { return true; };
__anonb05139ed0e02(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
1582 /**
1583 * @tc.name: OnAccepted001
1584 * @tc.desc: Test OnAccepted function
1585 */
1586 HWTEST_F(PinchRecognizerTestNg, OnAccepted001, TestSize.Level1)
1587 {
1588 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1589 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1590
1591 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1592 pinchRecognizerPtr->firstInputTime_ = timeStape;
1593 SystemProperties::traceInputEventEnable_ = true;
1594 pinchRecognizerPtr->OnAccepted();
1595 EXPECT_EQ(pinchRecognizerPtr->firstInputTime_.has_value(), true);
1596 }
1597
1598 /**
1599 * @tc.name: HandleTouchDownEvent001
1600 * @tc.desc: Test HandleTouchDownEvent function
1601 */
1602 HWTEST_F(PinchRecognizerTestNg, HandleTouchDownEvent001, TestSize.Level1)
1603 {
1604 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1605 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1606
1607 TouchEvent touchEvent;
1608 touchEvent.id = 1;
1609 touchEvent.SetX(-100);
1610 touchEvent.SetY(200);
1611 pinchRecognizerPtr->refereeState_ = RefereeState::FAIL;
1612 pinchRecognizerPtr->currentFingers_ = 2;
1613 pinchRecognizerPtr->fingers_ = 0;
1614 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1615 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1616 pinchRecognizerPtr->HandleTouchDownEvent(touchEvent);
1617
1618 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::READY);
1619 }
1620
1621 /**
1622 * @tc.name: HandleTouchDownEvent002
1623 * @tc.desc: Test HandleTouchDownEvent function
1624 */
1625 HWTEST_F(PinchRecognizerTestNg, HandleTouchDownEvent002, TestSize.Level1)
1626 {
1627 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1628 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1629
1630 AxisEvent event;
1631 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1632 event.isRotationEvent = true;
1633 event.time = timeStape;
1634 pinchRecognizerPtr->HandleTouchDownEvent(event);
1635 EXPECT_EQ(pinchRecognizerPtr->firstInputTime_, timeStape);
1636 }
1637
1638 /**
1639 * @tc.name: HandleTouchDownEvent003
1640 * @tc.desc: Test HandleTouchDownEvent function
1641 */
1642 HWTEST_F(PinchRecognizerTestNg, HandleTouchDownEvent003, TestSize.Level1)
1643 {
1644 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1645 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1646
1647 AxisEvent event;
1648 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1649 event.time = timeStape;
1650 event.pinchAxisScale = 1.0;
1651 int32_t apiVersion = 1018;
1652 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1653 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1654 AceApplicationInfo::GetInstance().SetApiTargetVersion(apiVersion);
1655 pinchRecognizerPtr->HandleTouchDownEvent(event);
1656 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1657
1658 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1659 event.pinchAxisScale = 1.0;
1660 event.sourceTool = SourceTool::FINGER;
1661 event.pressedCodes.clear();
1662 pinchRecognizerPtr->HandleTouchDownEvent(event);
1663 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1664
1665 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1666 event.pinchAxisScale = 1.0;
1667 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1668 pinchRecognizerPtr->HandleTouchDownEvent(event);
1669 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1670
1671 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1672 event.pinchAxisScale = 1.0;
1673 event.pressedCodes.clear();
1674 event.sourceTool = SourceTool::TOUCHPAD;
1675 pinchRecognizerPtr->HandleTouchDownEvent(event);
1676 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1677
1678 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1679 event.pinchAxisScale = 100.0;
1680 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1681 event.sourceTool = SourceTool::FINGER;
1682 pinchRecognizerPtr->HandleTouchDownEvent(event);
1683 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1684
1685 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1686 event.pinchAxisScale = 100.0;
1687 event.pressedCodes.clear();
1688 pinchRecognizerPtr->HandleTouchDownEvent(event);
1689 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::READY);
1690
1691 event.pinchAxisScale = 100.0;
1692 event.sourceTool = SourceTool::TOUCHPAD;
1693 pinchRecognizerPtr->HandleTouchDownEvent(event);
1694 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::READY);
1695
1696 event.pinchAxisScale = 100.0;
1697 pinchRecognizerPtr->HandleTouchDownEvent(event);
1698 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::READY);
1699 }
1700
1701 /**
1702 * @tc.name: HandleTouchDownEvent004
1703 * @tc.desc: Test HandleTouchDownEvent function
1704 */
1705 HWTEST_F(PinchRecognizerTestNg, HandleTouchDownEvent004, TestSize.Level1)
1706 {
1707 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1708 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1709
1710 AxisEvent event;
1711 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1712 event.time = timeStape;
1713 event.pinchAxisScale = 1.0;
1714 int32_t apiVersion = 1018;
1715 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1716 pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1717 AceApplicationInfo::GetInstance().SetApiTargetVersion(apiVersion);
1718 pinchRecognizerPtr->HandleTouchDownEvent(event);
1719 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1720
1721 event.pinchAxisScale = 1.0;
1722 event.sourceTool = SourceTool::FINGER;
1723 event.pressedCodes.clear();
1724 pinchRecognizerPtr->HandleTouchDownEvent(event);
1725 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1726
1727 event.pinchAxisScale = 1.0;
1728 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1729 pinchRecognizerPtr->HandleTouchDownEvent(event);
1730 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1731
1732 event.pinchAxisScale = 1.0;
1733 event.pressedCodes.clear();
1734 event.sourceTool = SourceTool::TOUCHPAD;
1735 pinchRecognizerPtr->HandleTouchDownEvent(event);
1736 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1737
1738 event.pinchAxisScale = 100.0;
1739 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1740 event.sourceTool = SourceTool::FINGER;
1741 pinchRecognizerPtr->HandleTouchDownEvent(event);
1742 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1743
1744 event.pinchAxisScale = 100.0;
1745 event.pressedCodes.clear();
1746 pinchRecognizerPtr->HandleTouchDownEvent(event);
1747 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1748
1749 event.pinchAxisScale = 100.0;
1750 event.sourceTool = SourceTool::TOUCHPAD;
1751 pinchRecognizerPtr->HandleTouchDownEvent(event);
1752 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1753
1754 event.pinchAxisScale = 100.0;
1755 pinchRecognizerPtr->HandleTouchDownEvent(event);
1756 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1757 }
1758
1759 /**
1760 * @tc.name: HandleTouchDownEvent005
1761 * @tc.desc: Test HandleTouchDownEvent function
1762 */
1763 HWTEST_F(PinchRecognizerTestNg, HandleTouchDownEvent005, TestSize.Level1)
1764 {
1765 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1766 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1767 int32_t apiVersion = 1000;
1768 AceApplicationInfo::GetInstance().SetApiTargetVersion(apiVersion);
1769 AxisEvent event;
1770 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1771 event.time = timeStape;
1772 event.pinchAxisScale = 1.0;
1773 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1774 pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
1775 pinchRecognizerPtr->HandleTouchDownEvent(event);
1776 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1777
1778 event.pinchAxisScale = 1.0;
1779 event.pressedCodes.clear();
1780 pinchRecognizerPtr->HandleTouchDownEvent(event);
1781 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1782
1783 event.pinchAxisScale = 100.0;
1784 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1785 pinchRecognizerPtr->HandleTouchDownEvent(event);
1786 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1787
1788 event.pinchAxisScale = 100.0;
1789 event.pressedCodes.clear();
1790 pinchRecognizerPtr->HandleTouchDownEvent(event);
1791 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1792 }
1793
1794 /**
1795 * @tc.name: HandleTouchDownEvent006
1796 * @tc.desc: Test HandleTouchDownEvent function
1797 */
1798 HWTEST_F(PinchRecognizerTestNg, HandleTouchDownEvent006, TestSize.Level1)
1799 {
1800 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1801 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1802
1803 AxisEvent event;
1804 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1805 event.time = timeStape;
1806 event.pinchAxisScale = 1.0;
1807 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1808 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1809 pinchRecognizerPtr->HandleTouchDownEvent(event);
1810 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1811
1812 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1813 event.pinchAxisScale = 1.0;
1814 event.pressedCodes.clear();
1815 pinchRecognizerPtr->HandleTouchDownEvent(event);
1816 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1817
1818 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1819 event.pinchAxisScale = 100.0;
1820 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
1821 pinchRecognizerPtr->HandleTouchDownEvent(event);
1822 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::DETECTING);
1823
1824 pinchRecognizerPtr->refereeState_ = RefereeState::READY;
1825 event.pinchAxisScale = 100.0;
1826 event.pressedCodes.clear();
1827 pinchRecognizerPtr->HandleTouchDownEvent(event);
1828 EXPECT_EQ(pinchRecognizerPtr->refereeState_, RefereeState::READY);
1829 }
1830
1831 /**
1832 * @tc.name: HandleTouchUpEvent001
1833 * @tc.desc: Test HandleTouchUpEvent function
1834 */
1835 HWTEST_F(PinchRecognizerTestNg, HandleTouchUpEvent001, TestSize.Level1)
1836 {
1837 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1838 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1839
1840 TouchEvent touchEvent;
1841 touchEvent.id = 1;
1842 pinchRecognizerPtr->isNeedResetVoluntarily_ = true;
1843 pinchRecognizerPtr->currentFingers_ = 1;
1844 pinchRecognizerPtr->fingers_ = 0;
1845 pinchRecognizerPtr->fingersId_.clear();
1846 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1847 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1848 pinchRecognizerPtr->HandleTouchUpEvent(touchEvent);
1849 EXPECT_EQ(pinchRecognizerPtr->isLastPinchFinished_, true);
1850 }
1851
1852 /**
1853 * @tc.name: HandleTouchUpEvent002
1854 * @tc.desc: Test HandleTouchUpEvent function
1855 */
1856 HWTEST_F(PinchRecognizerTestNg, HandleTouchUpEvent002, TestSize.Level1)
1857 {
1858 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1859 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1860
1861 TouchEvent touchEvent;
1862 touchEvent.id = 1;
1863 pinchRecognizerPtr->isNeedResetVoluntarily_ = false;
1864 pinchRecognizerPtr->currentFingers_ = 1;
1865 pinchRecognizerPtr->fingersId_.clear();
1866
1867 pinchRecognizerPtr->fingers_ = 2;
1868 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1869 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1870 pinchRecognizerPtr->refereeState_ = RefereeState::FAIL;
1871 pinchRecognizerPtr->HandleTouchUpEvent(touchEvent);
1872 EXPECT_EQ(pinchRecognizerPtr->activeFingers_.size(), 0);
1873
1874 pinchRecognizerPtr->fingers_ = 0;
1875 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1876 pinchRecognizerPtr->refereeState_ = RefereeState::FAIL;
1877 pinchRecognizerPtr->HandleTouchUpEvent(touchEvent);
1878 EXPECT_EQ(pinchRecognizerPtr->activeFingers_.size(), 0);
1879
1880 pinchRecognizerPtr->fingers_ = 2;
1881 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1882 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1883 pinchRecognizerPtr->HandleTouchUpEvent(touchEvent);
1884 EXPECT_EQ(pinchRecognizerPtr->activeFingers_.size(), 0);
1885
1886 pinchRecognizerPtr->fingers_ = 0;
1887 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1888 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1889 pinchRecognizerPtr->HandleTouchUpEvent(touchEvent);
1890 EXPECT_EQ(pinchRecognizerPtr->activeFingers_.size(), 0);
1891 }
1892
1893 /**
1894 * @tc.name: HandleTouchUpEvent003
1895 * @tc.desc: Test HandleTouchUpEvent function
1896 */
1897 HWTEST_F(PinchRecognizerTestNg, HandleTouchUpEvent003, TestSize.Level1)
1898 {
1899 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1900 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1901
1902 TouchEvent touchEvent;
1903 touchEvent.id = 1;
1904 pinchRecognizerPtr->isNeedResetVoluntarily_ = false;
1905 pinchRecognizerPtr->currentFingers_ = 1;
1906 pinchRecognizerPtr->fingersId_.clear();
1907
1908 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1909 pinchRecognizerPtr->firstInputTime_ = timeStape;
1910 SystemProperties::traceInputEventEnable_ = true;
1911 pinchRecognizerPtr->fingers_ = 1;
1912 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1913 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1914 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1915 pinchRecognizerPtr->HandleTouchUpEvent(touchEvent);
1916 EXPECT_EQ(pinchRecognizerPtr->activeFingers_.size(), 0);
1917
1918 pinchRecognizerPtr->fingers_ = 0;
1919 pinchRecognizerPtr->isNeedResetVoluntarily_ = false;
1920 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1921 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1922 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1923 pinchRecognizerPtr->HandleTouchUpEvent(touchEvent);
1924 EXPECT_EQ(pinchRecognizerPtr->activeFingers_.size(), 0);
1925
1926 pinchRecognizerPtr->fingers_ = 1;
1927 pinchRecognizerPtr->isNeedResetVoluntarily_ = false;
1928 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1929 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1930 pinchRecognizerPtr->refereeState_ = RefereeState::FAIL;
1931 pinchRecognizerPtr->HandleTouchUpEvent(touchEvent);
1932 EXPECT_EQ(pinchRecognizerPtr->activeFingers_.size(), 0);
1933
1934 pinchRecognizerPtr->fingers_ = 0;
1935 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1936 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1937 pinchRecognizerPtr->refereeState_ = RefereeState::FAIL;
1938 pinchRecognizerPtr->HandleTouchUpEvent(touchEvent);
1939 EXPECT_EQ(pinchRecognizerPtr->activeFingers_.size(), 0);
1940 }
1941
1942 /**
1943 * @tc.name: HandleTouchUpEvent004
1944 * @tc.desc: Test HandleTouchUpEvent function
1945 */
1946 HWTEST_F(PinchRecognizerTestNg, HandleTouchUpEvent004, TestSize.Level1)
1947 {
1948 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1949 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1950
1951 AxisEvent event;
1952 pinchRecognizerPtr->isNeedResetVoluntarily_ = false;
1953 pinchRecognizerPtr->currentFingers_ = 1;
1954 pinchRecognizerPtr->fingersId_.clear();
1955
1956 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1957 pinchRecognizerPtr->firstInputTime_ = timeStape;
1958 SystemProperties::traceInputEventEnable_ = true;
1959 pinchRecognizerPtr->fingers_ = 1;
1960 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
1961 pinchRecognizerPtr->HandleTouchUpEvent(event);
1962 EXPECT_EQ(pinchRecognizerPtr->activeFingers_.size(), 0);
1963 }
1964
1965 /**
1966 * @tc.name: HandleTouchMoveEvent001
1967 * @tc.desc: Test HandleTouchMoveEvent function
1968 */
1969 HWTEST_F(PinchRecognizerTestNg, HandleTouchMoveEvent001, TestSize.Level1)
1970 {
1971 RefPtr<PinchRecognizer> pinchRecognizerPtr =
1972 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
1973
1974 TouchEvent touchEvent;
1975 touchEvent.id = 1;
1976 pinchRecognizerPtr->isNeedResetVoluntarily_ = false;
1977 pinchRecognizerPtr->currentFingers_ = 1;
1978 pinchRecognizerPtr->fingersId_.clear();
1979
1980 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
1981 pinchRecognizerPtr->firstInputTime_ = timeStape;
1982 touchEvent.time = timeStape;
1983 SystemProperties::traceInputEventEnable_ = true;
1984 pinchRecognizerPtr->fingers_ = 3;
1985 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1986 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
1987 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
1988 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
1989
1990 pinchRecognizerPtr->fingers_ = 3;
1991 pinchRecognizerPtr->activeFingers_.clear();
1992 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
1993 pinchRecognizerPtr->activeFingers_.push_back(1);
1994 pinchRecognizerPtr->activeFingers_.push_back(2);
1995 pinchRecognizerPtr->touchPoints_.clear();
1996 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
1997 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
1998
1999 pinchRecognizerPtr->fingers_ = 2;
2000 pinchRecognizerPtr->activeFingers_.clear();
2001 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
2002 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
2003 pinchRecognizerPtr->touchPoints_[2] = touchEvent;
2004 pinchRecognizerPtr->touchPoints_[3] = touchEvent;
2005 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
2006 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2007
2008 pinchRecognizerPtr->fingers_ = 1;
2009 pinchRecognizerPtr->activeFingers_.clear();
2010 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
2011 pinchRecognizerPtr->activeFingers_.push_back(1);
2012 pinchRecognizerPtr->activeFingers_.push_back(2);
2013 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
2014 pinchRecognizerPtr->touchPoints_[2] = touchEvent;
2015 pinchRecognizerPtr->touchPoints_[3] = touchEvent;
2016 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
2017 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2018 }
2019
2020 /**
2021 * @tc.name: HandleTouchMoveEvent002
2022 * @tc.desc: Test HandleTouchMoveEvent function
2023 */
2024 HWTEST_F(PinchRecognizerTestNg, HandleTouchMoveEvent002, TestSize.Level1)
2025 {
2026 RefPtr<PinchRecognizer> pinchRecognizerPtr =
2027 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2028
2029 TouchEvent touchEvent;
2030 touchEvent.id = 1;
2031 pinchRecognizerPtr->isNeedResetVoluntarily_ = false;
2032 pinchRecognizerPtr->currentFingers_ = 1;
2033 pinchRecognizerPtr->fingersId_.clear();
2034
2035 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
2036 pinchRecognizerPtr->firstInputTime_ = timeStape;
2037 touchEvent.time = timeStape;
2038 SystemProperties::traceInputEventEnable_ = true;
2039 pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
2040 pinchRecognizerPtr->fingers_ = 0;
2041 pinchRecognizerPtr->initialDev_ = pinchRecognizerPtr->ComputeAverageDeviation()-1;
2042 pinchRecognizerPtr->distance_ = 1;
2043 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
2044 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
2045 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
2046 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2047 }
2048
2049 /**
2050 * @tc.name: HandleTouchMoveEvent003
2051 * @tc.desc: Test HandleTouchMoveEvent function
2052 */
2053 HWTEST_F(PinchRecognizerTestNg, HandleTouchMoveEvent003, TestSize.Level1)
2054 {
2055 RefPtr<PinchRecognizer> pinchRecognizerPtr =
2056 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2057
2058 TouchEvent touchEvent;
2059 touchEvent.id = 1;
2060 pinchRecognizerPtr->isNeedResetVoluntarily_ = false;
2061 pinchRecognizerPtr->currentFingers_ = 1;
2062 pinchRecognizerPtr->fingersId_.clear();
2063
2064 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
2065 pinchRecognizerPtr->firstInputTime_ = timeStape;
2066 touchEvent.time = timeStape;
2067
2068 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
2069 pinchRecognizerPtr->fingers_ = 0;
2070 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
2071 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
2072 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
2073 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2074
2075 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
2076 pinchRecognizerPtr->fingers_ = 0;
2077 pinchRecognizerPtr->isLimitFingerCount_ = true;
2078 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
2079 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2080
2081 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
2082 pinchRecognizerPtr->fingers_ = 3;
2083 pinchRecognizerPtr->activeFingers_.push_back(2);
2084 pinchRecognizerPtr->activeFingers_.push_back(3);
2085 pinchRecognizerPtr->isLimitFingerCount_ = true;
2086 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
2087 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2088
2089 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
2090 pinchRecognizerPtr->fingers_ = 3;
2091 pinchRecognizerPtr->isLimitFingerCount_ = false;
2092 pinchRecognizerPtr->isFlushTouchEventsEnd_ = true;
2093 pinchRecognizerPtr->HandleTouchMoveEvent(touchEvent);
2094 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2095 }
2096
2097 /**
2098 * @tc.name: HandleTouchMoveEvent004
2099 * @tc.desc: Test HandleTouchMoveEvent function
2100 */
2101 HWTEST_F(PinchRecognizerTestNg, HandleTouchMoveEvent004, TestSize.Level1)
2102 {
2103 RefPtr<PinchRecognizer> pinchRecognizerPtr =
2104 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2105
2106 int32_t apiVersion = 1000;
2107 AceApplicationInfo::GetInstance().SetApiTargetVersion(apiVersion);
2108
2109 AxisEvent event;
2110 event.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
2111 TimeStamp timeStape = std::chrono::high_resolution_clock::now();
2112 event.time = timeStape;
2113 event.pinchAxisScale = 0.0;
2114 event.verticalAxis = 1.0;
2115 event.horizontalAxis = 1.0;
2116 pinchRecognizerPtr->scale_ = 0.0;
2117 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
2118 pinchRecognizerPtr->HandleTouchMoveEvent(event);
2119 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2120
2121 event.pinchAxisScale = 0.0;
2122 event.verticalAxis = - 1.0;
2123 event.horizontalAxis = - 1.0;
2124 pinchRecognizerPtr->scale_ = 0.0;
2125 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
2126 pinchRecognizerPtr->HandleTouchMoveEvent(event);
2127 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2128
2129 event.pinchAxisScale = 0.0;
2130 event.verticalAxis = 1.0;
2131 event.horizontalAxis = - 1.0;
2132 pinchRecognizerPtr->scale_ = 0.0;
2133 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
2134 pinchRecognizerPtr->HandleTouchMoveEvent(event);
2135 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2136
2137 event.pinchAxisScale = 0.0;
2138 event.verticalAxis = - 1.0;
2139 event.horizontalAxis = 1.0;
2140 pinchRecognizerPtr->scale_ = 0.0;
2141 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
2142 pinchRecognizerPtr->HandleTouchMoveEvent(event);
2143 EXPECT_EQ(pinchRecognizerPtr->time_, timeStape);
2144 }
2145
2146 /**
2147 * @tc.name: HandleTouchCancelEvent001
2148 * @tc.desc: Test HandleTouchCancelEvent function
2149 */
2150 HWTEST_F(PinchRecognizerTestNg, HandleTouchCancelEvent001, TestSize.Level1)
2151 {
2152 RefPtr<PinchRecognizer> pinchRecognizerPtr =
2153 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2154
2155 TouchEvent touchEvent;
2156 touchEvent.id = 1;
2157 pinchRecognizerPtr->isNeedResetVoluntarily_ = false;
2158 pinchRecognizerPtr->currentFingers_ = 1;
2159 pinchRecognizerPtr->activeFingers_.push_back(touchEvent.id);
2160 pinchRecognizerPtr->touchPoints_[touchEvent.id] = touchEvent;
2161
2162 pinchRecognizerPtr->refereeState_ = RefereeState::SUCCEED;
2163 pinchRecognizerPtr->HandleTouchCancelEvent(touchEvent);
2164 EXPECT_EQ(pinchRecognizerPtr->IsActiveFinger(touchEvent.id), true);
2165
2166 pinchRecognizerPtr->refereeState_ = RefereeState::FAIL;
2167 pinchRecognizerPtr->HandleTouchCancelEvent(touchEvent);
2168 EXPECT_EQ(pinchRecognizerPtr->IsActiveFinger(touchEvent.id), true);
2169
2170 pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
2171 pinchRecognizerPtr->HandleTouchCancelEvent(touchEvent);
2172 EXPECT_EQ(pinchRecognizerPtr->IsActiveFinger(touchEvent.id), true);
2173 }
2174
2175 /**
2176 * @tc.name: ComputePinchCenter001
2177 * @tc.desc: Test ComputePinchCenter function
2178 */
2179 HWTEST_F(PinchRecognizerTestNg, ComputePinchCenter001, TestSize.Level1)
2180 {
2181 RefPtr<PinchRecognizer> pinchRecognizerPtr =
2182 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2183
2184 auto ret = pinchRecognizerPtr->ComputePinchCenter();
2185 EXPECT_EQ(ret, Offset());
2186 }
2187
2188 /**
2189 * @tc.name: SendCallbackMsg001
2190 * @tc.desc: Test SendCallbackMsg function
2191 */
2192 HWTEST_F(PinchRecognizerTestNg, SendCallbackMsg001, TestSize.Level1)
2193 {
2194 RefPtr<PinchRecognizer> pinchRecognizerPtr =
2195 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2196
2197 auto callback = std::make_unique<GestureEventFunc>(funtest);
2198 RefPtr<GestureInfo> gestureInfo = AceType::MakeRefPtr<GestureInfo>();
2199 gestureInfo->disposeTag_ = true;
2200 pinchRecognizerPtr->SetGestureInfo(gestureInfo);
2201 pinchRecognizerPtr->SendCallbackMsg(callback, GestureCallbackType::ACTION);
2202
2203 pinchRecognizerPtr->lastTouchEvent_.SetRollAngle(10.0);
2204 gestureInfo->disposeTag_ = false;
2205 pinchRecognizerPtr->SendCallbackMsg(callback, GestureCallbackType::ACTION);
2206 EXPECT_EQ(pinchRecognizerPtr->lastTouchEvent_.rollAngle.has_value(), true);
2207
2208 pinchRecognizerPtr->lastTouchEvent_.SetRollAngle(10.0);
2209 gestureInfo->disposeTag_ = false;
2210 pinchRecognizerPtr->SetGestureInfo(nullptr);
2211 pinchRecognizerPtr->SendCallbackMsg(callback, GestureCallbackType::ACTION);
2212 EXPECT_EQ(pinchRecognizerPtr->lastTouchEvent_.rollAngle.has_value(), true);
2213 }
2214
2215 /**
2216 * @tc.name: TriggerGestureJudgeCallback001
2217 * @tc.desc: Test TriggerGestureJudgeCallback function
2218 */
2219 HWTEST_F(PinchRecognizerTestNg, TriggerGestureJudgeCallback001, TestSize.Level1)
2220 {
2221 RefPtr<PinchRecognizer> pinchRecognizerPtr =
2222 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2223
2224 GestureRecognizerJudgeFunc judgeFunc1;
2225 GestureJudgeFunc judgeFunc2;
2226
2227 judgeFunc1 = [](const std::shared_ptr<BaseGestureEvent>& info,
2228 const RefPtr<NGGestureRecognizer>& current,
__anonb05139ed0f02(const std::shared_ptr<BaseGestureEvent>& info, const RefPtr<NGGestureRecognizer>& current, const std::list<RefPtr<NGGestureRecognizer>>& others) 2229 const std::list<RefPtr<NGGestureRecognizer>>& others) -> GestureJudgeResult {
2230 return GestureJudgeResult::REJECT;
2231 };
2232 judgeFunc2 = [](const RefPtr<GestureInfo>& gestureInfo,
__anonb05139ed1002(const RefPtr<GestureInfo>& gestureInfo, const std::shared_ptr<BaseGestureEvent>& info) 2233 const std::shared_ptr<BaseGestureEvent>& info) -> GestureJudgeResult {
2234 return GestureJudgeResult::REJECT;
2235 };
2236
2237 RefPtr<NG::TargetComponent> targetComponent = AceType::MakeRefPtr<NG::TargetComponent>();
2238 pinchRecognizerPtr->SetTargetComponent(targetComponent);
2239 EXPECT_EQ(pinchRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::CONTINUE);
2240
2241 targetComponent->SetOnGestureRecognizerJudgeBegin(std::move(judgeFunc1));
2242 pinchRecognizerPtr->SetTargetComponent(targetComponent);
2243 EXPECT_NE(pinchRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::CONTINUE);
2244
2245 targetComponent->onGestureJudgeBegin_ = judgeFunc2;
2246 pinchRecognizerPtr->SetTargetComponent(targetComponent);
2247 EXPECT_NE(pinchRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::CONTINUE);
2248
2249 pinchRecognizerPtr->inputEventType_ = InputEventType::AXIS;
2250 AxisEvent axisEvent;
2251 pinchRecognizerPtr->lastAxisEvent_ = axisEvent;
2252 EXPECT_EQ(pinchRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
2253
2254 pinchRecognizerPtr->inputEventType_ = InputEventType::TOUCH_SCREEN;
2255 TouchEvent touchEvent;
2256 pinchRecognizerPtr->lastTouchEvent_ = touchEvent;
2257 EXPECT_EQ(pinchRecognizerPtr->TriggerGestureJudgeCallback(), GestureJudgeResult::REJECT);
2258
2259 RefPtr<PinchRecognizer> pinchRecognizerPtr2 =
2260 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2261 RefPtr<NG::TargetComponent> targetComponent2 = AceType::MakeRefPtr<NG::TargetComponent>();
2262 targetComponent2->onGestureJudgeBegin_ = judgeFunc2;
2263 pinchRecognizerPtr2->lastTouchEvent_.SetRollAngle(10.0);
2264 pinchRecognizerPtr2->SetTargetComponent(targetComponent2);
2265 EXPECT_EQ(pinchRecognizerPtr2->lastTouchEvent_.rollAngle.has_value(), true);
2266 EXPECT_NE(pinchRecognizerPtr2->TriggerGestureJudgeCallback(), GestureJudgeResult::CONTINUE);
2267 }
2268
2269 /**
2270 * @tc.name: ProcessAxisAbnormalCondition001
2271 * @tc.desc: Test ProcessAxisAbnormalCondition function
2272 */
2273 HWTEST_F(PinchRecognizerTestNg, ProcessAxisAbnormalCondition001, TestSize.Level1)
2274 {
2275 RefPtr<PinchRecognizer> pinchRecognizerPtr =
2276 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2277
2278 int32_t apiVersion = 1018;
2279 AceApplicationInfo::GetInstance().SetApiTargetVersion(apiVersion);
2280 AxisEvent axisEvent;
2281 axisEvent.pinchAxisScale = 1.0;
2282 auto ret = pinchRecognizerPtr->ProcessAxisAbnormalCondition(axisEvent);
2283 EXPECT_EQ(ret, false);
2284
2285 axisEvent.sourceTool = SourceTool::TOUCHPAD;
2286 ret = pinchRecognizerPtr->ProcessAxisAbnormalCondition(axisEvent);
2287 EXPECT_EQ(ret, false);
2288
2289 AxisEvent axisEvent2;
2290 axisEvent2.pinchAxisScale = 1.0;
2291 axisEvent2.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
2292 ret = pinchRecognizerPtr->ProcessAxisAbnormalCondition(axisEvent2);
2293 EXPECT_EQ(ret, false);
2294
2295 axisEvent.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
2296 ret = pinchRecognizerPtr->ProcessAxisAbnormalCondition(axisEvent);
2297 EXPECT_EQ(ret, false);
2298
2299 AxisEvent axisEvent3;
2300 axisEvent3.pinchAxisScale = 0.0;
2301 ret = pinchRecognizerPtr->ProcessAxisAbnormalCondition(axisEvent3);
2302 EXPECT_EQ(ret, false);
2303
2304 axisEvent3.sourceTool = SourceTool::TOUCHPAD;
2305 pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
2306 ret = pinchRecognizerPtr->ProcessAxisAbnormalCondition(axisEvent3);
2307 EXPECT_EQ(ret, true);
2308
2309 AxisEvent axisEvent4;
2310 axisEvent4.pinchAxisScale = 0.0;
2311 axisEvent4.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
2312 pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
2313 ret = pinchRecognizerPtr->ProcessAxisAbnormalCondition(axisEvent4);
2314 EXPECT_EQ(ret, false);
2315
2316 axisEvent3.pressedCodes = {KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_A};
2317 pinchRecognizerPtr->refereeState_ = RefereeState::DETECTING;
2318 ret = pinchRecognizerPtr->ProcessAxisAbnormalCondition(axisEvent3);
2319 EXPECT_EQ(ret, true);
2320 }
2321 /**
2322 * @tc.name: PinchRecognizerTypeTest001
2323 * @tc.desc: Test PinchRecognizerTypeTest
2324 */
2325 HWTEST_F(PinchRecognizerTestNg, PinchRecognizerTypeTest001, TestSize.Level1)
2326 {
2327 RefPtr<PinchRecognizer> pinchRecognizerPtr =
2328 AceType::MakeRefPtr<PinchRecognizer>(SINGLE_FINGER_NUMBER, PINCH_GESTURE_DISTANCE);
2329 auto frameNode = FrameNode::CreateFrameNode("myButton", 100, AceType::MakeRefPtr<Pattern>());
2330 pinchRecognizerPtr->AttachFrameNode(frameNode);
2331
2332 pinchRecognizerPtr->SetRecognizerType(GestureTypeName::PINCH_GESTURE);
2333 GestureEvent info;
2334 pinchRecognizerPtr->HandleReports(info, GestureCallbackType::END);
2335 EXPECT_EQ(pinchRecognizerPtr->GetRecognizerType(), GestureTypeName::PINCH_GESTURE);
2336 }
2337 } // namespace OHOS::Ace::NG