1 /*
2  * Copyright (c) 2021-2022 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 <gtest/gtest.h>
17 
18 #include "define_multimodal.h"
19 #include "event_util_test.h"
20 #include "input_manager.h"
21 #include "key_event.h"
22 #include "mmi_log.h"
23 #include "proto.h"
24 
25 #undef MMI_LOG_TAG
26 #define MMI_LOG_TAG "KeyEventTest"
27 
28 namespace OHOS {
29 namespace MMI {
30 namespace {
31 using namespace testing::ext;
32 } // namespace
33 
34 class KeyEventTest : public testing::Test {
35 public:
SetUpTestCase(void)36     static void SetUpTestCase(void) {}
TearDownTestCase(void)37     static void TearDownTestCase(void) {}
38 };
39 
40 /**
41  * @tc.name: KeyEventTest_OnCheckKeyEvent_001
42  * @tc.desc: Verify key event
43  * @tc.type: FUNC
44  * @tc.require:
45  */
HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_001, TestSize.Level1)46 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_001, TestSize.Level1)
47 {
48     CALL_TEST_DEBUG;
49     auto KeyEvent = KeyEvent::Create();
50     ASSERT_NE(KeyEvent, nullptr);
51     KeyEvent->SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
52     ASSERT_TRUE(!KeyEvent->IsValid());
53 
54     KeyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME);
55     KeyEvent->SetActionTime(0);
56     ASSERT_TRUE(!KeyEvent->IsValid());
57 
58     KeyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME);
59     KeyEvent->SetActionTime(100);
60     KeyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UNKNOWN);
61     ASSERT_TRUE(!KeyEvent->IsValid());
62 }
63 
64 /**
65  * @tc.name: KeyEventTest_OnCheckKeyEvent_002
66  * @tc.desc: Verify key event
67  * @tc.type: FUNC
68  * @tc.require:
69  */
HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_002, TestSize.Level1)70 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_002, TestSize.Level1)
71 {
72     CALL_TEST_DEBUG;
73     auto KeyEvent1 = KeyEvent::Create();
74     ASSERT_NE(KeyEvent1, nullptr);
75     KeyEvent1->SetKeyCode(KeyEvent::KEYCODE_HOME);
76     KeyEvent1->SetActionTime(100);
77     KeyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL);
78     KeyEvent::KeyItem item;
79     item.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN);
80     KeyEvent1->AddKeyItem(item);
81     ASSERT_TRUE(!KeyEvent1->IsValid());
82 
83     auto KeyEvent2 = KeyEvent::Create();
84     ASSERT_NE(KeyEvent2, nullptr);
85     KeyEvent2->SetKeyCode(KeyEvent::KEYCODE_HOME);
86     KeyEvent2->SetActionTime(100);
87     KeyEvent2->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL);
88     item.SetKeyCode(KeyEvent::KEYCODE_HOME);
89     item.SetDownTime(0);
90     KeyEvent2->AddKeyItem(item);
91     ASSERT_TRUE(!KeyEvent2->IsValid());
92 }
93 
94 /**
95  * @tc.name: KeyEventTest_OnCheckKeyEvent_003
96  * @tc.desc: Verify key event
97  * @tc.type: FUNC
98  * @tc.require:
99  */
HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_003, TestSize.Level1)100 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_003, TestSize.Level1)
101 {
102     CALL_TEST_DEBUG;
103     auto KeyEvent1 = KeyEvent::Create();
104     ASSERT_NE(KeyEvent1, nullptr);
105     KeyEvent1->SetKeyCode(KeyEvent::KEYCODE_HOME);
106     KeyEvent1->SetActionTime(100);
107     KeyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL);
108     KeyEvent::KeyItem item;
109     item.SetKeyCode(KeyEvent::KEYCODE_HOME);
110     item.SetDownTime(100);
111     item.SetPressed(false);
112     KeyEvent1->AddKeyItem(item);
113     ASSERT_TRUE(!KeyEvent1->IsValid());
114 
115     auto KeyEvent2 = KeyEvent::Create();
116     ASSERT_NE(KeyEvent2, nullptr);
117     KeyEvent2->SetKeyCode(KeyEvent::KEYCODE_HOME);
118     KeyEvent2->SetActionTime(100);
119     KeyEvent2->SetKeyAction(KeyEvent::KEY_ACTION_UP);
120     item.SetKeyCode(KeyEvent::KEYCODE_BACK);
121     item.SetDownTime(100);
122     item.SetPressed(false);
123     KeyEvent2->AddKeyItem(item);
124     ASSERT_TRUE(!KeyEvent2->IsValid());
125 }
126 
127 /**
128  * @tc.name: KeyEventTest_OnCheckKeyEvent_004
129  * @tc.desc: Verify key event
130  * @tc.type: FUNC
131  * @tc.require:
132  */
HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_004, TestSize.Level1)133 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_004, TestSize.Level1)
134 {
135     CALL_TEST_DEBUG;
136     auto KeyEvent1 = KeyEvent::Create();
137     ASSERT_NE(KeyEvent1, nullptr);
138     KeyEvent1->SetKeyCode(KeyEvent::KEYCODE_HOME);
139     KeyEvent1->SetActionTime(100);
140     KeyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_UP);
141     KeyEvent::KeyItem item1;
142     item1.SetKeyCode(KeyEvent::KEYCODE_HOME);
143     item1.SetDownTime(100);
144     item1.SetPressed(false);
145     KeyEvent1->AddKeyItem(item1);
146     KeyEvent::KeyItem item2;
147     item2.SetKeyCode(KeyEvent::KEYCODE_HOME);
148     item2.SetDownTime(100);
149     item2.SetPressed(false);
150     KeyEvent1->AddKeyItem(item2);
151     ASSERT_TRUE(!KeyEvent1->IsValid());
152 
153     auto KeyEvent2 = KeyEvent::Create();
154     ASSERT_NE(KeyEvent2, nullptr);
155     KeyEvent2->SetKeyCode(KeyEvent::KEYCODE_HOME);
156     KeyEvent2->SetActionTime(100);
157     KeyEvent2->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL);
158     ASSERT_TRUE(!KeyEvent2->IsValid());
159 }
160 
161 /**
162  * @tc.name: KeyEventTest_OnCheckKeyEvent_005
163  * @tc.desc: Verify key event
164  * @tc.type: FUNC
165  * @tc.require:
166  */
HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_005, TestSize.Level1)167 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_005, TestSize.Level1)
168 {
169     CALL_TEST_DEBUG;
170     auto KeyEvent1 = KeyEvent::Create();
171     ASSERT_NE(KeyEvent1, nullptr);
172     KeyEvent1->SetKeyCode(KeyEvent::KEYCODE_HOME);
173     KeyEvent1->SetActionTime(100);
174     KeyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_UP);
175     KeyEvent::KeyItem item1;
176     item1.SetKeyCode(KeyEvent::KEYCODE_HOME);
177     item1.SetDownTime(100);
178     item1.SetPressed(false);
179     KeyEvent1->AddKeyItem(item1);
180     KeyEvent::KeyItem item2;
181     item2.SetKeyCode(KeyEvent::KEYCODE_BACK);
182     item2.SetDownTime(100);
183     item2.SetPressed(true);
184     KeyEvent1->AddKeyItem(item2);
185     ASSERT_TRUE(KeyEvent1->IsValid());
186 
187     auto KeyEvent2 = KeyEvent::Create();
188     ASSERT_NE(KeyEvent2, nullptr);
189     KeyEvent2->SetKeyCode(KeyEvent::KEYCODE_HOME);
190     KeyEvent2->SetActionTime(100);
191     KeyEvent2->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
192     item1.SetKeyCode(KeyEvent::KEYCODE_HOME);
193     item1.SetDownTime(100);
194     item1.SetPressed(true);
195     KeyEvent2->AddKeyItem(item1);
196     ASSERT_TRUE(KeyEvent2->IsValid());
197 }
198 
199 /**
200  * @tc.name: KeyEventTest_OnCheckKeyEvent_006
201  * @tc.desc: Verify key event
202  * @tc.type: FUNC
203  * @tc.require: I5QSN3
204  */
HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_006, TestSize.Level1)205 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_006, TestSize.Level1)
206 {
207     CALL_TEST_DEBUG;
208     auto inputEvent = InputEvent::Create();
209     ASSERT_NE(inputEvent, nullptr);
210     auto event1 = KeyEvent::from(inputEvent);
211     ASSERT_EQ(event1, nullptr);
212     auto keyEvent = KeyEvent::Create();
213     ASSERT_NE(keyEvent, nullptr);
214     auto event2 = KeyEvent::Clone(keyEvent);
215     ASSERT_NE(event2, nullptr);
216     keyEvent->SetKeyCode(KeyEvent::KEYCODE_BACK);
217     keyEvent->SetActionTime(100);
218     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
219 
220     InputManager::GetInstance()->SimulateInputEvent(keyEvent);
221     keyEvent->ActionToString(KeyEvent::KEY_ACTION_DOWN);
222     keyEvent->KeyCodeToString(KeyEvent::KEYCODE_BACK);
223     KeyEvent::KeyItem item;
224     item.SetKeyCode(KeyEvent::KEYCODE_BACK);
225     item.SetDownTime(100);
226     item.SetPressed(true);
227     item.SetUnicode(0);
228     keyEvent->AddKeyItem(item);
229     ASSERT_TRUE(keyEvent->IsValid());
230     std::vector<KeyEvent::KeyItem> items = keyEvent->GetKeyItems();
231     TestUtil->DumpInputEvent(keyEvent);
232 }
233 
234 /**
235  * @tc.name: KeyEventTest_GetFunctionKey_001
236  * @tc.desc: Set Numlock for keyevent to false
237  * @tc.type: FUNC
238  * @tc.require: I5HMCX
239  */
HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_001, TestSize.Level1)240 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_001, TestSize.Level1)
241 {
242     CALL_TEST_DEBUG;
243     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
244     ASSERT_NE(keyEvent, nullptr);
245     keyEvent->SetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY, false);
246     bool result = keyEvent->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY);
247     ASSERT_FALSE(result);
248 }
249 
250 /**
251  * @tc.name: KeyEventTest_GetFunctionKey_002
252  * @tc.desc: Set Numlock for keyevent to true
253  * @tc.type: FUNC
254  * @tc.require: I5HMCX
255  */
HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_002, TestSize.Level1)256 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_002, TestSize.Level1)
257 {
258     CALL_TEST_DEBUG;
259     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
260     ASSERT_NE(keyEvent, nullptr);
261     keyEvent->SetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY, true);
262     bool result = keyEvent->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY);
263     ASSERT_TRUE(result);
264 }
265 
266 /**
267  * @tc.name: KeyEventTest_GetFunctionKey_003
268  * @tc.desc: Set Capslock for keyevent to false
269  * @tc.type: FUNC
270  * @tc.require: I5HMCX
271  */
HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_003, TestSize.Level1)272 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_003, TestSize.Level1)
273 {
274     CALL_TEST_DEBUG;
275     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
276     ASSERT_NE(keyEvent, nullptr);
277     keyEvent->SetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY, false);
278     bool result = keyEvent->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY);
279     ASSERT_FALSE(result);
280 }
281 
282 /**
283  * @tc.name: KeyEventTest_GetFunctionKey_004
284  * @tc.desc: Set Capslock for keyevent to true
285  * @tc.type: FUNC
286  * @tc.require: I5HMCX
287  */
HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_004, TestSize.Level1)288 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_004, TestSize.Level1)
289 {
290     CALL_TEST_DEBUG;
291     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
292     ASSERT_NE(keyEvent, nullptr);
293     keyEvent->SetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY, true);
294     bool result = keyEvent->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY);
295     ASSERT_TRUE(result);
296 }
297 
298 /**
299  * @tc.name: KeyEventTest_GetKeyIntention_001
300  * @tc.desc: GetKey intention
301  * @tc.type: FUNC
302  * @tc.require: I5HMCX
303  */
HWTEST_F(KeyEventTest, KeyEventTest_GetKeyIntention_001, TestSize.Level1)304 HWTEST_F(KeyEventTest, KeyEventTest_GetKeyIntention_001, TestSize.Level1)
305 {
306     CALL_TEST_DEBUG;
307     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
308     ASSERT_NE(keyEvent, nullptr);
309     int32_t result = keyEvent->GetKeyIntention();
310     ASSERT_EQ(result, -1);
311 }
312 
313 /**
314  * @tc.name: KeyEventTest_GetFunctionKey_005
315  * @tc.desc: Set Scrolllock for keyevent to false
316  * @tc.type: FUNC
317  * @tc.require: I5HMCX
318  */
HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_005, TestSize.Level1)319 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_005, TestSize.Level1)
320 {
321     CALL_TEST_DEBUG;
322     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
323     ASSERT_NE(keyEvent, nullptr);
324     keyEvent->SetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY, false);
325     bool result = keyEvent->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY);
326     ASSERT_FALSE(result);
327 }
328 
329 /**
330  * @tc.name: KeyEventTest_GetFunctionKey_006
331  * @tc.desc: Set Scrolllock for keyevent to true
332  * @tc.type: FUNC
333  * @tc.require: I5HMCX
334  */
HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_006, TestSize.Level1)335 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_006, TestSize.Level1)
336 {
337     CALL_TEST_DEBUG;
338     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
339     ASSERT_NE(keyEvent, nullptr);
340     keyEvent->SetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY, true);
341     bool result = keyEvent->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY);
342     ASSERT_TRUE(result);
343 }
344 
345 /**
346  * @tc.name: KeyEventTest_TransitionFunctionKey_001
347  * @tc.desc: Transition keycode to function key
348  * @tc.type: FUNC
349  * @tc.require: I5HMCX
350  */
HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_001, TestSize.Level1)351 HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_001, TestSize.Level1)
352 {
353     CALL_TEST_DEBUG;
354     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
355     ASSERT_NE(keyEvent, nullptr);
356     int32_t lockCode = keyEvent->TransitionFunctionKey(KeyEvent::KEYCODE_NUM_LOCK);
357     ASSERT_EQ(lockCode, KeyEvent::NUM_LOCK_FUNCTION_KEY);
358 }
359 
360 /**
361  * @tc.name: KeyEventTest_TransitionFunctionKey_002
362  * @tc.desc: Transition keycode to function key
363  * @tc.type: FUNC
364  * @tc.require: I5HMCX
365  */
HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_002, TestSize.Level1)366 HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_002, TestSize.Level1)
367 {
368     CALL_TEST_DEBUG;
369     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
370     ASSERT_NE(keyEvent, nullptr);
371     int32_t lockCode = keyEvent->TransitionFunctionKey(KeyEvent::KEYCODE_SCROLL_LOCK);
372     ASSERT_EQ(lockCode, KeyEvent::SCROLL_LOCK_FUNCTION_KEY);
373 }
374 
375 /**
376  * @tc.name: KeyEventTest_TransitionFunctionKey_003
377  * @tc.desc: Transition keycode to function key
378  * @tc.type: FUNC
379  * @tc.require: I5HMCX
380  */
HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_003, TestSize.Level1)381 HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_003, TestSize.Level1)
382 {
383     CALL_TEST_DEBUG;
384     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
385     ASSERT_NE(keyEvent, nullptr);
386     int32_t lockCode = keyEvent->TransitionFunctionKey(KeyEvent::KEYCODE_CAPS_LOCK);
387     ASSERT_EQ(lockCode, KeyEvent::CAPS_LOCK_FUNCTION_KEY);
388 }
389 
390 /**
391  * @tc.name: KeyEventTest_TransitionFunctionKey_004
392  * @tc.desc: Transition not support keycode to function key
393  * @tc.type: FUNC
394  * @tc.require: I5HMCX
395  */
HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_004, TestSize.Level1)396 HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_004, TestSize.Level1)
397 {
398     CALL_TEST_DEBUG;
399     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
400     ASSERT_NE(keyEvent, nullptr);
401     int32_t lockCode = keyEvent->TransitionFunctionKey(KeyEvent::KEYCODE_A);
402     ASSERT_EQ(lockCode, KeyEvent::UNKNOWN_FUNCTION_KEY);
403 }
404 
405 /**
406  * @tc.name: KeyEventTest_ReadFromParcel_001
407  * @tc.desc: Read from parcel
408  * @tc.type: FUNC
409  * @tc.require:
410  */
HWTEST_F(KeyEventTest, KeyEventTest_ReadFromParcel_001, TestSize.Level1)411 HWTEST_F(KeyEventTest, KeyEventTest_ReadFromParcel_001, TestSize.Level1)
412 {
413     CALL_TEST_DEBUG;
414     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
415     ASSERT_NE(keyEvent, nullptr);
416     keyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME);
417     keyEvent->SetActionTime(100);
418     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
419     keyEvent->ActionToString(KeyEvent::KEY_ACTION_DOWN);
420     keyEvent->KeyCodeToString(KeyEvent::KEYCODE_HOME);
421     KeyEvent::KeyItem item;
422     item.SetKeyCode(KeyEvent::KEYCODE_HOME);
423     item.SetDownTime(100);
424     item.SetPressed(true);
425     keyEvent->AddKeyItem(item);
426     MessageParcel data;
427     bool ret = keyEvent->WriteToParcel(data);
428     ASSERT_TRUE(ret);
429     ret = keyEvent->ReadFromParcel(data);
430     ASSERT_TRUE(ret);
431 }
432 
433 /**
434  * @tc.name: KeyEventTest_ReadFromParcel_002
435  * @tc.desc: Read from parcel
436  * @tc.type: FUNC
437  * @tc.require:
438  */
HWTEST_F(KeyEventTest, KeyEventTest_ReadFromParcel_002, TestSize.Level1)439 HWTEST_F(KeyEventTest, KeyEventTest_ReadFromParcel_002, TestSize.Level1)
440 {
441     CALL_TEST_DEBUG;
442     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
443     ASSERT_NE(keyEvent, nullptr);
444     keyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME);
445     keyEvent->SetActionTime(100);
446     keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN);
447     keyEvent->ActionToString(KeyEvent::KEY_ACTION_DOWN);
448     keyEvent->KeyCodeToString(KeyEvent::KEYCODE_HOME);
449     KeyEvent::KeyItem item;
450     item.SetKeyCode(KeyEvent::KEYCODE_HOME);
451     item.SetDownTime(100);
452     item.SetPressed(true);
453     keyEvent->AddKeyItem(item);
454     MessageParcel data;
455     bool ret = keyEvent->WriteToParcel(data);
456     ASSERT_TRUE(ret);
457     std::shared_ptr<InputEvent> inputEvent = InputEvent::Create();
458     ret = inputEvent->ReadFromParcel(data);
459     ASSERT_TRUE(ret);
460     int32_t keyCode;
461     ret = data.ReadInt32(keyCode);
462     ASSERT_TRUE(ret);
463     const int32_t keysSize = data.ReadInt32();
464     ASSERT_FALSE(keysSize < 0);
465     for (int32_t i = 0; i < keysSize; ++i) {
466         KeyEvent::KeyItem keyItem = {};
467         ret = keyItem.ReadFromParcel(data);
468         ASSERT_TRUE(ret);
469     }
470 }
471 
472 /**
473  * @tc.name: KeyEventTest_ReadFromParcel_003
474  * @tc.desc: Verify keyoption read from parcel
475  * @tc.type: FUNC
476  * @tc.require:
477  */
478 HWTEST_F(KeyEventTest, KeyEventTest_ReadFromParcel_003, TestSize.Level1)
479 {
480     CALL_TEST_DEBUG;
481     std::set<int32_t> preKeys;
482     std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>();
483     keyOption->SetPreKeys(preKeys);
484     MessageParcel data;
485     bool ret = keyOption->ReadFromParcel(data);
486     ASSERT_FALSE(ret);
487     preKeys.insert(0);
488     preKeys.insert(1);
489     keyOption->SetPreKeys(preKeys);
490     keyOption->SetFinalKey(0);
491     keyOption->SetFinalKeyDown(0);
492     keyOption->SetFinalKeyDownDuration(0);
493     keyOption->SetFinalKeyUpDelay(0);
494     keyOption->WriteToParcel(data);
495     ret = keyOption->ReadFromParcel(data);
496     ASSERT_TRUE(ret);
497 }
498 
499 #ifdef OHOS_BUILD_ENABLE_SECURITY_COMPONENT
500 /**
501  * @tc.name: KeyEventTest_SetEnhanceData_001
502  * @tc.desc: Set the enhance data.
503  * @tc.type: FUNC
504  * @tc.require:
505  */
HWTEST_F(KeyEventTest, KeyEventTest_SetEnhanceData_001, TestSize.Level1)506 HWTEST_F(KeyEventTest, KeyEventTest_SetEnhanceData_001, TestSize.Level1)
507 {
508     CALL_TEST_DEBUG;
509     auto KeyEvent = KeyEvent::Create();
510     ASSERT_NE(KeyEvent, nullptr);
511     uint32_t enHanceDataLen = 3;
512     uint8_t enhanceDataBuf[enHanceDataLen];
513     std::vector<uint8_t> enhanceData;
514     for (uint32_t i = 0; i < enHanceDataLen; i++) {
515         enhanceData.push_back(enhanceDataBuf[i]);
516     }
517 
518     ASSERT_NO_FATAL_FAILURE(KeyEvent->SetEnhanceData(enhanceData));
519     ASSERT_EQ(KeyEvent->GetEnhanceData(), enhanceData);
520 }
521 #endif // OHOS_BUILD_ENABLE_SECURITY_COMPONENT
522 
523 /**
524  * @tc.name: KeyEventTest_IsRepeat_001
525  * @tc.desc: Set repeat_ to false
526  * @tc.type: FUNC
527  * @tc.require: I5HMCX
528  */
HWTEST_F(KeyEventTest, KeyEventTest_IsRepeat_001, TestSize.Level1)529 HWTEST_F(KeyEventTest, KeyEventTest_IsRepeat_001, TestSize.Level1)
530 {
531     CALL_TEST_DEBUG;
532     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
533     ASSERT_NE(keyEvent, nullptr);
534     keyEvent->SetRepeat(false);
535     bool result = keyEvent->IsRepeat();
536     ASSERT_FALSE(result);
537 }
538 
539 /**
540  * @tc.name: KeyEventTest_IsRepeat_002
541  * @tc.desc: Set repeat_ to true
542  * @tc.type: FUNC
543  * @tc.require: I5HMCX
544  */
HWTEST_F(KeyEventTest, KeyEventTest_IsRepeat_002, TestSize.Level1)545 HWTEST_F(KeyEventTest, KeyEventTest_IsRepeat_002, TestSize.Level1)
546 {
547     CALL_TEST_DEBUG;
548     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
549     ASSERT_NE(keyEvent, nullptr);
550     keyEvent->SetRepeat(true);
551     bool result = keyEvent->IsRepeat();
552     ASSERT_TRUE(result);
553 }
554 
555 /**
556  * @tc.name: KeyEventTest_Reset
557  * @tc.desc: Test Reset
558  * @tc.type: FUNC
559  * @tc.require: I5HMCX
560  */
HWTEST_F(KeyEventTest, KeyEventTest_Reset, TestSize.Level1)561 HWTEST_F(KeyEventTest, KeyEventTest_Reset, TestSize.Level1)
562 {
563     CALL_TEST_DEBUG;
564     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
565     ASSERT_NE(keyEvent, nullptr);
566     ASSERT_NO_FATAL_FAILURE(keyEvent->Reset());
567 }
568 
569 /**
570  * @tc.name: KeyEventTest_ToString
571  * @tc.desc: Test the funcation ToString
572  * @tc.type: FUNC
573  * @tc.require:
574  */
HWTEST_F(KeyEventTest, KeyEventTest_ToString, TestSize.Level1)575 HWTEST_F(KeyEventTest, KeyEventTest_ToString, TestSize.Level1)
576 {
577     CALL_TEST_DEBUG;
578     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
579     ASSERT_NE(keyEvent, nullptr);
580     ASSERT_NO_FATAL_FAILURE(keyEvent->ToString());
581 }
582 
583 /**
584  * @tc.name: KeyEventTest_SetKeyItem_001
585  * @tc.desc: Test the funcation SetKeyItem
586  * @tc.type: FUNC
587  * @tc.require:
588  */
HWTEST_F(KeyEventTest, KeyEventTest_SetKeyItem_001, TestSize.Level1)589 HWTEST_F(KeyEventTest, KeyEventTest_SetKeyItem_001, TestSize.Level1)
590 {
591     CALL_TEST_DEBUG;
592     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
593     ASSERT_NE(keyEvent, nullptr);
594     std::vector<KeyEvent::KeyItem> keyItem = keyEvent->GetKeyItems();
595     ASSERT_NO_FATAL_FAILURE(keyEvent->SetKeyItem(keyItem));
596 }
597 
598 /**
599  * @tc.name: KeyEventTest_IsRepeatKey_001
600  * @tc.desc: Test the funcation IsRepeatKey
601  * @tc.type: FUNC
602  * @tc.require:
603  */
HWTEST_F(KeyEventTest, KeyEventTest_IsRepeatKey_001, TestSize.Level1)604 HWTEST_F(KeyEventTest, KeyEventTest_IsRepeatKey_001, TestSize.Level1)
605 {
606     CALL_TEST_DEBUG;
607     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
608     ASSERT_NE(keyEvent, nullptr);
609     ASSERT_FALSE(keyEvent->IsRepeatKey());
610 }
611 
612 /**
613  * @tc.name: KeyEventTest_SetRepeatKey_001
614  * @tc.desc: Test the funcation SetRepeatKey
615  * @tc.type: FUNC
616  * @tc.require:
617  */
HWTEST_F(KeyEventTest, KeyEventTest_SetRepeatKey_001, TestSize.Level1)618 HWTEST_F(KeyEventTest, KeyEventTest_SetRepeatKey_001, TestSize.Level1)
619 {
620     CALL_TEST_DEBUG;
621     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
622     ASSERT_NE(keyEvent, nullptr);
623     bool repeatKey = true;
624     ASSERT_NO_FATAL_FAILURE(keyEvent->SetRepeatKey(repeatKey));
625     repeatKey = false;
626     ASSERT_NO_FATAL_FAILURE(keyEvent->SetRepeatKey(repeatKey));
627 }
628 
629 #ifdef OHOS_BUILD_ENABLE_VKEYBOARD
630 /**
631  * @tc.name: KeyEventTest_GetVKeyboardAction_001
632  * @tc.desc: Test the funcation GetVKeyboardAction
633  * @tc.type: FUNC
634  * @tc.require:
635  */
HWTEST_F(KeyEventTest, KeyEventTest_GetVKeyboardAction_001, TestSize.Level1)636 HWTEST_F(KeyEventTest, KeyEventTest_GetVKeyboardAction_001, TestSize.Level1)
637 {
638     CALL_TEST_DEBUG;
639     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
640     ASSERT_NE(keyEvent, nullptr);
641     ASSERT_NO_FATAL_FAILURE(keyEvent->GetVKeyboardAction());
642 }
643 
644 /**
645  * @tc.name: KeyEventTest_SetVKeyboardAction_001
646  * @tc.desc: Test the funcation SetVKeyboardAction
647  * @tc.type: FUNC
648  * @tc.require:
649  */
HWTEST_F(KeyEventTest, KeyEventTest_SetVKeyboardAction_001, TestSize.Level1)650 HWTEST_F(KeyEventTest, KeyEventTest_SetVKeyboardAction_001, TestSize.Level1)
651 {
652     CALL_TEST_DEBUG;
653     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
654     ASSERT_NE(keyEvent, nullptr);
655     VKeyboardAction vkAction = VKeyboardAction::ACTIVATE_KEYBOARD;
656     ASSERT_NO_FATAL_FAILURE(keyEvent->SetVKeyboardAction(vkAction));
657 }
658 
659 /**
660  * @tc.name: KeyEventTest_GetKeyName_001
661  * @tc.desc: Test the funcation GetKeyName
662  * @tc.type: FUNC
663  * @tc.require:
664  */
HWTEST_F(KeyEventTest, KeyEventTest_GetKeyName_001, TestSize.Level1)665 HWTEST_F(KeyEventTest, KeyEventTest_GetKeyName_001, TestSize.Level1)
666 {
667     CALL_TEST_DEBUG;
668     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
669     ASSERT_NE(keyEvent, nullptr);
670     keyEvent->keyName_ = "keyName";
671     std::string ret = keyEvent->GetKeyName();
672     ASSERT_EQ(ret, "keyName");
673 }
674 
675 /**
676  * @tc.name: KeyEventTest_SetKeyName_001
677  * @tc.desc: Test the funcation SetKeyName
678  * @tc.type: FUNC
679  * @tc.require:
680  */
HWTEST_F(KeyEventTest, KeyEventTest_SetKeyName_001, TestSize.Level1)681 HWTEST_F(KeyEventTest, KeyEventTest_SetKeyName_001, TestSize.Level1)
682 {
683     CALL_TEST_DEBUG;
684     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
685     ASSERT_NE(keyEvent, nullptr);
686     std::string keyName = "keyName";
687     ASSERT_NO_FATAL_FAILURE(keyEvent->SetKeyName(keyName));
688 }
689 
690 /**
691  * @tc.name: KeyEventTest_VKeyboardActionToStr_001
692  * @tc.desc: Test the funcation VKeyboardActionToStr
693  * @tc.type: FUNC
694  * @tc.require:
695  */
HWTEST_F(KeyEventTest, KeyEventTest_VKeyboardActionToStr_001, TestSize.Level1)696 HWTEST_F(KeyEventTest, KeyEventTest_VKeyboardActionToStr_001, TestSize.Level1)
697 {
698     CALL_TEST_DEBUG;
699     std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create();
700     ASSERT_NE(keyEvent, nullptr);
701     VKeyboardAction vKeyAction = VKeyboardAction::ACTIVATE_KEYBOARD;
702     const char* ret = keyEvent->VKeyboardActionToStr(vKeyAction);
703     ASSERT_EQ(ret, "ACTIVATE_KEYBOARD");
704     vKeyAction = VKeyboardAction::VKEY_DOWN;
705     ret = keyEvent->VKeyboardActionToStr(vKeyAction);
706     ASSERT_EQ(ret, "VKEY_DOWN");
707     vKeyAction = VKeyboardAction::VKEY_UP;
708     ret = keyEvent->VKeyboardActionToStr(vKeyAction);
709     ASSERT_EQ(ret, "VKEY_UP");
710     vKeyAction = VKeyboardAction::RESET_BUTTON_COLOR;
711     ret = keyEvent->VKeyboardActionToStr(vKeyAction);
712     ASSERT_EQ(ret, "RESET_BUTTON_COLOR");
713     vKeyAction = VKeyboardAction::TWO_FINGERS_IN;
714     ret = keyEvent->VKeyboardActionToStr(vKeyAction);
715     ASSERT_EQ(ret, "TWO_FINGERS_IN");
716     vKeyAction = VKeyboardAction::TWO_FINGERS_OUT;
717     ret = keyEvent->VKeyboardActionToStr(vKeyAction);
718     ASSERT_EQ(ret, "TWO_FINGERS_OUT");
719     vKeyAction = VKeyboardAction::TWO_HANDS_UP;
720     ret = keyEvent->VKeyboardActionToStr(vKeyAction);
721     ASSERT_EQ(ret, "TWO_HANDS_UP");
722     vKeyAction = VKeyboardAction::TWO_HANDS_DOWN;
723     ret = keyEvent->VKeyboardActionToStr(vKeyAction);
724     ASSERT_EQ(ret, "TWO_HANDS_DOWN");
725     vKeyAction = VKeyboardAction::UNKNOWN;
726     ret = keyEvent->VKeyboardActionToStr(vKeyAction);
727     ASSERT_EQ(ret, "UNKNOWN");
728 }
729 #endif // OHOS_BUILD_ENABLE_VKEYBOARD
730 } // namespace MMI
731 } // namespace OHOS
732