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