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