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_TerminateRotate_001
89 * @tc.desc: Test the function TerminateRotate
90 * @tc.type: FUNC
91 * @tc.require:
92 */
93 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_TerminateRotate_001, TestSize.Level1)
94 {
95 CALL_TEST_DEBUG;
96 EventNormalizeHandler handler;
97 libinput_event event {};
98 NiceMock<LibinputInterfaceMock> libinputMock;
99 GestureHandler gestureHandler;
100 gestureHandler.isStartRotate_ = false;
101 ASSERT_NO_FATAL_FAILURE(handler.TerminateRotate(&event));
102 gestureHandler.isStartRotate_ = true;
103 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_BUTTON_TOUCHPAD));
104 ASSERT_NO_FATAL_FAILURE(handler.TerminateRotate(&event));
105 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_MOTION_TOUCHPAD));
106 ASSERT_NO_FATAL_FAILURE(handler.TerminateRotate(&event));
107 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_AXIS));
108 ASSERT_NO_FATAL_FAILURE(handler.TerminateRotate(&event));
109 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_TAP));
110 ASSERT_NO_FATAL_FAILURE(handler.TerminateRotate(&event));
111 }
112
113 /**
114 * @tc.name: EventNormalizeHandlerEXTest_ResetTouchUpEvent_001
115 * @tc.desc: Test the function ResetTouchUpEvent
116 * @tc.type: FUNC
117 * @tc.require:
118 */
119 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_ResetTouchUpEvent_001, TestSize.Level1)
120 {
121 CALL_TEST_DEBUG;
122 EventNormalizeHandler handler;
123 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
124 ASSERT_NE(pointerEvent, nullptr);
125 libinput_event event {};
126 NiceMock<LibinputInterfaceMock> libinputMock;
127 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCH_UP));
128 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
129 PointerEvent::PointerItem testPointerItem;
130 pointerEvent->pointers_.push_back(PointerEvent::PointerItem());
131 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
132 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCH_DOWN));
133 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
134 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCH_MOTION));
135 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
136 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCH_CANCEL));
137 ASSERT_NO_FATAL_FAILURE(handler.ResetTouchUpEvent(pointerEvent, &event));
138 }
139
140 /**
141 * @tc.name: EventNormalizeHandlerEXTest_HandleMouseEvent_001
142 * @tc.desc: Test the function HandleMouseEvent
143 * @tc.type: FUNC
144 * @tc.require:
145 */
146 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_HandleMouseEvent_001, TestSize.Level1)
147 {
148 CALL_TEST_DEBUG;
149 EventNormalizeHandler handler;
150 libinput_event event {};
151 NiceMock<LibinputInterfaceMock> libinputMock;
152 libinput_device device {};
153 libinput_event_pointer pointerEvent {};
154 EXPECT_CALL(libinputMock, GetDevice).WillRepeatedly(Return(&device));
155 EXPECT_CALL(libinputMock, DeviceGetName).WillRepeatedly(Return(const_cast<char*>("rotary_crown")));
156 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_POINTER_AXIS));
157 EXPECT_CALL(libinputMock, LibinputGetPointerEvent).WillRepeatedly(Return(&pointerEvent));
158 EXPECT_CALL(libinputMock, GetAxisSource).WillRepeatedly(Return(LIBINPUT_POINTER_AXIS_SOURCE_WHEEL));
159 ASSERT_NO_FATAL_FAILURE(handler.HandleMouseEvent(&event));
160 EXPECT_CALL(libinputMock, GetAxisSource).WillRepeatedly(Return(LIBINPUT_POINTER_AXIS_SOURCE_FINGER));
161 ASSERT_NO_FATAL_FAILURE(handler.HandleMouseEvent(&event));
162 }
163
164 /**
165 * @tc.name: EventNormalizeHandlerEXTest_HandleGestureEvent_001
166 * @tc.desc: Test the function HandleGestureEvent
167 * @tc.type: FUNC
168 * @tc.require:
169 */
170 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_HandleGestureEvent_001, TestSize.Level1)
171 {
172 CALL_TEST_DEBUG;
173 EventNormalizeHandler handler;
174 handler.nextHandler_ = std::make_shared<EventFilterHandler>();
175 handler.SetNext(handler.nextHandler_);
176 libinput_event event {};
177 NiceMock<LibinputInterfaceMock> libinputMock;
178 libinput_device device {};
179 EXPECT_CALL(libinputMock, GetDevice).WillRepeatedly(Return(&device));
180 MouseEventNormalize mouseEventNormalize;
181 mouseEventNormalize.processors_.insert(std::make_pair(1, nullptr));
182 InputDeviceManager inputDevice;
183 InputDeviceManager::InputDeviceInfo inDevice;
184 int32_t deviceId = 2;
185 inDevice.isPointerDevice = false;
186 inDevice.enable = false;
187 inputDevice.inputDevice_.insert(std::make_pair(deviceId, inDevice));
188 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_SWIPE_END));
189 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
190 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_PINCH_END));
191 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
192 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
193 ASSERT_NE(pointerEvent, nullptr);
194 PointerEvent::PointerItem testPointerItem;
195 pointerEvent->pointers_.push_back(PointerEvent::PointerItem());
196 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
197 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE));
198 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
199 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN));
200 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
201 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_GESTURE_PINCH_UPDATE));
202 ASSERT_NO_FATAL_FAILURE(handler.HandleGestureEvent(&event));
203 }
204
205 /**
206 * @tc.name: EventNormalizeHandlerEXTest_HandlePalmEvent_001
207 * @tc.desc: Test the function HandlePalmEvent
208 * @tc.type: FUNC
209 * @tc.require:
210 */
211 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_HandlePalmEvent_001, TestSize.Level1)
212 {
213 CALL_TEST_DEBUG;
214 EventNormalizeHandler handler;
215 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
216 ASSERT_NE(pointerEvent, nullptr);
217 libinput_event event {};
218 libinput_event_touch touchevent {};
219 NiceMock<LibinputInterfaceMock> libinputMock;
220 EXPECT_CALL(libinputMock, GetTouchpadEvent).WillRepeatedly(Return(nullptr));
221 ASSERT_NO_FATAL_FAILURE(handler.HandlePalmEvent(&event, pointerEvent));
222 EXPECT_CALL(libinputMock, GetTouchpadEvent).WillRepeatedly(Return(&touchevent));
223 EXPECT_CALL(libinputMock, TouchpadGetTool).WillRepeatedly(Return(2));
224 ASSERT_NO_FATAL_FAILURE(handler.HandlePalmEvent(&event, pointerEvent));
225 EXPECT_CALL(libinputMock, TouchpadGetTool).WillRepeatedly(Return(3));
226 ASSERT_NO_FATAL_FAILURE(handler.HandlePalmEvent(&event, pointerEvent));
227 }
228
229 /**
230 * @tc.name: EventNormalizeHandlerEXTest_HandleTouchPadEvent_001
231 * @tc.desc: Test the function HandleTouchPadEvent
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(EventNormalizeHandlerEXTest, EventNormalizeHandlerEXTest_HandleTouchPadEvent_001, TestSize.Level1)
236 {
237 CALL_TEST_DEBUG;
238 EventNormalizeHandler handler;
239 int32_t deviceId = 6;
240 TabletToolTransformProcessor tabletToolTransformProcessor(deviceId);
241 tabletToolTransformProcessor.pointerEvent_ = PointerEvent::Create();
242 libinput_event event {};
243 handler.nextHandler_ = std::make_shared<EventFilterHandler>();
244 handler.SetNext(handler.nextHandler_);
245 libinput_event_touch touchevent {};
246 NiceMock<LibinputInterfaceMock> libinputMock;
247 EXPECT_CALL(libinputMock, GetTouchpadEvent).WillRepeatedly(Return(&touchevent));
248 MultiFingersTapHandler processor;
249 processor.multiFingersState_ = MulFingersTap::TRIPLETAP;
250 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
251 processor.multiFingersState_ = MulFingersTap::QUAD_TAP;
252 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
253 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCHPAD_DOWN));
254 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
255 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCHPAD_UP));
256 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
257 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(Return(LIBINPUT_EVENT_TOUCHPAD_MOTION));
258 ASSERT_NO_FATAL_FAILURE(handler.HandleTouchPadEvent(&event));
259 }
260 } // namespace MMI
261 } // namespace OHOS