1 /*
2 * Copyright (c) 2023-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 <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 #include "define_multimodal.h"
21 #include "libinput_mock.h"
22 #include "tablet_tool_tranform_processor.h"
23
24 #include "input_device_manager.h"
25
26 #undef MMI_LOG_TAG
27 #define MMI_LOG_TAG "TabletToolTranformProcessorTest"
28
29 namespace OHOS {
30 namespace MMI {
31 using namespace testing;
32 using namespace testing::ext;
33
34 class TabletToolTranformProcessorTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 };
41
SetUpTestCase(void)42 void TabletToolTranformProcessorTest::SetUpTestCase(void)
43 {
44 }
45
TearDownTestCase(void)46 void TabletToolTranformProcessorTest::TearDownTestCase(void)
47 {
48 }
49
SetUp()50 void TabletToolTranformProcessorTest::SetUp()
51 {
52 }
53
TearDown()54 void TabletToolTranformProcessorTest::TearDown()
55 {
56 }
57
58 /**
59 * @tc.name: TabletToolTranformProcessorTest_OnEvent_001
60 * @tc.desc: Verify that TabletToolTranformProcessor can correctly handle events when receive
61 * @tc.type: FUNC
62 * @tc.require:
63 */
64 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_OnEvent_001, TestSize.Level1)
65 {
66 CALL_TEST_DEBUG;
67 int32_t deviceId = 6;
68 TabletToolTransformProcessor processor(deviceId);
69 libinput_event *event = nullptr;
70 std::shared_ptr<PointerEvent> ret = processor.OnEvent(event);
71 ASSERT_EQ(ret, nullptr);
72 }
73
74 /**
75 * @tc.name: TabletToolTranformProcessorTest_OnTip_001
76 * @tc.desc: Tablet tool transformation processor test, testing under the tip function
77 * @tc.type: FUNC
78 * @tc.require:
79 */
80 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_OnTip_001, TestSize.Level1)
81 {
82 CALL_TEST_DEBUG;
83 int32_t deviceId = 6;
84 TabletToolTransformProcessor processor(deviceId);
85 libinput_event_tablet_tool event {};
86
87 NiceMock<LibinputInterfaceMock> libinputMock;
88 EXPECT_CALL(libinputMock, GetTabletToolEvent).WillOnce(Return(&event));
89 EXPECT_CALL(libinputMock, TabletToolGetTipState).WillOnce(Return(LIBINPUT_TABLET_TOOL_TIP_DOWN));
90
91 bool ret = processor.OnTip(&event.base);
92 EXPECT_FALSE(ret);
93 }
94
95 /**
96 * @tc.name: TabletToolTranformProcessorTest_OnTipDown_001
97 * @tc.desc: Test the OnTipDown method in the TabletToolTranformProcessor class
98 * @tc.type: FUNC
99 * @tc.require:
100 */
101 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_OnTipDown_001, TestSize.Level1)
102 {
103 CALL_TEST_DEBUG;
104 int32_t deviceId = 6;
105 TabletToolTransformProcessor processor(deviceId);
106 libinput_event_tablet_tool *event = nullptr;
107 bool ret = processor.OnTipDown(event);
108 ASSERT_FALSE(ret);
109 }
110
111 /**
112 * @tc.name: TabletToolTranformProcessorTest_OnTipMotion_001
113 * @tc.desc: Test the response of TabletToolTranformProcessor when the tip is moving
114 * @tc.type: FUNC
115 * @tc.require:
116 */
117 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_OnTipMotion_001, TestSize.Level1)
118 {
119 CALL_TEST_DEBUG;
120 int32_t deviceId = 6;
121 TabletToolTransformProcessor processor(deviceId);
122 libinput_event *event = nullptr;
123 bool ret = processor.OnTipMotion(event);
124 ASSERT_FALSE(ret);
125 }
126
127 /**
128 * @tc.name: TabletToolTranformProcessorTest_OnTipUp_001
129 * @tc.desc: Test case for the OnTipUp method of the TabletToolTranformProcessor class
130 * @tc.type: FUNC
131 * @tc.require:
132 */
133 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_OnTipUp_001, TestSize.Level1)
134 {
135 CALL_TEST_DEBUG;
136 int32_t deviceId = 6;
137 TabletToolTransformProcessor processor(deviceId);
138 libinput_event_tablet_tool *event = nullptr;
139 bool ret = processor.OnTipUp(event);
140 ASSERT_FALSE(ret);
141 }
142
143 /**
144 * @tc.name: TabletToolTranformProcessorTest_GetToolType_01
145 * @tc.desc: Tablet tool transformation processor test, testing under the tip function
146 * @tc.type: FUNC
147 * @tc.require:
148 */
149 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_GetToolType_01, TestSize.Level1)
150 {
151 CALL_TEST_DEBUG;
152 int32_t deviceId = 6;
153 TabletToolTransformProcessor processor(deviceId);
154
155 NiceMock<LibinputInterfaceMock> libinputMock;
156 EXPECT_CALL(libinputMock, TabletToolGetToolType).WillOnce(Return(1));
157 libinput_event_tablet_tool* tabletEvent = nullptr;
158 int32_t ret = processor.GetToolType(tabletEvent);
159 EXPECT_EQ(ret, PointerEvent::TOOL_TYPE_PEN);
160 }
161
162 /**
163 * @tc.name: TabletToolTranformProcessorTest_GetToolType_02
164 * @tc.desc: Tablet tool transformation processor test, testing under the tip function
165 * @tc.type: FUNC
166 * @tc.require:
167 */
168 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_GetToolType_02, TestSize.Level1)
169 {
170 CALL_TEST_DEBUG;
171 int32_t deviceId = 6;
172 libinput_event_tablet_tool* tabletEvent = nullptr;
173 TabletToolTransformProcessor processor(deviceId);
174 libinput_tablet_tool event {};
175
176 NiceMock<LibinputInterfaceMock> libinputMock;
177 EXPECT_CALL(libinputMock, TabletToolGetToolType).WillOnce(Return(0));
178 EXPECT_CALL(libinputMock, TabletToolGetTool).WillOnce(Return(&event));
179 EXPECT_CALL(libinputMock, TabletToolGetType).WillOnce(Return(LIBINPUT_TABLET_TOOL_TYPE_PEN));
180
181 int32_t ret = processor.GetToolType(tabletEvent);
182 EXPECT_EQ(ret, PointerEvent::TOOL_TYPE_PEN);
183 }
184
185 /**
186 * @tc.name: TabletToolTranformProcessorTest_GetToolType_03
187 * @tc.desc: Tablet tool transformation processor test, testing under the tip function
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_GetToolType_03, TestSize.Level1)
192 {
193 CALL_TEST_DEBUG;
194 int32_t deviceId = 6;
195 libinput_event_tablet_tool* tabletEvent = nullptr;
196 TabletToolTransformProcessor processor(deviceId);
197 libinput_tablet_tool event {};
198
199 NiceMock<LibinputInterfaceMock> libinputMock;
200 EXPECT_CALL(libinputMock, TabletToolGetToolType).WillOnce(Return(0));
201 EXPECT_CALL(libinputMock, TabletToolGetTool).WillOnce(Return(&event));
202 EXPECT_CALL(libinputMock, TabletToolGetType).WillOnce(Return(LIBINPUT_TABLET_TOOL_TYPE_ERASER));
203
204 int32_t ret = processor.GetToolType(tabletEvent);
205 EXPECT_EQ(ret, PointerEvent::TOOL_TYPE_RUBBER);
206 }
207
208 /**
209 * @tc.name: TabletToolTranformProcessorTest_GetToolType_04
210 * @tc.desc: Tablet tool transformation processor test, testing under the tip function
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_GetToolType_04, TestSize.Level1)
215 {
216 CALL_TEST_DEBUG;
217 int32_t deviceId = 6;
218 libinput_event_tablet_tool* tabletEvent = nullptr;
219 TabletToolTransformProcessor processor(deviceId);
220 libinput_tablet_tool event {};
221
222 NiceMock<LibinputInterfaceMock> libinputMock;
223 EXPECT_CALL(libinputMock, TabletToolGetToolType).WillOnce(Return(0));
224 EXPECT_CALL(libinputMock, TabletToolGetTool).WillOnce(Return(&event));
225 EXPECT_CALL(libinputMock, TabletToolGetType).WillOnce(Return(LIBINPUT_TABLET_TOOL_TYPE_BRUSH));
226
227 int32_t ret = processor.GetToolType(tabletEvent);
228 EXPECT_EQ(ret, PointerEvent::TOOL_TYPE_BRUSH);
229 }
230
231 /**
232 * @tc.name: TabletToolTranformProcessorTest_GetToolType_05
233 * @tc.desc: Tablet tool transformation processor test, testing under the tip function
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_GetToolType_05, TestSize.Level1)
238 {
239 CALL_TEST_DEBUG;
240 int32_t deviceId = 6;
241 libinput_event_tablet_tool* tabletEvent = nullptr;
242 TabletToolTransformProcessor processor(deviceId);
243 libinput_tablet_tool event {};
244
245 NiceMock<LibinputInterfaceMock> libinputMock;
246 EXPECT_CALL(libinputMock, TabletToolGetToolType).WillOnce(Return(0));
247 EXPECT_CALL(libinputMock, TabletToolGetTool).WillOnce(Return(&event));
248 EXPECT_CALL(libinputMock, TabletToolGetType).WillOnce(Return(LIBINPUT_TABLET_TOOL_TYPE_PENCIL));
249
250 int32_t ret = processor.GetToolType(tabletEvent);
251 EXPECT_EQ(ret, PointerEvent::TOOL_TYPE_PENCIL);
252 }
253
254 /**
255 * @tc.name: TabletToolTranformProcessorTest_GetToolType_06
256 * @tc.desc: Tablet tool transformation processor test, testing under the tip function
257 * @tc.type: FUNC
258 * @tc.require:
259 */
260 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_GetToolType_06, TestSize.Level1)
261 {
262 CALL_TEST_DEBUG;
263 int32_t deviceId = 6;
264 libinput_event_tablet_tool* tabletEvent = nullptr;
265 TabletToolTransformProcessor processor(deviceId);
266 libinput_tablet_tool event {};
267
268 NiceMock<LibinputInterfaceMock> libinputMock;
269 EXPECT_CALL(libinputMock, TabletToolGetToolType).WillOnce(Return(0));
270 EXPECT_CALL(libinputMock, TabletToolGetTool).WillOnce(Return(&event));
271 EXPECT_CALL(libinputMock, TabletToolGetType).WillOnce(Return(LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH));
272
273 int32_t ret = processor.GetToolType(tabletEvent);
274 EXPECT_EQ(ret, PointerEvent::TOOL_TYPE_AIRBRUSH);
275 }
276
277 /**
278 * @tc.name: TabletToolTranformProcessorTest_GetToolType_07
279 * @tc.desc: Tablet tool transformation processor test, testing under the tip function
280 * @tc.type: FUNC
281 * @tc.require:
282 */
283 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_GetToolType_07, TestSize.Level1)
284 {
285 CALL_TEST_DEBUG;
286 int32_t deviceId = 6;
287 libinput_event_tablet_tool* tabletEvent = nullptr;
288 TabletToolTransformProcessor processor(deviceId);
289 libinput_tablet_tool event {};
290
291 NiceMock<LibinputInterfaceMock> libinputMock;
292 EXPECT_CALL(libinputMock, TabletToolGetToolType).WillOnce(Return(0));
293 EXPECT_CALL(libinputMock, TabletToolGetTool).WillOnce(Return(&event));
294 EXPECT_CALL(libinputMock, TabletToolGetType).WillOnce(Return(LIBINPUT_TABLET_TOOL_TYPE_MOUSE));
295
296 int32_t ret = processor.GetToolType(tabletEvent);
297 EXPECT_EQ(ret, PointerEvent::TOOL_TYPE_MOUSE);
298 }
299
300 /**
301 * @tc.name: TabletToolTranformProcessorTest_GetToolType_08
302 * @tc.desc: Tablet tool transformation processor test, testing under the tip function
303 * @tc.type: FUNC
304 * @tc.require:
305 */
306 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_GetToolType_08, TestSize.Level1)
307 {
308 CALL_TEST_DEBUG;
309 int32_t deviceId = 6;
310 libinput_event_tablet_tool* tabletEvent = nullptr;
311 TabletToolTransformProcessor processor(deviceId);
312 libinput_tablet_tool event {};
313
314 NiceMock<LibinputInterfaceMock> libinputMock;
315 EXPECT_CALL(libinputMock, TabletToolGetToolType).WillOnce(Return(0));
316 EXPECT_CALL(libinputMock, TabletToolGetTool).WillOnce(Return(&event));
317 EXPECT_CALL(libinputMock, TabletToolGetType).WillOnce(Return(LIBINPUT_TABLET_TOOL_TYPE_LENS));
318
319 int32_t ret = processor.GetToolType(tabletEvent);
320 EXPECT_EQ(ret, PointerEvent::TOOL_TYPE_LENS);
321 }
322
323 /**
324 * @tc.name: TabletToolTranformProcessorTest_OnEvent_002
325 * @tc.desc: Test the funcation OnEvent
326 * @tc.type: FUNC
327 * @tc.require:
328 */
329 HWTEST_F(TabletToolTranformProcessorTest, TabletToolTranformProcessorTest_OnEvent_002, TestSize.Level1)
330 {
331 int32_t deviceId = 2;
332 TabletToolTransformProcessor processor(deviceId);
333 libinput_event_tablet_tool event {};
334
335 NiceMock<LibinputInterfaceMock> libinputMock;
336 EXPECT_CALL(libinputMock, GetEventType).WillOnce(Return(LIBINPUT_EVENT_TABLET_TOOL_AXIS));
337
338 auto pointerEvent = processor.OnEvent(&event.base);
339 ASSERT_TRUE(pointerEvent == nullptr);
340 }
341 } // namespace MMI
342 } // namespace OHOS