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 #include <cstdio>
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "define_multimodal.h"
20 #include "libinput_mock.h"
21 #include "pointer_event.h"
22 #include "preferences_manager_mock.h"
23 #include "touchpad_transform_processor.h"
24
25 #include "input_device_manager.h"
26
27 #undef MMI_LOG_TAG
28 #define MMI_LOG_TAG "TouchPadTransformProcessorMockTest"
29
30 namespace OHOS {
31 namespace MMI {
32 using namespace testing;
33 using namespace testing::ext;
34
35 class TouchPadTransformProcessorMockTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 void SetUp();
40 void TearDown();
41 };
42
SetUpTestCase(void)43 void TouchPadTransformProcessorMockTest::SetUpTestCase(void)
44 {}
45
TearDownTestCase(void)46 void TouchPadTransformProcessorMockTest::TearDownTestCase(void)
47 {}
48
SetUp()49 void TouchPadTransformProcessorMockTest::SetUp()
50 {}
51
TearDown()52 void TouchPadTransformProcessorMockTest::TearDown()
53 {}
54
55 /**
56 * @tc.name: TouchPadTransformProcessorMockTest_OnEvent_01
57 * @tc.desc: OnEvent
58 * @tc.type: FUNC
59 * @tc.require:
60 */
61 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMockTest_OnEvent_01, TestSize.Level1)
62 {
63 CALL_TEST_DEBUG;
64 int32_t deviceId = 2;
65 TouchPadTransformProcessor processor(deviceId);
66 processor.pointerEvent_ = PointerEvent::Create();
67 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
68 libinput_event event {};
69
70 NiceMock<LibinputInterfaceMock> libinputMock;
71 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(testing::Return(LIBINPUT_EVENT_TOUCHPAD_DOWN));
72
73 auto pointerEvent = processor.OnEvent(&event);
74 ASSERT_TRUE(pointerEvent == nullptr);
75 }
76
77 /**
78 * @tc.name: TouchPadTransformProcessorMockTest_OnEvent_02
79 * @tc.desc: OnEvent
80 * @tc.type: FUNC
81 * @tc.require:
82 */
83 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMockTest_OnEvent_02, TestSize.Level1)
84 {
85 CALL_TEST_DEBUG;
86 int32_t deviceId = 2;
87 TouchPadTransformProcessor processor(deviceId);
88 processor.pointerEvent_ = PointerEvent::Create();
89 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
90 libinput_event event {};
91
92 NiceMock<LibinputInterfaceMock> libinputMock;
93 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(testing::Return(LIBINPUT_EVENT_TOUCHPAD_UP));
94
95 auto pointerEvent = processor.OnEvent(&event);
96 ASSERT_TRUE(pointerEvent == nullptr);
97 }
98
99 /**
100 * @tc.name: TouchPadTransformProcessorMockTest_OnEvent_03
101 * @tc.desc: OnEvent
102 * @tc.type: FUNC
103 * @tc.require:
104 */
105 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMockTest_OnEvent_03, TestSize.Level1)
106 {
107 CALL_TEST_DEBUG;
108 int32_t deviceId = 2;
109 TouchPadTransformProcessor processor(deviceId);
110 processor.pointerEvent_ = PointerEvent::Create();
111 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
112 libinput_event event {};
113
114 NiceMock<LibinputInterfaceMock> libinputMock;
115 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(testing::Return(LIBINPUT_EVENT_TOUCHPAD_MOTION));
116
117 auto pointerEvent = processor.OnEvent(&event);
118 ASSERT_TRUE(pointerEvent == nullptr);
119 }
120
121 /**
122 * @tc.name: TouchPadTransformProcessorMockTest_OnEvent_04
123 * @tc.desc: OnEvent
124 * @tc.type: FUNC
125 * @tc.require:
126 */
127 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMockTest_OnEvent_04, TestSize.Level1)
128 {
129 CALL_TEST_DEBUG;
130 int32_t deviceId = 2;
131 TouchPadTransformProcessor processor(deviceId);
132 processor.pointerEvent_ = PointerEvent::Create();
133 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
134 libinput_event event {};
135
136 NiceMock<LibinputInterfaceMock> libinputMock;
137 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(testing::Return(LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN));
138
139 auto pointerEvent = processor.OnEvent(&event);
140 ASSERT_TRUE(pointerEvent == nullptr);
141 }
142
143 /**
144 * @tc.name: TouchPadTransformProcessorMockTest_OnEvent_05
145 * @tc.desc: OnEvent
146 * @tc.type: FUNC
147 * @tc.require:
148 */
149 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMockTest_OnEvent_05, TestSize.Level1)
150 {
151 CALL_TEST_DEBUG;
152 int32_t deviceId = 2;
153 TouchPadTransformProcessor processor(deviceId);
154 processor.pointerEvent_ = PointerEvent::Create();
155 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
156 libinput_event event {};
157
158 NiceMock<LibinputInterfaceMock> libinputMock;
159 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(testing::Return(LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE));
160
161 auto pointerEvent = processor.OnEvent(&event);
162 ASSERT_TRUE(pointerEvent == nullptr);
163 }
164
165 /**
166 * @tc.name: TouchPadTransformProcessorMockTest_OnEvent_06
167 * @tc.desc: OnEvent
168 * @tc.type: FUNC
169 * @tc.require:
170 */
171 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMockTest_OnEvent_06, TestSize.Level1)
172 {
173 CALL_TEST_DEBUG;
174 int32_t deviceId = 2;
175 TouchPadTransformProcessor processor(deviceId);
176 processor.pointerEvent_ = PointerEvent::Create();
177 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
178 libinput_event event {};
179
180 NiceMock<LibinputInterfaceMock> libinputMock;
181 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(testing::Return(LIBINPUT_EVENT_GESTURE_SWIPE_END));
182
183 auto pointerEvent = processor.OnEvent(&event);
184 ASSERT_TRUE(pointerEvent == nullptr);
185 }
186
187 /**
188 * @tc.name: TouchPadTransformProcessorMockTest_OnEvent_07
189 * @tc.desc: OnEvent
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMockTest_OnEvent_07, TestSize.Level1)
194 {
195 CALL_TEST_DEBUG;
196 int32_t deviceId = 2;
197 TouchPadTransformProcessor processor(deviceId);
198 processor.pointerEvent_ = PointerEvent::Create();
199 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
200 libinput_event event {};
201
202 NiceMock<LibinputInterfaceMock> libinputMock;
203 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(testing::Return(LIBINPUT_EVENT_GESTURE_PINCH_BEGIN));
204
205 auto pointerEvent = processor.OnEvent(&event);
206 ASSERT_TRUE(pointerEvent == nullptr);
207 }
208
209 /**
210 * @tc.name: TouchPadTransformProcessorMockTest_OnEvent_08
211 * @tc.desc: OnEvent
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMockTest_OnEvent_08, TestSize.Level1)
216 {
217 CALL_TEST_DEBUG;
218 int32_t deviceId = 2;
219 TouchPadTransformProcessor processor(deviceId);
220 processor.pointerEvent_ = PointerEvent::Create();
221 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
222 libinput_event event {};
223
224 NiceMock<LibinputInterfaceMock> libinputMock;
225 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(testing::Return(LIBINPUT_EVENT_GESTURE_PINCH_UPDATE));
226
227 auto pointerEvent = processor.OnEvent(&event);
228 ASSERT_TRUE(pointerEvent == nullptr);
229 }
230
231 /**
232 * @tc.name: TouchPadTransformProcessorMockTest_OnEvent_09
233 * @tc.desc: OnEvent
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMockTest_OnEvent_09, TestSize.Level1)
238 {
239 CALL_TEST_DEBUG;
240 int32_t deviceId = 2;
241 TouchPadTransformProcessor processor(deviceId);
242 processor.pointerEvent_ = PointerEvent::Create();
243 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
244 libinput_event event {};
245
246 NiceMock<LibinputInterfaceMock> libinputMock;
247 EXPECT_CALL(libinputMock, GetEventType).WillRepeatedly(testing::Return(LIBINPUT_EVENT_GESTURE_PINCH_END));
248
249 auto pointerEvent = processor.OnEvent(&event);
250 ASSERT_TRUE(pointerEvent == nullptr);
251 }
252
253 /**
254 * @tc.name: TouchPadTransformProcessorMock_SetTouchPadSwipeData_01
255 * @tc.desc: SetTouchPadSwipeData
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMock_SetTouchPadSwipeData_01, TestSize.Level1)
260 {
261 CALL_TEST_DEBUG;
262 int32_t deviceId = 2;
263 TouchPadTransformProcessor processor(deviceId);
264 int32_t action = PointerEvent::POINTER_ACTION_SWIPE_UPDATE;
265 processor.pointerEvent_ = PointerEvent::Create();
266 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
267
268 libinput_event_gesture gestureevent {};
269 libinput_event event {};
270 NiceMock<LibinputInterfaceMock> libinputMock;
271 EXPECT_CALL(libinputMock, GetGestureEvent).WillRepeatedly(Return(&gestureevent));
272 EXPECT_CALL(libinputMock, GestureEventGetTime).WillRepeatedly(Return(1000));
273 EXPECT_CALL(libinputMock, GestureEventGetFingerCount).WillRepeatedly(Return(-1));
274
275 int32_t ret = processor.SetTouchPadSwipeData(&event, action);
276 EXPECT_EQ(ret, RET_ERR);
277 }
278
279 /**
280 * @tc.name: TouchPadTransformProcessorMock_SetTouchPadSwipeData_02
281 * @tc.desc: SetTouchPadSwipeData
282 * @tc.type: FUNC
283 * @tc.require:
284 */
285 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMock_SetTouchPadSwipeData_02, TestSize.Level1)
286 {
287 CALL_TEST_DEBUG;
288 int32_t deviceId = 2;
289 TouchPadTransformProcessor processor(deviceId);
290 int32_t action = PointerEvent::POINTER_ACTION_SWIPE_UPDATE;
291 processor.pointerEvent_ = PointerEvent::Create();
292 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
293
294 libinput_event_gesture gestureevent {};
295 libinput_event event {};
296 NiceMock<LibinputInterfaceMock> libinputMock;
297 EXPECT_CALL(libinputMock, GetGestureEvent).WillRepeatedly(Return(&gestureevent));
298 EXPECT_CALL(libinputMock, GestureEventGetTime).WillRepeatedly(Return(1000));
299 EXPECT_CALL(libinputMock, GestureEventGetFingerCount).WillRepeatedly(Return(0));
300
301 int32_t ret = processor.SetTouchPadSwipeData(&event, action);
302 EXPECT_EQ(ret, RET_ERR);
303 }
304
305 /**
306 * @tc.name: TouchPadTransformProcessorMock_SetTouchPadSwipeData_03
307 * @tc.desc: SetTouchPadSwipeData
308 * @tc.type: FUNC
309 * @tc.require:
310 */
311 HWTEST_F(TouchPadTransformProcessorMockTest, TouchPadTransformProcessorMock_SetTouchPadSwipeData_03, TestSize.Level1)
312 {
313 CALL_TEST_DEBUG;
314 int32_t deviceId = 2;
315 TouchPadTransformProcessor processor(deviceId);
316 int32_t action = PointerEvent::POINTER_ACTION_SWIPE_UPDATE;
317 processor.pointerEvent_ = PointerEvent::Create();
318 ASSERT_TRUE(processor.pointerEvent_ != nullptr);
319
320 libinput_event_gesture gestureevent {};
321 libinput_event event {};
322 NiceMock<LibinputInterfaceMock> libinputMock;
323 EXPECT_CALL(libinputMock, GetGestureEvent).WillRepeatedly(Return(&gestureevent));
324 EXPECT_CALL(libinputMock, GestureEventGetTime).WillRepeatedly(Return(1000));
325 EXPECT_CALL(libinputMock, GestureEventGetFingerCount).WillRepeatedly(Return(7));
326
327 int32_t ret = processor.SetTouchPadSwipeData(&event, action);
328 EXPECT_EQ(ret, RET_ERR);
329 }
330
331 } // namespace MMI
332 } // namespace OHOS