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