1 /*
2  * Copyright (c) 2023 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 "input_device_manager.h"
20 #include "i_input_windows_manager.h"
21 #include "libinput_wrapper.h"
22 #include "mouse_event_normalize.h"
23 #include "general_mouse.h"
24 
25 namespace OHOS {
26 namespace MMI {
27 namespace {
28 using namespace testing::ext;
29 }
30 class MouseEventNormalizeTest : public testing::Test {
31 public:
32     static void SetUpTestCase(void);
33     static void TearDownTestCase(void);
34     static void SetupMouse();
35     static void CloseMouse();
36 
37     void SetUp();
38     void TearDown();
39 
40 private:
41     static GeneralMouse vMouse_;
42     static LibinputWrapper libinput_;
43 
44     int32_t prePointerSpeed_ { 5 };
45     int32_t prePrimaryButton_ { 0 };
46     int32_t preScrollRows_ { 3 };
47     int32_t preTouchpadPointerSpeed_ { 9 };
48     int32_t preRightClickType_ { 1 };
49     bool preScrollSwitch_ { true };
50     bool preScrollDirection_ { true };
51     bool preTapSwitch_ { true };
52 };
53 
54 GeneralMouse MouseEventNormalizeTest::vMouse_;
55 LibinputWrapper MouseEventNormalizeTest::libinput_;
56 
SetUpTestCase(void)57 void MouseEventNormalizeTest::SetUpTestCase(void)
58 {
59     ASSERT_TRUE(libinput_.Init());
60     SetupMouse();
61 }
62 
TearDownTestCase(void)63 void MouseEventNormalizeTest::TearDownTestCase(void)
64 {
65     CloseMouse();
66 }
67 
SetupMouse()68 void MouseEventNormalizeTest::SetupMouse()
69 {
70     ASSERT_TRUE(vMouse_.SetUp());
71     std::cout << "device node name: " << vMouse_.GetDevPath() << std::endl;
72     ASSERT_TRUE(libinput_.AddPath(vMouse_.GetDevPath()));
73 
74     libinput_event *event = libinput_.Dispatch();
75     ASSERT_TRUE(event != nullptr);
76     ASSERT_EQ(libinput_event_get_type(event), LIBINPUT_EVENT_DEVICE_ADDED);
77     struct libinput_device *device = libinput_event_get_device(event);
78     ASSERT_TRUE(device != nullptr);
79     INPUT_DEV_MGR->OnInputDeviceAdded(device);
80 }
81 
CloseMouse()82 void MouseEventNormalizeTest::CloseMouse()
83 {
84     libinput_.RemovePath(vMouse_.GetDevPath());
85     vMouse_.Close();
86 }
87 
SetUp()88 void MouseEventNormalizeTest::SetUp()
89 {
90     prePointerSpeed_ = MouseEventHdr->GetPointerSpeed();
91     prePrimaryButton_ = MouseEventHdr->GetMousePrimaryButton();
92     preScrollRows_ = MouseEventHdr->GetMouseScrollRows();
93     MouseEventHdr->GetTouchpadPointerSpeed(preTouchpadPointerSpeed_);
94     MouseEventHdr->GetTouchpadRightClickType(preRightClickType_);
95     MouseEventHdr->GetTouchpadScrollSwitch(preScrollSwitch_);
96     MouseEventHdr->GetTouchpadScrollDirection(preScrollDirection_);
97     MouseEventHdr->GetTouchpadTapSwitch(preTapSwitch_);
98 }
99 
TearDown()100 void MouseEventNormalizeTest::TearDown()
101 {
102     MouseEventHdr->SetPointerSpeed(prePointerSpeed_);
103     MouseEventHdr->SetMousePrimaryButton(prePrimaryButton_);
104     MouseEventHdr->SetMouseScrollRows(preScrollRows_);
105     MouseEventHdr->SetTouchpadPointerSpeed(preTouchpadPointerSpeed_);
106     MouseEventHdr->SetTouchpadRightClickType(preRightClickType_);
107     MouseEventHdr->SetTouchpadScrollSwitch(preScrollSwitch_);
108     MouseEventHdr->SetTouchpadScrollDirection(preScrollDirection_);
109     MouseEventHdr->SetTouchpadTapSwitch(preTapSwitch_);
110 }
111 
112 /**
113  * @tc.name: MouseEventNormalizeTest_GetDisplayId()_001
114  * @tc.desc: Test GetDisplayId()
115  * @tc.type: FUNC
116  * @tc.require:
117  */
118 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetDisplayId_001, TestSize.Level1)
119 {
120     int32_t idNames = -1;
121     ASSERT_EQ(MouseEventHdr->GetDisplayId(), idNames);
122 }
123 
124 /**
125  * @tc.name: MouseEventNormalizeTest_GetPointerEvent_002
126  * @tc.desc: Test GetPointerEvent()
127  * @tc.type: FUNC
128  * @tc.require:
129  */
130 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetPointerEvent_002, TestSize.Level1)
131 {
132     ASSERT_EQ(MouseEventHdr->GetPointerEvent(), nullptr);
133 }
134 
135 /**
136  * @tc.name: MouseEventNormalizeTest_OnEvent_003
137  * @tc.desc: Test OnEvent
138  * @tc.type: FUNC
139  * @tc.require:
140  */
141 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_OnEvent_003, TestSize.Level1)
142 {
143     CALL_TEST_DEBUG;
144     vMouse_.SendEvent(EV_REL, REL_X, 5);
145     vMouse_.SendEvent(EV_REL, REL_Y, -10);
146     vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
147 
148     libinput_event *event = libinput_.Dispatch();
149     ASSERT_TRUE(event != nullptr);
150 
151     struct libinput_device *dev = libinput_event_get_device(event);
152     ASSERT_TRUE(dev != nullptr);
153     std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
154     ASSERT_EQ(MouseEventHdr->OnEvent(event), RET_ERR);
155 
156     auto pointerEvent = MouseEventHdr->GetPointerEvent();
157     ASSERT_TRUE(pointerEvent != nullptr);
158     EXPECT_EQ(pointerEvent->GetPointerAction(), PointerEvent::POINTER_ACTION_MOVE);
159 }
160 
161 /**
162  * @tc.name: MouseEventNormalizeTest_NormalizeRotateEvent_025
163  * @tc.desc: Test NormalizeRotateEvent
164  * @tc.type: FUNC
165  * @tc.require:
166  */
167 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_NormalizeRotateEvent_025, TestSize.Level1)
168 {
169     CALL_TEST_DEBUG;
170     vMouse_.SendEvent(EV_REL, REL_X, 5);
171     vMouse_.SendEvent(EV_REL, REL_Y, -10);
172     vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
173 
174     libinput_event *event = libinput_.Dispatch();
175     ASSERT_TRUE(event != nullptr);
176     struct libinput_device *dev = libinput_event_get_device(event);
177     ASSERT_TRUE(dev != nullptr);
178     std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
179 
180     auto iter = INPUT_DEV_MGR->inputDevice_.begin();
181     for (; iter != INPUT_DEV_MGR->inputDevice_.end(); ++iter) {
182         if (iter->second.inputDeviceOrigin == dev) {
183             break;
184         }
185     }
186     ASSERT_TRUE(iter != INPUT_DEV_MGR->inputDevice_.end());
187     int32_t deviceId = iter->first;
188     struct InputDeviceManager::InputDeviceInfo info = iter->second;
189     INPUT_DEV_MGR->inputDevice_.erase(iter);
190 
191     auto actionType  = PointerEvent::POINTER_ACTION_UNKNOWN;
192     double angle = 0.5;
193     EXPECT_NO_FATAL_FAILURE(MouseEventHdr->NormalizeRotateEvent(event, actionType, angle));
194     INPUT_DEV_MGR->inputDevice_[deviceId] = info;
195 }
196 
197 /**
198  * @tc.name: MouseEventNormalizeTest_NormalizeRotateEvent_026
199  * @tc.desc: Test NormalizeRotateEvent
200  * @tc.type: FUNC
201  * @tc.require:
202  */
203 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_NormalizeRotateEvent_026, TestSize.Level1)
204 {
205     CALL_TEST_DEBUG;
206     vMouse_.SendEvent(EV_REL, REL_X, 5);
207     vMouse_.SendEvent(EV_REL, REL_Y, -10);
208     vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
209 
210     libinput_event *event = libinput_.Dispatch();
211     ASSERT_TRUE(event != nullptr);
212     struct libinput_device *dev = libinput_event_get_device(event);
213     ASSERT_TRUE(dev != nullptr);
214     std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
215 
216     int32_t deviceId = INPUT_DEV_MGR->FindInputDeviceId(dev);
217     auto iter = MouseEventHdr->processors_.find(deviceId);
218     if (iter != MouseEventHdr->processors_.end()) {
219         MouseEventHdr->processors_.erase(iter);
220     }
221 
222     auto actionType  = PointerEvent::POINTER_ACTION_UNKNOWN;
223     double angle = 0.5;
224     EXPECT_NO_FATAL_FAILURE(MouseEventHdr->NormalizeRotateEvent(event, actionType, angle));
225     EXPECT_NO_FATAL_FAILURE(MouseEventHdr->NormalizeRotateEvent(event, actionType, angle));
226 }
227 
228 /**
229  * @tc.name: MouseEventNormalizeTest_NormalizeMoveMouse_004
230  * @tc.desc: Test NormalizeMoveMouse
231  * @tc.type: FUNC
232  * @tc.require:
233  */
234 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_NormalizeMoveMouse_004, TestSize.Level1)
235 {
236     bool isNormalize = true;
237     int32_t offsetX = 0;
238     int32_t offsetY = 0;
239     ASSERT_EQ(MouseEventHdr->NormalizeMoveMouse(offsetX, offsetY), isNormalize);
240 }
241 
242 /**
243  * @tc.name: MouseEventNormalizeTest_Dump_005
244  * @tc.desc: Test Dump
245  * @tc.type: FUNC
246  * @tc.require:
247  */
248 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_Dump_005, TestSize.Level1)
249 {
250     std::vector<std::string> args;
251     std::vector<std::string> idNames;
252     int32_t fd = 0;
253     MouseEventHdr->Dump(fd, args);
254     ASSERT_EQ(args, idNames);
255 }
256 
257 /**
258  * @tc.name: MouseEventNormalizeTest_SetPointerSpeed_006
259  * @tc.desc: Test SetPointerSpeed
260  * @tc.type: FUNC
261  * @tc.require:
262  */
263 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetPointerSpeed_006, TestSize.Level1)
264 {
265     int32_t idNames = 0;
266     int32_t speed = 2;
267     ASSERT_EQ(MouseEventHdr->SetPointerSpeed(speed), idNames);
268 }
269 
270 /**
271  * @tc.name: MouseEventNormalizeTest_GetPointerSpeed_007
272  * @tc.desc: Test GetPointerSpeed
273  * @tc.type: FUNC
274  * @tc.require:
275  */
276 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetPointerSpeed_007, TestSize.Level1)
277 {
278     int32_t speed = 2;
279     MouseEventHdr->SetPointerSpeed(speed);
280     int32_t idNames = 2;
281     ASSERT_EQ(MouseEventHdr->GetPointerSpeed(), idNames);
282 }
283 
284 /**
285  * @tc.name: MouseEventNormalizeTest_SetPointerLocation_008
286  * @tc.desc: Test SetPointerLocation
287  * @tc.type: FUNC
288  * @tc.require:
289  */
290 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetPointerLocation_008, TestSize.Level1)
291 {
292     int32_t idNames = -1;
293     int32_t x = 0;
294     int32_t y = 0;
295     ASSERT_EQ(MouseEventHdr->SetPointerLocation(x, y), idNames);
296 }
297 
298 /**
299  * @tc.name: MouseEventNormalizeTest_SetMousePrimaryButton_009
300  * @tc.desc: Test SetMousePrimaryButton
301  * @tc.type: FUNC
302  * @tc.require:
303  */
304 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetMousePrimaryButton_009, TestSize.Level1)
305 {
306     int32_t primaryButton = 1;
307     ASSERT_TRUE(MouseEventHdr->SetMousePrimaryButton(primaryButton) == RET_OK);
308 }
309 
310 /**
311  * @tc.name: MouseEventNormalizeTest_GetMousePrimaryButton_010
312  * @tc.desc: Test GetMousePrimaryButton
313  * @tc.type: FUNC
314  * @tc.require:
315  */
316 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetMousePrimaryButton_010, TestSize.Level1)
317 {
318     int32_t primaryButton = 1;
319     MouseEventHdr->SetMousePrimaryButton(primaryButton);
320     int32_t primaryButtonRes = 1;
321     ASSERT_TRUE(MouseEventHdr->GetMousePrimaryButton() == primaryButtonRes);
322 }
323 
324 /**
325  * @tc.name: MouseEventNormalizeTest_SetMouseScrollRows_011
326  * @tc.desc: Test SetMouseScrollRows
327  * @tc.type: FUNC
328  * @tc.require:
329  */
330 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetMouseScrollRows_011, TestSize.Level1)
331 {
332     int32_t rows = 1;
333     ASSERT_TRUE(MouseEventHdr->SetMouseScrollRows(rows) == RET_OK);
334 }
335 
336 /**
337  * @tc.name: MouseEventNormalizeTest_GetMouseScrollRows_012
338  * @tc.desc: Test GetMouseScrollRows
339  * @tc.type: FUNC
340  * @tc.require:
341  */
342 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetMouseScrollRows_012, TestSize.Level1)
343 {
344     int32_t rows = 50;
345     MouseEventHdr->SetMouseScrollRows(rows);
346     int32_t newRows = 50;
347     ASSERT_TRUE(MouseEventHdr->GetMouseScrollRows() == newRows);
348 }
349 
350 /**
351  * @tc.name: MouseEventNormalizeTest_SetTouchpadScrollSwitch_013
352  * @tc.desc: Test SetTouchpadScrollSwitch
353  * @tc.type: FUNC
354  * @tc.require:
355  */
356 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetTouchpadScrollSwitch_013, TestSize.Level1)
357 {
358     bool flag = false;
359     ASSERT_TRUE(MouseEventHdr->SetTouchpadScrollSwitch(flag) == RET_OK);
360 }
361 
362 /**
363  * @tc.name: MouseEventNormalizeTest_GetTouchpadScrollSwitch_014
364  * @tc.desc: Test GetTouchpadScrollSwitch
365  * @tc.type: FUNC
366  * @tc.require:
367  */
368 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetTouchpadScrollSwitch_014, TestSize.Level1)
369 {
370     bool flag = true;
371     MouseEventHdr->SetTouchpadScrollSwitch(flag);
372     bool newFlag = true;
373     MouseEventHdr->GetTouchpadScrollSwitch(flag);
374     ASSERT_TRUE(flag == newFlag);
375 }
376 
377 /**
378  * @tc.name: MouseEventNormalizeTest_SetTouchpadScrollDirection_015
379  * @tc.desc: Test SetTouchpadScrollDirection
380  * @tc.type: FUNC
381  * @tc.require:
382  */
383 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetTouchpadScrollDirection_015, TestSize.Level1)
384 {
385     bool state = false;
386     ASSERT_TRUE(MouseEventHdr->SetTouchpadScrollDirection(state) == RET_OK);
387 }
388 
389 /**
390  * @tc.name: MouseEventNormalizeTest_GetTouchpadScrollDirection_016
391  * @tc.desc: Test GetTouchpadScrollDirection
392  * @tc.type: FUNC
393  * @tc.require:
394  */
395 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetTouchpadScrollDirection_016, TestSize.Level1)
396 {
397     bool state = true;
398     MouseEventHdr->SetTouchpadScrollDirection(state);
399     bool newState = true;
400     MouseEventHdr->GetTouchpadScrollDirection(state);
401     ASSERT_TRUE(state == newState);
402 }
403 
404 /**
405  * @tc.name: MouseEventNormalizeTest_SetTouchpadTapSwitch_017
406  * @tc.desc: Test SetTouchpadTapSwitch
407  * @tc.type: FUNC
408  * @tc.require:
409  */
410 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetTouchpadTapSwitch_017, TestSize.Level1)
411 {
412     bool flag = false;
413     ASSERT_TRUE(MouseEventHdr->SetTouchpadTapSwitch(flag) == RET_OK);
414 }
415 
416 /**
417  * @tc.name: MouseEventNormalizeTest_GetTouchpadTapSwitch_018
418  * @tc.desc: Test GetTouchpadTapSwitch
419  * @tc.type: FUNC
420  * @tc.require:
421  */
422 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetTouchpadTapSwitch_018, TestSize.Level1)
423 {
424     bool flag = true;
425     MouseEventHdr->SetTouchpadTapSwitch(flag);
426     bool newFlag = true;
427     MouseEventHdr->GetTouchpadTapSwitch(flag);
428     ASSERT_TRUE(flag == newFlag);
429 }
430 
431 /**
432  * @tc.name: MouseEventNormalizeTest_SetTouchpadPointerSpeed_019
433  * @tc.desc: Test SetTouchpadPointerSpeed
434  * @tc.type: FUNC
435  * @tc.require:
436  */
437 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetTouchpadPointerSpeed_019, TestSize.Level1)
438 {
439     int32_t speed = 3;
440     ASSERT_TRUE(MouseEventHdr->SetTouchpadPointerSpeed(speed) == RET_OK);
441 }
442 
443 /**
444  * @tc.name: MouseEventNormalizeTest_GetTouchpadPointerSpeed_020
445  * @tc.desc: Test GetTouchpadPointerSpeed
446  * @tc.type: FUNC
447  * @tc.require:
448  */
449 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetTouchpadPointerSpeed_020, TestSize.Level1)
450 {
451     int32_t speed = 8;
452     MouseEventHdr->SetTouchpadPointerSpeed(speed);
453     int32_t newSpeed = 4;
454     MouseEventHdr->GetTouchpadPointerSpeed(newSpeed);
455     ASSERT_TRUE(speed == newSpeed);
456 }
457 
458 /**
459  * @tc.name: MouseEventNormalizeTest_SetTouchpadPointerSpeed_021
460  * @tc.desc: Test SetTouchpadPointerSpeed
461  * @tc.type: FUNC
462  * @tc.require:
463  */
464 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetTouchpadPointerSpeed_021, TestSize.Level1)
465 {
466     int32_t speed = 3;
467     ASSERT_TRUE(MouseEventHdr->SetTouchpadPointerSpeed(speed) == RET_OK);
468 }
469 
470 /**
471  * @tc.name: MouseEventNormalizeTest_GetTouchpadPointerSpeed_022
472  * @tc.desc: Test GetTouchpadPointerSpeed
473  * @tc.type: FUNC
474  * @tc.require:
475  */
476 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetTouchpadPointerSpeed_022, TestSize.Level1)
477 {
478     int32_t speed = 8;
479     MouseEventHdr->SetTouchpadPointerSpeed(speed);
480     int32_t newSpeed = 4;
481     MouseEventHdr->GetTouchpadPointerSpeed(newSpeed);
482     ASSERT_TRUE(speed == newSpeed);
483 }
484 
485 /**
486  * @tc.name: MouseEventNormalizeTest_SetTouchpadRightClickType_023
487  * @tc.desc: Test SetTouchpadRightClickType
488  * @tc.type: FUNC
489  * @tc.require:
490  */
491 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_SetTouchpadRightClickType_023, TestSize.Level1)
492 {
493     int32_t type = 3;
494     ASSERT_TRUE(MouseEventHdr->SetTouchpadRightClickType(type) == RET_OK);
495 }
496 
497 /**
498  * @tc.name: MouseEventNormalizeTest_GetTouchpadRightClickType_024
499  * @tc.desc: Test GetTouchpadRightClickType
500  * @tc.type: FUNC
501  * @tc.require:
502  */
503 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetTouchpadRightClickType_024, TestSize.Level1)
504 {
505     int32_t type = 1;
506     MouseEventHdr->SetTouchpadRightClickType(type);
507     int32_t newType = 2;
508     MouseEventHdr->GetTouchpadRightClickType(newType);
509     ASSERT_TRUE(type == newType);
510 }
511 
512 /**
513  * @tc.name: MouseEventNormalizeTest_CheckAndPackageAxisEvent_025
514  * @tc.desc: Test CheckAndPackageAxisEvent
515  * @tc.type: FUNC
516  * @tc.require:
517  */
518 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_CheckAndPackageAxisEvent_025, TestSize.Level1)
519 {
520     CALL_TEST_DEBUG;
521     vMouse_.SendEvent(EV_REL, REL_X, 5);
522     vMouse_.SendEvent(EV_REL, REL_Y, -10);
523     vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
524 
525     libinput_event *event = libinput_.Dispatch();
526     ASSERT_TRUE(event != nullptr);
527     struct libinput_device *dev = libinput_event_get_device(event);
528     ASSERT_TRUE(dev != nullptr);
529     std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
530 
531     auto it = INPUT_DEV_MGR->inputDevice_.begin();
532     for (; it != INPUT_DEV_MGR->inputDevice_.end(); ++it) {
533         if (it->second.inputDeviceOrigin == dev) {
534             break;
535         }
536     }
537     ASSERT_TRUE(it != INPUT_DEV_MGR->inputDevice_.end());
538     int32_t deviceId = it->first;
539     struct InputDeviceManager::InputDeviceInfo info = it->second;
540     INPUT_DEV_MGR->inputDevice_.erase(it);
541 
542     MouseEventHdr->CheckAndPackageAxisEvent(event);
543 
544     INPUT_DEV_MGR->inputDevice_[deviceId] = info;
545 }
546 
547 /**
548  * @tc.name: MouseEventNormalizeTest_CheckAndPackageAxisEvent_026
549  * @tc.desc: Test CheckAndPackageAxisEvent
550  * @tc.type: FUNC
551  * @tc.require:
552  */
553 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_CheckAndPackageAxisEvent_026, TestSize.Level1)
554 {
555     CALL_TEST_DEBUG;
556     vMouse_.SendEvent(EV_REL, REL_X, 5);
557     vMouse_.SendEvent(EV_REL, REL_Y, -10);
558     vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
559 
560     libinput_event *event = libinput_.Dispatch();
561     ASSERT_TRUE(event != nullptr);
562 
563     struct libinput_device *dev = libinput_event_get_device(event);
564     ASSERT_TRUE(dev != nullptr);
565     std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
566     MouseEventHdr->CheckAndPackageAxisEvent(event);
567 }
568 
569 /**
570  * @tc.name: MouseEventNormalizeTest_GetPointerEvent01
571  * @tc.desc: Test the funcation GetPointerEvent
572  * @tc.type: FUNC
573  * @tc.require:
574  */
575 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetPointerEvent01, TestSize.Level1)
576 {
577     CALL_TEST_DEBUG;
578     MouseEventNormalize mouseEventNormalize;
579     int32_t deviceId = 1;
580     mouseEventNormalize.processors_.insert(std::make_pair(1, std::make_shared<OHOS::MMI::MouseTransformProcessor>(1)));
581     EXPECT_NO_FATAL_FAILURE(mouseEventNormalize.GetPointerEvent(deviceId));
582 }
583 
584 /**
585  * @tc.name: MouseEventNormalizeTest_GetPointerEvent02
586  * @tc.desc: Test the funcation GetPointerEvent
587  * @tc.type: FUNC
588  * @tc.require:
589  */
590 HWTEST_F(MouseEventNormalizeTest, MouseEventNormalizeTest_GetPointerEvent02, TestSize.Level1)
591 {
592     CALL_TEST_DEBUG;
593     MouseEventNormalize mouseEventNormalize;
594     int32_t deviceId = 1;
595     mouseEventNormalize.processors_.insert(std::make_pair(2, std::make_shared<OHOS::MMI::MouseTransformProcessor>(2)));
596     EXPECT_NO_FATAL_FAILURE(mouseEventNormalize.GetPointerEvent(deviceId));
597 }
598 }
599 }