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 "input_device_manager.h"
24 #include "input_scene_board_judgement.h"
25 #include "i_input_windows_manager.h"
26 #include "libinput_wrapper.h"
27 #include "touchpad_transform_processor.h"
28 
29 #include "libinput-private.h"
30 
31 namespace OHOS {
32 namespace MMI {
33 namespace {
34 using namespace testing::ext;
35 } // namespace
36 
37 class EventNormalizeHandlerTest : public testing::Test {
38 public:
39     static void SetUpTestCase(void);
40     static void TearDownTestCase(void);
41 
42 private:
43     static void SetupTouchpad();
44     static void CloseTouchpad();
45     static GeneralTouchpad vTouchpad_;
46     static LibinputWrapper libinput_;
47     int32_t trackingID_ { 0 };
48 };
49 
50 GeneralTouchpad EventNormalizeHandlerTest::vTouchpad_;
51 LibinputWrapper EventNormalizeHandlerTest::libinput_;
52 
SetUpTestCase(void)53 void EventNormalizeHandlerTest::SetUpTestCase(void)
54 {
55     ASSERT_TRUE(libinput_.Init());
56     SetupTouchpad();
57 }
58 
TearDownTestCase(void)59 void EventNormalizeHandlerTest::TearDownTestCase(void)
60 {
61     CloseTouchpad();
62 }
63 
SetupTouchpad()64 void EventNormalizeHandlerTest::SetupTouchpad()
65 {
66     ASSERT_TRUE(vTouchpad_.SetUp());
67     std::cout << "device node name: " << vTouchpad_.GetDevPath() << std::endl;
68     ASSERT_TRUE(libinput_.AddPath(vTouchpad_.GetDevPath()));
69     libinput_event *event = libinput_.Dispatch();
70     ASSERT_TRUE(event != nullptr);
71     ASSERT_EQ(libinput_event_get_type(event), LIBINPUT_EVENT_DEVICE_ADDED);
72     struct libinput_device *device = libinput_event_get_device(event);
73     ASSERT_TRUE(device != nullptr);
74     INPUT_DEV_MGR->OnInputDeviceAdded(device);
75 }
76 
CloseTouchpad()77 void EventNormalizeHandlerTest::CloseTouchpad()
78 {
79     libinput_.RemovePath(vTouchpad_.GetDevPath());
80     vTouchpad_.Close();
81 }
82 
83 /**
84  * @tc.name: EventNormalizeHandlerTest_HandleEvent_002
85  * @tc.desc: Test the function HandleEvent
86  * @tc.type: FUNC
87  * @tc.require:
88  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleEvent_002, TestSize.Level1)89 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleEvent_002, TestSize.Level1)
90 {
91     EventNormalizeHandler handler;
92     int64_t frameTime = 10000;
93     libinput_event* event = new (std::nothrow) libinput_event;
94     ASSERT_NE(event, nullptr);
95     event->type = LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN;
96     handler.HandleEvent(event, frameTime);
97     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
98     event->type = LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE;
99     handler.HandleEvent(event, frameTime);
100     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
101     event->type = LIBINPUT_EVENT_GESTURE_SWIPE_END;
102     handler.HandleEvent(event, frameTime);
103     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
104     event->type = LIBINPUT_EVENT_GESTURE_PINCH_UPDATE;
105     handler.HandleEvent(event, frameTime);
106     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
107     event->type = LIBINPUT_EVENT_GESTURE_PINCH_END;
108     handler.HandleEvent(event, frameTime);
109     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
110     event->type = LIBINPUT_EVENT_TOUCH_DOWN;
111     handler.HandleEvent(event, frameTime);
112     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
113     event->type = LIBINPUT_EVENT_TOUCH_UP;
114     handler.HandleEvent(event, frameTime);
115     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
116     event->type = LIBINPUT_EVENT_TOUCH_MOTION;
117     handler.HandleEvent(event, frameTime);
118     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
119     event->type = LIBINPUT_EVENT_TABLET_TOOL_AXIS;
120     handler.HandleEvent(event, frameTime);
121     ASSERT_NO_FATAL_FAILURE(handler.HandleTableToolEvent(event));
122     event->type = LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY;
123     handler.HandleEvent(event, frameTime);
124     ASSERT_NO_FATAL_FAILURE(handler.HandleTableToolEvent(event));
125     event->type = LIBINPUT_EVENT_TABLET_TOOL_TIP;
126     handler.HandleEvent(event, frameTime);
127     ASSERT_NO_FATAL_FAILURE(handler.HandleTableToolEvent(event));
128     event->type = LIBINPUT_EVENT_JOYSTICK_BUTTON;
129     handler.HandleEvent(event, frameTime);
130     ASSERT_NO_FATAL_FAILURE(handler.HandleJoystickEvent(event));
131     event->type = LIBINPUT_EVENT_JOYSTICK_AXIS;
132     handler.HandleEvent(event, frameTime);
133     ASSERT_NO_FATAL_FAILURE(handler.HandleJoystickEvent(event));
134     event->type = LIBINPUT_EVENT_SWITCH_TOGGLE;
135     handler.HandleEvent(event, frameTime);
136     ASSERT_NO_FATAL_FAILURE(handler.HandleSwitchInputEvent(event));
137 }
138 
139 /**
140  * @tc.name: EventNormalizeHandlerTest_ProcessNullEvent_001
141  * @tc.desc: Test the function ProcessNullEvent
142  * @tc.type: FUNC
143  * @tc.require:
144  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_001, TestSize.Level1)145 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_001, TestSize.Level1)
146 {
147     EventNormalizeHandler handler;
148     int64_t frameTime = 10000;
149     libinput_event* event = nullptr;
150     EventResampleHdr->pointerEvent_ = PointerEvent::Create();
151     bool ret = handler.ProcessNullEvent(event, frameTime);
152     ASSERT_FALSE(ret);
153     event = new (std::nothrow) libinput_event;
154     ASSERT_NE(event, nullptr);
155     event->type = LIBINPUT_EVENT_NONE;
156     ret = handler.ProcessNullEvent(event, frameTime);
157     ASSERT_FALSE(ret);
158 }
159 
160 /**
161  * @tc.name: EventNormalizeHandlerTest_HandleKeyEvent_001
162  * @tc.desc: Test the function HandleKeyEvent
163  * @tc.type: FUNC
164  * @tc.require:
165  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleKeyEvent_001, TestSize.Level1)166 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleKeyEvent_001, TestSize.Level1)
167 {
168     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
169     ASSERT_NE(keyEvent, nullptr);
170     keyEvent->SetRepeat(true);
171     EventNormalizeHandler handler;
172     ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent));
173     keyEvent->SetRepeat(false);
174     ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent));
175 }
176 
177 /**
178  * @tc.name: EventNormalizeHandlerTest_HandlePointerEvent_001
179  * @tc.desc: Test the function HandlePointerEvent
180  * @tc.type: FUNC
181  * @tc.require:
182  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandlePointerEvent_001, TestSize.Level1)183 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandlePointerEvent_001, TestSize.Level1)
184 {
185     auto pointerEvent = PointerEvent::Create();
186     ASSERT_NE(pointerEvent, nullptr);
187     EventNormalizeHandler handler;
188     handler.nextHandler_ = std::make_shared<EventFilterHandler>();
189     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
190     ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
191     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
192     ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
193     pointerEvent->SetPointerId(0);
194     PointerEvent::PointerItem item;
195     item.SetPointerId(0);
196     pointerEvent->UpdatePointerItem(0, item);
197     ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
198 }
199 
200 /**
201  * @tc.name: EventNormalizeHandlerTest_HandleTouchEvent_001
202  * @tc.desc: Test the function HandleTouchEvent
203  * @tc.type: FUNC
204  * @tc.require:
205  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent_001, TestSize.Level1)206 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent_001, TestSize.Level1)
207 {
208     auto pointerEvent = PointerEvent::Create();
209     ASSERT_NE(pointerEvent, nullptr);
210     EventNormalizeHandler handler;
211     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(pointerEvent));
212     pointerEvent = nullptr;
213     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(pointerEvent));
214 }
215 
216 /**
217  * @tc.name: EventNormalizeHandlerTest_UpdateKeyEventHandlerChain_001
218  * @tc.desc: Test the function UpdateKeyEventHandlerChain
219  * @tc.type: FUNC
220  * @tc.require:
221  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_UpdateKeyEventHandlerChain_001, TestSize.Level1)222 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_UpdateKeyEventHandlerChain_001, TestSize.Level1)
223 {
224     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
225     ASSERT_NE(keyEvent, nullptr);
226     EventNormalizeHandler handler;
227     ASSERT_NO_FATAL_FAILURE(handler.UpdateKeyEventHandlerChain(keyEvent));
228     keyEvent = nullptr;
229     ASSERT_NO_FATAL_FAILURE(handler.UpdateKeyEventHandlerChain(keyEvent));
230 }
231 
232 /**
233  * @tc.name: EventNormalizeHandlerTest_SetOriginPointerId_001
234  * @tc.desc: Test the function SetOriginPointerId
235  * @tc.type: FUNC
236  * @tc.require:
237  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetOriginPointerId_001, TestSize.Level1)238 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetOriginPointerId_001, TestSize.Level1)
239 {
240     auto pointerEvent = PointerEvent::Create();
241     ASSERT_NE(pointerEvent, nullptr);
242     EventNormalizeHandler handler;
243     ASSERT_NO_FATAL_FAILURE(handler.SetOriginPointerId(pointerEvent));
244     pointerEvent = nullptr;
245     int32_t ret = handler.SetOriginPointerId(pointerEvent);
246     pointerEvent = nullptr;
247     ASSERT_EQ(ret, ERROR_NULL_POINTER);
248 }
249 
250 /**
251  * @tc.name: EventNormalizeHandlerTest_HandlePalmEvent
252  * @tc.desc: Test the function HandlePalmEvent
253  * @tc.type: FUNC
254  * @tc.require:
255  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandlePalmEvent, TestSize.Level1)256 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandlePalmEvent, TestSize.Level1)
257 {
258     CALL_TEST_DEBUG;
259     EventNormalizeHandler handler;
260     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
261     ASSERT_NE(pointerEvent, nullptr);
262     vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
263     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 2220);
264     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 727);
265     vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
266     vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
267     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 715);
268 
269     libinput_event *event = libinput_.Dispatch();
270     ASSERT_TRUE(event != nullptr);
271     struct libinput_device *dev = libinput_event_get_device(event);
272     ASSERT_TRUE(dev != nullptr);
273     std::cout << "touchpad device: " << libinput_device_get_name(dev) << std::endl;
274     EXPECT_NO_FATAL_FAILURE(handler.HandlePalmEvent(event, pointerEvent));
275 }
276 
277 /**
278  * @tc.name: EventNormalizeHandlerTest_HandleTouchEvent
279  * @tc.desc: Test the function HandleTouchEvent
280  * @tc.type: FUNC
281  * @tc.require:
282  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent, TestSize.Level1)283 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent, TestSize.Level1)
284 {
285     CALL_TEST_DEBUG;
286     EventNormalizeHandler handler;
287     int64_t frameTime = 10000;
288     vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
289     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 958);
290     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 896);
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, 712);
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     handler.nextHandler_ = std::make_shared<EventFilterHandler>();
301     handler.SetNext(handler.nextHandler_);
302     ASSERT_NE(handler.HandleTouchEvent(event, frameTime), RET_OK);
303 }
304 
305 /**
306  * @tc.name: EventNormalizeHandlerTest_ResetTouchUpEvent
307  * @tc.desc: Test the function ResetTouchUpEvent
308  * @tc.type: FUNC
309  * @tc.require:
310  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ResetTouchUpEvent, TestSize.Level1)311 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ResetTouchUpEvent, TestSize.Level1)
312 {
313     CALL_TEST_DEBUG;
314     EventNormalizeHandler handler;
315     vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
316     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 729);
317     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 562);
318     vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
319     vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
320     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 711);
321 
322     libinput_event *event = libinput_.Dispatch();
323     ASSERT_TRUE(event != nullptr);
324     struct libinput_device *dev = libinput_event_get_device(event);
325     ASSERT_TRUE(dev != nullptr);
326     std::cout << "touchpad device: " << libinput_device_get_name(dev) << std::endl;
327     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
328     ASSERT_NE(pointerEvent, nullptr);
329     EXPECT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, event));
330     PointerEvent::PointerItem item;
331     item.SetPointerId(1);
332     pointerEvent->AddPointerItem(item);
333     EXPECT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, event));
334 }
335 
336 /**
337  * @tc.name: EventNormalizeHandlerTest_TerminateAxis
338  * @tc.desc: Test the function TerminateAxis
339  * @tc.type: FUNC
340  * @tc.require:
341  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_TerminateAxis, TestSize.Level1)342 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_TerminateAxis, TestSize.Level1)
343 {
344     CALL_TEST_DEBUG;
345     EventNormalizeHandler handler;
346     vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, ++trackingID_);
347     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 723);
348     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 693);
349     vTouchpad_.SendEvent(EV_ABS, ABS_MT_TOOL_TYPE, 2);
350     vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
351     vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 710);
352 
353     libinput_event *event = libinput_.Dispatch();
354     ASSERT_TRUE(event != nullptr);
355     struct libinput_device *dev = libinput_event_get_device(event);
356     ASSERT_TRUE(dev != nullptr);
357     std::cout << "touchpad device: " << libinput_device_get_name(dev) << std::endl;
358     handler.nextHandler_ = std::make_shared<EventFilterHandler>();
359     handler.SetNext(handler.nextHandler_);
360     EXPECT_NO_FATAL_FAILURE(handler.TerminateAxis(event));
361 }
362 
363 /**
364  * @tc.name: EventNormalizeHandlerTest_ProcessNullEvent_002
365  * @tc.desc: Test the function ProcessNullEvent
366  * @tc.type: FUNC
367  * @tc.require:
368  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_002, TestSize.Level1)369 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_002, TestSize.Level1)
370 {
371     EventNormalizeHandler handler;
372     int64_t frameTime = 100;
373     libinput_event* event = nullptr;
374     EventResampleHdr->pointerEvent_ = PointerEvent::Create();
375     MMISceneBoardJudgement judgement;
376     judgement.IsSceneBoardEnabled();
377     judgement.IsResampleEnabled();
378     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
379     ASSERT_NE(pointerEvent, nullptr);
380     pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
381     bool ret = handler.ProcessNullEvent(event, frameTime);
382     ASSERT_FALSE(ret);
383     pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHPAD;
384     ret = handler.ProcessNullEvent(event, frameTime);
385     ASSERT_FALSE(ret);
386     pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_JOYSTICK;
387     ret = handler.ProcessNullEvent(event, frameTime);
388     ASSERT_FALSE(ret);
389     EventResampleHdr->pointerEvent_ = nullptr;
390     ret = handler.ProcessNullEvent(event, frameTime);
391     ASSERT_FALSE(ret);
392 }
393 
394 #ifdef OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
395 /**
396  * @tc.name: EventNormalizeHandlerTest_SetMoveEventFilters_001
397  * @tc.desc: Set moveEventFilterFlag_
398  * @tc.type: FUNC
399  * @tc.require:SR000HQ0RR
400  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetMoveEventFilters_001, TestSize.Level1)401 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetMoveEventFilters_001, TestSize.Level1)
402 {
403     EventNormalizeHandler eventNormalizeHandler;
404     bool flag = true;
405     int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
406     ASSERT_EQ(ret, RET_OK);
407 }
408 
409 /**
410  * @tc.name: EventNormalizeHandlerTest_SetMoveEventFilters_002
411  * @tc.desc: Set moveEventFilterFlag_
412  * @tc.type: FUNC
413  * @tc.require:SR000HQ0RR
414  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetMoveEventFilters_002, TestSize.Level1)415 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetMoveEventFilters_002, TestSize.Level1)
416 {
417     EventNormalizeHandler eventNormalizeHandler;
418     bool flag = false;
419     int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
420     ASSERT_EQ(ret, RET_OK);
421 }
422 
423 /**
424  * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_001
425  * @tc.desc: Handle Touch Event
426  * @tc.type: FUNC
427  * @tc.require:SR000HQ0RR
428  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_001, TestSize.Level1)429 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_001, TestSize.Level1)
430 {
431     EventNormalizeHandler eventNormalizeHandler;
432     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
433     ASSERT_NE(pointerEvent, nullptr);
434     bool flag = true;
435     int32_t ret = eventNormalizeHandler.SetMoveEventFilters(flag);
436     ASSERT_EQ(ret, RET_OK);
437     PointerEvent::PointerItem item1;
438     item1.SetPointerId(0);
439     item1.SetDisplayX(0);
440     item1.SetDisplayY(0);
441     pointerEvent->SetPointerId(0);
442     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
443     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
444     pointerEvent->AddPointerItem(item1);
445     flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
446     ASSERT_FALSE(flag);
447 
448     pointerEvent->RemovePointerItem(0);
449     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
450     PointerEvent::PointerItem item2;
451     item2.SetPointerId(0);
452     item2.SetDisplayX(0);
453     item2.SetDisplayY(0);
454     pointerEvent->AddPointerItem(item2);
455     flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
456     ASSERT_TRUE(flag);
457 }
458 
459 /**
460  * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_002
461  * @tc.desc: Handle Touch Event
462  * @tc.type: FUNC
463  * @tc.require:SR000HQ0RR
464  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_002, TestSize.Level1)465 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_002, 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(1);
490     pointerEvent->AddPointerItem(item2);
491     flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
492     ASSERT_FALSE(flag);
493 }
494 
495 /**
496  * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_003
497  * @tc.desc: Handle Touch Event
498  * @tc.type: FUNC
499  * @tc.require:SR000HQ0RR
500  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_003, TestSize.Level1)501 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_003, 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(2);
526     pointerEvent->AddPointerItem(item2);
527     flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
528     ASSERT_FALSE(flag);
529 }
530 
531 /**
532  * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_004
533  * @tc.desc: Handle Touch Event
534  * @tc.type: FUNC
535  * @tc.require:SR000HQ0RR
536  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_004, TestSize.Level1)537 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_004, TestSize.Level1)
538 {
539     EventNormalizeHandler eventNormalizeHandler;
540     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
541     ASSERT_NE(pointerEvent, nullptr);
542     bool flag = false;
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(0);
562     pointerEvent->AddPointerItem(item2);
563     flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
564     ASSERT_FALSE(flag);
565 }
566 
567 /**
568  * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_005
569  * @tc.desc: Handle Touch Event
570  * @tc.type: FUNC
571  * @tc.require:SR000HQ0RR
572  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_005, TestSize.Level1)573 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_005, 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(1);
598     pointerEvent->AddPointerItem(item2);
599     flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
600     ASSERT_FALSE(flag);
601 }
602 
603 /**
604  * @tc.name: EventNormalizeHandlerTest_HandleTouchEventWithFlag_006
605  * @tc.desc: Handle Touch Event
606  * @tc.type: FUNC
607  * @tc.require:SR000HQ0RR
608  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_006, TestSize.Level1)609 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEventWithFlag_006, 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(2);
634     pointerEvent->AddPointerItem(item2);
635     flag = eventNormalizeHandler.HandleTouchEventWithFlag(pointerEvent);
636     ASSERT_FALSE(flag);
637 }
638 
639 /**
640  * @tc.name: EventNormalizeHandlerTest_CalcTouchOffset_001
641  * @tc.desc: Determine whether the touch produces displacement
642  * @tc.type: FUNC
643  * @tc.require:SR000HQ0RR
644  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_CalcTouchOffset_001, TestSize.Level1)645 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_CalcTouchOffset_001, TestSize.Level1)
646 {
647     EventNormalizeHandler eventNormalizeHandler;
648     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
649     ASSERT_NE(pointerEvent, nullptr);
650     double offSet = eventNormalizeHandler.CalcTouchOffset(pointerEvent);
651     ASSERT_EQ(offSet, 0.f);
652 }
653 
654 /**
655  * @tc.name: EventNormalizeHandlerTest_CalcTouchOffset_002
656  * @tc.desc: Determine whether the touch produces displacement
657  * @tc.type: FUNC
658  * @tc.require:SR000HQ0RR
659  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_CalcTouchOffset_002, TestSize.Level1)660 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_CalcTouchOffset_002, TestSize.Level1)
661 {
662     EventNormalizeHandler eventNormalizeHandler;
663     PointerEvent::PointerItem item1;
664     item1.SetPointerId(0);
665     item1.SetDisplayX(0);
666     item1.SetDisplayY(0);
667     eventNormalizeHandler.lastTouchDownItems_.push_back(item1);
668     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
669     ASSERT_NE(pointerEvent, nullptr);
670     PointerEvent::PointerItem item2;
671     item2.SetPointerId(0);
672     item2.SetDisplayX(0);
673     item2.SetDisplayY(1);
674     pointerEvent->AddPointerItem(item2);
675     double offSet = eventNormalizeHandler.CalcTouchOffset(pointerEvent);
676     ASSERT_EQ(offSet, 1.f);
677 }
678 #endif // #ifdef OHOS_BUILD_ENABLE_MOVE_EVENT_FILTERS
679 
680 /**
681  * @tc.name: EventNormalizeHandlerTest_AddHandleTimer_001
682  * @tc.desc: Add handlerTimer
683  * @tc.type: FUNC
684  * @tc.require:SR000HQ0RR
685  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_AddHandleTimer_001, TestSize.Level1)686 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_AddHandleTimer_001, TestSize.Level1)
687 {
688     EventNormalizeHandler eventNormalizeHandler;
689     const int32_t timeOut = 400;
690     int32_t timeId = eventNormalizeHandler.AddHandleTimer(timeOut);
691     ASSERT_NE(timeId, -1);
692 }
693 
694 /**
695  * @tc.name: EventNormalizeHandlerTest_HandleSwitchInputEvent_001
696  * @tc.desc: Handle Switch Input Event
697  * @tc.type: FUNC
698  * @tc.require:SR000HQ0RR
699  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleSwitchInputEvent_001, TestSize.Level1)700 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleSwitchInputEvent_001, TestSize.Level1)
701 {
702     EventNormalizeHandler eventNormalizeHandler;
703     libinput_event *event = nullptr;
704     int32_t ret = eventNormalizeHandler.HandleSwitchInputEvent(event);
705     ASSERT_EQ(ret, ERROR_UNSUPPORT);
706 }
707 
708 /**
709  * @tc.name: EventNormalizeHandlerTest_HandleJoystickEvent_001
710  * @tc.desc: Handle Joystick Event
711  * @tc.type: FUNC
712  * @tc.require:SR000HQ0RR
713  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleJoystickEvent_001, TestSize.Level1)714 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleJoystickEvent_001, TestSize.Level1)
715 {
716     EventNormalizeHandler eventNormalizeHandler;
717     libinput_event *event = nullptr;
718     int32_t ret = eventNormalizeHandler.HandleJoystickEvent(event);
719     ASSERT_EQ(ret, ERROR_UNSUPPORT);
720 }
721 
722 /**
723  * @tc.name: EventNormalizeHandlerTest_HandleTableToolEvent_001
724  * @tc.desc: Handle TableTool Event
725  * @tc.type: FUNC
726  * @tc.require:SR000HQ0RR
727  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTableToolEvent_001, TestSize.Level1)728 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTableToolEvent_001, TestSize.Level1)
729 {
730     EventNormalizeHandler eventNormalizeHandler;
731     libinput_event *event = nullptr;
732     int32_t ret = eventNormalizeHandler.HandleTableToolEvent(event);
733     ASSERT_EQ(ret, ERROR_UNSUPPORT);
734 }
735 
736 /**
737  * @tc.name: EventNormalizeHandlerTest_HandleTouchEvent_002
738  * @tc.desc: Handle touch event
739  * @tc.type: FUNC
740  * @tc.require:SR000HQ0RR
741  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent_002, TestSize.Level1)742 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent_002, TestSize.Level1)
743 {
744     EventNormalizeHandler eventNormalizeHandler;
745     libinput_event *event = nullptr;
746     int64_t frameTime = 50;
747     int32_t ret = eventNormalizeHandler.HandleTouchEvent(event, frameTime);
748     ASSERT_EQ(ret, ERROR_UNSUPPORT);
749 }
750 
751 /**
752  * @tc.name: EventNormalizeHandlerTest_HandleGestureEvent_001
753  * @tc.desc: Handle Gesture Event
754  * @tc.type: FUNC
755  * @tc.require:SR000HQ0RR
756  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleGestureEvent_001, TestSize.Level1)757 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleGestureEvent_001, TestSize.Level1)
758 {
759     EventNormalizeHandler eventNormalizeHandler;
760     libinput_event *event = nullptr;
761     int32_t ret = eventNormalizeHandler.HandleGestureEvent(event);
762     ASSERT_EQ(ret, ERROR_UNSUPPORT);
763 }
764 
765 /**
766  * @tc.name: EventNormalizeHandlerTest_HandleTouchPadEvent_001
767  * @tc.desc: Handle TouchPadEvent
768  * @tc.type: FUNC
769  * @tc.require:SR000HQ0RR
770  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchPadEvent_001, TestSize.Level1)771 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchPadEvent_001, TestSize.Level1)
772 {
773     EventNormalizeHandler eventNormalizeHandler;
774     libinput_event *event = nullptr;
775     int32_t ret = eventNormalizeHandler.HandleTouchPadEvent(event);
776     ASSERT_EQ(ret, ERROR_UNSUPPORT);
777 }
778 
779 /**
780  * @tc.name: EventNormalizeHandlerTest_HandleMouseEvent_001
781  * @tc.desc: Handle mouseEvent
782  * @tc.type: FUNC
783  * @tc.require:SR000HQ0RR
784  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleMouseEvent_001, TestSize.Level1)785 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleMouseEvent_001, TestSize.Level1)
786 {
787     EventNormalizeHandler eventNormalizeHandler;
788     libinput_event *event = nullptr;
789     int32_t ret = eventNormalizeHandler.HandleMouseEvent(event);
790     ASSERT_EQ(ret, ERROR_UNSUPPORT);
791 }
792 
793 /**
794  * @tc.name: EventNormalizeHandlerTest_OnEventDeviceRemoved_001
795  * @tc.desc: OnEvent device removed
796  * @tc.type: FUNC
797  * @tc.require:SR000HQ0RR
798  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_OnEventDeviceRemoved_001, TestSize.Level1)799 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_OnEventDeviceRemoved_001, TestSize.Level1)
800 {
801     EventNormalizeHandler eventNormalizeHandler;
802     libinput_event *event = nullptr;
803     int32_t ret = eventNormalizeHandler.OnEventDeviceRemoved(event);
804     ASSERT_EQ(ret, ERROR_NULL_POINTER);
805 }
806 
807 /**
808  * @tc.name: EventNormalizeHandlerTest_ProcessNullEvent_003
809  * @tc.desc: Process nullEvent
810  * @tc.type: FUNC
811  * @tc.require:SR000HQ0RR
812  */
HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_003, TestSize.Level1)813 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_003, TestSize.Level1)
814 {
815     EventNormalizeHandler eventNormalizeHandler;
816     libinput_event *event = nullptr;
817     int64_t frametime = 30;
818     bool flag = eventNormalizeHandler.ProcessNullEvent(event, frametime);
819     ASSERT_FALSE(flag);
820 }
821 } // namespace MMI
822 } // namespace OHOS