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 #include <libinput.h>
18 
19 #include "dfx_hisysevent.h"
20 #include "event_filter_handler.h"
21 #include "event_normalize_handler.h"
22 #include "event_resample.h"
23 #include "i_input_windows_manager.h"
24 #include "input_scene_board_judgement.h"
25 #include "input_device_manager.h"
26 #include "touchpad_transform_processor.h"
27 
28 #include "libinput-private.h"
29 
30 namespace OHOS {
31 namespace MMI {
32 namespace {
33 using namespace testing::ext;
34 } // namespace
35 
36 class EventNormalizeHandlerTest : public testing::Test {
37 public:
SetUpTestCase(void)38     static void SetUpTestCase(void) {}
TearDownTestCase(void)39     static void TearDownTestCase(void) {}
40 };
41 
42 /**
43  * @tc.name: EventNormalizeHandlerTest_HandleEvent_002
44  * @tc.desc: Test the function HandleEvent
45  * @tc.type: FUNC
46  * @tc.require:
47  */
48 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleEvent_002, TestSize.Level1)
49 {
50     EventNormalizeHandler handler;
51     int64_t frameTime = 10000;
52     libinput_event* event = new (std::nothrow) libinput_event;
53     ASSERT_NE(event, nullptr);
54     event->type = LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN;
55     handler.HandleEvent(event, frameTime);
56     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
57     event->type = LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE;
58     handler.HandleEvent(event, frameTime);
59     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
60     event->type = LIBINPUT_EVENT_GESTURE_SWIPE_END;
61     handler.HandleEvent(event, frameTime);
62     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
63     event->type = LIBINPUT_EVENT_GESTURE_PINCH_UPDATE;
64     handler.HandleEvent(event, frameTime);
65     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
66     event->type = LIBINPUT_EVENT_GESTURE_PINCH_END;
67     handler.HandleEvent(event, frameTime);
68     ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(event));
69     event->type = LIBINPUT_EVENT_TOUCH_DOWN;
70     handler.HandleEvent(event, frameTime);
71     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
72     event->type = LIBINPUT_EVENT_TOUCH_UP;
73     handler.HandleEvent(event, frameTime);
74     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
75     event->type = LIBINPUT_EVENT_TOUCH_MOTION;
76     handler.HandleEvent(event, frameTime);
77     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(event, frameTime));
78     event->type = LIBINPUT_EVENT_TABLET_TOOL_AXIS;
79     handler.HandleEvent(event, frameTime);
80     ASSERT_NO_FATAL_FAILURE(handler.HandleTableToolEvent(event));
81     event->type = LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY;
82     handler.HandleEvent(event, frameTime);
83     ASSERT_NO_FATAL_FAILURE(handler.HandleTableToolEvent(event));
84     event->type = LIBINPUT_EVENT_TABLET_TOOL_TIP;
85     handler.HandleEvent(event, frameTime);
86     ASSERT_NO_FATAL_FAILURE(handler.HandleTableToolEvent(event));
87     event->type = LIBINPUT_EVENT_JOYSTICK_BUTTON;
88     handler.HandleEvent(event, frameTime);
89     ASSERT_NO_FATAL_FAILURE(handler.HandleJoystickEvent(event));
90     event->type = LIBINPUT_EVENT_JOYSTICK_AXIS;
91     handler.HandleEvent(event, frameTime);
92     ASSERT_NO_FATAL_FAILURE(handler.HandleJoystickEvent(event));
93     event->type = LIBINPUT_EVENT_SWITCH_TOGGLE;
94     handler.HandleEvent(event, frameTime);
95     ASSERT_NO_FATAL_FAILURE(handler.HandleSwitchInputEvent(event));
96 }
97 
98 /**
99  * @tc.name: EventNormalizeHandlerTest_ProcessNullEvent_001
100  * @tc.desc: Test the function ProcessNullEvent
101  * @tc.type: FUNC
102  * @tc.require:
103  */
104 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_001, TestSize.Level1)
105 {
106     EventNormalizeHandler handler;
107     int64_t frameTime = 10000;
108     libinput_event* event = nullptr;
109     EventResampleHdr->pointerEvent_ = PointerEvent::Create();
110     bool ret = handler.ProcessNullEvent(event, frameTime);
111     ASSERT_FALSE(ret);
112     event = new (std::nothrow) libinput_event;
113     ASSERT_NE(event, nullptr);
114     event->type = LIBINPUT_EVENT_NONE;
115     ret = handler.ProcessNullEvent(event, frameTime);
116     ASSERT_FALSE(ret);
117 }
118 
119 /**
120  * @tc.name: EventNormalizeHandlerTest_HandleKeyEvent_001
121  * @tc.desc: Test the function HandleKeyEvent
122  * @tc.type: FUNC
123  * @tc.require:
124  */
125 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleKeyEvent_001, TestSize.Level1)
126 {
127     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
128     ASSERT_NE(keyEvent, nullptr);
129     keyEvent->SetRepeat(true);
130     EventNormalizeHandler handler;
131     ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent));
132     keyEvent->SetRepeat(false);
133     ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent));
134 }
135 
136 /**
137  * @tc.name: EventNormalizeHandlerTest_HandlePointerEvent_001
138  * @tc.desc: Test the function HandlePointerEvent
139  * @tc.type: FUNC
140  * @tc.require:
141  */
142 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandlePointerEvent_001, TestSize.Level1)
143 {
144     auto pointerEvent = PointerEvent::Create();
145     ASSERT_NE(pointerEvent, nullptr);
146     EventNormalizeHandler handler;
147     handler.nextHandler_ = std::make_shared<EventFilterHandler>();
148     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
149     ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
150     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
151     ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
152     pointerEvent->SetPointerId(0);
153     PointerEvent::PointerItem item;
154     item.SetPointerId(0);
155     pointerEvent->UpdatePointerItem(0, item);
156     ASSERT_NO_FATAL_FAILURE(handler.HandlePointerEvent(pointerEvent));
157 }
158 
159 /**
160  * @tc.name: EventNormalizeHandlerTest_HandleTouchEvent_001
161  * @tc.desc: Test the function HandleTouchEvent
162  * @tc.type: FUNC
163  * @tc.require:
164  */
165 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleTouchEvent_001, TestSize.Level1)
166 {
167     auto pointerEvent = PointerEvent::Create();
168     ASSERT_NE(pointerEvent, nullptr);
169     EventNormalizeHandler handler;
170     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(pointerEvent));
171     pointerEvent = nullptr;
172     ASSERT_NO_FATAL_FAILURE(handler.HandleTouchEvent(pointerEvent));
173 }
174 
175 /**
176  * @tc.name: EventNormalizeHandlerTest_UpdateKeyEventHandlerChain_001
177  * @tc.desc: Test the function UpdateKeyEventHandlerChain
178  * @tc.type: FUNC
179  * @tc.require:
180  */
181 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_UpdateKeyEventHandlerChain_001, TestSize.Level1)
182 {
183     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
184     ASSERT_NE(keyEvent, nullptr);
185     EventNormalizeHandler handler;
186     ASSERT_NO_FATAL_FAILURE(handler.UpdateKeyEventHandlerChain(keyEvent));
187     keyEvent = nullptr;
188     ASSERT_NO_FATAL_FAILURE(handler.UpdateKeyEventHandlerChain(keyEvent));
189 }
190 
191 /**
192  * @tc.name: EventNormalizeHandlerTest_SetOriginPointerId_001
193  * @tc.desc: Test the function SetOriginPointerId
194  * @tc.type: FUNC
195  * @tc.require:
196  */
197 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_SetOriginPointerId_001, TestSize.Level1)
198 {
199     auto pointerEvent = PointerEvent::Create();
200     ASSERT_NE(pointerEvent, nullptr);
201     EventNormalizeHandler handler;
202     ASSERT_NO_FATAL_FAILURE(handler.SetOriginPointerId(pointerEvent));
203     pointerEvent = nullptr;
204     int32_t ret = handler.SetOriginPointerId(pointerEvent);
205     pointerEvent = nullptr;
206     ASSERT_EQ(ret, ERROR_NULL_POINTER);
207 }
208 
209 /**
210  * @tc.name: EventNormalizeHandlerTest_ProcessNullEvent_002
211  * @tc.desc: Test the function ProcessNullEvent
212  * @tc.type: FUNC
213  * @tc.require:
214  */
215 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_ProcessNullEvent_002, TestSize.Level1)
216 {
217     EventNormalizeHandler handler;
218     int64_t frameTime = 100;
219     libinput_event* event = nullptr;
220     EventResampleHdr->pointerEvent_ = PointerEvent::Create();
221     MMISceneBoardJudgement judgement;
222     judgement.IsSceneBoardEnabled();
223     judgement.IsResampleEnabled();
224     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
225     ASSERT_NE(pointerEvent, nullptr);
226     pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
227     bool ret = handler.ProcessNullEvent(event, frameTime);
228     ASSERT_FALSE(ret);
229     pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_TOUCHPAD;
230     ret = handler.ProcessNullEvent(event, frameTime);
231     ASSERT_FALSE(ret);
232     pointerEvent->sourceType_ = PointerEvent::SOURCE_TYPE_JOYSTICK;
233     ret = handler.ProcessNullEvent(event, frameTime);
234     ASSERT_FALSE(ret);
235     EventResampleHdr->pointerEvent_ = nullptr;
236     ret = handler.ProcessNullEvent(event, frameTime);
237     ASSERT_FALSE(ret);
238 }
239 
240 /**
241  * @tc.name: EventNormalizeHandlerTest_HandleEvent_001
242  * @tc.desc: Test the function HandleEvent
243  * @tc.type: FUNC
244  * @tc.require:
245  */
246 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleEvent_001, TestSize.Level1)
247 {
248     EventNormalizeHandler handler;
249     MultiFingersTapHandler processor;
250     int64_t frameTime = 100;
251     libinput_event* event = new (std::nothrow) libinput_event;
252     ASSERT_NE(event, nullptr);
253     event->type = LIBINPUT_EVENT_TOUCH_CANCEL;
254     handler.HandleEvent(event, frameTime);
255     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
256     event->type = LIBINPUT_EVENT_TOUCH_FRAME;
257     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
258     event->type = LIBINPUT_EVENT_POINTER_TAP;
259     processor.multiFingersState_ = MulFingersTap::TRIPLE_TAP;
260     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
261     processor.multiFingersState_ = MulFingersTap::NO_TAP;
262     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
263     event->type = LIBINPUT_EVENT_DEVICE_ADDED;
264     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
265     event->type = LIBINPUT_EVENT_DEVICE_REMOVED;
266     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
267     event->type = LIBINPUT_EVENT_KEYBOARD_KEY;
268     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
269     event->type = LIBINPUT_EVENT_POINTER_MOTION;
270     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
271     event->type = LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE;
272     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
273     event->type = LIBINPUT_EVENT_POINTER_BUTTON;
274     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
275     event->type = LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD;
276     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
277     event->type = LIBINPUT_EVENT_POINTER_AXIS;
278     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
279     event->type = LIBINPUT_EVENT_POINTER_TAP;
280     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
281     event->type = LIBINPUT_EVENT_POINTER_MOTION_TOUCHPAD;
282     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
283     event->type = LIBINPUT_EVENT_TOUCHPAD_DOWN;
284     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
285     event->type = LIBINPUT_EVENT_TOUCHPAD_UP;
286     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
287     event->type = LIBINPUT_EVENT_TOUCHPAD_MOTION;
288     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
289     event->type = LIBINPUT_EVENT_NONE;
290     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
291     event->type = LIBINPUT_EVENT_GESTURE_PINCH_BEGIN;
292     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
293     event->type = LIBINPUT_EVENT_GESTURE_SWIPE_END;
294     ASSERT_NO_FATAL_FAILURE(handler.HandleEvent(event, frameTime));
295 }
296 
297 /**
298  * @tc.name: EventNormalizeHandlerTest_HandleKeyboardEvent_001
299  * @tc.desc: Test the function HandleKeyboardEvent
300  * @tc.type: FUNC
301  * @tc.require:
302  */
303 HWTEST_F(EventNormalizeHandlerTest, EventNormalizeHandlerTest_HandleKeyboardEvent_001, TestSize.Level1)
304 {
305     EventNormalizeHandler handler;
306     libinput_event* event = nullptr;
307     ASSERT_NO_FATAL_FAILURE(handler.HandleKeyboardEvent(event));
308     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
309     ASSERT_NE(pointerEvent, nullptr);
310     pointerEvent->pressedKeys_.push_back(1);
311     pointerEvent->pressedKeys_.push_back(2);
312     pointerEvent->pressedKeys_.push_back(3);
313     pointerEvent->pressedKeys_.push_back(4);
314     ASSERT_NO_FATAL_FAILURE(handler.HandleKeyboardEvent(event));
315 }
316 } // namespace MMI
317 } // namespace OHOS