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
16 #include <cstdio>
17 #include <gtest/gtest.h>
18
19 #include "touch_gesture_detector.h"
20 #include "mmi_log.h"
21
22 #undef MMI_LOG_TAG
23 #define MMI_LOG_TAG "TouchGestureDetectorTest"
24
25 namespace OHOS {
26 namespace MMI {
27 using namespace testing;
28 using namespace testing::ext;
29 constexpr double MAXIMUM_SINGLE_SLIDE_DISTANCE { 3.0 };
30
31 class TouchGestureDetectorTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
39 class MyGestureListener : public TouchGestureDetector::GestureListener {
40 public:
OnGestureEvent(std::shared_ptr<PointerEvent> event,GestureMode mode)41 bool OnGestureEvent(std::shared_ptr<PointerEvent> event, GestureMode mode) override
42 {
43 return true;
44 }
45
OnGestureTrend(std::shared_ptr<PointerEvent> event)46 void OnGestureTrend(std::shared_ptr<PointerEvent> event) override {}
47 };
48
SetUpTestCase(void)49 void TouchGestureDetectorTest::SetUpTestCase(void)
50 {}
51
TearDownTestCase(void)52 void TouchGestureDetectorTest::TearDownTestCase(void)
53 {}
54
SetUp()55 void TouchGestureDetectorTest::SetUp()
56 {}
57
TearDown()58 void TouchGestureDetectorTest::TearDown()
59 {}
60
61 /**
62 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_01
63 * @tc.desc: Test OnTouchEvent
64 * @tc.type: FUNC
65 * @tc.require:
66 */
67 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_01, TestSize.Level1)
68 {
69 CALL_TEST_DEBUG;
70 auto listener = std::make_shared<MyGestureListener>();
71 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
72 TouchGestureDetector detector(type, listener);
73 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
74 ASSERT_NE(pointerEvent, nullptr);
75
76 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
77 detector.gestureEnable_ = true;
78 detector.gestureDisplayId_ = INT32_MAX;
79 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_UP;
80 pointerEvent->SetPointerId(0);
81 EXPECT_FALSE(detector.WhetherDiscardTouchEvent(pointerEvent));
82
83 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN;
84 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
85
86 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE;
87 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
88
89 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_UP;
90 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
91
92 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_AXIS_BEGIN;
93 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
94 }
95
96 /**
97 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_02
98 * @tc.desc: Test OnTouchEvent
99 * @tc.type: FUNC
100 * @tc.require:
101 */
102 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_02, TestSize.Level1)
103 {
104 CALL_TEST_DEBUG;
105 auto listener = std::make_shared<MyGestureListener>();
106 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
107 TouchGestureDetector detector(type, listener);
108 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
109 ASSERT_NE(pointerEvent, nullptr);
110
111 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
112 detector.gestureEnable_ = false;
113 EXPECT_TRUE(detector.WhetherDiscardTouchEvent(pointerEvent));
114 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
115 }
116
117 /**
118 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_05
119 * @tc.desc: Test OnTouchEvent
120 * @tc.type: FUNC
121 * @tc.require:
122 */
123 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_05, TestSize.Level1)
124 {
125 CALL_TEST_DEBUG;
126 auto listener = std::make_shared<MyGestureListener>();
127 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
128 ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(nullptr));
129 }
130
131 /**
132 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_06
133 * @tc.desc: Test OnTouchEvent
134 * @tc.type: FUNC
135 * @tc.require:
136 */
137 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_06, TestSize.Level1)
138 {
139 CALL_TEST_DEBUG;
140 auto pointerEvent = PointerEvent::Create();
141 ASSERT_NE(pointerEvent, nullptr);
142 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
143
144 auto listener = std::make_shared<MyGestureListener>();
145 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
146 ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
147 }
148
149 /**
150 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_07
151 * @tc.desc: Test OnTouchEvent
152 * @tc.type: FUNC
153 * @tc.require:
154 */
155 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_07, TestSize.Level1)
156 {
157 CALL_TEST_DEBUG;
158 auto pointerEvent = PointerEvent::Create();
159 ASSERT_NE(pointerEvent, nullptr);
160 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
161 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
162
163 auto listener = std::make_shared<MyGestureListener>();
164 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
165 int32_t fingerCnt = 3;
166 detector.AddGestureFingers(fingerCnt);
167 ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
168 }
169
170 /**
171 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_08
172 * @tc.desc: Test OnTouchEvent
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_08, TestSize.Level1)
177 {
178 CALL_TEST_DEBUG;
179 auto pointerEvent = PointerEvent::Create();
180 ASSERT_NE(pointerEvent, nullptr);
181 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
182 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
183
184 auto listener = std::make_shared<MyGestureListener>();
185 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
186 int32_t fingerCnt = 3;
187 detector.AddGestureFingers(fingerCnt);
188 ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
189 }
190
191 /**
192 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_09
193 * @tc.desc: Test OnTouchEvent
194 * @tc.type: FUNC
195 * @tc.require:
196 */
197 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_09, TestSize.Level1)
198 {
199 CALL_TEST_DEBUG;
200 auto pointerEvent = PointerEvent::Create();
201 ASSERT_NE(pointerEvent, nullptr);
202 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
203 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
204
205 auto listener = std::make_shared<MyGestureListener>();
206 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
207 int32_t fingerCnt = 3;
208 detector.AddGestureFingers(fingerCnt);
209 ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
210 }
211
212 /**
213 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_10
214 * @tc.desc: Test OnTouchEvent
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_10, TestSize.Level1)
219 {
220 CALL_TEST_DEBUG;
221 auto pointerEvent = PointerEvent::Create();
222 ASSERT_NE(pointerEvent, nullptr);
223 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
224 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
225
226 auto listener = std::make_shared<MyGestureListener>();
227 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
228 int32_t fingerCnt = 3;
229 detector.AddGestureFingers(fingerCnt);
230 ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
231 }
232
233 /**
234 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_11
235 * @tc.desc: Test OnTouchEvent
236 * @tc.type: FUNC
237 * @tc.require:
238 */
239 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_11, TestSize.Level1)
240 {
241 CALL_TEST_DEBUG;
242 auto pointerEvent = PointerEvent::Create();
243 ASSERT_NE(pointerEvent, nullptr);
244 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
245 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
246
247 auto listener = std::make_shared<MyGestureListener>();
248 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
249 int32_t fingerCnt = 3;
250 detector.AddGestureFingers(fingerCnt);
251 ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
252 }
253
254 /**
255 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_12
256 * @tc.desc: Test OnTouchEvent
257 * @tc.type: FUNC
258 * @tc.require:
259 */
260 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_12, TestSize.Level1)
261 {
262 CALL_TEST_DEBUG;
263 auto pointerEvent = PointerEvent::Create();
264 ASSERT_NE(pointerEvent, nullptr);
265 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
266 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
267
268 auto listener = std::make_shared<MyGestureListener>();
269 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
270 int32_t fingerCnt = 3;
271 detector.AddGestureFingers(fingerCnt);
272 ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
273 }
274
275 /**
276 * @tc.name: TouchGestureDetectorTest_HandleDownEvent_01
277 * @tc.desc: Test HandleDownEvent
278 * @tc.type: FUNC
279 * @tc.require:
280 */
281 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleDownEvent_01, TestSize.Level1)
282 {
283 CALL_TEST_DEBUG;
284 auto listener = std::make_shared<MyGestureListener>();
285 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
286 TouchGestureDetector detector(type, listener);
287 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
288 ASSERT_NE(pointerEvent, nullptr);
289
290 pointerEvent->pointerId_ = 3;
291 detector.isRecognized_ = false;
292
293 std::list<PointerEvent::PointerItem> pointers_;
294 PointerEvent::PointerItem item1;
295 item1.SetPointerId(1);
296 PointerEvent::PointerItem item2;
297 item2.SetPointerId(2);
298 pointers_.push_back(item1);
299 pointers_.push_back(item2);
300
301 bool ret = pointerEvent->GetPointerItem(pointerEvent->pointerId_, item2);
302 EXPECT_FALSE(ret);
303 ASSERT_NO_FATAL_FAILURE(detector.HandleDownEvent(pointerEvent));
304 }
305
306 /**
307 * @tc.name: TouchGestureDetectorTest_HandleDownEvent_02
308 * @tc.desc: Test HandleDownEvent
309 * @tc.type: FUNC
310 * @tc.require:
311 */
312 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleDownEvent_02, TestSize.Level1)
313 {
314 CALL_TEST_DEBUG;
315 auto listener = std::make_shared<MyGestureListener>();
316 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
317 TouchGestureDetector detector(type, listener);
318 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
319 ASSERT_NE(pointerEvent, nullptr);
320 detector.isRecognized_ = true;
321 ASSERT_NO_FATAL_FAILURE(detector.HandleDownEvent(pointerEvent));
322 }
323
324 /**
325 * @tc.name: TouchGestureDetectorTest_HandleMoveEvent_01
326 * @tc.desc: Test HandleMoveEvent
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleMoveEvent_01, TestSize.Level1)
331 {
332 CALL_TEST_DEBUG;
333 auto listener = std::make_shared<MyGestureListener>();
334 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
335 TouchGestureDetector detector(type, listener);
336 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
337 ASSERT_NE(pointerEvent, nullptr);
338 detector.downPoint_[1] = Point(1.0f, 2.0f);
339 detector.downPoint_[2] = Point(3.0f, 4.0f);
340 detector.downPoint_[3] = Point(5.0f, 6.0f);
341
342 detector.fingers_.insert(1);
343 detector.fingers_.insert(0);
344 detector.fingers_.insert(3);
345 EXPECT_TRUE(detector.IsMatchGesture(ALL_FINGER_COUNT));
346
347 detector.isRecognized_ = false;
348 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
349 detector.gestureType_ = TOUCH_GESTURE_TYPE_SWIPE;
350 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
351
352 detector.gestureType_ = TOUCH_GESTURE_TYPE_PINCH;
353 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
354
355 detector.gestureType_ = 8;
356 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
357 }
358
359 /**
360 * @tc.name: TouchGestureDetectorTest_HandleMoveEvent_02
361 * @tc.desc: Test HandleMoveEvent
362 * @tc.type: FUNC
363 * @tc.require:
364 */
365 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleMoveEvent_02, TestSize.Level1)
366 {
367 CALL_TEST_DEBUG;
368 auto listener = std::make_shared<MyGestureListener>();
369 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
370 TouchGestureDetector detector(type, listener);
371 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
372 ASSERT_NE(pointerEvent, nullptr);
373 detector.downPoint_[1] = Point(1.0f, 2.0f);
374 detector.downPoint_[2] = Point(3.0f, 4.0f);
375 detector.downPoint_[3] = Point(5.0f, 6.0f);
376
377 detector.fingers_.insert(1);
378 detector.fingers_.insert(0);
379 detector.fingers_.insert(3);
380 detector.isRecognized_ = true;
381 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
382 }
383
384 /**
385 * @tc.name: TouchGestureDetectorTest_HandleMoveEvent_03
386 * @tc.desc: Test HandleMoveEvent
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleMoveEvent_03, TestSize.Level1)
391 {
392 CALL_TEST_DEBUG;
393 auto listener = std::make_shared<MyGestureListener>();
394 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
395 TouchGestureDetector detector(type, listener);
396 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
397 ASSERT_NE(pointerEvent, nullptr);
398
399 detector.downPoint_[1] = Point(1.0f, 2.0f);
400 detector.downPoint_[2] = Point(3.0f, 4.0f);
401 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
402 }
403
404 /**
405 * @tc.name: TouchGestureDetectorTest_HandleSwipeMoveEvent_01
406 * @tc.desc: Test HandleSwipeMoveEvent
407 * @tc.type: FUNC
408 * @tc.require:
409 */
410 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleSwipeMoveEvent_01, TestSize.Level1)
411 {
412 CALL_TEST_DEBUG;
413 auto listener = std::make_shared<MyGestureListener>();
414 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
415 TouchGestureDetector detector(type, listener);
416 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
417 ASSERT_NE(pointerEvent, nullptr);
418
419 detector.downPoint_[1] = Point(1.0f, 2.0f);
420 detector.downPoint_[2] = Point(3.0f, 4.0f, 150000);
421 detector.isFingerReady_ = false;
422 ASSERT_NO_FATAL_FAILURE(detector.HandleSwipeMoveEvent(pointerEvent));
423 }
424
425 /**
426 * @tc.name: TouchGestureDetectorTest_HandleSwipeMoveEvent_02
427 * @tc.desc: Test HandleSwipeMoveEvent
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleSwipeMoveEvent_02, TestSize.Level1)
432 {
433 CALL_TEST_DEBUG;
434 auto listener = std::make_shared<MyGestureListener>();
435 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
436 TouchGestureDetector detector(type, listener);
437 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
438 ASSERT_NE(pointerEvent, nullptr);
439
440 detector.downPoint_[1] = Point(1.0f, 2.0f);
441 detector.downPoint_[2] = Point(3.0f, 4.0f, 150000);
442 detector.downPoint_[3] = Point(5.0f, 6.0f, 200000);
443 detector.isFingerReady_ = true;
444
445 auto state = detector.ClacFingerMoveDirection(pointerEvent);
446 state = TouchGestureDetector::SlideState::DIRECTION_UNKNOW;
447 ASSERT_NO_FATAL_FAILURE(detector.HandleSwipeMoveEvent(pointerEvent));
448
449 state = TouchGestureDetector::SlideState::DIRECTION_DOWN;
450 GestureMode mode = detector.ChangeToGestureMode(state);
451 EXPECT_FALSE(detector.NotifyGestureEvent(pointerEvent, mode));
452 ASSERT_NO_FATAL_FAILURE(detector.HandleSwipeMoveEvent(pointerEvent));
453 }
454
455 /**
456 * @tc.name: TouchGestureDetectorTest_HandlePinchMoveEvent_01
457 * @tc.desc: Test HandlePinchMoveEvent
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandlePinchMoveEvent_01, TestSize.Level1)
462 {
463 CALL_TEST_DEBUG;
464 auto listener = std::make_shared<MyGestureListener>();
465 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
466 TouchGestureDetector detector(type, listener);
467 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
468 ASSERT_NE(pointerEvent, nullptr);
469
470 detector.downPoint_[1] = Point(1.0f, 2.0f);
471 detector.downPoint_[2] = Point(3.0f, 4.0f);
472 EXPECT_TRUE(detector.lastDistance_.empty());
473 ASSERT_NO_FATAL_FAILURE(detector.HandlePinchMoveEvent(pointerEvent));
474 }
475
476 /**
477 * @tc.name: TouchGestureDetectorTest_HandlePinchMoveEvent_02
478 * @tc.desc: Test HandlePinchMoveEvent
479 * @tc.type: FUNC
480 * @tc.require:
481 */
482 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandlePinchMoveEvent_02, TestSize.Level1)
483 {
484 CALL_TEST_DEBUG;
485 auto listener = std::make_shared<MyGestureListener>();
486 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
487 TouchGestureDetector detector(type, listener);
488 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
489 ASSERT_NE(pointerEvent, nullptr);
490
491 detector.downPoint_[1] = Point(1.0f, 2.0f);
492 detector.downPoint_[2] = Point(3.0f, 4.0f);
493 detector.downPoint_[3] = Point(5.0f, 6.0f);
494 detector.downPoint_[4] = Point(7.0f, 8.0f);
495
496 detector.lastDistance_[1] = 1.0;
497 detector.lastDistance_[2] = 2.0;
498 detector.lastDistance_[3] = 3.0;
499 EXPECT_FALSE(detector.lastDistance_.empty());
500 ASSERT_NO_FATAL_FAILURE(detector.HandlePinchMoveEvent(pointerEvent));
501 }
502
503 /**
504 * @tc.name: TouchGestureDetectorTest_HandleUpEvent_01
505 * @tc.desc: Test HandleUpEvent
506 * @tc.type: FUNC
507 * @tc.require:
508 */
509 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleUpEvent_01, TestSize.Level1)
510 {
511 CALL_TEST_DEBUG;
512 auto listener = std::make_shared<MyGestureListener>();
513 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
514 TouchGestureDetector detector(type, listener);
515 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
516 ASSERT_NE(pointerEvent, nullptr);
517 pointerEvent->pointerId_ = 1;
518 detector.downPoint_[1] = Point(1.0f, 2.0f);
519 detector.downPoint_[2] = Point(3.0f, 4.0f);
520 ASSERT_NO_FATAL_FAILURE(detector.HandleUpEvent(pointerEvent));
521
522 pointerEvent->pointerId_ = 3;
523 ASSERT_NO_FATAL_FAILURE(detector.HandleUpEvent(pointerEvent));
524 }
525
526 /**
527 * @tc.name: TouchGestureDetectorTest_HandleUpEvent_02
528 * @tc.desc: Test HandleUpEvent
529 * @tc.type: FUNC
530 * @tc.require:
531 */
532 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleUpEvent_02, TestSize.Level1)
533 {
534 CALL_TEST_DEBUG;
535 auto listener = std::make_shared<MyGestureListener>();
536 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
537 TouchGestureDetector detector(type, listener);
538 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
539 ASSERT_NE(pointerEvent, nullptr);
540 pointerEvent->pointerId_ = 1;
541 EXPECT_TRUE(detector.downPoint_.empty());
542 ASSERT_NO_FATAL_FAILURE(detector.HandleUpEvent(pointerEvent));
543 }
544
545 /**
546 * @tc.name: TouchGestureDetectorTest_WhetherDiscardTouchEvent_01
547 * @tc.desc: Test WhetherDiscardTouchEvent
548 * @tc.type: FUNC
549 * @tc.require:
550 */
551 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_WhetherDiscardTouchEvent_01, TestSize.Level1)
552 {
553 CALL_TEST_DEBUG;
554 auto listener = std::make_shared<MyGestureListener>();
555 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
556 TouchGestureDetector detector(type, listener);
557 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
558 ASSERT_NE(pointerEvent, nullptr);
559
560 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_MOUSE;
561 EXPECT_TRUE(detector.WhetherDiscardTouchEvent(pointerEvent));
562
563 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
564 detector.gestureEnable_ = false;
565 EXPECT_TRUE(detector.WhetherDiscardTouchEvent(pointerEvent));
566
567 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
568 detector.gestureEnable_ = true;
569 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
570 pointerEvent->SetPointerId(0);
571 EXPECT_TRUE(detector.WhetherDiscardTouchEvent(pointerEvent));
572
573 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
574 detector.gestureEnable_ = true;
575 detector.gestureDisplayId_ = INT32_MAX - 2;
576 pointerEvent->bitwise_ = 0;
577 pointerEvent->SetPointerId(7);
578 pointerEvent->targetDisplayId_ = INT32_MAX - 1;
579 EXPECT_TRUE(detector.WhetherDiscardTouchEvent(pointerEvent));
580
581 detector.gestureDisplayId_ = INT32_MAX;
582 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
583 EXPECT_FALSE(detector.WhetherDiscardTouchEvent(pointerEvent));
584
585 detector.gestureDisplayId_ = INT32_MAX;
586 pointerEvent->targetDisplayId_ = INT32_MAX;
587 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
588 EXPECT_FALSE(detector.WhetherDiscardTouchEvent(pointerEvent));
589 }
590
591 /**
592 * @tc.name: TouchGestureDetectorTest_HandleFingerDown_01
593 * @tc.desc: Test HandleFingerDown
594 * @tc.type: FUNC
595 * @tc.require:
596 */
597 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleFingerDown_01, TestSize.Level1)
598 {
599 CALL_TEST_DEBUG;
600 auto listener = std::make_shared<MyGestureListener>();
601 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
602 TouchGestureDetector detector(type, listener);
603 detector.downPoint_[1] = Point(1.0f, 2.0f);
604 detector.downPoint_[2] = Point(3.0f, 4.0f);
605 auto fingersCount = detector.downPoint_.size();
606 EXPECT_TRUE(fingersCount < 3);
607 EXPECT_FALSE(detector.HandleFingerDown());
608 }
609
610 /**
611 * @tc.name: TouchGestureDetectorTest_HandleFingerDown_02
612 * @tc.desc: Test HandleFingerDown
613 * @tc.type: FUNC
614 * @tc.require:
615 */
616 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleFingerDown_02, TestSize.Level1)
617 {
618 CALL_TEST_DEBUG;
619 auto listener = std::make_shared<MyGestureListener>();
620 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
621 TouchGestureDetector detector(type, listener);
622 detector.downPoint_[1] = Point(0.0f, 0.0f);
623 detector.downPoint_[2] = Point(1000.0f, 1000.0f);
624 detector.downPoint_[3] = Point(-1000.0f, -1000.0f);
625 detector.downPoint_[4] = Point(500.0f, -500.0f);
626 detector.downPoint_[5] = Point(-500.0f, 500.0f);
627 EXPECT_FALSE(detector.HandleFingerDown());
628 }
629
630 /**
631 * @tc.name: TouchGestureDetectorTest_HandleFingerDown_03
632 * @tc.desc: Test HandleFingerDown
633 * @tc.type: FUNC
634 * @tc.require:
635 */
636 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleFingerDown_03, TestSize.Level1)
637 {
638 CALL_TEST_DEBUG;
639 auto listener = std::make_shared<MyGestureListener>();
640 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
641 TouchGestureDetector detector(type, listener);
642 detector.downPoint_[1] = Point(0.0f, 0.0f);
643 detector.downPoint_[2] = Point(100.0f, 100.0f);
644 detector.downPoint_[3] = Point(200.0f, 200.0f);
645 detector.downPoint_[4] = Point(300.0f, 300.0f);
646 detector.downPoint_[5] = Point(400.0f, 400.0f);
647 EXPECT_TRUE(detector.HandleFingerDown());
648 }
649
650 /**
651 * @tc.name: TouchGestureDetectorTest_HandleFingerDown_04
652 * @tc.desc: Test HandleFingerDown
653 * @tc.type: FUNC
654 * @tc.require:
655 */
656 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleFingerDown_04, TestSize.Level1)
657 {
658 CALL_TEST_DEBUG;
659 auto listener = std::make_shared<MyGestureListener>();
660 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
661 TouchGestureDetector detector(type, listener);
662 detector.downPoint_[1] = Point(0.0f, 0.0f, 50000);
663 detector.downPoint_[2] = Point(100.0f, 100.0f, 150000);
664 detector.downPoint_[3] = Point(200.0f, 200.0f, 250000);
665 EXPECT_FALSE(detector.HandleFingerDown());
666 }
667
668 /**
669 * @tc.name: TouchGestureDetectorTest_GetMaxFingerSpacing_01
670 * @tc.desc: Test GetMaxFingerSpacing
671 * @tc.type: FUNC
672 * @tc.require:
673 */
674 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxFingerSpacing_01, TestSize.Level1)
675 {
676 CALL_TEST_DEBUG;
677 auto listener = std::make_shared<MyGestureListener>();
678 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
679 TouchGestureDetector detector(type, listener);
680 detector.downPoint_[1] = Point(1.0f, 2.0f);
681 detector.downPoint_[2] = Point(3.0f, 4.0f);
682 ASSERT_NO_FATAL_FAILURE(detector.GetMaxFingerSpacing());
683 }
684
685 /**
686 * @tc.name: TouchGestureDetectorTest_GetMaxFingerSpacing_02
687 * @tc.desc: Test GetMaxFingerSpacing
688 * @tc.type: FUNC
689 * @tc.require:
690 */
691 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxFingerSpacing_02, TestSize.Level1)
692 {
693 CALL_TEST_DEBUG;
694 auto listener = std::make_shared<MyGestureListener>();
695 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
696 TouchGestureDetector detector(type, listener);
697 detector.downPoint_[1] = Point(1.0f, 2.0f);
698 detector.downPoint_[2] = Point(3.0f, 4.0f);
699 detector.downPoint_[3] = Point(5.0f, 6.0f);
700 ASSERT_NO_FATAL_FAILURE(detector.GetMaxFingerSpacing());
701 }
702
703 /**
704 * @tc.name: TouchGestureDetectorTest_GetMaxFingerSpacing_03
705 * @tc.desc: Test GetMaxFingerSpacing
706 * @tc.type: FUNC
707 * @tc.require:
708 */
709 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxFingerSpacing_03, TestSize.Level1)
710 {
711 CALL_TEST_DEBUG;
712 auto listener = std::make_shared<MyGestureListener>();
713 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
714 TouchGestureDetector detector(type, listener);
715 EXPECT_FLOAT_EQ(detector.GetMaxFingerSpacing(), 0.0f);
716 }
717
718 /**
719 * @tc.name: TouchGestureDetectorTest_GetMaxFingerSpacing_04
720 * @tc.desc: Test GetMaxFingerSpacing
721 * @tc.type: FUNC
722 * @tc.require:
723 */
724 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxFingerSpacing_04, TestSize.Level1)
725 {
726 CALL_TEST_DEBUG;
727 auto listener = std::make_shared<MyGestureListener>();
728 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
729 TouchGestureDetector detector(type, listener);
730 detector.downPoint_[1] = Point(1.0f, 1.0f);
731 detector.downPoint_[2] = Point(2.0f, 2.0f);
732 detector.downPoint_[3] = Point(3.0f, 3.0f);
733 EXPECT_FLOAT_EQ(detector.GetMaxFingerSpacing(), std::hypot(2.0f, 2.0f));
734 }
735
736 /**
737 * @tc.name: TouchGestureDetectorTest_GetMaxFingerSpacing_05
738 * @tc.desc: Test GetMaxFingerSpacing
739 * @tc.type: FUNC
740 * @tc.require:
741 */
742 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxFingerSpacing_05, TestSize.Level1)
743 {
744 CALL_TEST_DEBUG;
745 auto listener = std::make_shared<MyGestureListener>();
746 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
747 TouchGestureDetector detector(type, listener);
748 detector.downPoint_[1] = Point(1.0f, 1.0f);
749 detector.downPoint_[2] = Point(2.0f, 2.0f);
750 detector.downPoint_[3] = Point(3.0f, 3.0f);
751 detector.downPoint_[4] = Point(4.0f, 4.0f);
752 EXPECT_FLOAT_EQ(detector.GetMaxFingerSpacing(), std::hypot(3.0f, 3.0f));
753 }
754
755 /**
756 * @tc.name: TouchGestureDetectorTest_GetMaxDownInterval_01
757 * @tc.desc: Test GetMaxDownInterval
758 * @tc.type: FUNC
759 * @tc.require:
760 */
761 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxDownInterval_01, TestSize.Level1)
762 {
763 CALL_TEST_DEBUG;
764 auto listener = std::make_shared<MyGestureListener>();
765 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
766 TouchGestureDetector detector(type, listener);
767 detector.downPoint_[1] = Point(1.0f, 2.0f);
768 detector.downPoint_[2] = Point(3.0f, 4.0f);
769 ASSERT_NO_FATAL_FAILURE(detector.GetMaxDownInterval());
770 }
771
772 /**
773 * @tc.name: TouchGestureDetectorTest_GetMaxDownInterval_02
774 * @tc.desc: Test GetMaxDownInterval
775 * @tc.type: FUNC
776 * @tc.require:
777 */
778 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxDownInterval_02, TestSize.Level1)
779 {
780 CALL_TEST_DEBUG;
781 auto listener = std::make_shared<MyGestureListener>();
782 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
783 TouchGestureDetector detector(type, listener);
784 detector.downPoint_[1] = Point(1.0f, 2.0f);
785 detector.downPoint_[2] = Point(3.0f, 4.0f);
786 detector.downPoint_[3] = Point(5.0f, 6.0f);
787 ASSERT_NO_FATAL_FAILURE(detector.GetMaxDownInterval());
788 }
789
790 /**
791 * @tc.name: TouchGestureDetectorTest_GetSlidingDirection_01
792 * @tc.desc: Test GetSlidingDirection
793 * @tc.type: FUNC
794 * @tc.require:
795 */
796 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetSlidingDirection_01, TestSize.Level1)
797 {
798 CALL_TEST_DEBUG;
799 auto listener = std::make_shared<MyGestureListener>();
800 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
801 TouchGestureDetector detector(type, listener);
802 double angle;
803 angle = 20;
804 ASSERT_NO_FATAL_FAILURE(detector.GetSlidingDirection(angle));
805 angle = 50;
806 ASSERT_NO_FATAL_FAILURE(detector.GetSlidingDirection(angle));
807 angle = -60;
808 ASSERT_NO_FATAL_FAILURE(detector.GetSlidingDirection(angle));
809 angle = 200;
810 ASSERT_NO_FATAL_FAILURE(detector.GetSlidingDirection(angle));
811 }
812
813 /**
814 * @tc.name: TouchGestureDetectorTest_ChangeToGestureMode_01
815 * @tc.desc: Test ChangeToGestureMode
816 * @tc.type: FUNC
817 * @tc.require:
818 */
819 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_ChangeToGestureMode_01, TestSize.Level1)
820 {
821 CALL_TEST_DEBUG;
822 auto listener = std::make_shared<MyGestureListener>();
823 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
824 TouchGestureDetector detector(type, listener);
825 TouchGestureDetector::SlideState state;
826 state = TouchGestureDetector::SlideState::DIRECTION_UP;
827 EXPECT_EQ(detector.ChangeToGestureMode(state), GestureMode::ACTION_SWIPE_UP);
828
829 state = TouchGestureDetector::SlideState::DIRECTION_DOWN;
830 EXPECT_EQ(detector.ChangeToGestureMode(state), GestureMode::ACTION_SWIPE_DOWN);
831
832 state = TouchGestureDetector::SlideState::DIRECTION_LEFT;
833 EXPECT_EQ(detector.ChangeToGestureMode(state), GestureMode::ACTION_SWIPE_LEFT);
834
835 state = TouchGestureDetector::SlideState::DIRECTION_RIGHT;
836 EXPECT_EQ(detector.ChangeToGestureMode(state), GestureMode::ACTION_SWIPE_RIGHT);
837
838 state = TouchGestureDetector::SlideState::DIRECTION_UNKNOW;
839 EXPECT_EQ(detector.ChangeToGestureMode(state), GestureMode::ACTION_UNKNOWN);
840 }
841
842 /**
843 * @tc.name: TouchGestureDetectorTest_ClacFingerMoveDirection_01
844 * @tc.desc: Test ClacFingerMoveDirection
845 * @tc.type: FUNC
846 * @tc.require:
847 */
848 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_ClacFingerMoveDirection_01, TestSize.Level1)
849 {
850 CALL_TEST_DEBUG;
851 auto listener = std::make_shared<MyGestureListener>();
852 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
853 TouchGestureDetector detector(type, listener);
854 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
855 ASSERT_NE(pointerEvent, nullptr);
856 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_UP;
857 ASSERT_NO_FATAL_FAILURE(detector.ClacFingerMoveDirection(pointerEvent));
858
859 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE;
860 detector.downPoint_[1] = Point(1.0f, 2.0f);
861 detector.downPoint_[2] = Point(3.0f, 4.0f);
862 ASSERT_NO_FATAL_FAILURE(detector.ClacFingerMoveDirection(pointerEvent));
863 }
864
865 /**
866 * @tc.name: TouchGestureDetectorTest_ClacFingerMoveDirection_02
867 * @tc.desc: Test ClacFingerMoveDirection
868 * @tc.type: FUNC
869 * @tc.require:
870 */
871 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_ClacFingerMoveDirection_02, TestSize.Level1)
872 {
873 CALL_TEST_DEBUG;
874 auto listener = std::make_shared<MyGestureListener>();
875 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
876 TouchGestureDetector detector(type, listener);
877 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
878 ASSERT_NE(pointerEvent, nullptr);
879 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE;
880 detector.downPoint_[1] = Point(1.0f, 2.0f);
881 detector.downPoint_[2] = Point(3.0f, 4.0f);
882 detector.downPoint_[3] = Point(5.0f, 6.0f);
883 ASSERT_NO_FATAL_FAILURE(detector.ClacFingerMoveDirection(pointerEvent));
884 }
885
886 /**
887 * @tc.name: TouchGestureDetectorTest_CalcGravityCenter_01
888 * @tc.desc: Test CalcGravityCenter
889 * @tc.type: FUNC
890 * @tc.require:
891 */
892 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcGravityCenter_01, TestSize.Level1)
893 {
894 CALL_TEST_DEBUG;
895 auto listener = std::make_shared<MyGestureListener>();
896 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
897 TouchGestureDetector detector(type, listener);
898 std::map<int32_t, Point> points;
899 points[1] = Point(1.0f, 2.0f);
900 points[2] = Point(3.0f, 4.0f);
901 points[3] = Point(5.0f, 6.0f);
902 points[4] = Point(7.0f, 8.0f);
903 points[5] = Point(9.0f, 10.0f);
904 points[6] = Point(11.0f, 12.0f);
905 int32_t count = static_cast<int32_t>(points.size());
906 EXPECT_TRUE(count > 5);
907 ASSERT_NO_FATAL_FAILURE(detector.CalcGravityCenter(points));
908 }
909
910 /**
911 * @tc.name: TouchGestureDetectorTest_CalcGravityCenter_02
912 * @tc.desc: Test CalcGravityCenter
913 * @tc.type: FUNC
914 * @tc.require:
915 */
916 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcGravityCenter_02, TestSize.Level1)
917 {
918 CALL_TEST_DEBUG;
919 auto listener = std::make_shared<MyGestureListener>();
920 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
921 TouchGestureDetector detector(type, listener);
922 std::map<int32_t, Point> points;
923 points[1] = Point(1.0f, 2.0f);
924 points[2] = Point(3.0f, 4.0f);
925 points[3] = Point(5.0f, 6.0f);
926 ASSERT_NO_FATAL_FAILURE(detector.CalcGravityCenter(points));
927 }
928
929 /**
930 * @tc.name: TouchGestureDetectorTest_IsFingerMove
931 * @tc.desc: Test IsFingerMove
932 * @tc.type: FUNC
933 * @tc.require:
934 */
935 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_IsFingerMove, TestSize.Level1)
936 {
937 CALL_TEST_DEBUG;
938 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
939 ASSERT_NO_FATAL_FAILURE(detector.IsFingerMove(Point(1.0f, 2.0f), Point(3.0f, 4.0f)));
940 }
941
942 /**
943 * @tc.name: TouchGestureDetectorTest_CalcTwoPointsDistance
944 * @tc.desc: Test CalcTwoPointsDistance
945 * @tc.type: FUNC
946 * @tc.require:
947 */
948 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcTwoPointsDistance, TestSize.Level1)
949 {
950 CALL_TEST_DEBUG;
951 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
952 ASSERT_NO_FATAL_FAILURE(detector.CalcTwoPointsDistance(Point(1.0f, 2.0f), Point(3.0f, 4.0f)));
953 }
954
955 /**
956 * @tc.name: TouchGestureDetectorTest_CalcClusterCenter_01
957 * @tc.desc: Test CalcClusterCenter
958 * @tc.type: FUNC
959 * @tc.require:
960 */
961 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcClusterCenter_01, TestSize.Level1)
962 {
963 CALL_TEST_DEBUG;
964 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
965 std::map<int32_t, Point> points;
966 ASSERT_NO_FATAL_FAILURE(detector.CalcClusterCenter(points));
967 }
968
969 /**
970 * @tc.name: TouchGestureDetectorTest_CalcClusterCenter_02
971 * @tc.desc: Test CalcClusterCenter
972 * @tc.type: FUNC
973 * @tc.require:
974 */
975 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcClusterCenter_02, TestSize.Level1)
976 {
977 CALL_TEST_DEBUG;
978 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
979 std::map<int32_t, Point> points;
980 points[1] = Point(1.0f, 2.0f);
981 points[2] = Point(3.0f, 4.0f);
982 points[3] = Point(5.0f, 6.0f);
983 ASSERT_NO_FATAL_FAILURE(detector.CalcClusterCenter(points));
984 }
985
986 /**
987 * @tc.name: TouchGestureDetectorTest_CalcAndStoreDistance_01
988 * @tc.desc: Test CalcAndStoreDistance
989 * @tc.type: FUNC
990 * @tc.require:
991 */
992 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcAndStoreDistance_01, TestSize.Level1)
993 {
994 CALL_TEST_DEBUG;
995 auto listener = std::make_shared<MyGestureListener>();
996 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
997 TouchGestureDetector detector(type, listener);
998 std::map<int32_t, Point> points;
999 points[1] = Point(1.0f, 2.0f);
1000 points[2] = Point(3.0f, 4.0f);
1001
1002 detector.downPoint_[1] = Point(1.0f, 2.0f);
1003 detector.downPoint_[2] = Point(3.0f, 4.0f);
1004 ASSERT_NO_FATAL_FAILURE(detector.CalcAndStoreDistance());
1005 }
1006
1007 /**
1008 * @tc.name: TouchGestureDetectorTest_CalcAndStoreDistance_02
1009 * @tc.desc: Test CalcAndStoreDistance
1010 * @tc.type: FUNC
1011 * @tc.require:
1012 */
1013 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcAndStoreDistance_02, TestSize.Level1)
1014 {
1015 CALL_TEST_DEBUG;
1016 auto listener = std::make_shared<MyGestureListener>();
1017 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1018 TouchGestureDetector detector(type, listener);
1019 std::map<int32_t, Point> points;
1020 points[1] = Point(1.0f, 2.0f);
1021 points[2] = Point(3.0f, 4.0f);
1022
1023 detector.downPoint_[1] = Point(1.0f, 2.0f, 50000);
1024 detector.downPoint_[2] = Point(3.0f, 4.0f, 150000);
1025 detector.downPoint_[3] = Point(5.0f, 6.0f, 250000);
1026 detector.downPoint_[4] = Point(7.0f, 8.0f, 350000);
1027 ASSERT_NO_FATAL_FAILURE(detector.CalcAndStoreDistance());
1028 }
1029
1030 /**
1031 * @tc.name: TouchGestureDetectorTest_CalcAndStoreDistance_03
1032 * @tc.desc: Test CalcAndStoreDistance
1033 * @tc.type: FUNC
1034 * @tc.require:
1035 */
1036 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcAndStoreDistance_03, TestSize.Level1)
1037 {
1038 CALL_TEST_DEBUG;
1039 auto listener = std::make_shared<MyGestureListener>();
1040 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1041 TouchGestureDetector detector(type, listener);
1042 std::map<int32_t, Point> points;
1043 points[1] = Point(1.0f, 2.0f);
1044 points[2] = Point(3.0f, 4.0f);
1045
1046 detector.downPoint_[1] = Point(1.0f, 2.0f, 5000);
1047 detector.downPoint_[2] = Point(3.0f, 4.0f, 6000);
1048 detector.downPoint_[3] = Point(5.0f, 6.0f, 7000);
1049 detector.downPoint_[4] = Point(7.0f, 8.0f, 8000);
1050
1051 detector.lastDistance_[1] = 10.5;
1052 detector.lastDistance_[2] = 20.5;
1053 detector.lastDistance_[3] = 30.5;
1054 ASSERT_NO_FATAL_FAILURE(detector.CalcAndStoreDistance());
1055 }
1056
1057 /**
1058 * @tc.name: TouchGestureDetectorTest_CalcMultiFingerMovement_01
1059 * @tc.desc: Test CalcMultiFingerMovement
1060 * @tc.type: FUNC
1061 * @tc.require:
1062 */
1063 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcMultiFingerMovement_01, TestSize.Level1)
1064 {
1065 CALL_TEST_DEBUG;
1066 auto listener = std::make_shared<MyGestureListener>();
1067 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1068 TouchGestureDetector detector(type, listener);
1069 std::map<int32_t, Point> points;
1070 points[1] = Point(1.0f, 2.0f);
1071 points[2] = Point(3.0f, 4.0f);
1072 points[3] = Point(5.0f, 6.0f);
1073
1074 detector.downPoint_[1] = Point(1.0f, 2.0f, 50000);
1075 detector.downPoint_[2] = Point(3.0f, 4.0f, 150000);
1076 detector.downPoint_[3] = Point(5.0f, 6.0f, 250000);
1077 ASSERT_NO_FATAL_FAILURE(detector.CalcMultiFingerMovement(points));
1078 }
1079
1080 /**
1081 * @tc.name: TouchGestureDetectorTest_CalcMultiFingerMovement_02
1082 * @tc.desc: Test CalcMultiFingerMovement
1083 * @tc.type: FUNC
1084 * @tc.require:
1085 */
1086 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcMultiFingerMovement_02, TestSize.Level1)
1087 {
1088 CALL_TEST_DEBUG;
1089 auto listener = std::make_shared<MyGestureListener>();
1090 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1091 TouchGestureDetector detector(type, listener);
1092 std::map<int32_t, Point> points;
1093 points[1] = Point(1.0f, 2.0f);
1094 points[2] = Point(3.0f, 4.0f);
1095 points[3] = Point(5.0f, 6.0f);
1096
1097 detector.downPoint_[4] = Point(1.0f, 2.0f, 5000);
1098 detector.downPoint_[5] = Point(3.0f, 4.0f, 6000);
1099 detector.downPoint_[6] = Point(5.0f, 6.0f, 7000);
1100 ASSERT_NO_FATAL_FAILURE(detector.CalcMultiFingerMovement(points));
1101 }
1102
1103 /**
1104 * @tc.name: TouchGestureDetectorTest_JudgeOperationMode_01
1105 * @tc.desc: Test JudgeOperationMode
1106 * @tc.type: FUNC
1107 * @tc.require:
1108 */
1109 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_JudgeOperationMode_01, TestSize.Level1)
1110 {
1111 CALL_TEST_DEBUG;
1112 auto listener = std::make_shared<MyGestureListener>();
1113 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1114 TouchGestureDetector detector(type, listener);
1115 std::map<int32_t, Point> movePoints;
1116 movePoints[1] = Point(1.0f, 2.0f);
1117 movePoints[2] = Point(3.0f, 4.0f);
1118 movePoints[3] = Point(5.0f, 6.0f);
1119
1120 detector.downPoint_[4] = Point(1.0f, 2.0f, 5000);
1121 detector.downPoint_[5] = Point(3.0f, 4.0f, 6000);
1122 detector.downPoint_[6] = Point(5.0f, 6.0f, 7000);
1123
1124 ASSERT_NO_FATAL_FAILURE(detector.JudgeOperationMode(movePoints));
1125 }
1126
1127 /**
1128 * @tc.name: TouchGestureDetectorTest_JudgeOperationMode_02
1129 * @tc.desc: Test JudgeOperationMode
1130 * @tc.type: FUNC
1131 * @tc.require:
1132 */
1133 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_JudgeOperationMode_02, TestSize.Level1)
1134 {
1135 CALL_TEST_DEBUG;
1136 auto listener = std::make_shared<MyGestureListener>();
1137 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1138 TouchGestureDetector detector(type, listener);
1139 std::map<int32_t, Point> movePoints;
1140 movePoints[1] = Point(1.0f, 2.0f);
1141 movePoints[2] = Point(3.0f, 4.0f);
1142 movePoints[3] = Point(5.0f, 6.0f);
1143
1144 detector.downPoint_[4] = Point(1.0f, 2.0f, 5000);
1145 detector.downPoint_[5] = Point(3.0f, 4.0f, 6000);
1146 detector.downPoint_[6] = Point(5.0f, 6.0f, 7000);
1147 detector.downPoint_[7] = Point(7.0f, 8.0f, 8000);
1148
1149 ASSERT_NO_FATAL_FAILURE(detector.JudgeOperationMode(movePoints));
1150 }
1151
1152 /**
1153 * @tc.name: TouchGestureDetectorTest_JudgeOperationMode_03
1154 * @tc.desc: Test JudgeOperationMode
1155 * @tc.type: FUNC
1156 * @tc.require:
1157 */
1158 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_JudgeOperationMode_03, TestSize.Level1)
1159 {
1160 CALL_TEST_DEBUG;
1161 auto listener = std::make_shared<MyGestureListener>();
1162 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1163 TouchGestureDetector detector(type, listener);
1164 std::map<int32_t, Point> movePoints;
1165 movePoints[1] = Point(1.0f, 2.0f);
1166 movePoints[2] = Point(3.0f, 4.0f);
1167 movePoints[3] = Point(5.0f, 6.0f);
1168
1169 detector.downPoint_[1] = Point(1.0f, 2.0f, 5000);
1170 detector.downPoint_[2] = Point(3.0f, 4.0f, 6000);
1171 detector.downPoint_[3] = Point(5.0f, 6.0f, 7000);
1172 detector.downPoint_[4] = Point(7.0f, 8.0f, 8000);
1173
1174 detector.lastDistance_[4] = 1.0;
1175 detector.lastDistance_[5] = 2.0;
1176 detector.lastDistance_[6] = 3.0;
1177 ASSERT_NO_FATAL_FAILURE(detector.JudgeOperationMode(movePoints));
1178 }
1179
1180 /**
1181 * @tc.name: TouchGestureDetectorTest_JudgeOperationMode_04
1182 * @tc.desc: Test JudgeOperationMode
1183 * @tc.type: FUNC
1184 * @tc.require:
1185 */
1186 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_JudgeOperationMode_04, TestSize.Level1)
1187 {
1188 CALL_TEST_DEBUG;
1189 auto listener = std::make_shared<MyGestureListener>();
1190 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1191 TouchGestureDetector detector(type, listener);
1192 std::map<int32_t, Point> movePoints;
1193 movePoints[1] = Point(1.0f, 2.0f);
1194 movePoints[2] = Point(3.0f, 4.0f);
1195 movePoints[3] = Point(5.0f, 6.0f);
1196 movePoints[4] = Point(7.0f, 8.0f);
1197
1198 detector.downPoint_[1] = Point(1.0f, 2.0f, 5000);
1199 detector.downPoint_[2] = Point(3.0f, 4.0f, 6000);
1200 detector.downPoint_[3] = Point(5.0f, 6.0f, 7000);
1201 detector.downPoint_[4] = Point(7.0f, 8.0f, 8000);
1202
1203 detector.lastDistance_[1] = 1.0;
1204 detector.lastDistance_[2] = 2.0;
1205 detector.lastDistance_[3] = 3.0;
1206 detector.lastDistance_[4] = 4.0;
1207 ASSERT_NO_FATAL_FAILURE(detector.JudgeOperationMode(movePoints));
1208 }
1209
1210 /**
1211 * @tc.name: TouchGestureDetectorTest_AntiJitter_01
1212 * @tc.desc: Test AntiJitter
1213 * @tc.type: FUNC
1214 * @tc.require:
1215 */
1216 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AntiJitter_01, TestSize.Level1)
1217 {
1218 CALL_TEST_DEBUG;
1219 auto listener = std::make_shared<MyGestureListener>();
1220 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1221 TouchGestureDetector detector(type, listener);
1222 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1223 ASSERT_NE(pointerEvent, nullptr);
1224
1225 GestureMode mode;
1226 mode = GestureMode::ACTION_PINCH_CLOSED;
1227 detector.continuousCloseCount_ = 3;
1228 EXPECT_FALSE(detector.AntiJitter(pointerEvent, mode));
1229 detector.continuousCloseCount_ = 1;
1230 EXPECT_FALSE(detector.AntiJitter(pointerEvent, mode));
1231
1232 mode = GestureMode::ACTION_PINCH_OPENED;
1233 detector.continuousOpenCount_ = 3;
1234 EXPECT_FALSE(detector.AntiJitter(pointerEvent, mode));
1235 detector.continuousOpenCount_ = 1;
1236 EXPECT_FALSE(detector.AntiJitter(pointerEvent, mode));
1237
1238 mode = GestureMode::ACTION_UNKNOWN;
1239 EXPECT_FALSE(detector.AntiJitter(pointerEvent, mode));
1240 }
1241
1242 /**
1243 * @tc.name: TouchGestureDetectorTest_AddGestureFingers_01
1244 * @tc.desc: Test AddGestureFingers
1245 * @tc.type: FUNC
1246 * @tc.require:
1247 */
1248 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AddGestureFingers_01, TestSize.Level1)
1249 {
1250 CALL_TEST_DEBUG;
1251 auto listener = std::make_shared<MyGestureListener>();
1252 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1253 TouchGestureDetector detector(type, listener);
1254 detector.fingers_.insert(1);
1255 detector.fingers_.insert(2);
1256 detector.fingers_.insert(3);
1257 int32_t fingers = 1;
1258 ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
1259 fingers = 4;
1260 ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
1261
1262 detector.fingers_.clear();
1263 ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
1264 }
1265
1266 /**
1267 * @tc.name: TouchGestureDetectorTest_AddGestureFingers_02
1268 * @tc.desc: Test AddGestureFingers
1269 * @tc.type: FUNC
1270 * @tc.require:
1271 */
1272 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AddGestureFingers_02, TestSize.Level1)
1273 {
1274 CALL_TEST_DEBUG;
1275 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
1276 int32_t fingers = 5;
1277 ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
1278 EXPECT_TRUE(detector.gestureEnable_);
1279 }
1280
1281 /**
1282 * @tc.name: TouchGestureDetectorTest_AddGestureFingers_03
1283 * @tc.desc: Test AddGestureFingers
1284 * @tc.type: FUNC
1285 * @tc.require:
1286 */
1287 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AddGestureFingers_03, TestSize.Level1)
1288 {
1289 CALL_TEST_DEBUG;
1290 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
1291 int32_t fingers = 5;
1292 ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
1293 EXPECT_TRUE(detector.gestureEnable_);
1294 detector.gestureEnable_ = false;
1295 ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
1296 EXPECT_FALSE(detector.gestureEnable_);
1297 }
1298
1299 /**
1300 * @tc.name: TouchGestureDetectorTest_AddGestureFingers_04
1301 * @tc.desc: Test AddGestureFingers
1302 * @tc.type: FUNC
1303 * @tc.require:
1304 */
1305 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AddGestureFingers_04, TestSize.Level1)
1306 {
1307 CALL_TEST_DEBUG;
1308 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
1309 int32_t fingers1 = 3;
1310 ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers1));
1311 EXPECT_TRUE(detector.gestureEnable_);
1312 detector.gestureEnable_ = false;
1313 int32_t fingers2 = 4;
1314 ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers2));
1315 EXPECT_TRUE(detector.gestureEnable_);
1316 }
1317
1318 /**
1319 * @tc.name: TouchGestureDetectorTest_RemoveGestureFingers_01
1320 * @tc.desc: Test RemoveGestureFingers
1321 * @tc.type: FUNC
1322 * @tc.require:
1323 */
1324 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_RemoveGestureFingers_01, TestSize.Level1)
1325 {
1326 CALL_TEST_DEBUG;
1327 auto listener = std::make_shared<MyGestureListener>();
1328 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1329 TouchGestureDetector detector(type, listener);
1330 detector.fingers_.insert(1);
1331 detector.fingers_.insert(2);
1332 detector.fingers_.insert(3);
1333 int32_t fingers = 1;
1334 ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(fingers));
1335 fingers = 4;
1336 ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(fingers));
1337
1338 detector.fingers_.clear();
1339 ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(fingers));
1340 }
1341
1342 /**
1343 * @tc.name: TouchGestureDetectorTest_RemoveGestureFingers_02
1344 * @tc.desc: Test RemoveGestureFingers
1345 * @tc.type: FUNC
1346 * @tc.require:
1347 */
1348 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_RemoveGestureFingers_02, TestSize.Level1)
1349 {
1350 CALL_TEST_DEBUG;
1351 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
1352 int32_t fingers = 1;
1353 detector.AddGestureFingers(fingers);
1354 ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(fingers));
1355 EXPECT_FALSE(detector.fingers_.find(fingers) != detector.fingers_.cend());
1356 EXPECT_FALSE(detector.gestureEnable_);
1357 }
1358
1359 /**
1360 * @tc.name: TouchGestureDetectorTest_RemoveGestureFingers_03
1361 * @tc.desc: Test RemoveGestureFingers
1362 * @tc.type: FUNC
1363 * @tc.require:
1364 */
1365 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_RemoveGestureFingers_03, TestSize.Level1)
1366 {
1367 CALL_TEST_DEBUG;
1368 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
1369 int32_t finger1 = 3;
1370 detector.AddGestureFingers(finger1);
1371 int32_t finger2 = 4;
1372 ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(finger2));
1373 EXPECT_TRUE(detector.fingers_.find(finger1) != detector.fingers_.cend());
1374 EXPECT_TRUE(detector.gestureEnable_);
1375 }
1376
1377 /**
1378 * @tc.name: TouchGestureDetectorTest_RemoveGestureFingers_04
1379 * @tc.desc: Test RemoveGestureFingers
1380 * @tc.type: FUNC
1381 * @tc.require:
1382 */
1383 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_RemoveGestureFingers_04, TestSize.Level1)
1384 {
1385 CALL_TEST_DEBUG;
1386 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
1387 int32_t finger1 = 3;
1388 detector.AddGestureFingers(finger1);
1389 int32_t finger2 = 4;
1390 detector.AddGestureFingers(finger2);
1391 ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(finger2));
1392 EXPECT_TRUE(detector.fingers_.find(finger1) != detector.fingers_.cend());
1393 EXPECT_TRUE(detector.gestureEnable_);
1394 }
1395
1396 /**
1397 * @tc.name: TouchGestureDetectorTest_IsMatchGesture_01
1398 * @tc.desc: Test IsMatchGesture
1399 * @tc.type: FUNC
1400 * @tc.require:
1401 */
1402 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_IsMatchGesture_01, TestSize.Level1)
1403 {
1404 CALL_TEST_DEBUG;
1405 auto listener = std::make_shared<MyGestureListener>();
1406 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1407 TouchGestureDetector detector(type, listener);
1408 detector.fingers_.insert(1);
1409 detector.fingers_.insert(2);
1410 detector.fingers_.insert(3);
1411
1412 int32_t count = 1;
1413 GestureMode mode;
1414 mode = GestureMode::ACTION_SWIPE_DOWN;
1415 EXPECT_TRUE(detector.IsMatchGesture(mode, count));
1416 mode = GestureMode::ACTION_SWIPE_UP;
1417 EXPECT_TRUE(detector.IsMatchGesture(mode, count));
1418 mode = GestureMode::ACTION_SWIPE_LEFT;
1419 EXPECT_TRUE(detector.IsMatchGesture(mode, count));
1420 mode = GestureMode::ACTION_SWIPE_RIGHT;
1421 EXPECT_TRUE(detector.IsMatchGesture(mode, count));
1422 mode = GestureMode::ACTION_PINCH_OPENED;
1423 EXPECT_FALSE(detector.IsMatchGesture(mode, count));
1424 mode = GestureMode::ACTION_PINCH_CLOSED;
1425 EXPECT_FALSE(detector.IsMatchGesture(mode, count));
1426 mode = GestureMode::ACTION_UNKNOWN;
1427 EXPECT_FALSE(detector.IsMatchGesture(mode, count));
1428 }
1429
1430 /**
1431 * @tc.name: TouchGestureDetectorTest_IsMatchGesture_02
1432 * @tc.desc: Test IsMatchGesture
1433 * @tc.type: FUNC
1434 * @tc.require:
1435 */
1436 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_IsMatchGesture_02, TestSize.Level1)
1437 {
1438 CALL_TEST_DEBUG;
1439 auto listener = std::make_shared<MyGestureListener>();
1440 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1441 TouchGestureDetector detector(type, listener);
1442 detector.fingers_.insert(1);
1443 detector.fingers_.insert(2);
1444 detector.fingers_.insert(3);
1445
1446 int32_t count = 4;
1447 GestureMode mode;
1448 mode = GestureMode::ACTION_UNKNOWN;
1449 EXPECT_FALSE(detector.IsMatchGesture(mode, count));
1450 }
1451
1452 /**
1453 * @tc.name: TouchGestureDetectorTest_NotifyGestureEvent_01
1454 * @tc.desc: Test NotifyGestureEvent
1455 * @tc.type: FUNC
1456 * @tc.require:
1457 */
1458 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_NotifyGestureEvent_01, TestSize.Level1)
1459 {
1460 CALL_TEST_DEBUG;
1461 auto listener = std::make_shared<MyGestureListener>();
1462 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1463 TouchGestureDetector detector(type, listener);
1464 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1465 ASSERT_NE(pointerEvent, nullptr);
1466
1467 GestureMode mode;
1468 mode = GestureMode::ACTION_UNKNOWN;
1469 EXPECT_FALSE(detector.NotifyGestureEvent(pointerEvent, mode));
1470
1471 mode = GestureMode::ACTION_GESTURE_END;
1472 for (auto i = 0; i < 5; i++) {
1473 PointerEvent::PointerItem pointerItem;
1474 detector.fingers_.insert(i + 1);
1475 pointerEvent->pointers_.push_back(pointerItem);
1476 }
1477 EXPECT_FALSE(detector.NotifyGestureEvent(pointerEvent, mode));
1478 }
1479
1480 /**
1481 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_003
1482 * @tc.desc: Test OnTouchEvent
1483 * @tc.type: FUNC
1484 * @tc.require:
1485 */
1486 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_003, TestSize.Level1)
1487 {
1488 CALL_TEST_DEBUG;
1489 auto listener = std::make_shared<MyGestureListener>();
1490 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1491 TouchGestureDetector detector(type, listener);
1492 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1493 ASSERT_NE(pointerEvent, nullptr);
1494 std::shared_ptr<InputEvent> inputEvent = InputEvent::Create();
1495 ASSERT_NE(inputEvent, nullptr);
1496 inputEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
1497 detector.gestureEnable_ = true;
1498 inputEvent->bitwise_ = 0x00000000;
1499 pointerEvent->SetPointerId(5);
1500 detector.gestureDisplayId_ = INT32_MAX;
1501 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1502 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
1503 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
1504 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
1505 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1506 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
1507 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE);
1508 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
1509 }
1510
1511 /**
1512 * @tc.name: TouchGestureDetectorTest_HandleDownEvent_003
1513 * @tc.desc: Test HandleDownEvent
1514 * @tc.type: FUNC
1515 * @tc.require:
1516 */
1517 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleDownEvent_003, TestSize.Level1)
1518 {
1519 CALL_TEST_DEBUG;
1520 auto listener = std::make_shared<MyGestureListener>();
1521 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1522 TouchGestureDetector detector(type, listener);
1523 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1524 ASSERT_NE(pointerEvent, nullptr);
1525 detector.isRecognized_ = false;
1526 PointerEvent::PointerItem item1;
1527 item1.SetPointerId(1);
1528 PointerEvent::PointerItem item2;
1529 item2.SetPointerId(2);
1530 pointerEvent->pointers_.push_back(item1);
1531 pointerEvent->pointers_.push_back(item2);
1532 pointerEvent->SetPointerId(2);
1533 ASSERT_NO_FATAL_FAILURE(detector.HandleDownEvent(pointerEvent));
1534 detector.gestureType_ = TOUCH_GESTURE_TYPE_SWIPE;
1535 ASSERT_NO_FATAL_FAILURE(detector.HandleDownEvent(pointerEvent));
1536 detector.gestureType_ = TOUCH_GESTURE_TYPE_PINCH;
1537 ASSERT_NO_FATAL_FAILURE(detector.HandleDownEvent(pointerEvent));
1538 detector.gestureType_ = TOUCH_GESTURE_TYPE_NONE;
1539 ASSERT_NO_FATAL_FAILURE(detector.HandleDownEvent(pointerEvent));
1540 }
1541
1542 /**
1543 * @tc.name: TouchGestureDetectorTest_HandleMoveEvent_004
1544 * @tc.desc: Test HandleMoveEvent
1545 * @tc.type: FUNC
1546 * @tc.require:
1547 */
1548 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleMoveEvent_004, TestSize.Level1)
1549 {
1550 CALL_TEST_DEBUG;
1551 auto listener = std::make_shared<MyGestureListener>();
1552 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1553 TouchGestureDetector detector(type, listener);
1554 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1555 ASSERT_NE(pointerEvent, nullptr);
1556 detector.isRecognized_ = true;
1557 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
1558 detector.isRecognized_ = false;
1559 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
1560 }
1561
1562 /**
1563 * @tc.name: TouchGestureDetectorTest_HandlePinchMoveEvent_003
1564 * @tc.desc: Test HandlePinchMoveEvent
1565 * @tc.type: FUNC
1566 * @tc.require:
1567 */
1568 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandlePinchMoveEvent_003, TestSize.Level1)
1569 {
1570 CALL_TEST_DEBUG;
1571 auto listener = std::make_shared<MyGestureListener>();
1572 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1573 TouchGestureDetector detector(type, listener);
1574 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1575 ASSERT_NE(pointerEvent, nullptr);
1576 detector.downPoint_[1] = Point(1.0f, 2.0f);
1577 detector.downPoint_[2] = Point(3.0f, 4.0f);
1578 detector.downPoint_[3] = Point(5.0f, 6.0f);
1579 detector.downPoint_[4] = Point(7.0f, 8.0f);
1580 detector.lastDistance_[1] = 1.0;
1581 detector.lastDistance_[2] = 2.0;
1582 detector.lastDistance_[3] = 3.0;
1583 PointerEvent::PointerItem item1;
1584 item1.SetPointerId(1);
1585 PointerEvent::PointerItem item2;
1586 item2.SetPointerId(2);
1587 pointerEvent->pointers_.push_back(item1);
1588 pointerEvent->pointers_.push_back(item2);
1589 pointerEvent->SetPointerId(2);
1590 ASSERT_NO_FATAL_FAILURE(detector.HandlePinchMoveEvent(pointerEvent));
1591 }
1592
1593 /**
1594 * @tc.name: TouchGestureDetectorTest_IsPhysicalPointer_001
1595 * @tc.desc: Test IsPhysicalPointer
1596 * @tc.type: FUNC
1597 * @tc.require:
1598 */
1599 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_IsPhysicalPointer_001, TestSize.Level1)
1600 {
1601 CALL_TEST_DEBUG;
1602 auto listener = std::make_shared<MyGestureListener>();
1603 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1604 TouchGestureDetector detector(type, listener);
1605 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1606 ASSERT_NE(pointerEvent, nullptr);
1607 std::shared_ptr<InputEvent> inputEvent = InputEvent::Create();
1608 ASSERT_NE(inputEvent, nullptr);
1609 inputEvent->bitwise_ = 0x00000000;
1610 pointerEvent->SetPointerId(5);
1611 bool ret = detector.IsPhysicalPointer(pointerEvent);
1612 EXPECT_TRUE(ret);
1613 }
1614
1615 /**
1616 * @tc.name: TouchGestureDetectorTest_HandleUpEvent_003
1617 * @tc.desc: Test HandleUpEvent
1618 * @tc.type: FUNC
1619 * @tc.require:
1620 */
1621 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleUpEvent_003, TestSize.Level1)
1622 {
1623 CALL_TEST_DEBUG;
1624 auto listener = std::make_shared<MyGestureListener>();
1625 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1626 TouchGestureDetector detector(type, listener);
1627 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1628 ASSERT_NE(pointerEvent, nullptr);
1629 pointerEvent->pointerId_ = 1;
1630 detector.downPoint_[1] = Point(1.0f, 2.0f);
1631 detector.downPoint_[2] = Point(3.0f, 4.0f);
1632 detector.isRecognized_ = true;
1633 detector.lastTouchEvent_ = pointerEvent;
1634 ASSERT_NO_FATAL_FAILURE(detector.HandleUpEvent(pointerEvent));
1635 }
1636
1637 /**
1638 * @tc.name: TouchGestureDetectorTest_OnTouchEvent_04
1639 * @tc.desc: Test OnTouchEvent
1640 * @tc.type: FUNC
1641 * @tc.require:nhj
1642 */
1643 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_04, TestSize.Level1)
1644 {
1645 CALL_TEST_DEBUG;
1646 auto listener = std::make_shared<MyGestureListener>();
1647 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1648 TouchGestureDetector detector(type, listener);
1649 std::shared_ptr<PointerEvent> nullEvent = nullptr;
1650 EXPECT_FALSE(detector.OnTouchEvent(nullEvent));
1651
1652 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1653 ASSERT_NE(pointerEvent, nullptr);
1654
1655 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
1656 detector.gestureEnable_ = true;
1657 detector.gestureDisplayId_ = INT32_MAX;
1658 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_CANCEL;
1659 EXPECT_TRUE(detector.WhetherDiscardTouchEvent(pointerEvent));
1660
1661 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_UP;
1662 EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
1663 }
1664
1665 /**
1666 * @tc.name: TouchGestureDetectorTest_HandleDownEvent_04
1667 * @tc.desc: Test HandleDownEvent
1668 * @tc.type: FUNC
1669 * @tc.require:
1670 */
1671 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleDownEvent_04, TestSize.Level1)
1672 {
1673 CALL_TEST_DEBUG;
1674 auto listener = std::make_shared<MyGestureListener>();
1675 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1676 TouchGestureDetector detector(type, listener);
1677 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1678 ASSERT_NE(pointerEvent, nullptr);
1679
1680 pointerEvent->pointerId_ = 1;
1681 detector.isRecognized_ = true;
1682 detector.haveGestureWinEmerged_ = true;
1683 ASSERT_NO_FATAL_FAILURE(detector.HandleDownEvent(pointerEvent));
1684 detector.lastTouchEvent_ = pointerEvent;
1685 ASSERT_NO_FATAL_FAILURE(detector.HandleDownEvent(pointerEvent));
1686 }
1687
1688 /**
1689 * @tc.name: TouchGestureDetectorTest_HandleMoveEvent_05
1690 * @tc.desc: Test HandleMoveEvent
1691 * @tc.type: FUNC
1692 * @tc.require:
1693 */
1694 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleMoveEvent_05, TestSize.Level1)
1695 {
1696 CALL_TEST_DEBUG;
1697 auto listener = std::make_shared<MyGestureListener>();
1698 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1699 TouchGestureDetector detector(type, listener);
1700 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1701 ASSERT_NE(pointerEvent, nullptr);
1702
1703 detector.isRecognized_ = true;
1704 detector.gestureTimer_= 2;
1705 detector.lastTouchEvent_ = pointerEvent;
1706 detector.listener_ = nullptr;
1707 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
1708 detector.isRecognized_ = true;
1709 detector.gestureTimer_= 2;
1710 detector.listener_ = listener;
1711 ASSERT_NO_FATAL_FAILURE(detector.HandleMoveEvent(pointerEvent));
1712 }
1713
1714 /**
1715 * @tc.name: TouchGestureDetectorTest_HandleSwipeMoveEvent_03
1716 * @tc.desc: Test HandleSwipeMoveEvent
1717 * @tc.type: FUNC
1718 * @tc.require:
1719 */
1720 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleSwipeMoveEvent_03, TestSize.Level1)
1721 {
1722 CALL_TEST_DEBUG;
1723 auto listener = std::make_shared<MyGestureListener>();
1724 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1725 TouchGestureDetector detector(type, listener);
1726 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1727 ASSERT_NE(pointerEvent, nullptr);
1728
1729 detector.downPoint_[1] = Point(1.0f, 2.0f);
1730 detector.downPoint_[2] = Point(3.0f, 4.0f, 150000);
1731 detector.downPoint_[3] = Point(5.0f, 6.0f, 200000);
1732 detector.isFingerReady_ = true;
1733
1734 auto state = detector.ClacFingerMoveDirection(pointerEvent);
1735 state = TouchGestureDetector::SlideState::DIRECTION_LEFT;
1736 ASSERT_NO_FATAL_FAILURE(detector.HandleSwipeMoveEvent(pointerEvent));
1737
1738 state = TouchGestureDetector::SlideState::DIRECTION_UNKNOW;
1739 GestureMode mode = detector.ChangeToGestureMode(state);
1740 EXPECT_EQ(mode, GestureMode::ACTION_UNKNOWN);
1741 detector.isRecognized_ = true;
1742 detector.gestureTimer_= -1;
1743 detector.lastTouchEvent_ = pointerEvent;
1744 EXPECT_FALSE(detector.NotifyGestureEvent(pointerEvent, mode));
1745 ASSERT_NO_FATAL_FAILURE(detector.HandleSwipeMoveEvent(pointerEvent));
1746 }
1747
1748 /**
1749 * @tc.name: TouchGestureDetectorTest_HandleSwipeMoveEvent_04
1750 * @tc.desc: Test HandleSwipeMoveEvent
1751 * @tc.type: FUNC
1752 * @tc.require:
1753 */
1754 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleSwipeMoveEvent_04, TestSize.Level1)
1755 {
1756 CALL_TEST_DEBUG;
1757 auto listener = std::make_shared<MyGestureListener>();
1758 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1759 TouchGestureDetector detector(type, listener);
1760 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1761 ASSERT_NE(pointerEvent, nullptr);
1762
1763 detector.downPoint_[1] = Point(1.0f, 2.0f);
1764 detector.downPoint_[2] = Point(3.0f, 4.0f, 150000);
1765 detector.downPoint_[3] = Point(5.0f, 6.0f, 200000);
1766 detector.isFingerReady_ = true;
1767
1768 auto state = detector.ClacFingerMoveDirection(pointerEvent);
1769 state = TouchGestureDetector::SlideState::DIRECTION_LEFT;
1770 detector.gestureTimer_= 2;
1771 ASSERT_NO_FATAL_FAILURE(detector.HandleSwipeMoveEvent(pointerEvent));
1772
1773 state = TouchGestureDetector::SlideState::DIRECTION_RIGHT;
1774 detector.gestureTimer_= -2;
1775 GestureMode mode = detector.ChangeToGestureMode(state);
1776 EXPECT_NE(mode, GestureMode::ACTION_UNKNOWN);
1777 ASSERT_NO_FATAL_FAILURE(detector.HandleSwipeMoveEvent(pointerEvent));
1778 }
1779
1780 /**
1781 * @tc.name: TouchGestureDetectorTest_HandlePinchMoveEvent_004
1782 * @tc.desc: Test HandlePinchMoveEvent
1783 * @tc.type: FUNC
1784 * @tc.require:
1785 */
1786 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandlePinchMoveEvent_004, TestSize.Level1)
1787 {
1788 CALL_TEST_DEBUG;
1789 auto listener = std::make_shared<MyGestureListener>();
1790 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1791 TouchGestureDetector detector(type, listener);
1792 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1793 std::unordered_set<TouchGestureDetector::SlideState> directions;
1794 double angle;
1795 angle = 20;
1796 auto direction1 = detector.GetSlidingDirection(angle);
1797 directions.insert(direction1);
1798 angle = 50;
1799 auto direction2 = detector.GetSlidingDirection(angle);
1800 directions.insert(direction2);
1801 EXPECT_EQ(directions.size(), 2);
1802 ASSERT_NE(pointerEvent, nullptr);
1803 detector.downPoint_[1] = Point(1.0f, 2.0f);
1804 detector.downPoint_[2] = Point(3.0f, 4.0f);
1805 detector.downPoint_[3] = Point(5.0f, 6.0f);
1806 detector.downPoint_[4] = Point(7.0f, 8.0f);
1807 detector.lastDistance_[1] = 1.0;
1808 detector.lastDistance_[2] = 2.0;
1809 detector.lastDistance_[3] = 3.0;
1810 ASSERT_NO_FATAL_FAILURE(detector.HandlePinchMoveEvent(pointerEvent));
1811 }
1812
1813 /**
1814 * @tc.name: TouchGestureDetectorTest_HandleUpEvent_004
1815 * @tc.desc: Test HandleUpEvent
1816 * @tc.type: FUNC
1817 * @tc.require:
1818 */
1819 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleUpEvent_004, TestSize.Level1)
1820 {
1821 CALL_TEST_DEBUG;
1822 auto listener = std::make_shared<MyGestureListener>();
1823 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1824 TouchGestureDetector detector(type, listener);
1825 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1826 ASSERT_NE(pointerEvent, nullptr);
1827 pointerEvent->pointerId_ = 1;
1828 detector.downPoint_[1] = Point(1.0f, 2.0f);
1829 detector.downPoint_[2] = Point(3.0f, 4.0f);
1830 detector.downPoint_[3] = Point(5.0f, 6.0f);
1831 detector.downPoint_[4] = Point(7.0f, 8.0f);
1832 detector.lastDistance_[1] = 1.0;
1833 detector.lastDistance_[2] = 2.0;
1834 detector.lastDistance_[3] = 3.0;
1835 EXPECT_FALSE(detector.lastDistance_.empty());
1836 detector.isRecognized_ = true;
1837 detector.lastTouchEvent_ = pointerEvent;
1838 PointerEvent::PointerItem item1;
1839 item1.SetPointerId(1);
1840 PointerEvent::PointerItem item2;
1841 item2.SetPointerId(2);
1842 pointerEvent->pointers_.push_back(item1);
1843 pointerEvent->pointers_.push_back(item2);
1844 pointerEvent->SetPointerId(2);
1845 ASSERT_NO_FATAL_FAILURE(detector.HandleUpEvent(pointerEvent));
1846 }
1847
1848 /**
1849 * @tc.name: TouchGestureDetectorTest_HandleUpEvent_005
1850 * @tc.desc: Test HandleUpEvent
1851 * @tc.type: FUNC
1852 * @tc.require:
1853 */
1854 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleUpEvent_005, TestSize.Level1)
1855 {
1856 CALL_TEST_DEBUG;
1857 auto listener = std::make_shared<MyGestureListener>();
1858 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1859 TouchGestureDetector detector(type, listener);
1860 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1861 ASSERT_NE(pointerEvent, nullptr);
1862 pointerEvent->pointerId_ = 1;
1863 detector.gestureTimer_= -1;
1864 detector.isRecognized_ = true;
1865 detector.lastTouchEvent_ = nullptr;
1866 detector.haveGestureWinEmerged_ = false;
1867 PointerEvent::PointerItem item1;
1868 item1.SetPointerId(1);
1869 PointerEvent::PointerItem item2;
1870 item2.SetPointerId(2);
1871 pointerEvent->pointers_.push_back(item1);
1872 pointerEvent->pointers_.push_back(item2);
1873 pointerEvent->SetPointerId(2);
1874 ASSERT_NO_FATAL_FAILURE(detector.HandleUpEvent(pointerEvent));
1875
1876 detector.isRecognized_ = true;
1877 detector.haveGestureWinEmerged_ = false;
1878 detector.lastTouchEvent_ = pointerEvent;
1879 ASSERT_NO_FATAL_FAILURE(detector.HandleUpEvent(pointerEvent));
1880 }
1881
1882 /**
1883 * @tc.name: TouchGestureDetectorTest_HandleUpEvent_006
1884 * @tc.desc: Test HandleUpEvent
1885 * @tc.type: FUNC
1886 * @tc.require:
1887 */
1888 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleUpEvent_006, TestSize.Level1)
1889 {
1890 CALL_TEST_DEBUG;
1891 auto listener = std::make_shared<MyGestureListener>();
1892 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1893 TouchGestureDetector detector(type, listener);
1894 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1895 ASSERT_NE(pointerEvent, nullptr);
1896 detector.gestureTimer_= -1;
1897 detector.isRecognized_ = false;
1898 detector.lastTouchEvent_ = pointerEvent;
1899 detector.haveGestureWinEmerged_ = false;
1900 PointerEvent::PointerItem item1;
1901 item1.SetPointerId(1);
1902 pointerEvent->pointers_.push_back(item1);
1903 pointerEvent->SetPointerId(2);
1904 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
1905 ASSERT_NO_FATAL_FAILURE(detector.HandleUpEvent(pointerEvent));
1906 }
1907
1908 /**
1909 * @tc.name: TouchGestureDetectorTest_WhetherDiscardTouchEvent_02
1910 * @tc.desc: Test WhetherDiscardTouchEvent
1911 * @tc.type: FUNC
1912 * @tc.require:
1913 */
1914 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_WhetherDiscardTouchEvent_02, TestSize.Level1)
1915 {
1916 CALL_TEST_DEBUG;
1917 auto listener = std::make_shared<MyGestureListener>();
1918 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1919 TouchGestureDetector detector(type, listener);
1920 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1921 ASSERT_NE(pointerEvent, nullptr);
1922
1923 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_MOUSE;
1924 detector.gestureEnable_ = true;
1925 pointerEvent->bitwise_ = InputEvent::EVENT_FLAG_SIMULATE;
1926 pointerEvent->SetPointerId(0);
1927 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
1928 detector.gestureDisplayId_ = INT32_MAX;
1929 pointerEvent->targetDisplayId_ = INT32_MAX;
1930 EXPECT_TRUE(detector.WhetherDiscardTouchEvent(pointerEvent));
1931 }
1932
1933 /**
1934 * @tc.name: TouchGestureDetectorTest_ClacFingerMoveDirection_03
1935 * @tc.desc: Test ClacFingerMoveDirection
1936 * @tc.type: FUNC
1937 * @tc.require:
1938 */
1939 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_ClacFingerMoveDirection_03, TestSize.Level1)
1940 {
1941 CALL_TEST_DEBUG;
1942 auto listener = std::make_shared<MyGestureListener>();
1943 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1944 TouchGestureDetector detector(type, listener);
1945 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1946 ASSERT_NE(pointerEvent, nullptr);
1947 size_t recognizedCount { 0 };
1948 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE;
1949 std::unordered_set<TouchGestureDetector::SlideState> directions;
1950 double angle;
1951 angle = 20;
1952 auto direction1 = detector.GetSlidingDirection(angle);
1953 directions.insert(direction1);
1954 angle = 50;
1955 auto direction2 = detector.GetSlidingDirection(angle);
1956 directions.insert(direction2);
1957 std::map<int32_t, Point> points;
1958 points[1] = Point(1.0f, 2.0f);
1959 points[2] = Point(3.0f, 4.0f);
1960 points[3] = Point(5.0f, 6.0f);
1961 detector.downPoint_[1] = Point(1.0f, 2.0f);
1962 detector.downPoint_[2] = Point(3.0f, 4.0f);
1963 detector.downPoint_[3] = Point(5.0f, 6.0f);
1964 int32_t count = static_cast<int32_t>(points.size());
1965 EXPECT_TRUE(count > recognizedCount);
1966 ASSERT_NO_FATAL_FAILURE(detector.ClacFingerMoveDirection(pointerEvent));
1967 }
1968
1969 /**
1970 * @tc.name: TouchGestureDetectorTest_SortPoints_01
1971 * @tc.desc: Test SortPoints
1972 * @tc.type: FUNC
1973 * @tc.require:
1974 */
1975 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_SortPoints_01, TestSize.Level1)
1976 {
1977 CALL_TEST_DEBUG;
1978 auto listener = std::make_shared<MyGestureListener>();
1979 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
1980 TouchGestureDetector detector(type, listener);
1981 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1982 ASSERT_NE(pointerEvent, nullptr);
1983
1984 std::map<int32_t, Point> points;
1985 points[1] = Point(1.0f, 2.0f);
1986 points[2] = Point(3.0f, 4.0f);
1987 points[3] = Point(5.0f, 6.0f);
1988 int32_t count = static_cast<int32_t>(points.size());
1989 EXPECT_TRUE(count > 0);
1990 EXPECT_FALSE(points.empty());
1991 auto ret = detector.SortPoints(points);
1992 EXPECT_FALSE(ret.empty());
1993 }
1994
1995 /**
1996 * @tc.name: TouchGestureDetectorTest_SortPoints_02
1997 * @tc.desc: Test SortPoints
1998 * @tc.type: FUNC
1999 * @tc.require:
2000 */
2001 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_SortPoints_02, TestSize.Level1)
2002 {
2003 CALL_TEST_DEBUG;
2004 auto listener = std::make_shared<MyGestureListener>();
2005 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
2006 TouchGestureDetector detector(type, listener);
2007 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2008 ASSERT_NE(pointerEvent, nullptr);
2009 std::map<int32_t, Point> points;
2010 int32_t count = static_cast<int32_t>(points.size());
2011 EXPECT_EQ(count, 0);
2012 EXPECT_TRUE(points.empty());
2013 auto ret = detector.SortPoints(points);
2014 EXPECT_TRUE(ret.empty());
2015 }
2016
2017 /**
2018 * @tc.name: TouchGestureDetectorTest_CalcClusterCenter_03
2019 * @tc.desc: Test CalcClusterCenter
2020 * @tc.type: FUNC
2021 * @tc.require:
2022 */
2023 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcClusterCenter_03, TestSize.Level1)
2024 {
2025 CALL_TEST_DEBUG;
2026 auto listener = std::make_shared<MyGestureListener>();
2027 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
2028 TouchGestureDetector detector(type, listener);
2029 std::map<int32_t, Point> points;
2030 EXPECT_TRUE(points.empty());
2031 Point result = detector.CalcClusterCenter(points);
2032 EXPECT_EQ(result.x, 0.0f);
2033 EXPECT_EQ(result.y, 0.0f);
2034 }
2035
2036 /**
2037 * @tc.name: TouchGestureDetectorTest_CalcClusterCenter_04
2038 * @tc.desc: Test CalcClusterCenter
2039 * @tc.type: FUNC
2040 * @tc.require:
2041 */
2042 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcClusterCenter_04, TestSize.Level1)
2043 {
2044 CALL_TEST_DEBUG;
2045 std::map<int32_t, Point> points{
2046 {0, Point(2.0f, 3.0f)}, {1, Point(4.0f, 5.0f)}, {2, Point(6.0f, 7.0f)}
2047 };
2048 auto listener = std::make_shared<MyGestureListener>();
2049 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
2050 TouchGestureDetector detector(type, listener);
2051 Point result = detector.CalcClusterCenter(points);
2052 // 平均值：(2+4+6)/3=4, (3+5+7)/3=5
2053 EXPECT_EQ(result.x, 4.0f);
2054 EXPECT_EQ(result.y, 5.0f);
2055 }
2056
2057 /**
2058 * @tc.name: TouchGestureDetectorTest_CalcGravityCenter_03
2059 * @tc.desc: Test CalcGravityCenter
2060 * @tc.type: FUNC
2061 * @tc.require:
2062 */
2063 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcGravityCenter_03, TestSize.Level1)
2064 {
2065 CALL_TEST_DEBUG;
2066 auto listener = std::make_shared<MyGestureListener>();
2067 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
2068 TouchGestureDetector detector(type, listener);
2069 std::map<int32_t, Point> points;
2070 int32_t count = static_cast<int32_t>(points.size());
2071 EXPECT_EQ(count, 0);
2072 EXPECT_TRUE(points.empty());
2073 ASSERT_NO_FATAL_FAILURE(detector.CalcGravityCenter(points));
2074 }
2075
2076 /**
2077 * @tc.name: TouchGestureDetectorTest_CalcMultiFingerMovement_03
2078 * @tc.desc: Test CalcMultiFingerMovement
2079 * @tc.type: FUNC
2080 * @tc.require:
2081 */
2082 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcMultiFingerMovement_03, TestSize.Level1)
2083 {
2084 CALL_TEST_DEBUG;
2085 auto listener = std::make_shared<MyGestureListener>();
2086 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
2087 TouchGestureDetector detector(type, listener);
2088 std::map<int32_t, Point> points;
2089 points[1] = Point(1.0f, 2.0f);
2090 points[2] = Point(3.0f, 4.0f);
2091 points[3] = Point(5.0f, 6.0f);
2092 detector.movePoint_ = {}; // 设置空的 movePoint_
2093 int32_t result = detector.CalcMultiFingerMovement(points);
2094 EXPECT_EQ(result, 0);
2095 }
2096
2097 /**
2098 * @tc.name: TouchGestureDetectorTest_CalcMultiFingerMovement_04
2099 * @tc.desc: Test CalcMultiFingerMovement
2100 * @tc.type: FUNC
2101 * @tc.require:
2102 */
2103 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcMultiFingerMovement_04, TestSize.Level1)
2104 {
2105 CALL_TEST_DEBUG;
2106 auto listener = std::make_shared<MyGestureListener>();
2107 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
2108 TouchGestureDetector detector(type, listener);
2109 std::map<int32_t, Point> points;
2110 points[1] = Point(1.0f, 2.0f);
2111 detector.movePoint_[1] = Point(1.0f, 2.0f);
2112 detector.movePoint_[2] = Point(3.0f, 4.0f);
2113 int32_t result = detector.CalcMultiFingerMovement(points);
2114 EXPECT_EQ(result, 0);
2115 }
2116
2117 /**
2118 * @tc.name: TouchGestureDetectorTest_CalcMultiFingerMovement_05
2119 * @tc.desc: Test CalcMultiFingerMovement
2120 * @tc.type: FUNC
2121 * @tc.require:
2122 */
2123 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CalcMultiFingerMovement_05, TestSize.Level1)
2124 {
2125 CALL_TEST_DEBUG;
2126 auto listener = std::make_shared<MyGestureListener>();
2127 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
2128 TouchGestureDetector detector(type, listener);
2129 std::map<int32_t, Point> points;
2130 points[1] = Point(MAXIMUM_SINGLE_SLIDE_DISTANCE + 0.0f, 0.0f);
2131 points[2] = Point(1.0f, 2.0f + MAXIMUM_SINGLE_SLIDE_DISTANCE);
2132 detector.movePoint_[1] = Point(0.0f, 0.0f);
2133 detector.movePoint_[2] = Point(1.0f, 2.0f);
2134 int32_t result = detector.CalcMultiFingerMovement(points);
2135 EXPECT_EQ(result, 2);
2136 }
2137
2138 /**
2139 * @tc.name: TouchGestureDetectorTest_AntiJitter_02
2140 * @tc.desc: Test AntiJitter
2141 * @tc.type: FUNC
2142 * @tc.require:
2143 */
2144 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AntiJitter_02, TestSize.Level1)
2145 {
2146 CALL_TEST_DEBUG;
2147 auto listener = std::make_shared<MyGestureListener>();
2148 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
2149 TouchGestureDetector detector(type, listener);
2150 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2151 ASSERT_NE(pointerEvent, nullptr);
2152
2153 GestureMode mode;
2154 mode = GestureMode::ACTION_PINCH_CLOSED;
2155 detector.continuousCloseCount_ = 0;
2156 EXPECT_FALSE(detector.AntiJitter(pointerEvent, mode));
2157 mode = GestureMode::ACTION_PINCH_OPENED;
2158 detector.continuousOpenCount_ = 0;
2159 EXPECT_FALSE(detector.AntiJitter(pointerEvent, mode));
2160
2161 mode = GestureMode::ACTION_GESTURE_END;
2162 EXPECT_FALSE(detector.AntiJitter(pointerEvent, mode));
2163 }
2164
2165 /**
2166 * @tc.name: TouchGestureDetectorTest_HandleGestureWindowEmerged_001
2167 * @tc.desc: Test HandleUpEvent
2168 * @tc.type: FUNC
2169 * @tc.require:
2170 */
2171 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_HandleGestureWindowEmerged_001, TestSize.Level1)
2172 {
2173 CALL_TEST_DEBUG;
2174 auto listener = std::make_shared<MyGestureListener>();
2175 TouchGestureType type = TOUCH_GESTURE_TYPE_PINCH;
2176 TouchGestureDetector detector(type, listener);
2177 std::shared_ptr<PointerEvent> lastTouchEvent = PointerEvent::Create();
2178 ASSERT_NE(lastTouchEvent, nullptr);
2179 int32_t windowId = 1;
2180 detector.isRecognized_ = true;
2181 detector.lastTouchEvent_ = lastTouchEvent;
2182 detector.haveGestureWinEmerged_ = false;
2183 ASSERT_NO_FATAL_FAILURE(detector.HandleGestureWindowEmerged(windowId, lastTouchEvent));
2184 }
2185
2186 /**
2187 * @tc.name: TouchGestureDetectorTest_CheckGestureTrend_001
2188 * @tc.desc: Test CheckGestureTrend
2189 * @tc.type: FUNC
2190 * @tc.require:
2191 */
2192 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CheckGestureTrend_001, TestSize.Level1)
2193 {
2194 CALL_TEST_DEBUG;
2195 auto listener = std::make_shared<MyGestureListener>();
2196 TouchGestureType type = TOUCH_GESTURE_TYPE_PINCH;
2197 TouchGestureDetector detector(type, listener);
2198 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2199 ASSERT_NE(pointerEvent, nullptr);
2200
2201 detector.downPoint_[1] = Point(1.0f, 2.0f);
2202 detector.downPoint_[2] = Point(3.0f, 4.0f);
2203 detector.downPoint_[3] = Point(5.0f, 6.0f);
2204 PointerEvent::PointerItem item1;
2205 item1.SetPointerId(1);
2206 PointerEvent::PointerItem item2;
2207 item2.SetPointerId(2);
2208 pointerEvent->pointers_.push_back(item1);
2209 pointerEvent->pointers_.push_back(item2);
2210 pointerEvent->SetPointerId(2);
2211 ASSERT_NO_FATAL_FAILURE(detector.CheckGestureTrend(pointerEvent));
2212 }
2213
2214 /**
2215 * @tc.name: TouchGestureDetectorTest_GetAngle_01
2216 * @tc.desc: Test TouchGestureDetector::GetAngle
2217 * @tc.type: FUNC
2218 * @tc.require:
2219 */
2220 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetAngle_01, TestSize.Level1)
2221 {
2222 CALL_TEST_DEBUG;
2223 float startX = 0.0f;
2224 float startY = 0.0f;
2225 float endX = 0.0f;
2226 float endY = 1.0f;
2227 constexpr double expectedAngle = 90.0;
2228 constexpr double precision = 0.001;
2229
2230 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
2231 double actualAngle = detector.GetAngle(startX, startY, endX, endY);
2232 EXPECT_NEAR(expectedAngle, actualAngle, precision);
2233 }
2234
2235 /**
2236 * @tc.name: TouchGestureDetectorTest_GetAngle_02
2237 * @tc.desc: Test TouchGestureDetector::GetAngle
2238 * @tc.type: FUNC
2239 * @tc.require:
2240 */
2241 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetAngle_02, TestSize.Level1)
2242 {
2243 CALL_TEST_DEBUG;
2244 float startX = 0.0f;
2245 float startY = 0.0f;
2246 float endX = 1.0f;
2247 float endY = 1.0f;
2248 constexpr double expectedAngle = 45.0;
2249 constexpr double precision = 0.001;
2250
2251 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
2252 double actualAngle = detector.GetAngle(startX, startY, endX, endY);
2253 EXPECT_NEAR(expectedAngle, actualAngle, precision);
2254 }
2255
2256 /**
2257 * @tc.name: TouchGestureDetectorTest_GetAngle_03
2258 * @tc.desc: Test TouchGestureDetector::GetAngle
2259 * @tc.type: FUNC
2260 * @tc.require:
2261 */
2262 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetAngle_03, TestSize.Level1)
2263 {
2264 CALL_TEST_DEBUG;
2265 float startX = 0.0f;
2266 float startY = 0.0f;
2267 float endX = -1.0f;
2268 float endY = 1.0f;
2269 constexpr double expectedAngle = 135.0;
2270 constexpr double precision = 0.001;
2271
2272 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
2273 double actualAngle = detector.GetAngle(startX, startY, endX, endY);
2274 EXPECT_NEAR(expectedAngle, actualAngle, precision);
2275 }
2276
2277 /**
2278 * @tc.name: TouchGestureDetectorTest_GetAngle_04
2279 * @tc.desc: Test TouchGestureDetector::GetAngle
2280 * @tc.type: FUNC
2281 * @tc.require:
2282 */
2283 HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetAngle_04, TestSize.Level1)
2284 {
2285 CALL_TEST_DEBUG;
2286 float startX = 0.0f;
2287 float startY = 0.0f;
2288 float endX = -1.0f;
2289 float endY = -1.0f;
2290 constexpr double expectedAngle = -135.0;
2291 constexpr double precision = 0.001;
2292
2293 TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
2294 double actualAngle = detector.GetAngle(startX, startY, endX, endY);
2295 EXPECT_NEAR(expectedAngle, actualAngle, precision);
2296 }
2297
2298 /**
2299 * @tc.name: NotifyGestureEventTest1
2300 * @tc.desc: Test NotifyGestureEvent
2301 * @tc.type: FUNC
2302 * @tc.require:
2303 */
2304 HWTEST_F(TouchGestureDetectorTest, NotifyGestureEventTest1, TestSize.Level1)
2305 {
2306 CALL_TEST_DEBUG;
2307 auto listener = std::make_shared<MyGestureListener>();
2308 TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
2309 TouchGestureDetector detector(type, listener);
2310 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
2311 ASSERT_NE(pointerEvent, nullptr);
2312
2313 GestureMode mode = GestureMode::ACTION_UNKNOWN;
2314 ASSERT_NO_FATAL_FAILURE(detector.NotifyGestureEvent(pointerEvent, mode));
2315 }
2316 } // namespace MMI
2317 } // namespace OHOS