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 #include <sys/stat.h>
19 #include <unistd.h>
20
21 #include <cinttypes>
22 #include <cstdio>
23 #include <cstring>
24 #include <functional>
25 #include <vector>
26
27 #include "general_touchpad.h"
28 #include "input_device_manager.h"
29 #include "input_event_handler.h"
30 #include "i_input_windows_manager.h"
31 #include "key_command_handler.h"
32 #include "libinput_wrapper.h"
33 #include "mmi_log.h"
34 #include "timer_manager.h"
35 #include "util.h"
36
37 #undef MMI_LOG_TAG
38 #define MMI_LOG_TAG "InputEventHandlerTest"
39 namespace OHOS {
40 namespace MMI {
41 namespace {
42 using namespace testing::ext;
43 } // namespace
44
45 class InputEventHandlerTest : public testing::Test {
46 public:
47 static void SetUpTestCase(void);
48 static void TearDownTestCase(void);
49 void SetUp();
50 void TearDown();
51
52 private:
53 static void SetupTouchpad();
54 static void CloseTouchpad();
55 static GeneralTouchpad vTouchpad_;
56 static LibinputWrapper libinput_;
57 };
58
59 GeneralTouchpad InputEventHandlerTest::vTouchpad_;
60 LibinputWrapper InputEventHandlerTest::libinput_;
61
SetUpTestCase(void)62 void InputEventHandlerTest::SetUpTestCase(void)
63 {
64 ASSERT_TRUE(libinput_.Init());
65 SetupTouchpad();
66 }
67
TearDownTestCase(void)68 void InputEventHandlerTest::TearDownTestCase(void)
69 {
70 CloseTouchpad();
71 }
72
SetupTouchpad()73 void InputEventHandlerTest::SetupTouchpad()
74 {
75 ASSERT_TRUE(vTouchpad_.SetUp());
76 std::cout << "device node name: " << vTouchpad_.GetDevPath() << std::endl;
77 ASSERT_TRUE(libinput_.AddPath(vTouchpad_.GetDevPath()));
78 libinput_event *event = libinput_.Dispatch();
79 ASSERT_TRUE(event != nullptr);
80 ASSERT_EQ(libinput_event_get_type(event), LIBINPUT_EVENT_DEVICE_ADDED);
81 struct libinput_device *device = libinput_event_get_device(event);
82 ASSERT_TRUE(device != nullptr);
83 INPUT_DEV_MGR->OnInputDeviceAdded(device);
84 }
85
CloseTouchpad()86 void InputEventHandlerTest::CloseTouchpad()
87 {
88 libinput_.RemovePath(vTouchpad_.GetDevPath());
89 vTouchpad_.Close();
90 }
91
SetUp()92 void InputEventHandlerTest::SetUp()
93 {
94 }
95
TearDown()96 void InputEventHandlerTest::TearDown()
97 {
98 }
99
100 /**
101 * @tc.name: InputEventHandler_GetEventDispatchHandler_001
102 * @tc.desc: Get event dispatch handler verify
103 * @tc.type: FUNC
104 * @tc.require:SR000HQ0RR
105 */
106 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_GetEventDispatchHandler_001, TestSize.Level1)
107 {
108 CALL_DEBUG_ENTER;
109 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
110 auto result = inputHandler->GetEventDispatchHandler();
111 ASSERT_EQ(result, nullptr);
112 }
113
114 /**
115 * @tc.name: InputEventHandler_GetFilterHandler_001
116 * @tc.desc: Get filter handler verify
117 * @tc.type: FUNC
118 * @tc.require:SR000HQ0RR
119 */
120 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_GetFilterHandler_001, TestSize.Level1)
121 {
122 CALL_DEBUG_ENTER;
123 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
124 auto result = inputHandler->GetFilterHandler();
125 ASSERT_EQ(result, nullptr);
126 }
127
128 /**
129 * @tc.name: InputEventHandler_GetMonitorHandler_001
130 * @tc.desc: Get monitor handler verify
131 * @tc.type: FUNC
132 * @tc.require:SR000HQ0RR
133 */
134 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_GetMonitorHandler_001, TestSize.Level1)
135 {
136 CALL_DEBUG_ENTER;
137 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
138 auto result = inputHandler->GetMonitorHandler();
139 ASSERT_EQ(result, nullptr);
140 }
141
142 /**
143 * @tc.name: InputEventHandler_GetKeyCommandHandler_001
144 * @tc.desc: Get monitor handler verify
145 * @tc.type: FUNC
146 * @tc.require:SR000HQ0RR
147 */
148 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_GetKeyCommandHandler_001, TestSize.Level1)
149 {
150 CALL_DEBUG_ENTER;
151 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
152 auto result = inputHandler->GetKeyCommandHandler();
153 ASSERT_EQ(result, nullptr);
154 }
155
156 /**
157 * @tc.name: InputEventHandler_GetSwitchSubscriberHandler_001
158 * @tc.desc: Get switch subscriber handler verify
159 * @tc.type: FUNC
160 * @tc.require:SR000HQ0RR
161 */
162 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_GetSwitchSubscriberHandler_001, TestSize.Level1)
163 {
164 CALL_DEBUG_ENTER;
165 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
166 auto result = inputHandler->GetSwitchSubscriberHandler();
167 ASSERT_EQ(result, nullptr);
168 }
169
170 /**
171 * @tc.name: InputEventHandler_GetSubscriberHandler_001
172 * @tc.desc: Get subscriber handler verify
173 * @tc.type: FUNC
174 * @tc.require:SR000HQ0RR
175 */
176 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_GetSubscriberHandler_001, TestSize.Level1)
177 {
178 CALL_DEBUG_ENTER;
179 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
180 auto result = inputHandler->GetSubscriberHandler();
181 ASSERT_EQ(result, nullptr);
182 }
183
184 /**
185 * @tc.name: InputEventHandler_GetInterceptorHandler_001
186 * @tc.desc: Get interceptor handler verify
187 * @tc.type: FUNC
188 * @tc.require:SR000HQ0RR
189 */
190 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_GetInterceptorHandler_001, TestSize.Level1)
191 {
192 CALL_DEBUG_ENTER;
193 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
194 auto result = inputHandler->GetInterceptorHandler();
195 ASSERT_EQ(result, nullptr);
196 }
197
198 /**
199 * @tc.name: InputEventHandler_GetEventNormalizeHandler_001
200 * @tc.desc: Get eventNormalize handler verify
201 * @tc.type: FUNC
202 * @tc.require:SR000HQ0RR
203 */
204 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_GetEventNormalizeHandler_001, TestSize.Level1)
205 {
206 CALL_DEBUG_ENTER;
207 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
208 auto result = inputHandler->GetEventNormalizeHandler();
209 ASSERT_EQ(result, nullptr);
210 }
211
212 /**
213 * @tc.name: InputEventHandler_GetUDSServer_001
214 * @tc.desc: Get UDS server verify
215 * @tc.type: FUNC
216 * @tc.require:SR000HQ0RR
217 */
218 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_GetUDSServer_001, TestSize.Level1)
219 {
220 CALL_DEBUG_ENTER;
221 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
222 auto result = inputHandler->GetUDSServer();
223 ASSERT_EQ(result, nullptr);
224 }
225
226 /**
227 * @tc.name: InputEventHandler_BuildInputHandlerChain_001
228 * @tc.desc: Build input handler chain verify
229 * @tc.type: FUNC
230 * @tc.require:SR000HQ0RR
231 */
232 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_BuildInputHandlerChain_001, TestSize.Level1)
233 {
234 CALL_DEBUG_ENTER;
235 UDSServer udsServer;
236 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
237 ASSERT_NO_FATAL_FAILURE(inputHandler->Init(udsServer));
238 }
239
240 /**
241 * @tc.name: InputEventHandler_OnEvent_001
242 * @tc.desc: On event verify
243 * @tc.type: FUNC
244 * @tc.require:SR000HQ0RR
245 */
246 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_OnEvent_001, TestSize.Level1)
247 {
248 CALL_DEBUG_ENTER;
249 void* mockEvent = nullptr;
250 int64_t mockFrameTime = 123456789;
251 std::shared_ptr<OHOS::MMI::InputEventHandler> inputHandler = InputHandler;
252 ASSERT_NO_FATAL_FAILURE(inputHandler->OnEvent(mockEvent, mockFrameTime));
253 }
254
255 /**
256 * @tc.name: InputEventHandler_OnEvent_002
257 * @tc.desc: Test the funcation OnEvent
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_OnEvent_002, TestSize.Level1)
262 {
263 InputEventHandler inputEventHandler ;
264 void *event = nullptr;
265 int64_t frameTime = 1234;
266 inputEventHandler.eventNormalizeHandler_ = nullptr;
267 ASSERT_NO_FATAL_FAILURE(inputEventHandler.OnEvent(event, frameTime));
268 }
269
270 /**
271 * @tc.name: InputEventHandler_OnEvent_003
272 * @tc.desc: Test the funcation OnEvent
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_OnEvent_003, TestSize.Level1)
277 {
278 InputEventHandler inputEventHandler ;
279 void *event = nullptr;
280 int64_t frameTime = 1234;
281 inputEventHandler.eventNormalizeHandler_ = std::make_shared<EventNormalizeHandler>();
282 ASSERT_TRUE(inputEventHandler.eventNormalizeHandler_ != nullptr);
283 ASSERT_NO_FATAL_FAILURE(inputEventHandler.OnEvent(event, frameTime));
284 }
285
286 /**
287 * @tc.name: InputEventHandler_OnEvent_004
288 * @tc.desc: Test the funcation OnEvent
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_OnEvent_004, TestSize.Level1)
293 {
294 InputEventHandler inputEventHandler ;
295 int64_t frameTime = 1234;
296 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, 185);
297 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 1511);
298 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 384);
299 vTouchpad_.SendEvent(EV_KEY, BTN_TOUCH, 1);
300 vTouchpad_.SendEvent(EV_KEY, BTN_TOOL_FINGER, 1);
301 vTouchpad_.SendEvent(EV_ABS, ABS_X, 1511);
302 vTouchpad_.SendEvent(EV_ABS, ABS_Y, 384);
303 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 0);
304 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
305 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 1510);
306 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 386);
307 vTouchpad_.SendEvent(EV_ABS, ABS_X, 1510);
308 vTouchpad_.SendEvent(EV_ABS, ABS_Y, 386);
309 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 42000);
310 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
311 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, -1);
312 vTouchpad_.SendEvent(EV_KEY, BTN_TOUCH, 0);
313 vTouchpad_.SendEvent(EV_KEY, BTN_TOOL_FINGER, 0);
314 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 123000);
315 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
316 inputEventHandler.eventNormalizeHandler_ = std::make_shared<EventNormalizeHandler>();
317 ASSERT_TRUE(inputEventHandler.eventNormalizeHandler_ != nullptr);
318 libinput_event *event = libinput_.Dispatch();
319 ASSERT_TRUE(event != nullptr);
320 struct libinput_device *dev = libinput_event_get_device(event);
321 ASSERT_TRUE(dev != nullptr);
322 std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
323 const uint64_t maxUInt64 = (std::numeric_limits<uint64_t>::max)() - 1;
324 inputEventHandler.idSeed_ = maxUInt64 + 1;
325 ASSERT_NO_FATAL_FAILURE(inputEventHandler.OnEvent(event, frameTime));
326 inputEventHandler.idSeed_ = 123;
327 ASSERT_NO_FATAL_FAILURE(inputEventHandler.OnEvent(event, frameTime));
328 }
329
330 /**
331 * @tc.name: InputEventHandler_IsTouchpadMistouch_001
332 * @tc.desc: Test the funcation IsTouchpadMistouch
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_IsTouchpadMistouch_001, TestSize.Level1)
337 {
338 InputEventHandler inputEventHandler ;
339 libinput_event* event = nullptr;
340 bool ret = inputEventHandler.IsTouchpadMistouch(event);
341 ASSERT_FALSE(ret);
342 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, 185);
343 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 1511);
344 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 384);
345 vTouchpad_.SendEvent(EV_KEY, BTN_TOUCH, 1);
346 vTouchpad_.SendEvent(EV_KEY, BTN_TOOL_FINGER, 1);
347 vTouchpad_.SendEvent(EV_ABS, ABS_X, 1511);
348 vTouchpad_.SendEvent(EV_ABS, ABS_Y, 384);
349 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 0);
350 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
351 event = libinput_.Dispatch();
352 ASSERT_TRUE(event != nullptr);
353 auto touchpad = libinput_event_get_touchpad_event(event);
354 ASSERT_TRUE(touchpad != nullptr);
355 auto type = libinput_event_get_type(event);
356 ASSERT_FALSE(ret);
357 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 1510);
358 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 386);
359 vTouchpad_.SendEvent(EV_ABS, ABS_X, 1510);
360 vTouchpad_.SendEvent(EV_ABS, ABS_Y, 386);
361 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 42000);
362 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
363 event = libinput_.Dispatch();
364 ASSERT_TRUE(event != nullptr);
365 touchpad = libinput_event_get_touchpad_event(event);
366 ASSERT_TRUE(touchpad != nullptr);
367 type = libinput_event_get_type(event);
368 ASSERT_FALSE(ret);
369 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, -1);
370 vTouchpad_.SendEvent(EV_KEY, BTN_TOUCH, 0);
371 vTouchpad_.SendEvent(EV_KEY, BTN_TOOL_FINGER, 0);
372 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 123000);
373 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
374 event = libinput_.Dispatch();
375 ASSERT_TRUE(event != nullptr);
376 touchpad = libinput_event_get_touchpad_event(event);
377 type = libinput_event_get_type(event);
378 ASSERT_FALSE(ret);
379 }
380
381 /**
382 * @tc.name: InputEventHandler_IsTouchpadMistouch_002
383 * @tc.desc: Test the funcation IsTouchpadMistouch
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_IsTouchpadMistouch_002, TestSize.Level1)
388 {
389 InputEventHandler inputEventHandler ;
390 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, 189);
391 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 10);
392 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 1050);
393 vTouchpad_.SendEvent(EV_KEY, BTN_TOUCH, 1);
394 vTouchpad_.SendEvent(EV_KEY, BTN_TOOL_FINGER, 1);
395 vTouchpad_.SendEvent(EV_ABS, ABS_X, 10);
396 vTouchpad_.SendEvent(EV_ABS, ABS_Y, 1050);
397 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 0);
398 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
399 libinput_event *event = libinput_.Dispatch();
400 ASSERT_TRUE(event != nullptr);
401 auto touchpad = libinput_event_get_touchpad_event(event);
402 auto type = libinput_event_get_type(event);
403 bool ret = inputEventHandler.IsTouchpadMistouch(event);
404 ASSERT_FALSE(ret);
405 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 1510);
406 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 386);
407 vTouchpad_.SendEvent(EV_ABS, ABS_X, 1510);
408 vTouchpad_.SendEvent(EV_ABS, ABS_Y, 386);
409 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 42000);
410 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
411 event = libinput_.Dispatch();
412 ASSERT_TRUE(event != nullptr);
413 touchpad = libinput_event_get_touchpad_event(event);
414 ASSERT_TRUE(touchpad != nullptr);
415 type = libinput_event_get_type(event);
416 ASSERT_FALSE(ret);
417 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, -1);
418 vTouchpad_.SendEvent(EV_KEY, BTN_TOUCH, 0);
419 vTouchpad_.SendEvent(EV_KEY, BTN_TOOL_FINGER, 0);
420 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 362000);
421 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
422 event = libinput_.Dispatch();
423 ASSERT_TRUE(event != nullptr);
424 touchpad = libinput_event_get_touchpad_event(event);
425 ASSERT_TRUE(touchpad != nullptr);
426 type = libinput_event_get_type(event);
427 ASSERT_FALSE(ret);
428 }
429
430 /**
431 * @tc.name: InputEventHandler_IsTouchpadTapMistouch_001
432 * @tc.desc: Test the funcation IsTouchpadTapMistouch
433 * @tc.type: FUNC
434 * @tc.require:
435 */
436 HWTEST_F(InputEventHandlerTest, InputEventHandlerTest_IsTouchpadTapMistouch_001, TestSize.Level1)
437 {
438 InputEventHandler inputEventHandler ;
439 libinput_event* event = nullptr;
440 bool ret = inputEventHandler.IsTouchpadTapMistouch(event);
441 ASSERT_FALSE(ret);
442 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, 189);
443 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 10);
444 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 1050);
445 vTouchpad_.SendEvent(EV_KEY, BTN_TOUCH, 1);
446 vTouchpad_.SendEvent(EV_KEY, BTN_TOOL_FINGER, 1);
447 vTouchpad_.SendEvent(EV_ABS, ABS_X, 10);
448 vTouchpad_.SendEvent(EV_ABS, ABS_Y, 1050);
449 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 0);
450 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
451 event = libinput_.Dispatch();
452 ASSERT_TRUE(event != nullptr);
453 ASSERT_FALSE(ret);
454 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 1510);
455 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 386);
456 vTouchpad_.SendEvent(EV_ABS, ABS_X, 1510);
457 vTouchpad_.SendEvent(EV_ABS, ABS_Y, 386);
458 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 42000);
459 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
460 event = libinput_.Dispatch();
461 ASSERT_TRUE(event != nullptr);
462 ASSERT_FALSE(ret);
463 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, -1);
464 vTouchpad_.SendEvent(EV_KEY, BTN_TOUCH, 0);
465 vTouchpad_.SendEvent(EV_KEY, BTN_TOOL_FINGER, 0);
466 vTouchpad_.SendEvent(EV_MSC, MSC_TIMESTAMP, 362000);
467 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
468 event = libinput_.Dispatch();
469 ASSERT_TRUE(event != nullptr);
470 ASSERT_FALSE(ret);
471 }
472 } // namespace MMI
473 } // namespace OHOS