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