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 <cstdio>
17
18 #include <gtest/gtest.h>
19
20 #include "define_multimodal.h"
21 #include "general_keyboard.h"
22 #include "input_device_manager.h"
23 #include "i_input_windows_manager.h"
24 #include "key_event_normalize.h"
25 #include "libinput_wrapper.h"
26 #include "pointer_event.h"
27
28 #undef MMI_LOG_TAG
29 #define MMI_LOG_TAG "KeyEventNormalizeTest"
30
31 namespace OHOS {
32 namespace MMI {
33 namespace {
34 using namespace testing::ext;
35 }
36 class KeyEventNormalizeTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
SetUp()40 void SetUp(){};
TearDown()41 void TearDown(){};
42
43 private:
44 static void SetupKeyboard();
45 static void CloseKeyboard();
46 static GeneralKeyboard vKeyboard_;
47 static LibinputWrapper libinput_;
48 };
49
50 GeneralKeyboard KeyEventNormalizeTest::vKeyboard_;
51 LibinputWrapper KeyEventNormalizeTest::libinput_;
52
SetUpTestCase(void)53 void KeyEventNormalizeTest::SetUpTestCase(void)
54 {
55 ASSERT_TRUE(libinput_.Init());
56 SetupKeyboard();
57 }
58
TearDownTestCase(void)59 void KeyEventNormalizeTest::TearDownTestCase(void)
60 {
61 CloseKeyboard();
62 }
63
SetupKeyboard()64 void KeyEventNormalizeTest::SetupKeyboard()
65 {
66 ASSERT_TRUE(vKeyboard_.SetUp());
67 std::cout << "device node name: " << vKeyboard_.GetDevPath() << std::endl;
68 ASSERT_TRUE(libinput_.AddPath(vKeyboard_.GetDevPath()));
69 libinput_event *event = libinput_.Dispatch();
70 ASSERT_TRUE(event != nullptr);
71 ASSERT_EQ(libinput_event_get_type(event), LIBINPUT_EVENT_DEVICE_ADDED);
72 struct libinput_device *device = libinput_event_get_device(event);
73 ASSERT_TRUE(device != nullptr);
74 INPUT_DEV_MGR->OnInputDeviceAdded(device);
75 }
76
CloseKeyboard()77 void KeyEventNormalizeTest::CloseKeyboard()
78 {
79 libinput_.RemovePath(vKeyboard_.GetDevPath());
80 vKeyboard_.Close();
81 }
82
83 /**
84 * @tc.name: KeyEventNormalizeTest_Normalize_001
85 * @tc.desc: Test Normalize
86 * @tc.type: FUNC
87 * @tc.require:
88 */
89 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_Normalize_001, TestSize.Level1)
90 {
91 CALL_TEST_DEBUG;
92 vKeyboard_.SendEvent(EV_KEY, 29, 1);
93 vKeyboard_.SendEvent(EV_KEY, KEY_C, 1);
94 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
95 vKeyboard_.SendEvent(EV_KEY, KEY_C, 0);
96 vKeyboard_.SendEvent(EV_KEY, 29, 0);
97 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
98 libinput_event *event = libinput_.Dispatch();
99 ASSERT_TRUE(event != nullptr);
100 struct libinput_device *dev = libinput_event_get_device(event);
101 ASSERT_TRUE(dev != nullptr);
102 std::cout << "keyboard device: " << libinput_device_get_name(dev) << std::endl;
103 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
104 ASSERT_TRUE(keyEvent != nullptr);
105 keyEvent->SetAction(KeyEvent::KEY_ACTION_UP);
106 int32_t result = KeyEventHdr->Normalize(event, keyEvent);
107 EXPECT_EQ(result, RET_OK);
108 }
109
110 /**
111 * @tc.name: KeyEventNormalizeTest_Normalize_002
112 * @tc.desc: Test Normalize
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_Normalize_002, TestSize.Level1)
117 {
118 CALL_TEST_DEBUG;
119 vKeyboard_.SendEvent(EV_KEY, 29, 1);
120 vKeyboard_.SendEvent(EV_KEY, KEY_C, 1);
121 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
122 vKeyboard_.SendEvent(EV_KEY, KEY_C, 0);
123 vKeyboard_.SendEvent(EV_KEY, 29, 0);
124 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
125 libinput_event *event = libinput_.Dispatch();
126 ASSERT_TRUE(event != nullptr);
127 struct libinput_device *dev = libinput_event_get_device(event);
128 ASSERT_TRUE(dev != nullptr);
129 std::cout << "keyboard device: " << libinput_device_get_name(dev) << std::endl;
130 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
131 ASSERT_TRUE(keyEvent != nullptr);
132 keyEvent->SetAction(KeyEvent::KEY_ACTION_DOWN);
133 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
134 ASSERT_NE(pointerEvent, nullptr);
135 std::vector<int32_t> pressedKeys {};
136 pointerEvent->SetPressedKeys(pressedKeys);
137 int32_t result = KeyEventHdr->Normalize(event, keyEvent);
138 EXPECT_EQ(result, RET_OK);
139 }
140
141 /**
142 * @tc.name: KeyEventNormalizeTest_Normalize_003
143 * @tc.desc: Test Normalize
144 * @tc.type: FUNC
145 * @tc.require:
146 */
147 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_Normalize_003, TestSize.Level1)
148 {
149 CALL_TEST_DEBUG;
150 vKeyboard_.SendEvent(EV_KEY, 29, 1);
151 vKeyboard_.SendEvent(EV_KEY, KEY_C, 1);
152 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
153 vKeyboard_.SendEvent(EV_KEY, KEY_C, 0);
154 vKeyboard_.SendEvent(EV_KEY, 29, 0);
155 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
156 libinput_event *event = libinput_.Dispatch();
157 ASSERT_TRUE(event != nullptr);
158 struct libinput_device *dev = libinput_event_get_device(event);
159 ASSERT_TRUE(dev != nullptr);
160 std::cout << "keyboard device: " << libinput_device_get_name(dev) << std::endl;
161 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
162 ASSERT_TRUE(keyEvent != nullptr);
163 keyEvent->SetAction(KeyEvent::KEY_ACTION_DOWN);
164 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
165 ASSERT_NE(pointerEvent, nullptr);
166 std::vector<int32_t> pressedKeys { KeyEvent::KEYCODE_CTRL_LEFT };
167 pointerEvent->SetPressedKeys(pressedKeys);
168 int32_t result = KeyEventHdr->Normalize(event, keyEvent);
169 EXPECT_EQ(result, RET_OK);
170 }
171
172 /**
173 * @tc.name: KeyEventNormalizeTest_HandleKeyAction_001
174 * @tc.desc: Test HandleKeyAction
175 * @tc.type: FUNC
176 * @tc.require:
177 */
178 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_HandleKeyAction_001, TestSize.Level1)
179 {
180 CALL_TEST_DEBUG;
181 vKeyboard_.SendEvent(EV_KEY, 29, 1);
182 vKeyboard_.SendEvent(EV_KEY, KEY_C, 1);
183 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
184 vKeyboard_.SendEvent(EV_KEY, KEY_C, 0);
185 vKeyboard_.SendEvent(EV_KEY, 29, 0);
186 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
187 libinput_event *event = libinput_.Dispatch();
188 ASSERT_TRUE(event != nullptr);
189 struct libinput_device *dev = libinput_event_get_device(event);
190 ASSERT_TRUE(dev != nullptr);
191 std::cout << "keyboard device: " << libinput_device_get_name(dev) << std::endl;
192 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
193 ASSERT_TRUE(keyEvent != nullptr);
194 keyEvent->SetAction(KeyEvent::KEY_ACTION_DOWN);
195 KeyEvent::KeyItem item;
196 EXPECT_NO_FATAL_FAILURE(KeyEventHdr->HandleKeyAction(dev, item, keyEvent));
197 }
198
199 /**
200 * @tc.name: KeyEventNormalizeTest_HandleKeyAction_002
201 * @tc.desc: Test HandleKeyAction
202 * @tc.type: FUNC
203 * @tc.require:
204 */
205 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_HandleKeyAction_002, TestSize.Level1)
206 {
207 CALL_TEST_DEBUG;
208 vKeyboard_.SendEvent(EV_KEY, 29, 1);
209 vKeyboard_.SendEvent(EV_KEY, KEY_C, 1);
210 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
211 vKeyboard_.SendEvent(EV_KEY, KEY_C, 0);
212 vKeyboard_.SendEvent(EV_KEY, 29, 0);
213 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
214 libinput_event *event = libinput_.Dispatch();
215 ASSERT_TRUE(event != nullptr);
216 struct libinput_device *dev = libinput_event_get_device(event);
217 ASSERT_TRUE(dev != nullptr);
218 std::cout << "keyboard device: " << libinput_device_get_name(dev) << std::endl;
219 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
220 ASSERT_TRUE(keyEvent != nullptr);
221 keyEvent->SetAction(KeyEvent::KEY_ACTION_UP);
222 KeyEvent::KeyItem item;
223 item.SetKeyCode(1);
224 keyEvent->AddKeyItem(item);
225 keyEvent->SetKeyCode(1);
226 EXPECT_NO_FATAL_FAILURE(KeyEventHdr->HandleKeyAction(dev, item, keyEvent));
227 }
228
229 /**
230 * @tc.name: KeyEventNormalizeTest_HandleKeyAction_003
231 * @tc.desc: Test HandleKeyAction
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_HandleKeyAction_003, TestSize.Level1)
236 {
237 CALL_TEST_DEBUG;
238 vKeyboard_.SendEvent(EV_KEY, 29, 1);
239 vKeyboard_.SendEvent(EV_KEY, KEY_C, 1);
240 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
241 vKeyboard_.SendEvent(EV_KEY, KEY_C, 0);
242 vKeyboard_.SendEvent(EV_KEY, 29, 0);
243 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
244 libinput_event *event = libinput_.Dispatch();
245 ASSERT_TRUE(event != nullptr);
246 struct libinput_device *dev = libinput_event_get_device(event);
247 ASSERT_TRUE(dev != nullptr);
248 std::cout << "keyboard device: " << libinput_device_get_name(dev) << std::endl;
249 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
250 ASSERT_TRUE(keyEvent != nullptr);
251 keyEvent->SetAction(KeyEvent::KEY_ACTION_UP);
252 KeyEvent::KeyItem item;
253 item.SetKeyCode(1);
254 keyEvent->AddKeyItem(item);
255 keyEvent->SetKeyCode(3);
256 EXPECT_NO_FATAL_FAILURE(KeyEventHdr->HandleKeyAction(dev, item, keyEvent));
257 }
258
259 /**
260 * @tc.name: KeyEventNormalizeTest_ResetKeyEvent_001
261 * @tc.desc: Test ResetKeyEvent
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_ResetKeyEvent_001, TestSize.Level1)
266 {
267 CALL_TEST_DEBUG;
268 vKeyboard_.SendEvent(EV_KEY, 29, 1);
269 vKeyboard_.SendEvent(EV_KEY, KEY_C, 1);
270 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
271 vKeyboard_.SendEvent(EV_KEY, KEY_C, 0);
272 vKeyboard_.SendEvent(EV_KEY, 29, 0);
273 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
274 libinput_event *event = libinput_.Dispatch();
275 ASSERT_TRUE(event != nullptr);
276 struct libinput_device *dev = libinput_event_get_device(event);
277 ASSERT_TRUE(dev != nullptr);
278 std::cout << "keyboard device: " << libinput_device_get_name(dev) << std::endl;
279 std::shared_ptr<KeyEvent> keyEvent = nullptr;
280 EXPECT_NO_FATAL_FAILURE(KeyEventHdr->ResetKeyEvent(dev));
281 }
282
283 /**
284 * @tc.name: KeyEventNormalizeTest_ResetKeyEvent_002
285 * @tc.desc: Test ResetKeyEvent
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_ResetKeyEvent_002, TestSize.Level1)
290 {
291 CALL_TEST_DEBUG;
292 vKeyboard_.SendEvent(EV_KEY, 29, 1);
293 vKeyboard_.SendEvent(EV_KEY, KEY_C, 1);
294 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
295 vKeyboard_.SendEvent(EV_KEY, KEY_C, 0);
296 vKeyboard_.SendEvent(EV_KEY, 29, 0);
297 vKeyboard_.SendEvent(EV_SYN, SYN_REPORT, 0);
298 libinput_event *event = libinput_.Dispatch();
299 ASSERT_TRUE(event != nullptr);
300 struct libinput_device *dev = libinput_event_get_device(event);
301 ASSERT_TRUE(dev != nullptr);
302 std::cout << "keyboard device: " << libinput_device_get_name(dev) << std::endl;
303 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
304 ASSERT_TRUE(keyEvent != nullptr);
305 EXPECT_NO_FATAL_FAILURE(KeyEventHdr->ResetKeyEvent(dev));
306 }
307
308 /**
309 * @tc.name: KeyEventNormalizeTest_SetShieldStatus_001
310 * @tc.desc: Test SetShieldStatus
311 * @tc.type: FUNC
312 * @tc.require:
313 */
314 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_SetShieldStatus_001, TestSize.Level1)
315 {
316 CALL_TEST_DEBUG;
317 int32_t shieldMode = -1;
318 bool isShield = true;
319 int32_t ret = KeyEventHdr->SetShieldStatus(shieldMode, isShield);
320 ASSERT_EQ(ret, RET_ERR);
321 shieldMode = 2;
322 isShield = true;
323 ret = KeyEventHdr->SetShieldStatus(shieldMode, isShield);
324 ASSERT_EQ(ret, RET_ERR);
325 }
326
327 /**
328 * @tc.name: KeyEventNormalizeTest_SetShieldStatus_002
329 * @tc.desc: Test SetShieldStatus
330 * @tc.type: FUNC
331 * @tc.require:
332 */
333 HWTEST_F(KeyEventNormalizeTest, KeyEventNormalizeTest_SetShieldStatus_002, TestSize.Level1)
334 {
335 CALL_TEST_DEBUG;
336 int32_t shieldMode = 2;
337 bool isShield = false;
338 int32_t ret = KeyEventHdr->SetShieldStatus(shieldMode, isShield);
339 ASSERT_EQ(ret, RET_ERR);
340 shieldMode = -1;
341 isShield = false;
342 ret = KeyEventHdr->SetShieldStatus(shieldMode, isShield);
343 ASSERT_EQ(ret, RET_ERR);
344 }
345
346 /**
347 * @tc.name: KeyEventNormalizeTest
348 * @tc.desc: Test shieldMode_Equal_lastShieldMode
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(KeyEventNormalizeTest, shieldMode_Equal_lastShieldMode, TestSize.Level1)
353 {
354 CALL_TEST_DEBUG;
355 bool isShield = true;
356 int32_t shieldMode = -1;
357 int32_t result = KeyEventHdr->SetShieldStatus(shieldMode, isShield);
358 EXPECT_EQ(result, RET_ERR);
359 }
360
361 /**
362 * @tc.name: KeyEventNormalizeTest
363 * @tc.desc: Test shieldMode_NotEqual_lastShieldMode
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367 HWTEST_F(KeyEventNormalizeTest, shieldMode_NotEqual_lastShieldMode, TestSize.Level1)
368 {
369 CALL_TEST_DEBUG;
370 bool isShield = false;
371 int32_t shieldMode = 3;
372 int32_t result = KeyEventHdr->SetShieldStatus(shieldMode, isShield);
373 EXPECT_EQ(result, RET_OK);
374 }
375
376 /**
377 * @tc.name: KeyEventNormalizeTest
378 * @tc.desc: Test SetShieldStatus_FACTORY_MODE
379 * @tc.type: FUNC
380 * @tc.require:
381 */
382 HWTEST_F(KeyEventNormalizeTest, SetShieldStatus_FACTORY_MODE, TestSize.Level1)
383 {
384 CALL_TEST_DEBUG;
385 bool isShield = false;
386 int32_t shieldMode = 0;
387 int32_t result = KeyEventHdr->SetShieldStatus(shieldMode, isShield);
388 EXPECT_EQ(result, RET_OK);
389 }
390
391 /**
392 * @tc.name: KeyEventNormalizeTest
393 * @tc.desc: Test SetShieldStatus_OOBE_MODE
394 * @tc.type: FUNC
395 * @tc.require:
396 */
397 HWTEST_F(KeyEventNormalizeTest, SetShieldStatus_OOBE_MODE, TestSize.Level1)
398 {
399 CALL_TEST_DEBUG;
400 bool isShield = false;
401 int32_t shieldMode = 1;
402 int32_t result = KeyEventHdr->SetShieldStatus(shieldMode, isShield);
403 EXPECT_EQ(result, RET_OK);
404 }
405
406 /**
407 * @tc.name: KeyEventNormalizeTest
408 * @tc.desc: Test SetShieldStatus_NotFound
409 * @tc.type: FUNC
410 * @tc.require:
411 */
412 HWTEST_F(KeyEventNormalizeTest, SetShieldStatus_NotFound, TestSize.Level1)
413 {
414 CALL_TEST_DEBUG;
415 bool isShield = false;
416 int32_t shieldMode = -1;
417 int32_t result = KeyEventHdr->SetShieldStatus(shieldMode, isShield);
418 EXPECT_EQ(result, RET_ERR);
419 }
420
421 /**
422 * @tc.name: KeyEventNormalizeTest
423 * @tc.desc: Test GetShieldStatus_FACTORY_MODE
424 * @tc.type: FUNC
425 * @tc.require:
426 */
427 HWTEST_F(KeyEventNormalizeTest, GetShieldStatus_FACTORY_MODE, TestSize.Level1)
428 {
429 CALL_TEST_DEBUG;
430 bool isShield = false;
431 int32_t shieldMode = 0;
432 int32_t result = KeyEventHdr->GetShieldStatus(shieldMode, isShield);
433 EXPECT_EQ(result, RET_OK);
434 }
435
436 /**
437 * @tc.name: KeyEventNormalizeTest
438 * @tc.desc: Test GetShieldStatus_OOBE_MODE
439 * @tc.type: FUNC
440 * @tc.require:
441 */
442 HWTEST_F(KeyEventNormalizeTest, GetShieldStatus_OOBE_MODE, TestSize.Level1)
443 {
444 CALL_TEST_DEBUG;
445 bool isShield = false;
446 int32_t shieldMode = 1;
447 int32_t result = KeyEventHdr->GetShieldStatus(shieldMode, isShield);
448 EXPECT_EQ(result, RET_OK);
449 }
450
451 /**
452 * @tc.name: KeyEventNormalizeTest
453 * @tc.desc: Test GetShieldStatus_NotFound
454 * @tc.type: FUNC
455 * @tc.require:
456 */
457 HWTEST_F(KeyEventNormalizeTest, GetShieldStatus_NotFound, TestSize.Level1)
458 {
459 CALL_TEST_DEBUG;
460 bool isShield = false;
461 int32_t shieldMode = -1;
462 int32_t result = KeyEventHdr->GetShieldStatus(shieldMode, isShield);
463 EXPECT_EQ(result, RET_ERR);
464 }
465 }
466 }