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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "dfx_hisysevent.h"
20 #include "event_filter_handler.h"
21 #include "event_normalize_handler.h"
22 #include "event_resample.h"
23 #include "general_touchpad.h"
24 #include "input_device_manager.h"
25 #include "i_input_windows_manager.h"
26 #include "libinput_mock.h"
27 #include "libinput_wrapper.h"
28 #include "mouse_event_normalize.h"
29 #include "tablet_tool_tranform_processor.h"
30 #include "touchpad_transform_processor.h"
31
32 #undef MMI_LOG_TAG
33 #define MMI_LOG_TAG "EventNormalizeHandlerEXTest"
34 namespace OHOS {
35 namespace MMI {
36 namespace {
37 using namespace testing;
38 using namespace testing::ext;
39 } // namespace
40
41 class EventNormalizeHandlerEXTest : public testing::Test {
42 public:
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
45 void SetUp();
46 void TearDown();
47 };
48
SetUpTestCase(void)49 void EventNormalizeHandlerEXTest::SetUpTestCase(void)
50 {
51 }
52
TearDownTestCase(void)53 void EventNormalizeHandlerEXTest::TearDownTestCase(void)
54 {
55 }
56
SetUp()57 void EventNormalizeHandlerEXTest::SetUp()
58 {
59 }
60
TearDown()61 void EventNormalizeHandlerEXTest::TearDown()
62 {
63 }
64
65 /**
66 * @tc.name: EventNormalizeHandlerEXTest_TerminateAxis_001
67 * @tc.desc: Test the function TerminateAxis
68 * @tc.type: FUNC
69 * @tc.require:
70 */
71 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_TerminateAxis_001, TestSize.Level1)
72 {
73 CALL_TEST_DEBUG;
74 EventNormalizeHandler handler;
75 libinput_event event {};
76 NiceMock<LibinputInterfaceMock> libinputMock;
77 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD));
78 ASSERT_NO_FATAL_FAILURE(handler.TerminateAxis(&event));
79 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_MOTION_TOUCHPAD));
80 ASSERT_NO_FATAL_FAILURE(handler.TerminateAxis(&event));
81 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_AXIS));
82 ASSERT_NO_FATAL_FAILURE(handler.TerminateAxis(&event));
83 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_TAP));
84 ASSERT_NO_FATAL_FAILURE(handler.TerminateAxis(&event));
85 }
86
87 /**
88 * @tc.name: EventNormalizeHandlerEXTest_ResetTouchUpEvent_001
89 * @tc.desc: Test the function ResetTouchUpEvent
90 * @tc.type: FUNC
91 * @tc.require:
92 */
93 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_ResetTouchUpEvent_001, TestSize.Level1)
94 {
95 CALL_TEST_DEBUG;
96 EventNormalizeHandler handler;
97 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
98 ASSERT_NE(pointerEvent, nullptr);
99 libinput_event event {};
100 NiceMock<LibinputInterfaceMock> libinputMock;
101 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCH_UP));
102 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
103 PointerEvent::PointerItem testPointerItem;
104 pointerEvent->pointers_.push_back(PointerEvent::PointerItem());
105 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
106 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCH_DOWN));
107 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
108 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCH_MOTION));
109 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
110 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCH_CANCEL));
111 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
112 }
113
114 /**
115 * @tc.name: EventNormalizeHandlerEXTest_HandleMouseEvent_001
116 * @tc.desc: Test the function HandleMouseEvent
117 * @tc.type: FUNC
118 * @tc.require:
119 */
120 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_HandleMouseEvent_001, TestSize.Level1)
121 {
122 CALL_TEST_DEBUG;
123 EventNormalizeHandler handler;
124 libinput_event event {};
125 NiceMock<LibinputInterfaceMock> libinputMock;
126 libinput_device device {};
127 libinput_event_pointer pointerEvent {};
128 EXPECT_CALL(libinputMock, GetDevice).WillRepeatedly(Return(&device));
129 EXPECT_CALL(libinputMock, DeviceGetName).WillRepeatedly(Return(const_cast<char*>("rotary_crown")));
130 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_AXIS));
131 EXPECT_CALL(libinputMock, LibinputGetPointerEvent).WillRepeatedly(Return(&pointerEvent));
132 EXPECT_CALL(libinputMock, GetAxisSource).WillRepeatedly(Return(LIBINPUT_POINTER_AXIS_SOURCE_WHEEL));
133 ASSERT_NO_FATAL_FAILURE(handler.HandleMouseEvent(&event));
134 EXPECT_CALL(libinputMock, GetAxisSource).WillRepeatedly(Return(LIBINPUT_POINTER_AXIS_SOURCE_FINGER));
135 ASSERT_NO_FATAL_FAILURE(handler.HandleMouseEvent(&event));
136 }
137
138 /**
139 * @tc.name: EventNormalizeHandlerEXTest_HandleGestureEvent_001
140 * @tc.desc: Test the function HandleGestureEvent
141 * @tc.type: FUNC
142 * @tc.require:
143 */
144 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_HandleGestureEvent_001, TestSize.Level1)
145 {
146 CALL_TEST_DEBUG;
147 EventNormalizeHandler handler;
148 handler.nextHandler_ = std::make_shared<EventFilterHandler>();
149 handler.SetNext(handler.nextHandler_);
150 libinput_event event {};
151 NiceMock<LibinputInterfaceMock> libinputMock;
152 libinput_device device {};
153 EXPECT_CALL(libinputMock, GetDevice).WillRepeatedly(Return(&device));
154 MouseEventNormalize mouseEventNormalize;
155 mouseEventNormalize.processors_.insert(std::make_pair(1, nullptr));
156 InputDeviceManager inputDevice;
157 InputDeviceManager::InputDeviceInfo inDevice;
158 int32_t deviceId = 2;
159 inDevice.isPointerDevice = false;
160 inDevice.enable = false;
161 inputDevice.inputDevice_.insert(std::make_pair(deviceId, inDevice));
162 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_SWIPE_END));
163 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
164 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_PINCH_END));
165 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
166 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
167 ASSERT_NE(pointerEvent, nullptr);
168 PointerEvent::PointerItem testPointerItem;
169 pointerEvent->pointers_.push_back(PointerEvent::PointerItem());
170 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
171 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE));
172 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
173 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN));
174 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
175 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_PINCH_UPDATE));
176 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
177 }
178
179 /**
180 * @tc.name: EventNormalizeHandlerEXTest_HandlePalmEvent_001
181 * @tc.desc: Test the function HandlePalmEvent
182 * @tc.type: FUNC
183 * @tc.require:
184 */
185 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_HandlePalmEvent_001, TestSize.Level1)
186 {
187 CALL_TEST_DEBUG;
188 EventNormalizeHandler handler;
189 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
190 ASSERT_NE(pointerEvent, nullptr);
191 libinput_event event {};
192 libinput_event_touch touchevent {};
193 NiceMock<LibinputInterfaceMock> libinputMock;
194 EXPECT_CALL(libinputMock, GetTouchpadEvent).WillRepeatedly(Return(nullptr));
195 ASSERT_NO_FATAL_FAILURE(handler.HandlePalmEvent(&event, pointerEvent));
196 EXPECT_CALL(libinputMock, GetTouchpadEvent).WillRepeatedly(Return(&touchevent));
197 EXPECT_CALL(libinputMock, TouchpadGetTool).WillRepeatedly(Return(2));
198 ASSERT_NO_FATAL_FAILURE(handler.HandlePalmEvent(&event, pointerEvent));
199 EXPECT_CALL(libinputMock, TouchpadGetTool).WillRepeatedly(Return(3));
200 ASSERT_NO_FATAL_FAILURE(handler.HandlePalmEvent(&event, pointerEvent));
201 }
202
203 /**
204 * @tc.name: EventNormalizeHandlerEXTest_HandleTouchPadEvent_001
205 * @tc.desc: Test the function HandleTouchPadEvent
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_HandleTouchPadEvent_001, TestSize.Level1)
210 {
211 CALL_TEST_DEBUG;
212 EventNormalizeHandler handler;
213 int32_t deviceId = 6;
214 TabletToolTransformProcessor tabletToolTransformProcessor(deviceId);
215 tabletToolTransformProcessor.pointerEvent_ = PointerEvent::Create();
216 libinput_event event {};
217 handler.nextHandler_ = std::make_shared<EventFilterHandler>();
218 handler.SetNext(handler.nextHandler_);
219 libinput_event_touch touchevent {};
220 NiceMock<LibinputInterfaceMock> libinputMock;
221 EXPECT_CALL(libinputMock, GetTouchpadEvent).WillRepeatedly(Return(&touchevent));
222 MultiFingersTapHandler processor;
223 processor.multiFingersState_ = MulFingersTap::TRIPLETAP;
224 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
225 processor.multiFingersState_ = MulFingersTap::QUAD_TAP;
226 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
227 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCHPAD_DOWN));
228 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
229 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCHPAD_UP));
230 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
231 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCHPAD_MOTION));
232 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
233 }
234 } // namespace MMI
235 } // namespace OHOS