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 <cstdio>
17 #include <gtest/gtest.h>
18
19 #include "general_mouse.h"
20 #include "general_touchpad.h"
21 #include "mouse_transform_processor.h"
22 #include "window_info.h"
23 #include "mouse_device_state.h"
24 #include "input_device_manager.h"
25 #include "input_windows_manager.h"
26 #include "i_input_windows_manager.h"
27 #include "libinput_wrapper.h"
28
29 namespace OHOS {
30 namespace MMI {
31 namespace {
32 using namespace testing::ext;
33 constexpr int32_t BTN_RIGHT_MENUE_CODE = 0x118;
34 constexpr int32_t HARD_PC_PRO_DEVICE_WIDTH = 2880;
35 constexpr int32_t HARD_PC_PRO_DEVICE_HEIGHT = 1920;
36 }
37 class MouseTransformProcessorTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 static void SetupMouse();
42 static void CloseMouse();
43 void SetUp();
44 void TearDown();
45
46 private:
47 static GeneralMouse vMouse_;
48 static GeneralTouchpad vTouchpad_ ;
49 static LibinputWrapper libinput_;
50
51 MouseTransformProcessor g_processor_ { 0 };
52 int32_t prePointerSpeed_ { 5 };
53 int32_t prePrimaryButton_ { 0 };
54 int32_t preScrollRows_ { 3 };
55 int32_t preTouchpadPointerSpeed_ { 9 };
56 int32_t preRightClickType_ { 1 };
57 bool preScrollSwitch_ { true };
58 bool preScrollDirection_ { true };
59 bool preTapSwitch_ { true };
60 };
61
62 GeneralMouse MouseTransformProcessorTest::vMouse_;
63 GeneralTouchpad MouseTransformProcessorTest::vTouchpad_;
64 LibinputWrapper MouseTransformProcessorTest::libinput_;
65
SetUpTestCase(void)66 void MouseTransformProcessorTest::SetUpTestCase(void)
67 {
68 ASSERT_TRUE(libinput_.Init());
69 SetupMouse();
70 }
71
TearDownTestCase(void)72 void MouseTransformProcessorTest::TearDownTestCase(void)
73 {
74 CloseMouse();
75 }
76
SetupMouse()77 void MouseTransformProcessorTest::SetupMouse()
78 {
79 ASSERT_TRUE(vMouse_.SetUp());
80 std::cout << "device node name: " << vMouse_.GetDevPath() << std::endl;
81 ASSERT_TRUE(libinput_.AddPath(vMouse_.GetDevPath()));
82
83 ASSERT_TRUE(vTouchpad_.SetUp());
84 std::cout << "device node name: " << vTouchpad_.GetDevPath() << std::endl;
85 ASSERT_TRUE(libinput_.AddPath(vTouchpad_.GetDevPath()));
86
87 libinput_event *event = libinput_.Dispatch();
88 ASSERT_TRUE(event != nullptr);
89 ASSERT_EQ(libinput_event_get_type(event), LIBINPUT_EVENT_DEVICE_ADDED);
90 struct libinput_device *device = libinput_event_get_device(event);
91 ASSERT_TRUE(device != nullptr);
92 INPUT_DEV_MGR->OnInputDeviceAdded(device);
93 }
94
CloseMouse()95 void MouseTransformProcessorTest::CloseMouse()
96 {
97 libinput_.RemovePath(vMouse_.GetDevPath());
98 vMouse_.Close();
99 libinput_.RemovePath(vTouchpad_.GetDevPath());
100 vTouchpad_.Close();
101 }
102
SetUp()103 void MouseTransformProcessorTest::SetUp()
104 {
105 prePointerSpeed_ = g_processor_.GetPointerSpeed();
106 prePrimaryButton_ = g_processor_.GetMousePrimaryButton();
107 preScrollRows_ = g_processor_.GetMouseScrollRows();
108 g_processor_.GetTouchpadPointerSpeed(preTouchpadPointerSpeed_);
109 g_processor_.GetTouchpadRightClickType(preRightClickType_);
110 g_processor_.GetTouchpadScrollSwitch(preScrollSwitch_);
111 g_processor_.GetTouchpadScrollDirection(preScrollDirection_);
112 g_processor_.GetTouchpadTapSwitch(preTapSwitch_);
113 }
114
TearDown()115 void MouseTransformProcessorTest::TearDown()
116 {
117 g_processor_.SetPointerSpeed(prePointerSpeed_);
118 g_processor_.SetMousePrimaryButton(prePrimaryButton_);
119 g_processor_.SetMouseScrollRows(preScrollRows_);
120 g_processor_.SetTouchpadPointerSpeed(preTouchpadPointerSpeed_);
121 g_processor_.SetTouchpadRightClickType(preRightClickType_);
122 int32_t pid = 1;
123 g_processor_.SetTouchpadScrollSwitch(pid, preScrollSwitch_);
124 g_processor_.SetTouchpadScrollDirection(preScrollDirection_);
125 g_processor_.SetTouchpadTapSwitch(preTapSwitch_);
126 }
127
128 /**
129 * @tc.name: MouseTransformProcessorTest_DeletePressedButton_001
130 * @tc.desc: Test DeletePressedButton
131 * @tc.type: FUNC
132 * @tc.require:
133 */
134 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_DeletePressedButton_001, TestSize.Level1)
135 {
136 int32_t deviceId = 0;
137 MouseTransformProcessor processor(deviceId);
138 int32_t originButton = 1;
139 ASSERT_NO_FATAL_FAILURE(processor.DeletePressedButton(originButton));
140 }
141
142 /**
143 * @tc.name: MouseTransformProcessorTest_DeletePressedButton_002
144 * @tc.desc: Test DeletePressedButton
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_DeletePressedButton_002, TestSize.Level1)
149 {
150 int32_t deviceId = 0;
151 MouseTransformProcessor processor(deviceId);
152 int32_t originButton = 1;
153 int32_t mappedButton = 2;
154 processor.buttonMapping_[originButton] = mappedButton;
155 ASSERT_NO_FATAL_FAILURE(processor.DeletePressedButton(originButton));
156 }
157
158 /**
159 * @tc.name: MouseTransformProcessorTest_HandleAxisAccelateTouchPad_001
160 * @tc.desc: Test HandleAxisAccelateTouchPad
161 * @tc.type: FUNC
162 * @tc.require:
163 */
164 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleAxisAccelateTouchPad_001, TestSize.Level1)
165 {
166 int32_t deviceId = 0;
167 MouseTransformProcessor processor(deviceId);
168 double axisValue = 2.0;
169 auto inputWindowsManager = std::static_pointer_cast<InputWindowsManager>(WIN_MGR);
170 ASSERT_NE(inputWindowsManager, nullptr);
171 inputWindowsManager->captureModeInfo_.isCaptureMode = true;
172 double ret = processor.HandleAxisAccelateTouchPad(axisValue);
173 ASSERT_EQ(ret, 2.0);
174 }
175
176 /**
177 * @tc.name: MouseTransformProcessorTest_CheckDeviceType_01
178 * @tc.desc: Test CheckDeviceType
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_CheckDeviceType_01, TestSize.Level1)
183 {
184 int32_t deviceId = 0;
185 MouseTransformProcessor processor(deviceId);
186 int32_t width = HARD_PC_PRO_DEVICE_WIDTH;
187 int32_t height = HARD_PC_PRO_DEVICE_HEIGHT;
188 ASSERT_NO_FATAL_FAILURE(processor.CheckDeviceType(width, height));
189 }
190
191 /**
192 * @tc.name: MouseTransformProcessorTest_Dump_002
193 * @tc.desc: Test Dump
194 * @tc.type: FUNC
195 * @tc.require:
196 */
197 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_Dump_002, TestSize.Level1)
198 {
199 std::vector<std::string> args;
200 std::vector<std::string> idNames;
201 int32_t deviceId = 0;
202 MouseTransformProcessor processor(deviceId);
203 int32_t fd = 0;
204 processor.Dump(fd, args);
205 ASSERT_EQ(args, idNames);
206 }
207
208 /**
209 * @tc.name: MouseTransformProcessorTest_NormalizeMoveMouse_003
210 * @tc.desc: Test NormalizeMoveMouse
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_NormalizeMoveMouse_003, TestSize.Level1)
215 {
216 bool isNormalize = true;
217 int32_t deviceId = 0;
218 MouseTransformProcessor processor(deviceId);
219 int32_t offsetX = 0;
220 int32_t offsetY = 0;
221 ASSERT_EQ(processor.NormalizeMoveMouse(offsetX, offsetY), isNormalize);
222 }
223
224 /**
225 * @tc.name: MouseTransformProcessorTest_GetDisplayId_004
226 * @tc.desc: Test GetDisplayId
227 * @tc.type: FUNC
228 * @tc.require:
229 */
230 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetDisplayId_004, TestSize.Level1)
231 {
232 int32_t idNames = -1;
233 int32_t deviceId = 0;
234 MouseTransformProcessor processor(deviceId);
235 ASSERT_EQ(processor.GetDisplayId(), idNames);
236 }
237
238 /**
239 * @tc.name: MouseTransformProcessorTest_SetPointerSpeed_005
240 * @tc.desc: Test SetPointerSpeed
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetPointerSpeed_005, TestSize.Level1)
245 {
246 int32_t idNames = 0;
247 int32_t deviceId = 0;
248 MouseTransformProcessor processor(deviceId);
249 int32_t speed = 5;
250 ASSERT_EQ(processor.SetPointerSpeed(speed), idNames);
251 }
252
253 /**
254 * @tc.name: MouseTransformProcessorTest_SetPointerSpeed_006
255 * @tc.desc: Test GetPointerSpeed
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetPointerSpeed_006, TestSize.Level1)
260 {
261 int32_t idNames = 5;
262 int32_t deviceId = 0;
263 MouseTransformProcessor processor(deviceId);
264 int32_t speed = 5;
265 processor.SetPointerSpeed(speed);
266 ASSERT_EQ(processor.GetPointerSpeed(), idNames);
267 }
268
269 /**
270 * @tc.name: MouseTransformProcessorTest_SetPointerLocation_008
271 * @tc.desc: Test SetPointerLocation
272 * @tc.type: FUNC
273 * @tc.require:
274 */
275 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetPointerLocation_008, TestSize.Level1)
276 {
277 int32_t idNames = -1;
278 int32_t deviceId = 0;
279 int32_t displayId = -1;
280 MouseTransformProcessor processor(deviceId);
281 int32_t x = 0;
282 int32_t y = 0;
283 ASSERT_EQ(processor.SetPointerLocation(x, y, displayId), idNames);
284 }
285
286 /**
287 * @tc.name: MouseTransformProcessorTest_SetPointerSpeed_009
288 * @tc.desc: Test GetPointerSpeed
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetPointerSpeed_009, TestSize.Level1)
293 {
294 int32_t idNames = 1;
295 int32_t deviceId = 0;
296 MouseTransformProcessor processor(deviceId);
297 int32_t speed = 0;
298 processor.SetPointerSpeed(speed);
299 ASSERT_EQ(processor.GetPointerSpeed(), idNames);
300 }
301
302 /**
303 * @tc.name: MouseTransformProcessorTest_SetMousePrimaryButton_010
304 * @tc.desc: Test SetMousePrimaryButton
305 * @tc.type: FUNC
306 * @tc.require:
307 */
308 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetMousePrimaryButton_010, TestSize.Level1)
309 {
310 int32_t deviceId = 1;
311 MouseTransformProcessor processor(deviceId);
312 int32_t primaryButton = 1;
313 ASSERT_TRUE(processor.SetMousePrimaryButton(primaryButton) == RET_OK);
314 }
315
316 /**
317 * @tc.name: MouseTransformProcessorTest_GetMousePrimaryButton_011
318 * @tc.desc: Test GetMousePrimaryButton
319 * @tc.type: FUNC
320 * @tc.require:
321 */
322 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetMousePrimaryButton_011, TestSize.Level1)
323 {
324 int32_t deviceId = 0;
325 MouseTransformProcessor processor(deviceId);
326 int32_t primaryButton = 1;
327 processor.SetMousePrimaryButton(primaryButton);
328 int32_t primaryButtonRes = 1;
329 ASSERT_TRUE(processor.GetMousePrimaryButton() == primaryButtonRes);
330 }
331
332 /**
333 * @tc.name: MouseTransformProcessorTest_SetMouseScrollRows_012
334 * @tc.desc: Test SetMouseScrollRows
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetMouseScrollRows_012, TestSize.Level1)
339 {
340 int32_t deviceId = 1;
341 MouseTransformProcessor processor(deviceId);
342 int32_t rows = 1;
343 ASSERT_TRUE(processor.SetMouseScrollRows(rows) == RET_OK);
344 }
345
346 /**
347 * @tc.name: MouseTransformProcessorTest_GetMouseScrollRows_013
348 * @tc.desc: Test GetMouseScrollRows
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetMouseScrollRows_013, TestSize.Level1)
353 {
354 int32_t deviceId = 0;
355 MouseTransformProcessor processor(deviceId);
356 int32_t rows = 1;
357 processor.SetMouseScrollRows(rows);
358 int32_t newRows = 1;
359 ASSERT_TRUE(processor.GetMouseScrollRows() == newRows);
360 }
361 /**
362 * @tc.name: MouseTransformProcessorTest_SetTouchpadScrollSwitch_014
363 * @tc.desc: Test SetTouchpadScrollSwitch
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetTouchpadScrollSwitch_014, TestSize.Level1)
368 {
369 int32_t deviceId = 6;
370 MouseTransformProcessor processor(deviceId);
371 int32_t pid = 1;
372 bool flag = false;
373 ASSERT_TRUE(processor.SetTouchpadScrollSwitch(pid, flag) == RET_OK);
374 }
375
376 /**
377 * @tc.name: MouseTransformProcessorTest_GetTouchpadScrollSwitch_015
378 * @tc.desc: Test GetTouchpadScrollSwitch
379 * @tc.type: FUNC
380 * @tc.require:
381 */
382 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetTouchpadScrollSwitch_015, TestSize.Level1)
383 {
384 int32_t deviceId = 6;
385 MouseTransformProcessor processor(deviceId);
386 int32_t pid = 1;
387 bool flag = true;
388 processor.SetTouchpadScrollSwitch(pid, flag);
389 bool newFlag = true;
390 processor.GetTouchpadScrollSwitch(flag);
391 ASSERT_TRUE(flag == newFlag);
392 }
393
394 /**
395 * @tc.name: MouseTransformProcessorTest_SetTouchpadScrollSwitch_014
396 * @tc.desc: Test SetTouchpadScrollDirection
397 * @tc.type: FUNC
398 * @tc.require:
399 */
400 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetTouchpadScrollDirection_016, TestSize.Level1)
401 {
402 int32_t deviceId = 6;
403 MouseTransformProcessor processor(deviceId);
404 bool state = false;
405 ASSERT_TRUE(processor.SetTouchpadScrollDirection(state) == RET_OK);
406 }
407
408 /**
409 * @tc.name: MouseTransformProcessorTest_GetTouchpadScrollDirection_017
410 * @tc.desc: Test GetTouchpadScrollDirection
411 * @tc.type: FUNC
412 * @tc.require:
413 */
414 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetTouchpadScrollDirection_017, TestSize.Level1)
415 {
416 int32_t deviceId = 6;
417 MouseTransformProcessor processor(deviceId);
418 bool state = true;
419 processor.SetTouchpadScrollDirection(state);
420 bool newState = true;
421 processor.GetTouchpadScrollDirection(state);
422 ASSERT_TRUE(state == newState);
423 }
424
425 /**
426 * @tc.name: MouseTransformProcessorTest_SetTouchpadTapSwitch_018
427 * @tc.desc: Test SetTouchpadTapSwitch
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetTouchpadTapSwitch_018, TestSize.Level1)
432 {
433 int32_t deviceId = 6;
434 MouseTransformProcessor processor(deviceId);
435 bool flag = false;
436 ASSERT_TRUE(processor.SetTouchpadTapSwitch(flag) == RET_OK);
437 }
438
439 /**
440 * @tc.name: MouseTransformProcessorTest_GetTouchpadTapSwitch_019
441 * @tc.desc: Test GetTouchpadTapSwitch
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetTouchpadTapSwitch_019, TestSize.Level1)
446 {
447 int32_t deviceId = 6;
448 MouseTransformProcessor processor(deviceId);
449 bool flag = false;
450 processor.SetTouchpadTapSwitch(flag);
451 bool newFlag = false;
452 processor.GetTouchpadTapSwitch(flag);
453 ASSERT_TRUE(flag == newFlag);
454 }
455
456 /**
457 * @tc.name: MouseTransformProcessorTest_SetTouchpadPointerSpeed_020
458 * @tc.desc: Test SetTouchpadPointerSpeed
459 * @tc.type: FUNC
460 * @tc.require:
461 */
462 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetTouchpadPointerSpeed_020, TestSize.Level1)
463 {
464 int32_t deviceId = 6;
465 MouseTransformProcessor processor(deviceId);
466 int32_t speed = 2;
467 ASSERT_TRUE(processor.SetTouchpadPointerSpeed(speed) == RET_OK);
468 }
469
470 /**
471 * @tc.name: MouseTransformProcessorTest_GetTouchpadPointerSpeed_021
472 * @tc.desc: Test GetTouchpadPointerSpeed
473 * @tc.type: FUNC
474 * @tc.require:
475 */
476 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetTouchpadPointerSpeed_021, TestSize.Level1)
477 {
478 int32_t deviceId = 6;
479 MouseTransformProcessor processor(deviceId);
480 int32_t speed = 2;
481 processor.SetTouchpadPointerSpeed(speed);
482 int32_t newSpeed = 3;
483 processor.GetTouchpadPointerSpeed(newSpeed);
484 ASSERT_TRUE(speed == newSpeed);
485 }
486
487 /**
488 * @tc.name: MouseTransformProcessorTest_SetTouchpadPointerSpeed_022
489 * @tc.desc: Test SetTouchpadPointerSpeed
490 * @tc.type: FUNC
491 * @tc.require:
492 */
493 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetTouchpadPointerSpeed_022, TestSize.Level1)
494 {
495 int32_t deviceId = 6;
496 MouseTransformProcessor processor(deviceId);
497 int32_t speed = 8;
498 ASSERT_TRUE(processor.SetTouchpadPointerSpeed(speed) == RET_OK);
499 }
500
501 /**
502 * @tc.name: MouseTransformProcessorTest_GetTouchpadPointerSpeed_023
503 * @tc.desc: Test GetTouchpadPointerSpeed
504 * @tc.type: FUNC
505 * @tc.require:
506 */
507 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetTouchpadPointerSpeed_023, TestSize.Level1)
508 {
509 int32_t deviceId = 6;
510 MouseTransformProcessor processor(deviceId);
511 int32_t speed = 8;
512 processor.SetTouchpadPointerSpeed(speed);
513 int32_t newSpeed = 7;
514 processor.GetTouchpadPointerSpeed(newSpeed);
515 ASSERT_TRUE(speed == newSpeed);
516 }
517
518 /**
519 * @tc.name: MouseTransformProcessorTest_SetTouchpadRightClickType_024
520 * @tc.desc: Test SetTouchpadRightClickType
521 * @tc.type: FUNC
522 * @tc.require:
523 */
524 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetTouchpadRightClickType_024, TestSize.Level1)
525 {
526 int32_t deviceId = 6;
527 MouseTransformProcessor processor(deviceId);
528 int32_t type = 2;
529 ASSERT_TRUE(processor.SetTouchpadRightClickType(type) == RET_OK);
530 }
531
532 /**
533 * @tc.name: MouseTransformProcessorTest_GetTouchpadRightClickType_025
534 * @tc.desc: Test GetTouchpadRightClickType
535 * @tc.type: FUNC
536 * @tc.require:
537 */
538 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetTouchpadRightClickType_025, TestSize.Level1)
539 {
540 int32_t deviceId = 6;
541 MouseTransformProcessor processor(deviceId);
542 int32_t type = 1;
543 processor.SetTouchpadRightClickType(type);
544 int32_t newType = 3;
545 processor.GetTouchpadRightClickType(newType);
546 ASSERT_TRUE(type == newType);
547 }
548
549 /**
550 * @tc.name: MouseTransformProcessorTest_GetPointerEvent_001
551 * @tc.desc: Get pointer event verify
552 * @tc.type: FUNC
553 * @tc.require:
554 */
555 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetPointerEvent_001, TestSize.Level1)
556 {
557 int32_t deviceId = 0;
558 MouseTransformProcessor processor(deviceId);
559 auto ret = processor.GetPointerEvent();
560 ASSERT_NE(ret, nullptr);
561 }
562
563 /**
564 * @tc.name: MouseTransformProcessorTest_HandleMotionInner_001
565 * @tc.desc: Handle motion inner verify
566 * @tc.type: FUNC
567 * @tc.require:
568 */
569 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleMotionInner_001, TestSize.Level1)
570 {
571 int32_t deviceId = 0;
572 MouseTransformProcessor processor(deviceId);
573 struct libinput_event_pointer* data = nullptr;
574 struct libinput_event* event = nullptr;
575 auto ret = processor.HandleMotionInner(data, event);
576 ASSERT_NE(ret, RET_OK);
577 }
578
579 /**
580 * @tc.name: MouseTransformProcessorTest_CalculateOffset_001
581 * @tc.desc: Calculate offset verify
582 * @tc.type: FUNC
583 * @tc.require:
584 */
585 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_CalculateOffset_001, TestSize.Level1)
586 {
587 int32_t deviceId = 0;
588 MouseTransformProcessor processor(deviceId);
589 Offset offset;
590 DisplayInfo displayInfo;
591 displayInfo.direction = DIRECTION90;
592 displayInfo.displayDirection = DIRECTION0;
593 ASSERT_NO_FATAL_FAILURE(processor.CalculateOffset(&displayInfo, offset));
594 }
595
596 /**
597 * @tc.name: MouseTransformProcessorTest_CalculateOffset_002
598 * @tc.desc: Calculate offset verify
599 * @tc.type: FUNC
600 * @tc.require:
601 */
602 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_CalculateOffset_002, TestSize.Level1)
603 {
604 int32_t deviceId = 0;
605 MouseTransformProcessor processor(deviceId);
606 Offset offset;
607 DisplayInfo displayInfo;
608 displayInfo.direction = DIRECTION180;
609 displayInfo.displayDirection = DIRECTION0;
610 ASSERT_NO_FATAL_FAILURE(processor.CalculateOffset(&displayInfo, offset));
611 }
612
613 /**
614 * @tc.name: MouseTransformProcessorTest_CalculateOffset_003
615 * @tc.desc: Calculate offset verify
616 * @tc.type: FUNC
617 * @tc.require:
618 */
619 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_CalculateOffset_003, TestSize.Level1)
620 {
621 int32_t deviceId = 0;
622 MouseTransformProcessor processor(deviceId);
623 Offset offset;
624 DisplayInfo displayInfo;
625 displayInfo.direction = DIRECTION270;
626 displayInfo.displayDirection = DIRECTION0;
627 ASSERT_NO_FATAL_FAILURE(processor.CalculateOffset(&displayInfo, offset));
628 }
629
630 /**
631 * @tc.name: MouseTransformProcessorTest_HandleButtonInner_001
632 * @tc.desc: Handle button inner verify
633 * @tc.type: FUNC
634 * @tc.require:
635 */
636 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleButtonInner_001, TestSize.Level1)
637 {
638 int32_t deviceId = 0;
639 MouseTransformProcessor processor(deviceId);
640 struct libinput_event_pointer* data = nullptr;
641 struct libinput_event* event = nullptr;
642 auto ret = processor.HandleButtonInner(data, event);
643 ASSERT_NE(ret, RET_OK);
644 }
645
646 /**
647 * @tc.name: MouseTransformProcessorTest_HandleButtonValueInner_001
648 * @tc.desc: Handle button value inner verify
649 * @tc.type: FUNC
650 * @tc.require:
651 */
652 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleButtonValueInner_001, TestSize.Level1)
653 {
654 int32_t deviceId = 0;
655 MouseTransformProcessor processor(deviceId);
656 struct libinput_event_pointer* data = nullptr;
657 uint32_t button = -1;
658 int32_t type = 0;
659 auto ret = processor.HandleButtonValueInner(data, button, type);
660 ASSERT_NE(ret, RET_ERR);
661 }
662
663 /**
664 * @tc.name: MouseTransformProcessorTest_HandleButtonValueInner_002
665 * @tc.desc: Handle button value inner verify
666 * @tc.type: FUNC
667 * @tc.require:
668 */
669 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleButtonValueInner_002, TestSize.Level1)
670 {
671 int32_t deviceId = 0;
672 MouseTransformProcessor processor(deviceId);
673 struct libinput_event_pointer* data = nullptr;
674 uint32_t button = 272;
675 int32_t type = 1;
676 auto ret = processor.HandleButtonValueInner(data, button, type);
677 ASSERT_NE(ret, RET_OK);
678 }
679
680 /**
681 * @tc.name: MouseTransformProcessorTest_HandleTouchPadAxisState_001
682 * @tc.desc: Handle touch pad axis state verify
683 * @tc.type: FUNC
684 * @tc.require:
685 */
686 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchPadAxisState_001, TestSize.Level1)
687 {
688 int32_t deviceId = 0;
689 MouseTransformProcessor processor(deviceId);
690 libinput_pointer_axis_source source = LIBINPUT_POINTER_AXIS_SOURCE_FINGER;
691 int32_t direction = 0;
692 bool tpScrollSwitch = false;
693 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchPadAxisState(source, direction, tpScrollSwitch));
694 }
695
696 /**
697 * @tc.name: MouseTransformProcessorTest_HandleAxisInner_001
698 * @tc.desc: Handle axis inner verify
699 * @tc.type: FUNC
700 * @tc.require:
701 */
702 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleAxisInner_001, TestSize.Level1)
703 {
704 int32_t deviceId = 0;
705 MouseTransformProcessor processor(deviceId);
706 struct libinput_event_pointer* data = nullptr;
707 auto ret = processor.HandleAxisInner(data);
708 ASSERT_NE(ret, RET_OK);
709 }
710
711 /**
712 * @tc.name: MouseTransformProcessorTest_HandleAxisBeginEndInner_001
713 * @tc.desc: Handle axis begin end inner verify
714 * @tc.type: FUNC
715 * @tc.require:
716 */
717 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleAxisBeginEndInner_001, TestSize.Level1)
718 {
719 int32_t deviceId = 0;
720 MouseTransformProcessor processor(deviceId);
721 struct libinput_event* event = nullptr;
722 auto ret = processor.HandleAxisBeginEndInner(event);
723 ASSERT_NE(ret, RET_OK);
724 }
725
726 /**
727 * @tc.name: MouseTransformProcessorTest_HandleAxisPostInner_001
728 * @tc.desc: Handle axis post inner verify
729 * @tc.type: FUNC
730 * @tc.require:
731 */
732 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleAxisPostInner_001, TestSize.Level1)
733 {
734 int32_t deviceId = 0;
735 MouseTransformProcessor processor(deviceId);
736 PointerEvent::PointerItem pointerItem;
737 ASSERT_NO_FATAL_FAILURE(processor.HandleAxisPostInner(pointerItem));
738 }
739
740 /**
741 * @tc.name: MouseTransformProcessorTest_HandlePostInner_001
742 * @tc.desc: Handle post inner verify
743 * @tc.type: FUNC
744 * @tc.require:
745 */
746 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandlePostInner_001, TestSize.Level1)
747 {
748 int32_t deviceId = 0;
749 MouseTransformProcessor processor(deviceId);
750 struct libinput_event_pointer* data = nullptr;
751 PointerEvent::PointerItem pointerItem;
752 ASSERT_NO_FATAL_FAILURE(processor.HandlePostInner(data, pointerItem));
753 }
754
755 /**
756 * @tc.name: MouseTransformProcessorTest_Normalize_001
757 * @tc.desc: Normalize verify
758 * @tc.type: FUNC
759 * @tc.require:
760 */
761 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_Normalize_001, TestSize.Level1)
762 {
763 int32_t deviceId = 0;
764 MouseTransformProcessor processor(deviceId);
765 struct libinput_event* event = nullptr;
766 auto ret = processor.Normalize(event);
767 ASSERT_NE(ret, RET_OK);
768 }
769
770 /**
771 * @tc.name: MouseTransformProcessorTest_NormalizeRotateEvent_001
772 * @tc.desc: Normalize rotate event verify
773 * @tc.type: FUNC
774 * @tc.require:
775 */
776 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_NormalizeRotateEvent_001, TestSize.Level1)
777 {
778 int32_t deviceId = 0;
779 MouseTransformProcessor processor(deviceId);
780 struct libinput_event* event = nullptr;
781 int32_t type = 1;
782 double angle = 90.0;
783 auto ret = processor.NormalizeRotateEvent(event, type, angle);
784 ASSERT_NE(ret, RET_OK);
785 }
786
787 /**
788 * @tc.name: MouseTransformProcessorTest_HandleMotionMoveMouse_001
789 * @tc.desc: Handle motion move mouse verify
790 * @tc.type: FUNC
791 * @tc.require:
792 */
793 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleMotionMoveMouse_001, TestSize.Level1)
794 {
795 int32_t deviceId = 0;
796 MouseTransformProcessor processor(deviceId);
797 int32_t offsetX = 10;
798 int32_t offsetY = 20;
799 ASSERT_NO_FATAL_FAILURE(processor.HandleMotionMoveMouse(offsetX, offsetY));
800 }
801
802 /**
803 * @tc.name: MouseTransformProcessorTest_HandleMotionMoveMouse_002
804 * @tc.desc: Handle motion move mouse verify
805 * @tc.type: FUNC
806 * @tc.require:
807 */
808 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleMotionMoveMouse_002, TestSize.Level1)
809 {
810 int32_t deviceId = 0;
811 MouseTransformProcessor processor(deviceId);
812 int32_t offsetX = -1000;
813 int32_t offsetY = 500;
814 ASSERT_NO_FATAL_FAILURE(processor.HandleMotionMoveMouse(offsetX, offsetY));
815 }
816
817 /**
818 * @tc.name: MouseTransformProcessorTest_OnDisplayLost_001
819 * @tc.desc: On display lost verify
820 * @tc.type: FUNC
821 * @tc.require:
822 */
823 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_OnDisplayLost_001, TestSize.Level1)
824 {
825 int32_t deviceId = 0;
826 MouseTransformProcessor processor(deviceId);
827 int32_t displayId = -1;
828 ASSERT_NO_FATAL_FAILURE(processor.OnDisplayLost(displayId));
829 }
830
831 /**
832 * @tc.name: MouseTransformProcessorTest_OnDisplayLost_002
833 * @tc.desc: On display lost verify
834 * @tc.type: FUNC
835 * @tc.require:
836 */
837 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_OnDisplayLost_002, TestSize.Level1)
838 {
839 int32_t deviceId = 0;
840 MouseTransformProcessor processor(deviceId);
841 int32_t displayId = 1;
842 ASSERT_NO_FATAL_FAILURE(processor.OnDisplayLost(displayId));
843 }
844
845 /**
846 * @tc.name: MouseTransformProcessorTest_HandlePostMoveMouse_001
847 * @tc.desc: Handle post move mouse verify
848 * @tc.type: FUNC
849 * @tc.require:
850 */
851 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandlePostMoveMouse_001, TestSize.Level1)
852 {
853 int32_t deviceId = 0;
854 MouseTransformProcessor processor(deviceId);
855 PointerEvent::PointerItem pointerItem;
856 ASSERT_NO_FATAL_FAILURE(processor.HandlePostMoveMouse(pointerItem));
857 }
858
859 /**
860 * @tc.name: MouseTransformProcessorTest_DumpInner_001
861 * @tc.desc: Dump inner verify
862 * @tc.type: FUNC
863 * @tc.require:
864 */
865 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_DumpInner_001, TestSize.Level1)
866 {
867 int32_t deviceId = 0;
868 MouseTransformProcessor processor(deviceId);
869 ASSERT_NO_FATAL_FAILURE(processor.DumpInner());
870 }
871
872 /**
873 * @tc.name: MouseTransformProcessorTest_GetTouchpadSpeed_001
874 * @tc.desc: Get touchpad speed verify
875 * @tc.type: FUNC
876 * @tc.require:
877 */
878 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_GetTouchpadSpeed_001, TestSize.Level1)
879 {
880 int32_t deviceId = 0;
881 MouseTransformProcessor processor(deviceId);
882 auto ret = processor.GetTouchpadSpeed();
883 ASSERT_NE(ret, RET_OK);
884 }
885
886 /**
887 * @tc.name: MouseTransformProcessorTest_Normalize_01
888 * @tc.desc: Test the branch that handles mouse movement events
889 * @tc.type: FUNC
890 * @tc.require:
891 */
892 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_Normalize_01, TestSize.Level1)
893 {
894 CALL_TEST_DEBUG;
895 vMouse_.SendEvent(EV_REL, REL_X, 5);
896 vMouse_.SendEvent(EV_REL, REL_Y, -10);
897 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
898 libinput_event *event = libinput_.Dispatch();
899 ASSERT_TRUE(event != nullptr);
900 struct libinput_device *dev = libinput_event_get_device(event);
901 ASSERT_TRUE(dev != nullptr);
902 std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
903 int32_t deviceId = 0;
904 MouseTransformProcessor processor(deviceId);
905 EXPECT_EQ(processor.Normalize(event), RET_ERR);
906 }
907
908 /**
909 * @tc.name: MouseTransformProcessorTest_Normalize_02
910 * @tc.desc: Tests the branch that handles the left mouse button event
911 * @tc.type: FUNC
912 * @tc.require:
913 */
914 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_Normalize_02, TestSize.Level1)
915 {
916 CALL_TEST_DEBUG;
917 vMouse_.SendEvent(EV_KEY, BTN_LEFT, 1);
918 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
919 libinput_event *event = libinput_.Dispatch();
920 ASSERT_TRUE(event != nullptr);
921 struct libinput_device *dev = libinput_event_get_device(event);
922 ASSERT_TRUE(dev != nullptr);
923 std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
924 int32_t deviceId = 0;
925 MouseTransformProcessor processor(deviceId);
926 EXPECT_EQ(processor.Normalize(event), RET_ERR);
927 }
928
929 /**
930 * @tc.name: MouseTransformProcessorTest_NormalizeRotateEvent_01
931 * @tc.desc: Test normal conditions
932 * @tc.type: FUNC
933 * @tc.require:
934 */
935 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_NormalizeRotateEvent_01, TestSize.Level1)
936 {
937 CALL_TEST_DEBUG;
938 vMouse_.SendEvent(EV_REL, REL_X, 5);
939 vMouse_.SendEvent(EV_REL, REL_Y, -10);
940 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
941 libinput_event *event = libinput_.Dispatch();
942 ASSERT_TRUE(event != nullptr);
943 struct libinput_device *dev = libinput_event_get_device(event);
944 ASSERT_TRUE(dev != nullptr);
945 std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
946 int32_t deviceId = 0;
947 MouseTransformProcessor processor(deviceId);
948 int32_t type = 1;
949 double angle = 90.0;
950 int32_t result = processor.NormalizeRotateEvent(event, type, angle);
951 EXPECT_EQ(result, RET_OK);
952 }
953
954 /**
955 * @tc.name: MouseTransformProcessorTest_NormalizeRotateEvent_02
956 * @tc.desc: Tests HandlePostInner return false
957 * @tc.type: FUNC
958 * @tc.require:
959 */
960 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_NormalizeRotateEvent_02, TestSize.Level1)
961 {
962 CALL_TEST_DEBUG;
963 vMouse_.SendEvent(EV_REL, REL_X, 5);
964 vMouse_.SendEvent(EV_REL, REL_Y, -10);
965 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
966 libinput_event *event = libinput_.Dispatch();
967 ASSERT_TRUE(event != nullptr);
968 struct libinput_device *dev = libinput_event_get_device(event);
969 ASSERT_TRUE(dev != nullptr);
970 std::cout << "pointer device: " << libinput_device_get_name(dev) << std::endl;
971 int32_t deviceId = 0;
972 MouseTransformProcessor processor(deviceId);
973 int32_t type = 0;
974 double angle = 0.0;
975 std::shared_ptr<PointerEvent::PointerItem> pointerItem = nullptr;
976 int32_t result = processor.NormalizeRotateEvent(event, type, angle);
977 EXPECT_EQ(result, RET_OK);
978 }
979
980 /**
981 * @tc.name: MouseTransformProcessorTest_HandleTouchpadLeftButton_001
982 * @tc.desc: Handle touchpad left button verify
983 * @tc.type: FUNC
984 * @tc.require:
985 */
986 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchpadLeftButton_001, TestSize.Level1)
987 {
988 int32_t deviceId = 0;
989 MouseTransformProcessor processor(deviceId);
990 struct libinput_event_pointer* data = nullptr;
991 int32_t eventType = 1;
992 uint32_t button = 0x118;
993 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchpadLeftButton(data, eventType, button));
994 }
995
996 /**
997 * @tc.name: MouseTransformProcessorTest_HandleTouchpadLeftButton_002
998 * @tc.desc: Handle touchpad left button verify
999 * @tc.type: FUNC
1000 * @tc.require:
1001 */
1002 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchpadLeftButton_002, TestSize.Level1)
1003 {
1004 int32_t deviceId = 0;
1005 MouseTransformProcessor processor(deviceId);
1006 struct libinput_event_pointer* data = nullptr;
1007 int32_t eventType = 1;
1008 uint32_t button = MouseDeviceState::LIBINPUT_RIGHT_BUTTON_CODE;
1009 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchpadLeftButton(data, eventType, button));
1010 }
1011
1012 /**
1013 * @tc.name: MouseTransformProcessorTest_HandleTouchpadLeftButton_003
1014 * @tc.desc: Handle touchpad left button verify
1015 * @tc.type: FUNC
1016 * @tc.require:
1017 */
1018 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchpadLeftButton_003, TestSize.Level1)
1019 {
1020 int32_t deviceId = 0;
1021 MouseTransformProcessor processor(deviceId);
1022 struct libinput_event_pointer* data = nullptr;
1023 int32_t eventType = LIBINPUT_EVENT_POINTER_TAP;
1024 uint32_t button = MouseDeviceState::LIBINPUT_RIGHT_BUTTON_CODE;
1025 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchpadLeftButton(data, eventType, button));
1026 }
1027
1028 /**
1029 * @tc.name: MouseTransformProcessorTest_HandleTouchpadLeftButton_004
1030 * @tc.desc: Handle touchpad left button verify
1031 * @tc.type: FUNC
1032 * @tc.require:
1033 */
1034 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchpadLeftButton_004, TestSize.Level1)
1035 {
1036 int32_t deviceId = 0;
1037 MouseTransformProcessor processor(deviceId);
1038 struct libinput_event_pointer* data = nullptr;
1039 int32_t eventType = LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD;
1040 uint32_t button = MouseDeviceState::LIBINPUT_LEFT_BUTTON_CODE;
1041 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchpadLeftButton(data, eventType, button));
1042 }
1043
1044 /**
1045 * @tc.name: MouseTransformProcessorTest_HandleAxisBeginEndInner_01
1046 * @tc.desc: Test HandleAxisBeginEndInner
1047 * @tc.type: FUNC
1048 * @tc.require:
1049 */
1050 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleAxisBeginEndInner_01, TestSize.Level1)
1051 {
1052 CALL_TEST_DEBUG;
1053 int32_t deviceId = 1;
1054 bool isAxisBegin;
1055 bool isPressed;
1056 MouseTransformProcessor processor(deviceId);
1057
1058 vMouse_.SendEvent(EV_REL, REL_X, 5);
1059 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1060 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1061 libinput_event *event = libinput_.Dispatch();
1062 ASSERT_TRUE(event != nullptr);
1063 struct libinput_device *dev = libinput_event_get_device(event);
1064 ASSERT_TRUE(dev != nullptr);
1065
1066 isAxisBegin = false;
1067 isPressed = true;
1068 int32_t ret = processor.HandleAxisBeginEndInner(event);
1069 EXPECT_EQ(ret, RET_ERR);
1070 }
1071
1072 /**
1073 * @tc.name: MouseTransformProcessorTest_HandleAxisBeginEndInner_02
1074 * @tc.desc: Test HandleAxisBeginEndInner
1075 * @tc.type: FUNC
1076 * @tc.require:
1077 */
1078 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleAxisBeginEndInner_02, TestSize.Level1)
1079 {
1080 CALL_TEST_DEBUG;
1081 bool isAxisBegin;
1082 bool isPressed;
1083 int32_t deviceId = 1;
1084 MouseTransformProcessor processor(deviceId);
1085 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1086 ASSERT_TRUE(pointerEvent != nullptr);
1087
1088 vMouse_.SendEvent(EV_REL, REL_X, 5);
1089 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1090 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1091 libinput_event *event = libinput_.Dispatch();
1092 ASSERT_TRUE(event != nullptr);
1093 struct libinput_device *dev = libinput_event_get_device(event);
1094 ASSERT_TRUE(dev != nullptr);
1095
1096 isAxisBegin = true;
1097 isPressed = true;
1098 int32_t ret = processor.HandleAxisBeginEndInner(event);
1099 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END);
1100 EXPECT_EQ(ret, RET_ERR);
1101 }
1102
1103 /**
1104 * @tc.name: MouseTransformProcessorTest_HandleAxisBeginEndInner_03
1105 * @tc.desc: Test HandleAxisBeginEndInner
1106 * @tc.type: FUNC
1107 * @tc.require:
1108 */
1109 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleAxisBeginEndInner_03, TestSize.Level1)
1110 {
1111 CALL_TEST_DEBUG;
1112 int32_t buttonId;
1113 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1114 ASSERT_TRUE(pointerEvent != nullptr);
1115 int32_t deviceId = 1;
1116 MouseTransformProcessor processor(deviceId);
1117
1118 vMouse_.SendEvent(EV_REL, REL_X, 5);
1119 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1120 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1121 libinput_event *event = libinput_.Dispatch();
1122 ASSERT_TRUE(event != nullptr);
1123 struct libinput_device *dev = libinput_event_get_device(event);
1124 ASSERT_TRUE(dev != nullptr);
1125
1126 buttonId = PointerEvent::BUTTON_NONE;
1127 int32_t ret = processor.HandleAxisBeginEndInner(event);
1128 EXPECT_EQ(ret, RET_ERR);
1129 }
1130
1131 /**
1132 * @tc.name: MouseTransformProcessorTest_CheckAndPackageAxisEvent_001
1133 * @tc.desc: Test isAxisBegin is false
1134 * @tc.type: FUNC
1135 * @tc.require:
1136 */
1137 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_CheckAndPackageAxisEvent_001, TestSize.Level1)
1138 {
1139 CALL_TEST_DEBUG;
1140 int32_t deviceId = 0;
1141 MouseTransformProcessor processor(deviceId);
1142 processor.isAxisBegin_ = false;
1143 bool result = processor.CheckAndPackageAxisEvent();
1144 EXPECT_FALSE(result);
1145 }
1146
1147 /**
1148 * @tc.name: MouseTransformProcessorTest_CheckAndPackageAxisEvent_002
1149 * @tc.desc: Test isAxisBegin is true
1150 * @tc.type: FUNC
1151 * @tc.require:
1152 */
1153 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_CheckAndPackageAxisEvent_002, TestSize.Level1)
1154 {
1155 CALL_TEST_DEBUG;
1156 int32_t deviceId = 0;
1157 MouseTransformProcessor processor(deviceId);
1158 processor.isAxisBegin_ = true;
1159 bool result = processor.CheckAndPackageAxisEvent();
1160 EXPECT_TRUE(result);
1161 }
1162
1163 /**
1164 * @tc.name: MouseTransformProcessorTest_HandleButtonValueInner_003
1165 * @tc.desc: The corresponding key type cannot be found in the test overlay buttonId
1166 * @tc.type: FUNC
1167 * @tc.require:
1168 */
1169 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleButtonValueInner_003, TestSize.Level1)
1170 {
1171 CALL_TEST_DEBUG;
1172 vMouse_.SendEvent(EV_REL, REL_X, 5);
1173 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1174 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1175 libinput_event *event = libinput_.Dispatch();
1176 ASSERT_TRUE(event != nullptr);
1177 auto data = libinput_event_get_pointer_event(event);
1178 ASSERT_TRUE(data != nullptr);
1179 int32_t deviceId = 0;
1180 MouseTransformProcessor processor(deviceId);
1181 uint32_t button = 0;
1182 int32_t type = 2;
1183 int32_t ret = processor.HandleButtonValueInner(data, button, type);
1184 EXPECT_EQ(ret, RET_ERR);
1185 }
1186
1187 /**
1188 * @tc.name: MouseTransformProcessorTest_HandleButtonValueInner_004
1189 * @tc.desc: Test overwrite buttonId to find corresponding key type
1190 * @tc.type: FUNC
1191 * @tc.require:
1192 */
1193 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleButtonValueInner_004, TestSize.Level1)
1194 {
1195 CALL_TEST_DEBUG;
1196 vMouse_.SendEvent(EV_REL, REL_X, 5);
1197 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1198 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1199 libinput_event *event = libinput_.Dispatch();
1200 ASSERT_TRUE(event != nullptr);
1201 auto data = libinput_event_get_pointer_event(event);
1202 ASSERT_TRUE(data != nullptr);
1203 int32_t deviceId = 0;
1204 MouseTransformProcessor processor(deviceId);
1205 uint32_t button = MouseDeviceState::LIBINPUT_LEFT_BUTTON_CODE;
1206 int32_t type = 2;
1207 int32_t ret = processor.HandleButtonValueInner(data, button, type);
1208 EXPECT_EQ(ret, RET_OK);
1209 }
1210
1211 /**
1212 * @tc.name: MouseTransformProcessorTest_HandleButtonValueInner_005
1213 * @tc.desc: Test the case that the buttonId covers different key types
1214 * @tc.type: FUNC
1215 * @tc.require:
1216 */
1217 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleButtonValueInner_005, TestSize.Level1)
1218 {
1219 CALL_TEST_DEBUG;
1220 vMouse_.SendEvent(EV_REL, REL_X, 5);
1221 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1222 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1223 libinput_event *event = libinput_.Dispatch();
1224 ASSERT_TRUE(event != nullptr);
1225 auto data = libinput_event_get_pointer_event(event);
1226 ASSERT_TRUE(data != nullptr);
1227 int32_t deviceId = 0;
1228 MouseTransformProcessor processor(deviceId);
1229 uint32_t button = MouseDeviceState::LIBINPUT_RIGHT_BUTTON_CODE;
1230 int32_t type = 2;
1231 int32_t ret = processor.HandleButtonValueInner(data, button, type);
1232 EXPECT_EQ(ret, RET_OK);
1233 button = MouseDeviceState::LIBINPUT_MIDDLE_BUTTON_CODE;
1234 ret = processor.HandleButtonValueInner(data, button, type);
1235 EXPECT_EQ(ret, RET_OK);
1236 }
1237
1238 /**
1239 * @tc.name: MouseTransformProcessorTest_HandleMotionInner_002
1240 * @tc.desc: Test HandleMotionInner
1241 * @tc.type: FUNC
1242 * @tc.require:
1243 */
1244 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleMotionInner_002, TestSize.Level1)
1245 {
1246 CALL_TEST_DEBUG;
1247 vMouse_.SendEvent(EV_REL, REL_X, 5);
1248 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1249 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1250 libinput_event *event = libinput_.Dispatch();
1251 ASSERT_TRUE(event != nullptr);
1252 auto data = libinput_event_get_pointer_event(event);
1253 ASSERT_TRUE(data != nullptr);
1254 int32_t deviceId = 0;
1255 MouseTransformProcessor processor(deviceId);
1256 int32_t ret = processor.HandleMotionInner(data, event);
1257 EXPECT_EQ(ret, RET_ERR);
1258 }
1259
1260 /**
1261 * @tc.name: MouseTransformProcessorTest_HandleMotionInner_003
1262 * @tc.desc: Test HandleMotionInner
1263 * @tc.type: FUNC
1264 * @tc.require:
1265 */
1266 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleMotionInner_003, TestSize.Level1)
1267 {
1268 CALL_TEST_DEBUG;
1269 vMouse_.SendEvent(EV_REL, REL_X, 5);
1270 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1271 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1272 libinput_event *event = libinput_.Dispatch();
1273 ASSERT_TRUE(event != nullptr);
1274 auto data = libinput_event_get_pointer_event(event);
1275 ASSERT_TRUE(data != nullptr);
1276 int32_t deviceId = 0;
1277 MouseTransformProcessor processor(deviceId);
1278 CursorPosition cursorPos;
1279 cursorPos.displayId = -1;
1280 int32_t type = LIBINPUT_EVENT_POINTER_MOTION_TOUCHPAD;
1281 int32_t ret = processor.HandleMotionInner(data, event);
1282 EXPECT_EQ(ret, RET_ERR);
1283 type = LIBINPUT_EVENT_POINTER_BUTTON;
1284 ret = processor.HandleMotionInner(data, event);
1285 EXPECT_EQ(ret, RET_ERR);
1286 }
1287
1288 /**
1289 * @tc.name: MouseTransformProcessorTest_HandleButtonInner_002
1290 * @tc.desc: Test HandleButtonInner
1291 * @tc.type: FUNC
1292 * @tc.require:
1293 */
1294 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleButtonInner_002, TestSize.Level1)
1295 {
1296 CALL_TEST_DEBUG;
1297 vMouse_.SendEvent(EV_REL, REL_X, 5);
1298 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1299 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1300 libinput_event *event = libinput_.Dispatch();
1301 ASSERT_TRUE(event != nullptr);
1302 auto data = libinput_event_get_pointer_event(event);
1303 ASSERT_TRUE(data != nullptr);
1304 int32_t deviceId = 0;
1305 MouseTransformProcessor processor(deviceId);
1306 int32_t ret = processor.HandleButtonInner(data, event);
1307 EXPECT_EQ(ret, RET_ERR);
1308 }
1309
1310 /**
1311 * @tc.name: MouseTransformProcessorTest_HandleTouchPadAxisState_01
1312 * @tc.desc: Test HandleTouchPadAxisState
1313 * @tc.type: FUNC
1314 * @tc.require:
1315 */
1316 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchPadAxisState_01, TestSize.Level1)
1317 {
1318 int32_t deviceId = 0;
1319 MouseTransformProcessor processor(deviceId);
1320 libinput_pointer_axis_source source = LIBINPUT_POINTER_AXIS_SOURCE_FINGER;
1321 int32_t direction = 1;
1322 bool tpScrollSwitch = true;
1323 processor.HandleTouchPadAxisState(source, direction, tpScrollSwitch);
1324 }
1325
1326 /**
1327 * @tc.name: MouseTransformProcessorTest_HandleTouchpadLeftButton_01
1328 * @tc.desc: Test HandleTouchpadLeftButton
1329 * @tc.type: FUNC
1330 * @tc.require:
1331 */
1332 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchpadLeftButton_01, TestSize.Level1)
1333 {
1334 int32_t deviceId = 0;
1335 MouseTransformProcessor processor(deviceId);
1336 struct libinput_event_pointer *data = nullptr;
1337 int32_t evenType = LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD;
1338 uint32_t button = BTN_RIGHT_MENUE_CODE;
1339 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchpadLeftButton(data, evenType, button));
1340 }
1341
1342 /**
1343 * @tc.name: MouseTransformProcessorTest_HandleTouchpadLeftButton_02
1344 * @tc.desc: Test HandleTouchpadLeftButton
1345 * @tc.type: FUNC
1346 * @tc.require:
1347 */
1348 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchpadLeftButton_02, TestSize.Level1)
1349 {
1350 int32_t deviceId = 0;
1351 MouseTransformProcessor processor(deviceId);
1352 struct libinput_event_pointer *data = nullptr;
1353 int32_t evenType = LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD;
1354 uint32_t button = MouseDeviceState::LIBINPUT_BUTTON_CODE::LIBINPUT_RIGHT_BUTTON_CODE;
1355 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchpadLeftButton(data, evenType, button));
1356 }
1357
1358 /**
1359 * @tc.name: MouseTransformProcessorTest_HandleTouchpadLeftButton_03
1360 * @tc.desc: Test HandleTouchpadLeftButton
1361 * @tc.type: FUNC
1362 * @tc.require:
1363 */
1364 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchpadLeftButton_03, TestSize.Level1)
1365 {
1366 int32_t deviceId = 0;
1367 MouseTransformProcessor processor(deviceId);
1368 struct libinput_event_pointer *data = nullptr;
1369 int32_t evenType = LIBINPUT_EVENT_POINTER_TAP;
1370 uint32_t button = MouseDeviceState::LIBINPUT_BUTTON_CODE::LIBINPUT_RIGHT_BUTTON_CODE;
1371 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchpadLeftButton(data, evenType, button));
1372 }
1373
1374 /**
1375 * @tc.name: MouseTransformProcessorTest_HandleTouchpadLeftButton_04
1376 * @tc.desc: Test HandleTouchpadLeftButton
1377 * @tc.type: FUNC
1378 * @tc.require:
1379 */
1380 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchpadLeftButton_04, TestSize.Level1)
1381 {
1382 int32_t deviceId = 0;
1383 MouseTransformProcessor processor(deviceId);
1384 struct libinput_event_pointer *data = nullptr;
1385 int32_t evenType = LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD;
1386 uint32_t button = MouseDeviceState::LIBINPUT_BUTTON_CODE::LIBINPUT_LEFT_BUTTON_CODE;
1387 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchpadLeftButton(data, evenType, button));
1388 }
1389
1390 /**
1391 * @tc.name: MouseTransformProcessorTest_TransTouchpadRightButton_04
1392 * @tc.desc: Test TransTouchpadRightButton
1393 * @tc.type: FUNC
1394 * @tc.require:
1395 */
1396 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_TransTouchpadRightButton_04, TestSize.Level1)
1397 {
1398 int32_t deviceId = 0;
1399 MouseTransformProcessor processor(deviceId);
1400 struct libinput_event_pointer *data = nullptr;
1401 int32_t evenType = LIBINPUT_EVENT_KEYBOARD_KEY;
1402 uint32_t button = BTN_RIGHT_MENUE_CODE;
1403 processor.TransTouchpadRightButton(data, evenType, button);
1404 }
1405
1406 /**
1407 * @tc.name: MouseTransformProcessorTest_TransTouchpadRightButton_05
1408 * @tc.desc: Test TransTouchpadRightButton
1409 * @tc.type: FUNC
1410 * @tc.require:
1411 */
1412 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_TransTouchpadRightButton_05, TestSize.Level1)
1413 {
1414 int32_t deviceId = 0;
1415 MouseTransformProcessor processor(deviceId);
1416 struct libinput_event_pointer *data = nullptr;
1417 int32_t evenType = 55;
1418 uint32_t button = BTN_RIGHT_MENUE_CODE;
1419 processor.TransTouchpadRightButton(data, evenType, button);
1420 }
1421
1422 /**
1423 * @tc.name: MouseTransformProcessorTest_TransTouchpadRightButton_06
1424 * @tc.desc: Test TransTouchpadRightButton
1425 * @tc.type: FUNC
1426 * @tc.require:
1427 */
1428 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_TransTouchpadRightButton_06, TestSize.Level1)
1429 {
1430 int32_t deviceId = 0;
1431 MouseTransformProcessor processor(deviceId);
1432 processor.SetTouchpadRightClickType(2);
1433 struct libinput_event_pointer *data = nullptr;
1434 int32_t evenType = 60;
1435 uint32_t button = BTN_RIGHT_MENUE_CODE;
1436 processor.TransTouchpadRightButton(data, evenType, button);
1437 }
1438
1439 /**
1440 * @tc.name: MouseTransformProcessorTest_HandlePostInner_01
1441 * @tc.desc: Test HandlePostInner
1442 * @tc.type: FUNC
1443 * @tc.require:
1444 */
1445 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandlePostInner_01, TestSize.Level1)
1446 {
1447 CALL_TEST_DEBUG;
1448 int32_t deviceId = 1;
1449 MouseTransformProcessor processor(deviceId);
1450 PointerEvent::PointerItem item;
1451 item.SetDisplayX(10);
1452 item.SetDisplayY(15);
1453 item.SetWindowX(0);
1454 item.SetWindowY(0);
1455 item.SetPointerId(1);
1456 item.SetPressed(true);
1457 item.SetDownTime(1000);
1458 item.SetWidth(0);
1459 item.SetHeight(0);
1460 item.SetPressure(0.5);
1461
1462 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, 2);
1463 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 2220);
1464 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 727);
1465 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
1466 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 710);
1467 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
1468 libinput_event *event = libinput_.Dispatch();
1469 ASSERT_TRUE(event != nullptr);
1470 libinput_event_pointer* data = libinput_event_get_pointer_event(event);
1471 ASSERT_TRUE(data != nullptr);
1472 libinput_pointer_axis_source source = libinput_event_pointer_get_axis_source(data);
1473 source = LIBINPUT_POINTER_AXIS_SOURCE_FINGER;
1474
1475 bool ret = processor.HandlePostInner(data, item);
1476 EXPECT_TRUE(ret);
1477 }
1478
1479 /**
1480 * @tc.name: MouseTransformProcessorTest_HandleAxisInner_02
1481 * @tc.desc: Test HandleAxisInner
1482 * @tc.type: FUNC
1483 * @tc.require:
1484 */
1485 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleAxisInner_02, TestSize.Level1)
1486 {
1487 CALL_TEST_DEBUG;
1488 int32_t deviceId = 1;
1489 bool isAxisBegin;
1490 MouseTransformProcessor processor(deviceId);
1491
1492 vTouchpad_.SendEvent(EV_ABS, ABS_MT_TRACKING_ID, 2);
1493 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_X, 2220);
1494 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 727);
1495 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
1496 vTouchpad_.SendEvent(EV_ABS, ABS_MT_POSITION_Y, 710);
1497 vTouchpad_.SendEvent(EV_SYN, SYN_REPORT, 0);
1498 libinput_event *event = libinput_.Dispatch();
1499 ASSERT_TRUE(event != nullptr);
1500 auto data = libinput_event_get_pointer_event(event);
1501
1502 isAxisBegin = false;
1503 int32_t ret = processor.HandleAxisInner(data);
1504 EXPECT_EQ(ret, ERROR_NULL_POINTER);
1505 }
1506
1507 /**
1508 * @tc.name: MouseTransformProcessorTest_SetPointerSpeed_00
1509 * @tc.desc: Test the funcation SetPointerSpeed
1510 * @tc.type: FUNC
1511 * @tc.require:
1512 */
1513 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_SetPointerSpeed_001, TestSize.Level1)
1514 {
1515 CALL_TEST_DEBUG;
1516 int32_t deviceId = 1;
1517 MouseTransformProcessor processor(deviceId);
1518 int32_t speed = -1;
1519 ASSERT_EQ(processor.SetPointerSpeed(speed), 0);
1520 speed = 15;
1521 ASSERT_EQ(processor.SetPointerSpeed(speed), 0);
1522 speed = 5;
1523 EXPECT_NO_FATAL_FAILURE(processor.SetPointerSpeed(speed));
1524 }
1525
1526 /**
1527 * @tc.name: MouseTransformProcessorTest_HandleAxisBeginEndInner_002
1528 * @tc.desc: Test the funcation HandleAxisBeginEndInner
1529 * @tc.type: FUNC
1530 * @tc.require:
1531 */
1532 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleAxisBeginEndInner_002, TestSize.Level1)
1533 {
1534 CALL_TEST_DEBUG;
1535 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
1536 ASSERT_TRUE(pointerEvent != nullptr);
1537 int32_t deviceId = 1;
1538 MouseTransformProcessor processor(deviceId);
1539 vMouse_.SendEvent(EV_REL, REL_X, 5);
1540 vMouse_.SendEvent(EV_REL, REL_Y, -10);
1541 vMouse_.SendEvent(EV_SYN, SYN_REPORT, 0);
1542 libinput_event *event = libinput_.Dispatch();
1543 ASSERT_TRUE(event != nullptr);
1544 struct libinput_device *dev = libinput_event_get_device(event);
1545 ASSERT_TRUE(dev != nullptr);
1546 processor.buttonId_ = PointerEvent::BUTTON_NONE;
1547 processor.isAxisBegin_ = false;
1548 processor.isPressed_ = true;
1549 int32_t ret = processor.HandleAxisBeginEndInner(event);
1550 EXPECT_EQ(ret, RET_ERR);
1551 processor.isAxisBegin_ = true;
1552 ret = processor.HandleAxisBeginEndInner(event);
1553 EXPECT_EQ(ret, RET_OK);
1554 processor.isPressed_ = false;
1555 ret = processor.HandleAxisBeginEndInner(event);
1556 EXPECT_EQ(ret, RET_ERR);
1557 }
1558
1559 /**
1560 * @tc.name: MouseTransformProcessorTest_HandleTouchpadRightButton_001
1561 * @tc.desc: Test the funcation HandleTouchpadRightButton
1562 * @tc.type: FUNC
1563 * @tc.require:
1564 */
1565 HWTEST_F(MouseTransformProcessorTest, MouseTransformProcessorTest_HandleTouchpadRightButton_001, TestSize.Level1)
1566 {
1567 int32_t deviceId = 1;
1568 MouseTransformProcessor processor(deviceId);
1569 struct libinput_event_pointer* data = nullptr;
1570 int32_t evenType = 10;
1571 uint32_t button = BTN_RIGHT_MENUE_CODE;
1572 ASSERT_NO_FATAL_FAILURE(processor.HandleTouchpadRightButton(data, evenType, button));
1573 button = MouseDeviceState::LIBINPUT_RIGHT_BUTTON_CODE;
1574 evenType = LIBINPUT_EVENT_POINTER_TAP;
1575 processor.HandleTouchpadRightButton(data, evenType, button);
1576 ASSERT_EQ (button, 0);
1577 }
1578 }
1579 }