1 /*
2 * Copyright (c) 2025 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 <cstdio>
17 #include <gtest/gtest.h>
18
19 #include "general_mouse.h"
20 #include "libinput_interface.h"
21 #include "libinput_wrapper.h"
22 #include "multimodal_input_plugin_manager.h"
23
24 #undef MMI_LOG_TAG
25 #define MMI_LOG_TAG "MultimodalInputPluginManagerTest"
26 namespace OHOS {
27 namespace MMI {
28 namespace {
29 using namespace testing::ext;
30 } // namespace
31
32 const std::string PATH { "/system/lib64/multimodalinput/autorun" };
33
34 class MultimodalInputPluginManagerTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 static void SetupMouse();
39 static void CloseMouse();
40
41 void SetUp();
42 private:
43 std::shared_ptr<InputPluginManager> manager;
44 static LibinputWrapper libinput_;
45 static GeneralMouse vMouse_;
46 };
47
48 GeneralMouse MultimodalInputPluginManagerTest::vMouse_;
49 LibinputWrapper MultimodalInputPluginManagerTest::libinput_;
50
51
SetUpTestCase(void)52 void MultimodalInputPluginManagerTest::SetUpTestCase(void)
53 {
54 ASSERT_TRUE(libinput_.Init());
55 SetupMouse();
56 }
57
TearDownTestCase(void)58 void MultimodalInputPluginManagerTest::TearDownTestCase(void)
59 {
60 CloseMouse();
61 }
62
SetupMouse()63 void MultimodalInputPluginManagerTest::SetupMouse()
64 {
65 ASSERT_TRUE(vMouse_.SetUp());
66 std::cout << "device node name: " << vMouse_.GetDevPath() << std::endl;
67 ASSERT_TRUE(libinput_.AddPath(vMouse_.GetDevPath()));
68
69 libinput_event *event = libinput_.Dispatch();
70 ASSERT_TRUE(event != nullptr);
71 ASSERT_EQ(libinput_event_get_type(event), LIBINPUT_EVENT_DEVICE_ADDED);
72 }
73
CloseMouse()74 void MultimodalInputPluginManagerTest::CloseMouse()
75 {
76 libinput_.RemovePath(vMouse_.GetDevPath());
77 vMouse_.Close();
78 }
79
SetUp()80 void MultimodalInputPluginManagerTest::SetUp()
81 {
82 manager = std::make_shared<InputPluginManager>(PATH);
83 }
84
85 /**
86 * @tc.name : MultimodalInputPluginManagerTest_Init_001
87 * @tc.number: Init_001
88 * @tc.desc : 测试初始化是否成功
89 */
90 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_Init_001, TestSize.Level0) {
91 int32_t valV1 = manager->Init();
92 EXPECT_EQ(valV1, RET_OK);
93 }
94
95 /**
96 * @tc.name: MultimodalInputPluginManagerTest_HandleEvent_02
97 * @tc.desc: Test_HandleEvent_02
98 * @tc.type: FUNC
99 * @tc.require:
100 */
101 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_HandleEvent_02, TestSize.Level1)
102 {
103 CALL_TEST_DEBUG;
104 vMouse_.SendEvent(EV_REL, REL_X, 5);
105 vMouse_.SendEvent(EV_REL, REL_Y, -10);
106 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
107
108 libinput_event *event = libinput_.Dispatch();
109 ASSERT_TRUE(event != nullptr);
110 struct libinput_device *dev = libinput_event_get_device(event);
111 ASSERT_TRUE(dev != nullptr);
112 std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
113 int32_t result = manager->HandleEvent(event, GetSysClockTime(),
114 InputPluginStage::INPUT_BEFORE_LIBINPUT_ADAPTER_ON_EVENT);
115 EXPECT_GE(result, RET_OK);
116 }
117
118 /**
119 * @tc.name: MultimodalInputPluginManagerTest_IntermediateEndEvent_03
120 * @tc.desc: Test_IntermediateEndEvent_03
121 * @tc.require:
122 */
123 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_IntermediateEndEvent_03, TestSize.Level1)
124 {
125 CALL_TEST_DEBUG;
126 vMouse_.SendEvent(EV_REL, REL_X, 5);
127 vMouse_.SendEvent(EV_REL, REL_Y, -10);
128 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
129
130 libinput_event *event = libinput_.Dispatch();
131 ASSERT_TRUE(event != nullptr);
132 struct libinput_device *dev = libinput_event_get_device(event);
133 ASSERT_TRUE(dev != nullptr);
134 std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
135
136 EXPECT_TRUE(manager->IntermediateEndEvent(event));
137 }
138
139 /**
140 * @tc.name: MultimodalInputPluginManagerTest_GetInstance_001
141 * @tc.desc: GetInstance will return not nullptr when instance_=nullptr
142 * @tc.require:
143 */
144 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_GetInstance_001,
145 TestSize.Level1)
146 {
147 CALL_TEST_DEBUG;
148
149 std::string dir = "/system/lib64/multimodalinput/autorun/libpointer_predict_insertion.z.so";
150 InputPluginManager::instance_ = nullptr;
151 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance(dir);
152 ASSERT_NE(ptr, nullptr);
153 }
154
155 /**
156 * @tc.name: MultimodalInputPluginManagerTest_GetInstance_002
157 * @tc.desc: GetInstance will return not nullptr when instance_!=nullptr
158 * @tc.require:
159 */
160 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_GetInstance_002,
161 TestSize.Level1)
162 {
163 CALL_TEST_DEBUG;
164
165 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
166 ASSERT_NE(ptr, nullptr);
167 }
168
169 /**
170 * @tc.name: MultimodalInputPluginManagerTest_InputPluginManager_Init_001
171 * @tc.desc: Init will return RET_OK when directory_ is valid path
172 * @tc.require:
173 */
174 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_InputPluginManager_Init_001,
175 TestSize.Level1)
176 {
177 CALL_TEST_DEBUG;
178
179 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
180 ASSERT_NE(ptr, nullptr);
181
182 int32_t ret = ptr->Init();
183 EXPECT_EQ(ret, RET_OK);
184 }
185
186 /**
187 * @tc.name: MultimodalInputPluginManagerTest_InputPluginManager_Init_002
188 * @tc.desc: Init will return RET_OK when directory_ is invalid path
189 * @tc.require:
190 */
191 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_InputPluginManager_Init_002,
192 TestSize.Level1)
193 {
194 CALL_TEST_DEBUG;
195
196 std::string dir = "/test/test/test/test/";
197 InputPluginManager::instance_ = nullptr;
198 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance(dir);
199 ASSERT_NE(ptr, nullptr);
200
201 int32_t ret = ptr->Init();
202 EXPECT_EQ(ret, RET_OK);
203 }
204
205 /**
206 * @tc.name: MultimodalInputPluginManagerTest_InputPluginManager_Init_003
207 * @tc.desc: Init will return RET_OK when directory_ is invalid path
208 * @tc.require:
209 */
210 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_InputPluginManager_Init_003,
211 TestSize.Level1)
212 {
213 CALL_TEST_DEBUG;
214
215 std::string dir = "/";
216 InputPluginManager::instance_ = nullptr;
217 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance(dir);
218 ASSERT_NE(ptr, nullptr);
219
220 int32_t ret = ptr->Init();
221 EXPECT_EQ(ret, RET_OK);
222 }
223
224 /**
225 * @tc.name: MultimodalInputPluginManagerTest_InputPluginManager_Init_004
226 * @tc.desc: Init will return RET_OK when directory_ is invalid path
227 * @tc.require:
228 */
229 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_InputPluginManager_Init_004,
230 TestSize.Level1)
231 {
232 CALL_TEST_DEBUG;
233
234 std::string dir = "/system/lib64/multimodalinput/autorun/test.c";
235 InputPluginManager::instance_ = nullptr;
236 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance(dir);
237 ASSERT_NE(ptr, nullptr);
238
239 int32_t ret = ptr->Init();
240 EXPECT_EQ(ret, RET_OK);
241 }
242
243 /**
244 * @tc.name: MultimodalInputPluginManagerTest_InputPluginManager_Init_005
245 * @tc.desc: Init will return RET_OK when directory_ is invalid path
246 * @tc.require:
247 */
248 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_InputPluginManager_Init_005,
249 TestSize.Level1)
250 {
251 CALL_TEST_DEBUG;
252
253 std::string dir = "/system/lib64/multimodalinput/autorun/test.so";
254 InputPluginManager::instance_ = nullptr;
255 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance(dir);
256 ASSERT_NE(ptr, nullptr);
257
258 int32_t ret = ptr->Init();
259 EXPECT_EQ(ret, RET_OK);
260 }
261
262 /**
263 * @tc.name: MultimodalInputPluginManagerTest_LoadPlugin_001
264 * @tc.desc: LoadPlugin will return true when LoadPlugin get valid path
265 * @tc.require:
266 */
267 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_LoadPlugin_001, TestSize.Level1)
268 {
269 CALL_TEST_DEBUG;
270
271 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
272 ASSERT_NE(ptr, nullptr);
273
274 std::string dir = "/system/lib64/multimodalinput/autorun/libpointer_predict_insertion.z.so";
275 bool ret = ptr->LoadPlugin(dir);
276 EXPECT_EQ(ret, true);
277 }
278
279 /**
280 * @tc.name: MultimodalInputPluginManagerTest_LoadPlugin_002
281 * @tc.desc: LoadPlugin will return true when LoadPlugin get valid path
282 * @tc.require:
283 */
284 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_LoadPlugin_002, TestSize.Level1)
285 {
286 CALL_TEST_DEBUG;
287
288 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
289 ASSERT_NE(ptr, nullptr);
290
291 std::string dir = "/system/lib64/multimodalinput/autorun/test.so";
292 bool ret = ptr->LoadPlugin(dir);
293 EXPECT_EQ(ret, true);
294 }
295
296 /**
297 * @tc.name: MultimodalInputPluginManagerTest_PrintPlugins_001
298 * @tc.desc: PrintPlugins will print plugin info when plugins_!=nullptr
299 * @tc.require:
300 */
301 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_PrintPlugins_001, TestSize.Level1)
302 {
303 CALL_TEST_DEBUG;
304
305 std::string path = "/system/lib64/multimodalinput/autorun/libpointer_predict_insertion.z.so";
306 void *handle = dlopen(path.c_str(), RTLD_LAZY);
307 ASSERT_NE(handle, nullptr);
308
309 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
310 ASSERT_NE(ptr, nullptr);
311
312 std::shared_ptr<IInputPlugin> iPin;
313 InputPluginStage stage = iPin->GetStage();
314 ptr->plugins_.insert({stage, {nullptr}});
315
316 ASSERT_NO_FATAL_FAILURE(ptr->PrintPlugins());
317 }
318
319 /**
320 * @tc.name: MultimodalInputPluginManagerTest_PluginAssignmentCallBack_001
321 * @tc.desc: Nothing will happenned when callback=nullptr
322 * @tc.require:
323 */
324 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_PluginAssignmentCallBack_001,
325 TestSize.Level1)
326 {
327 CALL_TEST_DEBUG;
328
329 std::function<void(libinput_event *, int64_t)> callback = nullptr;
330 std::shared_ptr<IInputPlugin> iPin;
331 InputPluginStage stage = iPin->GetStage();
332
333 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
334 ASSERT_NE(ptr, nullptr);
335
336 ASSERT_NO_FATAL_FAILURE(ptr->PluginAssignmentCallBack(callback, stage));
337 }
338
DispatchEvent(libinput_event * event,int64_t frameTime)339 static void DispatchEvent(libinput_event *event, int64_t frameTime)
340 {
341 (void)event;
342 (void)frameTime;
343 }
344
345 /**
346 * @tc.name: MultimodalInputPluginManagerTest_PluginAssignmentCallBack_002
347 * @tc.desc: Nothing will happenned when callback!=nullptr
348 * @tc.require:
349 */
350 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_PluginAssignmentCallBack_002,
351 TestSize.Level1)
352 {
353 CALL_TEST_DEBUG;
354
355 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
356 ASSERT_NE(ptr, nullptr);
357
358 InputPlugin inputPlugin;
359 std::function<void(libinput_event *, int64_t)> callback = DispatchEvent;
360
361 std::shared_ptr<IInputPlugin> iPin;
362 InputPluginStage stage = iPin->GetStage();
363
364 ASSERT_NO_FATAL_FAILURE(ptr->PluginAssignmentCallBack(callback, stage));
365 }
366
367 /**
368 * @tc.name: MultimodalInputPluginManagerTest_HandleEvent_001
369 * @tc.desc: HandleEvent will return RET_NOTDO when event=nullptr
370 * @tc.require:
371 */
372 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_HandleEvent_001, TestSize.Level1)
373 {
374 CALL_TEST_DEBUG;
375
376 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
377 ASSERT_NE(ptr, nullptr);
378
379 int64_t frameTime = 0;
380 std::shared_ptr<IInputPlugin> iPin;
381 InputPluginStage stage = iPin->GetStage();
382
383 int32_t ret = ptr->HandleEvent(nullptr, frameTime, stage);
384 EXPECT_EQ(ret, RET_NOTDO);
385 }
386
387 /**
388 * @tc.name: MultimodalInputPluginManagerTest_DoHandleEvent_001
389 * @tc.desc: DoHandleEvent will return RET_NOTDO when event=nullptr
390 * @tc.require:
391 */
392 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_DoHandleEvent_001, TestSize.Level1)
393 {
394 CALL_TEST_DEBUG;
395
396 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
397 ASSERT_NE(ptr, nullptr);
398
399 int64_t frameTime = 0;
400 InputPlugin iplugin;
401 std::shared_ptr<IInputPlugin> iPin;
402 InputPluginStage stage = iPin->GetStage();
403
404 int32_t ret = ptr->DoHandleEvent(nullptr, frameTime, &iplugin, stage);
405 EXPECT_EQ(ret, RET_NOTDO);
406 }
407
408 /**
409 * @tc.name: MultimodalInputPluginManagerTest_DoHandleEvent_002
410 * @tc.desc: DoHandleEvent will return RET_NOTDO when event=nullptr
411 * @tc.require:
412 */
413 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_DoHandleEvent_002, TestSize.Level1)
414 {
415 CALL_TEST_DEBUG;
416
417 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
418 ASSERT_NE(ptr, nullptr);
419
420 int64_t frameTime = 0;
421 std::shared_ptr<IInputPlugin> iPin;
422 InputPluginStage stage = iPin->GetStage();
423
424 int32_t ret = ptr->DoHandleEvent(nullptr, frameTime, nullptr, stage);
425 EXPECT_EQ(ret, RET_NOTDO);
426 }
427
428 /**
429 * @tc.name: MultimodalInputPluginManagerTest_DoHandleEvent_003
430 * @tc.desc: DoHandleEvent will return RET_NOTDO when event=nullptr
431 * @tc.require:
432 */
433 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_DoHandleEvent_003, TestSize.Level1)
434 {
435 CALL_TEST_DEBUG;
436
437 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
438 ASSERT_NE(ptr, nullptr);
439
440 libinput_event *event = libinput_.Dispatch();
441 ASSERT_TRUE(event != nullptr);
442
443 int64_t frameTime = 0;
444 std::shared_ptr<IInputPlugin> iPin;
445 InputPluginStage stage = iPin->GetStage();
446
447 int32_t ret = ptr->DoHandleEvent(event, frameTime, nullptr, stage);
448 EXPECT_EQ(ret, RET_NOTDO);
449 }
450
451 /**
452 * @tc.name: MultimodalInputPluginManagerTest_DoHandleEvent_004
453 * @tc.desc: DoHandleEvent will return RET_NOTDO when event=nullptr
454 * @tc.require:
455 */
456 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_DoHandleEvent_004, TestSize.Level1)
457 {
458 CALL_TEST_DEBUG;
459
460 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
461 ASSERT_NE(ptr, nullptr);
462
463 libinput_event *event = libinput_.Dispatch();
464 ASSERT_TRUE(event != nullptr);
465
466 int64_t frameTime = 0;
467 InputPlugin iplugin;
468 std::shared_ptr<IInputPlugin> iPin;
469 InputPluginStage stage = iPin->GetStage();
470
471 int32_t ret = ptr->DoHandleEvent(event, frameTime, &iplugin, stage);
472 EXPECT_EQ(ret, RET_NOTDO);
473 }
474
475 /**
476 * @tc.name: MultimodalInputPluginManagerTest_IntermediateEndEvent_001
477 * @tc.desc: IntermediateEndEvent will true when libinput_event_type before LIBINPUT_EVENT_GESTURE_HOLD_END
478 * @tc.require:
479 */
480 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_IntermediateEndEvent_001, TestSize.Level1)
481 {
482 CALL_TEST_DEBUG;
483
484 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
485 ASSERT_NE(ptr, nullptr);
486
487 libinput_event event;
488 event.type = LIBINPUT_EVENT_TABLET_TOOL_TIP;
489
490 bool ret = ptr->IntermediateEndEvent(&event);
491 EXPECT_EQ(ret, true);
492
493 event.type = LIBINPUT_EVENT_POINTER_MOTION;
494 ret = ptr->IntermediateEndEvent(&event);
495 EXPECT_EQ(ret, true);
496
497 event.type = LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE;
498 ret = ptr->IntermediateEndEvent(&event);
499 EXPECT_EQ(ret, true);
500
501 event.type = LIBINPUT_EVENT_POINTER_AXIS;
502 ret = ptr->IntermediateEndEvent(&event);
503 EXPECT_EQ(ret, true);
504
505 event.type = LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY;
506 ret = ptr->IntermediateEndEvent(&event);
507 EXPECT_EQ(ret, true);
508 }
509
510 /**
511 * @tc.name: MultimodalInputPluginManagerTest_IntermediateEndEvent_002
512 * @tc.desc: IntermediateEndEvent will true when libinput_event_type before LIBINPUT_EVENT_GESTURE_HOLD_END
513 * @tc.require:
514 */
515 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_IntermediateEndEvent_002, TestSize.Level1)
516 {
517 CALL_TEST_DEBUG;
518
519 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
520 ASSERT_NE(ptr, nullptr);
521
522 libinput_event event;
523 event.type = LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY;
524
525 bool ret = ptr->IntermediateEndEvent(&event);
526 EXPECT_EQ(ret, true);
527
528 event.type = LIBINPUT_EVENT_POINTER_MOTION_TOUCHPAD;
529 ret = ptr->IntermediateEndEvent(&event);
530 EXPECT_EQ(ret, true);
531
532 event.type = LIBINPUT_EVENT_TOUCH_UP;
533 ret = ptr->IntermediateEndEvent(&event);
534 EXPECT_EQ(ret, true);
535
536 event.type = LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE;
537 ret = ptr->IntermediateEndEvent(&event);
538 EXPECT_EQ(ret, true);
539
540 event.type = LIBINPUT_EVENT_TOUCH_UP;
541 ret = ptr->IntermediateEndEvent(&event);
542 EXPECT_EQ(ret, true);
543
544 event.type = LIBINPUT_EVENT_TOUCH_MOTION;
545 ret = ptr->IntermediateEndEvent(&event);
546 EXPECT_EQ(ret, true);
547
548 event.type = LIBINPUT_EVENT_TOUCH_CANCEL;
549 ret = ptr->IntermediateEndEvent(&event);
550 EXPECT_EQ(ret, true);
551
552 event.type = LIBINPUT_EVENT_TOUCHPAD_UP;
553 ret = ptr->IntermediateEndEvent(&event);
554 EXPECT_EQ(ret, true);
555
556 event.type = LIBINPUT_EVENT_TOUCHPAD_MOTION;
557 ret = ptr->IntermediateEndEvent(&event);
558 EXPECT_EQ(ret, true);
559 }
560
561 /**
562 * @tc.name: MultimodalInputPluginManagerTest_IntermediateEndEvent_003
563 * @tc.desc: IntermediateEndEvent will true when libinput_event_type before LIBINPUT_EVENT_GESTURE_HOLD_END
564 * @tc.require:
565 */
566 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_IntermediateEndEvent_003, TestSize.Level1)
567 {
568 CALL_TEST_DEBUG;
569
570 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
571 ASSERT_NE(ptr, nullptr);
572
573 libinput_event event;
574 event.type = LIBINPUT_EVENT_TABLET_TOOL_AXIS;
575
576 bool ret = ptr->IntermediateEndEvent(&event);
577 EXPECT_EQ(ret, true);
578
579 event.type = LIBINPUT_EVENT_GESTURE_SWIPE_END;
580 ret = ptr->IntermediateEndEvent(&event);
581 EXPECT_EQ(ret, true);
582
583 event.type = LIBINPUT_EVENT_KEYBOARD_KEY;
584 ret = ptr->IntermediateEndEvent(&event);
585 EXPECT_EQ(ret, true);
586
587 event.type = LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE;
588 ret = ptr->IntermediateEndEvent(&event);
589 EXPECT_EQ(ret, true);
590
591 event.type = LIBINPUT_EVENT_GESTURE_SWIPE_END;
592 ret = ptr->IntermediateEndEvent(&event);
593 EXPECT_EQ(ret, true);
594
595 event.type = LIBINPUT_EVENT_GESTURE_PINCH_UPDATE;
596 ret = ptr->IntermediateEndEvent(&event);
597 EXPECT_EQ(ret, true);
598
599 event.type = LIBINPUT_EVENT_GESTURE_PINCH_END;
600 ret = ptr->IntermediateEndEvent(&event);
601 EXPECT_EQ(ret, true);
602 }
603
604 /**
605 * @tc.name: MultimodalInputPluginManagerTest_IntermediateEndEvent_004
606 * @tc.desc: IntermediateEndEvent will true when libinput_event_type before LIBINPUT_EVENT_GESTURE_HOLD_END
607 * @tc.require:
608 */
609 HWTEST_F(MultimodalInputPluginManagerTest, MultimodalInputPluginManagerTest_IntermediateEndEvent_004, TestSize.Level1)
610 {
611 CALL_TEST_DEBUG;
612
613 std::shared_ptr<InputPluginManager> ptr = InputPluginManager::GetInstance();
614 ASSERT_NE(ptr, nullptr);
615
616 libinput_event event;
617 event.type = LIBINPUT_EVENT_KEYBOARD_KEY;
618
619 bool ret = ptr->IntermediateEndEvent(&event);
620 EXPECT_EQ(ret, false);
621
622 event.type = LIBINPUT_EVENT_POINTER_BUTTON;
623 ret = ptr->IntermediateEndEvent(&event);
624 EXPECT_EQ(ret, false);
625
626 event.type = LIBINPUT_EVENT_POINTER_TAP;
627 ret = ptr->IntermediateEndEvent(&event);
628 EXPECT_EQ(ret, false);
629
630 event.type = LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD;
631 ret = ptr->IntermediateEndEvent(&event);
632 EXPECT_EQ(ret, false);
633
634 event.type = LIBINPUT_EVENT_POINTER_TAP;
635 ret = ptr->IntermediateEndEvent(&event);
636 EXPECT_EQ(ret, false);
637
638 event.type = LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY;
639 ret = ptr->IntermediateEndEvent(&event);
640 EXPECT_EQ(ret, false);
641
642 event.type = LIBINPUT_EVENT_TABLET_TOOL_TIP;
643 ret = ptr->IntermediateEndEvent(&event);
644 EXPECT_EQ(ret, false);
645 }
646
647 } // namespace MMI
648 } // namespace OHOS
649