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 <gtest/gtest.h>
17
18 #include "dfx_hisysevent.h"
19 #include "event_filter_handler.h"
20 #include "event_normalize_handler.h"
21 #include "event_resample.h"
22 #include "general_touchpad.h"
23 #include "general_uwb_remote_control.h"
24 #include "input_device_manager.h"
25 #include "input_scene_board_judgement.h"
26 #include "i_input_windows_manager.h"
27 #include "libinput_wrapper.h"
28 #include "touchpad_transform_processor.h"
29
30 #include "libinput-private.h"
31
32 namespace OHOS {
33 namespace MMI {
34 namespace {
35 using namespace testing::ext;
36 constexpr int32_t POINTER_MOVEFLAG {7};
37 constexpr int32_t ONE_SECOND = 1000;
38 } // namespace
39
40 class EventNormalizeHandlerTest : public testing::Test {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase(void);
44
TearDown()45 void TearDown()
46 {
47 std::this_thread::sleep_for(std::chrono::milliseconds(ONE_SECOND));
48 }
49
50 private:
51 static void SetupTouchpad();
52 static void CloseTouchpad();
53 static void SetupUwbRemoteControl();
54 static void CloseUwbRemoteControl();
55 static GeneralUwbRemoteControl vUwbRemoteControl_;
56 static GeneralTouchpad vTouchpad_;
57 static LibinputWrapper libinput_;
58 int32_t trackingID_ {0};
59 };
60
61 GeneralUwbRemoteControl EventNormalizeHandlerTest::vUwbRemoteControl_;
62 GeneralTouchpad EventNormalizeHandlerTest::vTouchpad_;
63 LibinputWrapper EventNormalizeHandlerTest::libinput_;
64
SetUpTestCase(void)65 void EventNormalizeHandlerTest::SetUpTestCase(void)
66 {
67 ASSERT_TRUE(libinput_.Init());
68 SetupTouchpad();
69 SetupUwbRemoteControl();
70 }
71
TearDownTestCase(void)72 void EventNormalizeHandlerTest::TearDownTestCase(void)
73 {
74 CloseTouchpad();
75 CloseUwbRemoteControl();
76 }
77
SetupTouchpad()78 void EventNormalizeHandlerTest::SetupTouchpad()
79 {
80 ASSERT_TRUE(vTouchpad_.SetUp());
81 std::cout << "device node name: " << vTouchpad_.GetDevPath() << std::endl;
82 ASSERT_TRUE(libinput_.AddPath(vTouchpad_.GetDevPath()));
83 libinput_event *event = libinput_.Dispatch();
84 ASSERT_TRUE(event != nullptr);
85 ASSERT_EQ(libinput_event_get_type(event), LIBINPUT_EVENT_DEVICE_ADDED);
86 struct libinput_device *device = libinput_event_get_device(event);
87 ASSERT_TRUE(device != nullptr);
88 INPUT_DEV_MGR->OnInputDeviceAdded(device);
89 }
90
CloseTouchpad()91 void EventNormalizeHandlerTest::CloseTouchpad()
92 {
93 if (!vTouchpad_.GetDevPath().empty()) {
94 libinput_.RemovePath(vTouchpad_.GetDevPath());
95 }
96 vTouchpad_.Close();
97 }
98
SetupUwbRemoteControl()99 void EventNormalizeHandlerTest::SetupUwbRemoteControl()
100 {
101 ASSERT_TRUE(vUwbRemoteControl_.SetUp());
102 std::cout << "device node name: " << vUwbRemoteControl_.GetDevPath() << std::endl;
103 ASSERT_TRUE(libinput_.AddPath(vUwbRemoteControl_.GetDevPath()));
104 libinput_event *event = libinput_.Dispatch();
105 ASSERT_TRUE(event != nullptr);
106 ASSERT_EQ(libinput_event_get_type(event), LIBINPUT_EVENT_DEVICE_ADDED);
107 struct libinput_device *device = libinput_event_get_device(event);
108 ASSERT_TRUE(device != nullptr);
109 }
110
CloseUwbRemoteControl()111 void EventNormalizeHandlerTest::CloseUwbRemoteControl()
112 {
113 if (!vUwbRemoteControl_.GetDevPath().empty()) {
114 libinput_.RemovePath(vUwbRemoteControl_.GetDevPath());
115 }
116 vUwbRemoteControl_.Close();
117 }
118
119 /**
120 * @tc.name: EventNormalizeHandlerTest_HandleEvent_002
121 * @tc.desc: Test the function HandleEvent
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleEvent_002, TestSize.Level1)
126 {
127 EventNormalizeHandler handler;
128 int64_t frameTime = 10000;
129 libinput_event *event = new (std::nothrow) libinput_event;
130 ASSERT_NE(event, nullptr);
131 event->type = LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN;
132 handler.HandleEvent(event, frameTime);
133 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
134 event->type = LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE;
135 handler.HandleEvent(event, frameTime);
136 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
137 event->type = LIBINPUT_EVENT_GESTURE_SWIPE_END;
138 handler.HandleEvent(event, frameTime);
139 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
140 event->type = LIBINPUT_EVENT_GESTURE_PINCH_UPDATE;
141 handler.HandleEvent(event, frameTime);
142 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
143 event->type = LIBINPUT_EVENT_GESTURE_PINCH_END;
144 handler.HandleEvent(event, frameTime);
145 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
146 event->type = LIBINPUT_EVENT_TOUCH_DOWN;
147 handler.HandleEvent(event, frameTime);
148 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
149 event->type = LIBINPUT_EVENT_TOUCH_UP;
150 handler.HandleEvent(event, frameTime);
151 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
152 event->type = LIBINPUT_EVENT_TOUCH_MOTION;
153 handler.HandleEvent(event, frameTime);
154 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
155 event->type = LIBINPUT_EVENT_TABLET_TOOL_AXIS;
156 handler.HandleEvent(event, frameTime);
157 ASSERT_NO_FATAL_FAILURE(handler.HandleTableToolEvent(event));
158 event->type = LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY;
159 handler.HandleEvent(event, frameTime);
160 ASSERT_NO_FATAL_FAILURE(handler.HandleTableToolEvent(event));
161 event->type = LIBINPUT_EVENT_TABLET_TOOL_TIP;
162 handler.HandleEvent(event, frameTime);
163 ASSERT_NO_FATAL_FAILURE(handler.HandleTableToolEvent(event));
164 event->type = LIBINPUT_EVENT_JOYSTICK_BUTTON;
165 handler.HandleEvent(event, frameTime);
166 ASSERT_NO_FATAL_FAILURE(handler.HandleJoystickButtonEvent(event));
167 event->type = LIBINPUT_EVENT_JOYSTICK_AXIS;
168 handler.HandleEvent(event, frameTime);
169 ASSERT_NO_FATAL_FAILURE(handler.HandleJoystickAxisEvent(event));
170 event->type = LIBINPUT_EVENT_SWITCH_TOGGLE;
171 handler.HandleEvent(event, frameTime);
172 ASSERT_NO_FATAL_FAILURE(handler.HandleSwitchInputEvent(event));
173 }
174
175 /**
176 * @tc.name: EventNormalizeHandlerTest_ProcessNullEvent_001
177 * @tc.desc: Test the function ProcessNullEvent
178 * @tc.type: FUNC
179 * @tc.require:
180 */
181 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_001, TestSize.Level1)
182 {
183 EventNormalizeHandler handler;
184 int64_t frameTime = 10000;
185 libinput_event *event = nullptr;
186 EventResampleHdr->pointerEvent_ = PointerEvent::Create();
187 bool ret = handler.ProcessNullEvent(event, frameTime);
188 ASSERT_FALSE(ret);
189 event = new (std::nothrow) libinput_event;
190 ASSERT_NE(event, nullptr);
191 event->type = LIBINPUT_EVENT_NONE;
192 ret = handler.ProcessNullEvent(event, frameTime);
193 ASSERT_FALSE(ret);
194 }
195
196 /**
197 * @tc.name: EventNormalizeHandlerTest_HandleKeyEvent_001
198 * @tc.desc: Test the function HandleKeyEvent
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleKeyEvent_001, TestSize.Level1)
203 {
204 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
205 ASSERT_NE(keyEvent, nullptr);
206 keyEvent->SetRepeat(true);
207 EventNormalizeHandler handler;
208 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent));
209 keyEvent->SetRepeat(false);
210 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent));
211 }
212
213 /**
214 * @tc.name: EventNormalizeHandlerTest_HandlePointerEvent_001
215 * @tc.desc: Test the function HandlePointerEvent
216 * @tc.type: FUNC
217 * @tc.require:
218 */
219 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandlePointerEvent_001, TestSize.Level1)
220 {
221 auto pointerEvent = PointerEvent::Create();
222 ASSERT_NE(pointerEvent, nullptr);
223 EventNormalizeHandler handler;
224 handler.nextHandler_ = std::make_shared<EventFilterHandler>();
225 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
226 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
227 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
228 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
229 pointerEvent->SetPointerId(0);
230 PointerEvent::PointerItem item;
231 item.SetPointerId(0);
232 pointerEvent->UpdatePointerItem(0, item);
233 ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
234 }
235
236 /**
237 * @tc.name: EventNormalizeHandlerTest_HandleTouchEvent_001
238 * @tc.desc: Test the function HandleTouchEvent
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent_001, TestSize.Level1)
243 {
244 auto pointerEvent = PointerEvent::Create();
245 ASSERT_NE(pointerEvent, nullptr);
246 EventNormalizeHandler handler;
247 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(pointerEvent));
248 pointerEvent = nullptr;
249 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(pointerEvent));
250 }
251
252 /**
253 * @tc.name: EventNormalizeHandlerTest_UpdateKeyEventHandlerChain_001
254 * @tc.desc: Test the function UpdateKeyEventHandlerChain
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_UpdateKeyEventHandlerChain_001, TestSize.Level1)
259 {
260 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
261 ASSERT_NE(keyEvent, nullptr);
262 EventNormalizeHandler handler;
263 ASSERT_NO_FATAL_FAILURE(handler.UpdateKeyEventHandlerChain(keyEvent));
264 keyEvent = nullptr;
265 ASSERT_NO_FATAL_FAILURE(handler.UpdateKeyEventHandlerChain(keyEvent));
266 }
267
268 /**
269 * @tc.name: EventNormalizeHandlerTest_SetOriginPointerId_001
270 * @tc.desc: Test the function SetOriginPointerId
271 * @tc.type: FUNC
272 * @tc.require:
273 */
274 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetOriginPointerId_001, TestSize.Level1)
275 {
276 auto pointerEvent = PointerEvent::Create();
277 ASSERT_NE(pointerEvent, nullptr);
278 EventNormalizeHandler handler;
279 ASSERT_NO_FATAL_FAILURE(handler.SetOriginPointerId(pointerEvent));
280 pointerEvent = nullptr;
281 int32_t ret = handler.SetOriginPointerId(pointerEvent);
282 pointerEvent = nullptr;
283 ASSERT_EQ(ret, ERROR_NULL_POINTER);
284 }
285
286 /**
287 * @tc.name: EventNormalizeHandlerTest_HandlePalmEvent
288 * @tc.desc: Test the function HandlePalmEvent
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandlePalmEvent, TestSize.Level1)
293 {
294 CALL_TEST_DEBUG;
295 EventNormalizeHandler handler;
296 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
297 ASSERT_NE(pointerEvent, nullptr);
298 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
299 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 2220);
300 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 727);
301 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
302 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
303 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 715);
304
305 libinput_event *event = libinput_.Dispatch();
306 ASSERT_TRUE(event != nullptr);
307 struct libinput_device *dev = libinput_event_get_device(event);
308 ASSERT_TRUE(dev != nullptr);
309 std::cout << "touchpad device: " << libinput_device_get_name(dev) << std::endl;
310 EXPECT_NO_FATAL_FAILURE(handler.HandlePalmEvent(event, pointerEvent));
311 }
312
313 /**
314 * @tc.name: EventNormalizeHandlerTest_HandleTouchEvent
315 * @tc.desc: Test the function HandleTouchEvent
316 * @tc.type: FUNC
317 * @tc.require:
318 */
319 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent, TestSize.Level1)
320 {
321 CALL_TEST_DEBUG;
322 EventNormalizeHandler handler;
323 int64_t frameTime = 10000;
324 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
325 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 958);
326 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 896);
327 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
328 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
329 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 712);
330
331 libinput_event *event = libinput_.Dispatch();
332 ASSERT_TRUE(event != nullptr);
333 struct libinput_device *dev = libinput_event_get_device(event);
334 ASSERT_TRUE(dev != nullptr);
335 std::cout << "touchpad device: " << libinput_device_get_name(dev) << std::endl;
336 handler.nextHandler_ = std::make_shared<EventFilterHandler>();
337 handler.SetNext(handler.nextHandler_);
338 ASSERT_NE(handler.HandleTouchEvent(event, frameTime), RET_OK);
339 }
340
341 /**
342 * @tc.name: EventNormalizeHandlerTest_ResetTouchUpEvent
343 * @tc.desc: Test the function ResetTouchUpEvent
344 * @tc.type: FUNC
345 * @tc.require:
346 */
347 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ResetTouchUpEvent, TestSize.Level1)
348 {
349 CALL_TEST_DEBUG;
350 EventNormalizeHandler handler;
351 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
352 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 729);
353 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 562);
354 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
355 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
356 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 711);
357
358 libinput_event *event = libinput_.Dispatch();
359 ASSERT_TRUE(event != nullptr);
360 struct libinput_device *dev = libinput_event_get_device(event);
361 ASSERT_TRUE(dev != nullptr);
362 std::cout << "touchpad device: " << libinput_device_get_name(dev) << std::endl;
363 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
364 ASSERT_NE(pointerEvent, nullptr);
365 EXPECT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, event));
366 PointerEvent::PointerItem item;
367 item.SetPointerId(1);
368 pointerEvent->AddPointerItem(item);
369 EXPECT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, event));
370 }
371
372 /**
373 * @tc.name: EventNormalizeHandlerTest_TerminateAxis
374 * @tc.desc: Test the function TerminateAxis
375 * @tc.type: FUNC
376 * @tc.require:
377 */
378 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_TerminateAxis, TestSize.Level1)
379 {
380 CALL_TEST_DEBUG;
381 EventNormalizeHandler handler;
382 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
383 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 723);
384 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 693);
385 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
386 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
387 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 710);
388
389 libinput_event *event = libinput_.Dispatch();
390 ASSERT_TRUE(event != nullptr);
391 struct libinput_device *dev = libinput_event_get_device(event);
392 ASSERT_TRUE(dev != nullptr);
393 std::cout << "touchpad device: " << libinput_device_get_name(dev) << std::endl;
394 handler.nextHandler_ = std::make_shared<EventFilterHandler>();
395 handler.SetNext(handler.nextHandler_);
396 EXPECT_NO_FATAL_FAILURE(handler.TerminateAxis(event));
397 }
398
399 /**
400 * @tc.name: EventNormalizeHandlerTest_ProcessNullEvent_002
401 * @tc.desc: Test the function ProcessNullEvent
402 * @tc.type: FUNC
403 * @tc.require:
404 */
405 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_002, TestSize.Level1)
406 {
407 EventNormalizeHandler handler;
408 int64_t frameTime = 100;
409 libinput_event *event = nullptr;
410 EventResampleHdr->pointerEvent_ = PointerEvent::Create();
411 MMISceneBoardJudgement judgement;
412 judgement.IsSceneBoardEnabled();
413 judgement.IsResampleEnabled();
414 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
415 ASSERT_NE(pointerEvent, nullptr);
416 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
417 bool ret = handler.ProcessNullEvent(event, frameTime);
418 ASSERT_FALSE(ret);
419 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHPAD;
420 ret = handler.ProcessNullEvent(event, frameTime);
421 ASSERT_FALSE(ret);
422 pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_JOYSTICK;
423 ret = handler.ProcessNullEvent(event, frameTime);
424 ASSERT_FALSE(ret);
425 EventResampleHdr->pointerEvent_ = nullptr;
426 ret = handler.ProcessNullEvent(event, frameTime);
427 ASSERT_FALSE(ret);
428 }
429
430 #ifdef OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
431 /**
432 * @tc.name: EventNormalizeHandlerTest_SetMoveEventFilters_001
433 * @tc.desc: Set moveEventFilterFlag_
434 * @tc.type: FUNC
435 * @tc.require:SR000HQ0RR
436 */
437 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetMoveEventFilters_001, TestSize.Level1)
438 {
439 EventNormalizeHandler eventNormalizeHandler;
440 bool flag = true;
441 int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
442 ASSERT_EQ(ret, RET_OK);
443 }
444
445 /**
446 * @tc.name: EventNormalizeHandlerTest_SetMoveEventFilters_002
447 * @tc.desc: Set moveEventFilterFlag_
448 * @tc.type: FUNC
449 * @tc.require:SR000HQ0RR
450 */
451 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetMoveEventFilters_002, TestSize.Level1)
452 {
453 EventNormalizeHandler eventNormalizeHandler;
454 bool flag = false;
455 int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
456 ASSERT_EQ(ret, RET_OK);
457 }
458
459 /**
460 * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_001
461 * @tc.desc: Handle Touch Event
462 * @tc.type: FUNC
463 * @tc.require:SR000HQ0RR
464 */
465 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_001, TestSize.Level1)
466 {
467 EventNormalizeHandler eventNormalizeHandler;
468 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
469 ASSERT_NE(pointerEvent, nullptr);
470 bool flag = true;
471 int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
472 ASSERT_EQ(ret, RET_OK);
473 PointerEvent::PointerItem item1;
474 item1.SetPointerId(0);
475 item1.SetDisplayX(0);
476 item1.SetDisplayY(0);
477 pointerEvent->SetPointerId(0);
478 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
479 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
480 pointerEvent->AddPointerItem(item1);
481 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
482 ASSERT_FALSE(flag);
483
484 pointerEvent->RemovePointerItem(0);
485 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
486 PointerEvent::PointerItem item2;
487 item2.SetPointerId(0);
488 item2.SetDisplayX(0);
489 item2.SetDisplayY(0);
490 pointerEvent->AddPointerItem(item2);
491 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
492 ASSERT_TRUE(flag);
493 }
494
495 /**
496 * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_002
497 * @tc.desc: Handle Touch Event
498 * @tc.type: FUNC
499 * @tc.require:SR000HQ0RR
500 */
501 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_002, TestSize.Level1)
502 {
503 EventNormalizeHandler eventNormalizeHandler;
504 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
505 ASSERT_NE(pointerEvent, nullptr);
506 bool flag = true;
507 int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
508 ASSERT_EQ(ret, RET_OK);
509 PointerEvent::PointerItem item1;
510 item1.SetPointerId(0);
511 item1.SetDisplayX(0);
512 item1.SetDisplayY(0);
513 pointerEvent->SetPointerId(0);
514 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
515 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
516 pointerEvent->AddPointerItem(item1);
517 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
518 ASSERT_FALSE(flag);
519
520 pointerEvent->RemovePointerItem(0);
521 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
522 PointerEvent::PointerItem item2;
523 item2.SetPointerId(0);
524 item2.SetDisplayX(0);
525 item2.SetDisplayY(1);
526 pointerEvent->AddPointerItem(item2);
527 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
528 ASSERT_FALSE(flag);
529 }
530
531 /**
532 * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_003
533 * @tc.desc: Handle Touch Event
534 * @tc.type: FUNC
535 * @tc.require:SR000HQ0RR
536 */
537 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_003, TestSize.Level1)
538 {
539 EventNormalizeHandler eventNormalizeHandler;
540 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
541 ASSERT_NE(pointerEvent, nullptr);
542 bool flag = true;
543 int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
544 ASSERT_EQ(ret, RET_OK);
545 PointerEvent::PointerItem item1;
546 item1.SetPointerId(0);
547 item1.SetDisplayX(0);
548 item1.SetDisplayY(0);
549 pointerEvent->SetPointerId(0);
550 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
551 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
552 pointerEvent->AddPointerItem(item1);
553 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
554 ASSERT_FALSE(flag);
555
556 pointerEvent->RemovePointerItem(0);
557 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
558 PointerEvent::PointerItem item2;
559 item2.SetPointerId(0);
560 item2.SetDisplayX(0);
561 item2.SetDisplayY(2);
562 pointerEvent->AddPointerItem(item2);
563 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
564 ASSERT_FALSE(flag);
565 }
566
567 /**
568 * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_004
569 * @tc.desc: Handle Touch Event
570 * @tc.type: FUNC
571 * @tc.require:SR000HQ0RR
572 */
573 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_004, TestSize.Level1)
574 {
575 EventNormalizeHandler eventNormalizeHandler;
576 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
577 ASSERT_NE(pointerEvent, nullptr);
578 bool flag = false;
579 int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
580 ASSERT_EQ(ret, RET_OK);
581 PointerEvent::PointerItem item1;
582 item1.SetPointerId(0);
583 item1.SetDisplayX(0);
584 item1.SetDisplayY(0);
585 pointerEvent->SetPointerId(0);
586 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
587 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
588 pointerEvent->AddPointerItem(item1);
589 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
590 ASSERT_FALSE(flag);
591
592 pointerEvent->RemovePointerItem(0);
593 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
594 PointerEvent::PointerItem item2;
595 item2.SetPointerId(0);
596 item2.SetDisplayX(0);
597 item2.SetDisplayY(0);
598 pointerEvent->AddPointerItem(item2);
599 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
600 ASSERT_FALSE(flag);
601 }
602
603 /**
604 * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_005
605 * @tc.desc: Handle Touch Event
606 * @tc.type: FUNC
607 * @tc.require:SR000HQ0RR
608 */
609 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_005, TestSize.Level1)
610 {
611 EventNormalizeHandler eventNormalizeHandler;
612 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
613 ASSERT_NE(pointerEvent, nullptr);
614 bool flag = false;
615 int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
616 ASSERT_EQ(ret, RET_OK);
617 PointerEvent::PointerItem item1;
618 item1.SetPointerId(0);
619 item1.SetDisplayX(0);
620 item1.SetDisplayY(0);
621 pointerEvent->SetPointerId(0);
622 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
623 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
624 pointerEvent->AddPointerItem(item1);
625 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
626 ASSERT_FALSE(flag);
627
628 pointerEvent->RemovePointerItem(0);
629 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
630 PointerEvent::PointerItem item2;
631 item2.SetPointerId(0);
632 item2.SetDisplayX(0);
633 item2.SetDisplayY(1);
634 pointerEvent->AddPointerItem(item2);
635 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
636 ASSERT_FALSE(flag);
637 }
638
639 /**
640 * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_006
641 * @tc.desc: Handle Touch Event
642 * @tc.type: FUNC
643 * @tc.require:SR000HQ0RR
644 */
645 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_006, TestSize.Level1)
646 {
647 EventNormalizeHandler eventNormalizeHandler;
648 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
649 ASSERT_NE(pointerEvent, nullptr);
650 bool flag = false;
651 int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
652 ASSERT_EQ(ret, RET_OK);
653 PointerEvent::PointerItem item1;
654 item1.SetPointerId(0);
655 item1.SetDisplayX(0);
656 item1.SetDisplayY(0);
657 pointerEvent->SetPointerId(0);
658 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
659 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
660 pointerEvent->AddPointerItem(item1);
661 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
662 ASSERT_FALSE(flag);
663
664 pointerEvent->RemovePointerItem(0);
665 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
666 PointerEvent::PointerItem item2;
667 item2.SetPointerId(0);
668 item2.SetDisplayX(0);
669 item2.SetDisplayY(2);
670 pointerEvent->AddPointerItem(item2);
671 flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
672 ASSERT_FALSE(flag);
673 }
674
675 /**
676 * @tc.name: EventNormalizeHandlerTest_CalcTouchOffset_001
677 * @tc.desc: Determine whether the touch produces displacement
678 * @tc.type: FUNC
679 * @tc.require:SR000HQ0RR
680 */
681 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_CalcTouchOffset_001, TestSize.Level1)
682 {
683 EventNormalizeHandler eventNormalizeHandler;
684 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
685 ASSERT_NE(pointerEvent, nullptr);
686 double offSet = eventNormalizeHandler.CalcTouchOffset(pointerEvent);
687 ASSERT_EQ(offSet, 0.f);
688 }
689
690 /**
691 * @tc.name: EventNormalizeHandlerTest_CalcTouchOffset_002
692 * @tc.desc: Determine whether the touch produces displacement
693 * @tc.type: FUNC
694 * @tc.require:SR000HQ0RR
695 */
696 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_CalcTouchOffset_002, TestSize.Level1)
697 {
698 EventNormalizeHandler eventNormalizeHandler;
699 PointerEvent::PointerItem item1;
700 item1.SetPointerId(0);
701 item1.SetDisplayX(0);
702 item1.SetDisplayY(0);
703 eventNormalizeHandler.lastTouchDownItems_.push_back(item1);
704 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
705 ASSERT_NE(pointerEvent, nullptr);
706 PointerEvent::PointerItem item2;
707 item2.SetPointerId(0);
708 item2.SetDisplayX(0);
709 item2.SetDisplayY(1);
710 pointerEvent->AddPointerItem(item2);
711 double offSet = eventNormalizeHandler.CalcTouchOffset(pointerEvent);
712 ASSERT_EQ(offSet, 1.f);
713 }
714 #endif // #ifdef OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
715
716 /**
717 * @tc.name: EventNormalizeHandlerTest_AddHandleTimer_001
718 * @tc.desc: Add handlerTimer
719 * @tc.type: FUNC
720 * @tc.require:SR000HQ0RR
721 */
722 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_AddHandleTimer_001, TestSize.Level1)
723 {
724 EventNormalizeHandler eventNormalizeHandler;
725 const int32_t timeOut = 400;
726 int32_t timeId = eventNormalizeHandler.AddHandleTimer(timeOut);
727 ASSERT_NE(timeId, -1);
728 }
729
730 /**
731 * @tc.name: EventNormalizeHandlerTest_HandleSwitchInputEvent_001
732 * @tc.desc: Handle Switch Input Event
733 * @tc.type: FUNC
734 * @tc.require:SR000HQ0RR
735 */
736 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleSwitchInputEvent_001, TestSize.Level1)
737 {
738 EventNormalizeHandler eventNormalizeHandler;
739 libinput_event *event = nullptr;
740 int32_t ret = eventNormalizeHandler.HandleSwitchInputEvent(event);
741 ASSERT_EQ(ret, ERROR_UNSUPPORT);
742 }
743
744 /**
745 * @tc.name: EventNormalizeHandlerTest_HandleTableToolEvent_001
746 * @tc.desc: Handle TableTool Event
747 * @tc.type: FUNC
748 * @tc.require:SR000HQ0RR
749 */
750 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTableToolEvent_001, TestSize.Level1)
751 {
752 EventNormalizeHandler eventNormalizeHandler;
753 libinput_event *event = nullptr;
754 int32_t ret = eventNormalizeHandler.HandleTableToolEvent(event);
755 ASSERT_EQ(ret, ERROR_UNSUPPORT);
756 }
757
758 /**
759 * @tc.name: EventNormalizeHandlerTest_HandleTouchEvent_002
760 * @tc.desc: Handle touch event
761 * @tc.type: FUNC
762 * @tc.require:SR000HQ0RR
763 */
764 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent_002, TestSize.Level1)
765 {
766 EventNormalizeHandler eventNormalizeHandler;
767 libinput_event *event = nullptr;
768 int64_t frameTime = 50;
769 int32_t ret = eventNormalizeHandler.HandleTouchEvent(event, frameTime);
770 ASSERT_EQ(ret, ERROR_UNSUPPORT);
771 }
772
773 /**
774 * @tc.name: EventNormalizeHandlerTest_HandleGestureEvent_001
775 * @tc.desc: Handle Gesture Event
776 * @tc.type: FUNC
777 * @tc.require:SR000HQ0RR
778 */
779 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleGestureEvent_001, TestSize.Level1)
780 {
781 EventNormalizeHandler eventNormalizeHandler;
782 libinput_event *event = nullptr;
783 int32_t ret = eventNormalizeHandler.HandleGestureEvent(event);
784 ASSERT_EQ(ret, ERROR_UNSUPPORT);
785 }
786
787 /**
788 * @tc.name: EventNormalizeHandlerTest_HandleTouchPadEvent_001
789 * @tc.desc: Handle TouchPadEvent
790 * @tc.type: FUNC
791 * @tc.require:SR000HQ0RR
792 */
793 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchPadEvent_001, TestSize.Level1)
794 {
795 EventNormalizeHandler eventNormalizeHandler;
796 libinput_event *event = nullptr;
797 int32_t ret = eventNormalizeHandler.HandleTouchPadEvent(event);
798 ASSERT_EQ(ret, ERROR_UNSUPPORT);
799 }
800
801 /**
802 * @tc.name: EventNormalizeHandlerTest_HandleMouseEvent_001
803 * @tc.desc: Handle mouseEvent
804 * @tc.type: FUNC
805 * @tc.require:SR000HQ0RR
806 */
807 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleMouseEvent_001, TestSize.Level1)
808 {
809 EventNormalizeHandler eventNormalizeHandler;
810 libinput_event *event = nullptr;
811 int32_t ret = eventNormalizeHandler.HandleMouseEvent(event);
812 ASSERT_EQ(ret, ERROR_UNSUPPORT);
813 }
814
815 /**
816 * @tc.name: EventNormalizeHandlerTest_OnEventDeviceRemoved_001
817 * @tc.desc: OnEvent device removed
818 * @tc.type: FUNC
819 * @tc.require:SR000HQ0RR
820 */
821 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_OnEventDeviceRemoved_001, TestSize.Level1)
822 {
823 EventNormalizeHandler eventNormalizeHandler;
824 libinput_event *event = nullptr;
825 int32_t ret = eventNormalizeHandler.OnEventDeviceRemoved(event);
826 ASSERT_EQ(ret, ERROR_NULL_POINTER);
827 }
828
829 /**
830 * @tc.name: EventNormalizeHandlerTest_ProcessNullEvent_003
831 * @tc.desc: Process nullEvent
832 * @tc.type: FUNC
833 * @tc.require:SR000HQ0RR
834 */
835 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_003, TestSize.Level1)
836 {
837 EventNormalizeHandler eventNormalizeHandler;
838 libinput_event *event = nullptr;
839 int64_t frametime = 30;
840 bool flag = eventNormalizeHandler.ProcessNullEvent(event, frametime);
841 ASSERT_FALSE(flag);
842 }
843
844 /**
845 * @tc.name: EventNormalizeHandlerTest_HandleTouchEvent_003
846 * @tc.desc: Test the function HandleTouchEvent
847 * @tc.type: FUNC
848 * @tc.require:
849 */
850 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent_003, TestSize.Level1)
851 {
852 CALL_TEST_DEBUG;
853 libinput_.DrainEvents();
854 EventNormalizeHandler handler;
855 int64_t frameTime = 10000;
856 int32_t varMoveFlag = POINTER_MOVEFLAG;
857 std::cout << "varMoveFlag: " << POINTER_MOVEFLAG << std::endl;
858 for (int32_t index = 1; index < POINTER_MOVEFLAG; ++index) {
859 vUwbRemoteControl_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, 0);
860 vUwbRemoteControl_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 5190 + index * 30);
861 vUwbRemoteControl_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 8306);
862 vUwbRemoteControl_.SendEvent(EV_ABS, ABS_MT_PRESSURE, 321);
863 vUwbRemoteControl_.SendEvent(EV_ABS, ABS_MT_MOVEFLAG, varMoveFlag);
864 vUwbRemoteControl_.SendEvent(EV_ABS, ABS_MT_TOUCH_MAJOR, 198);
865 vUwbRemoteControl_.SendEvent(EV_ABS, ABS_MT_TOUCH_MINOR, 180);
866 vUwbRemoteControl_.SendEvent(EV_ABS, ABS_MT_ORIENTATION, -64);
867 vUwbRemoteControl_.SendEvent(EV_ABS, ABS_MT_BLOB_ID, 2);
868 vUwbRemoteControl_.SendEvent(EV_SYN, SYN_MT_REPORT, 0);
869 vUwbRemoteControl_.SendEvent(EV_KEY, BTN_TOUCH, 0);
870 vUwbRemoteControl_.SendEvent(EV_SYN, SYN_REPORT, 0);
871 }
872 libinput_event *event = libinput_.Dispatch();
873 ASSERT_TRUE(event != nullptr);
874 while (event != nullptr) {
875 auto type = libinput_event_get_type(event);
876 if (type == LIBINPUT_EVENT_TOUCH_CANCEL || type == LIBINPUT_EVENT_TOUCH_FRAME) {
877 event = libinput_.Dispatch();
878 continue;
879 }
880 std::cout << "type: " << type << std::endl;
881 auto touch = libinput_event_get_touch_event(event);
882 ASSERT_TRUE(touch != nullptr);
883 int32_t moveFlag = libinput_event_touch_get_move_flag(touch);
884 std::cout << "moveFlag: " << moveFlag << std::endl;
885 auto dev = libinput_event_get_device(event);
886 ASSERT_TRUE(dev != nullptr);
887 std::cout << "touch device: " << libinput_device_get_name(dev) << std::endl;
888 handler.nextHandler_ = std::make_shared<EventFilterHandler>();
889 handler.SetNext(handler.nextHandler_);
890 EXPECT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
891 event = libinput_.Dispatch();
892 }
893 }
894
895 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchPadEdgeSwipe_001, TestSize.Level1)
896 {
897 CALL_TEST_DEBUG;
898 EventNormalizeHandler handler;
899 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
900 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 100);
901 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 100);
902 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
903 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
904 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 101);
905 vTouchpad_.SendEvent(EV_ABS, ABS_MT_PRESSURE, LEFT_SILDE_UP_ABS_PRESSURE_VALUE);
906 libinput_event *event = libinput_.Dispatch();
907 ASSERT_TRUE(event != nullptr);
908 EXPECT_NO_FATAL_FAILURE(handler.HandleTouchPadEdgeSwipe(event));
909 }
910
911 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchPadEdgeSwipe_002, TestSize.Level1)
912 {
913 CALL_TEST_DEBUG;
914 EventNormalizeHandler handler;
915 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
916 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 100);
917 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 100);
918 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
919 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
920 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 101);
921 vTouchpad_.SendEvent(EV_ABS, ABS_MT_PRESSURE, LEFT_SILDE_DOWN_ABS_PRESSURE_VALUE);
922 libinput_event *event = libinput_.Dispatch();
923 ASSERT_TRUE(event != nullptr);
924 EXPECT_NO_FATAL_FAILURE(handler.HandleTouchPadEdgeSwipe(event));
925 }
926
927 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchPadEdgeSwipe_003, TestSize.Level1)
928 {
929 CALL_TEST_DEBUG;
930 EventNormalizeHandler handler;
931 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
932 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 100);
933 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 100);
934 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
935 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
936 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 101);
937 vTouchpad_.SendEvent(EV_ABS, ABS_MT_PRESSURE, RIGHT_SILDE_UP_ABS_PRESSURE_VALUE);
938 libinput_event *event = libinput_.Dispatch();
939 ASSERT_TRUE(event != nullptr);
940 EXPECT_NO_FATAL_FAILURE(handler.HandleTouchPadEdgeSwipe(event));
941 }
942
943 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchPadEdgeSwipe_004, TestSize.Level1)
944 {
945 CALL_TEST_DEBUG;
946 EventNormalizeHandler handler;
947 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
948 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 100);
949 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 100);
950 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
951 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
952 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 101);
953 vTouchpad_.SendEvent(EV_ABS, ABS_MT_PRESSURE, RIGHT_SILDE_DOWN_ABS_PRESSURE_VALUE);
954 libinput_event *event = libinput_.Dispatch();
955 ASSERT_TRUE(event != nullptr);
956 EXPECT_NO_FATAL_FAILURE(handler.HandleTouchPadEdgeSwipe(event));
957 }
958
959 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchPadEdgeSwipe_005, TestSize.Level1)
960 {
961 CALL_TEST_DEBUG;
962 EventNormalizeHandler handler;
963 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
964 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 100);
965 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 100);
966 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
967 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
968 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 101);
969 vTouchpad_.SendEvent(EV_ABS, ABS_MT_PRESSURE, 200);
970 libinput_event *event = libinput_.Dispatch();
971 ASSERT_TRUE(event != nullptr);
972 EXPECT_NO_FATAL_FAILURE(handler.HandleTouchPadEdgeSwipe(event));
973 }
974
975 } // namespace MMI
976 } // namespace OHOS