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 "proto.h" 23 24 namespace OHOS { 25 namespace MMI { 26 namespace { 27 using namespace testing::ext; 28 } // namespace 29 30 class KeyEventTest : public testing::Test { 31 public: SetUpTestCase(void)32 static void SetUpTestCase(void) {} TearDownTestCase(void)33 static void TearDownTestCase(void) {} 34 }; 35 36 /** 37 * @tc.name: KeyEventTest_OnCheckKeyEvent_001 38 * @tc.desc: Verify key event 39 * @tc.type: FUNC 40 * @tc.require: 41 */ 42 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_001, TestSize.Level1) 43 { 44 auto KeyEvent = KeyEvent::Create(); 45 ASSERT_NE(KeyEvent, nullptr); 46 KeyEvent->SetKeyCode(KeyEvent::KEYCODE_UNKNOWN); 47 ASSERT_TRUE(!KeyEvent->IsValid()); 48 49 KeyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME); 50 KeyEvent->SetActionTime(0); 51 ASSERT_TRUE(!KeyEvent->IsValid()); 52 53 KeyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME); 54 KeyEvent->SetActionTime(100); 55 KeyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UNKNOWN); 56 ASSERT_TRUE(!KeyEvent->IsValid()); 57 } 58 59 /** 60 * @tc.name: KeyEventTest_OnCheckKeyEvent_002 61 * @tc.desc: Verify key event 62 * @tc.type: FUNC 63 * @tc.require: 64 */ 65 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_002, TestSize.Level1) 66 { 67 auto KeyEvent1 = KeyEvent::Create(); 68 ASSERT_NE(KeyEvent1, nullptr); 69 KeyEvent1->SetKeyCode(KeyEvent::KEYCODE_HOME); 70 KeyEvent1->SetActionTime(100); 71 KeyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 72 KeyEvent::KeyItem item; 73 item.SetKeyCode(KeyEvent::KEYCODE_UNKNOWN); 74 KeyEvent1->AddKeyItem(item); 75 ASSERT_TRUE(!KeyEvent1->IsValid()); 76 77 auto KeyEvent2 = KeyEvent::Create(); 78 ASSERT_NE(KeyEvent2, nullptr); 79 KeyEvent2->SetKeyCode(KeyEvent::KEYCODE_HOME); 80 KeyEvent2->SetActionTime(100); 81 KeyEvent2->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 82 item.SetKeyCode(KeyEvent::KEYCODE_HOME); 83 item.SetDownTime(0); 84 KeyEvent2->AddKeyItem(item); 85 ASSERT_TRUE(!KeyEvent2->IsValid()); 86 } 87 88 /** 89 * @tc.name: KeyEventTest_OnCheckKeyEvent_003 90 * @tc.desc: Verify key event 91 * @tc.type: FUNC 92 * @tc.require: 93 */ 94 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_003, TestSize.Level1) 95 { 96 auto KeyEvent1 = KeyEvent::Create(); 97 ASSERT_NE(KeyEvent1, nullptr); 98 KeyEvent1->SetKeyCode(KeyEvent::KEYCODE_HOME); 99 KeyEvent1->SetActionTime(100); 100 KeyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 101 KeyEvent::KeyItem item; 102 item.SetKeyCode(KeyEvent::KEYCODE_HOME); 103 item.SetDownTime(100); 104 item.SetPressed(false); 105 KeyEvent1->AddKeyItem(item); 106 ASSERT_TRUE(!KeyEvent1->IsValid()); 107 108 auto KeyEvent2 = KeyEvent::Create(); 109 ASSERT_NE(KeyEvent2, nullptr); 110 KeyEvent2->SetKeyCode(KeyEvent::KEYCODE_HOME); 111 KeyEvent2->SetActionTime(100); 112 KeyEvent2->SetKeyAction(KeyEvent::KEY_ACTION_UP); 113 item.SetKeyCode(KeyEvent::KEYCODE_BACK); 114 item.SetDownTime(100); 115 item.SetPressed(false); 116 KeyEvent2->AddKeyItem(item); 117 ASSERT_TRUE(!KeyEvent2->IsValid()); 118 } 119 120 /** 121 * @tc.name: KeyEventTest_OnCheckKeyEvent_004 122 * @tc.desc: Verify key event 123 * @tc.type: FUNC 124 * @tc.require: 125 */ 126 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_004, TestSize.Level1) 127 { 128 auto KeyEvent1 = KeyEvent::Create(); 129 ASSERT_NE(KeyEvent1, nullptr); 130 KeyEvent1->SetKeyCode(KeyEvent::KEYCODE_HOME); 131 KeyEvent1->SetActionTime(100); 132 KeyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_UP); 133 KeyEvent::KeyItem item1; 134 item1.SetKeyCode(KeyEvent::KEYCODE_HOME); 135 item1.SetDownTime(100); 136 item1.SetPressed(false); 137 KeyEvent1->AddKeyItem(item1); 138 KeyEvent::KeyItem item2; 139 item2.SetKeyCode(KeyEvent::KEYCODE_HOME); 140 item2.SetDownTime(100); 141 item2.SetPressed(false); 142 KeyEvent1->AddKeyItem(item2); 143 ASSERT_TRUE(!KeyEvent1->IsValid()); 144 145 auto KeyEvent2 = KeyEvent::Create(); 146 ASSERT_NE(KeyEvent2, nullptr); 147 KeyEvent2->SetKeyCode(KeyEvent::KEYCODE_HOME); 148 KeyEvent2->SetActionTime(100); 149 KeyEvent2->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 150 ASSERT_TRUE(!KeyEvent2->IsValid()); 151 } 152 153 /** 154 * @tc.name: KeyEventTest_OnCheckKeyEvent_005 155 * @tc.desc: Verify key event 156 * @tc.type: FUNC 157 * @tc.require: 158 */ 159 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_005, TestSize.Level1) 160 { 161 auto KeyEvent1 = KeyEvent::Create(); 162 ASSERT_NE(KeyEvent1, nullptr); 163 KeyEvent1->SetKeyCode(KeyEvent::KEYCODE_HOME); 164 KeyEvent1->SetActionTime(100); 165 KeyEvent1->SetKeyAction(KeyEvent::KEY_ACTION_UP); 166 KeyEvent::KeyItem item1; 167 item1.SetKeyCode(KeyEvent::KEYCODE_HOME); 168 item1.SetDownTime(100); 169 item1.SetPressed(false); 170 KeyEvent1->AddKeyItem(item1); 171 KeyEvent::KeyItem item2; 172 item2.SetKeyCode(KeyEvent::KEYCODE_BACK); 173 item2.SetDownTime(100); 174 item2.SetPressed(true); 175 KeyEvent1->AddKeyItem(item2); 176 ASSERT_TRUE(KeyEvent1->IsValid()); 177 178 auto KeyEvent2 = KeyEvent::Create(); 179 ASSERT_NE(KeyEvent2, nullptr); 180 KeyEvent2->SetKeyCode(KeyEvent::KEYCODE_HOME); 181 KeyEvent2->SetActionTime(100); 182 KeyEvent2->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 183 item1.SetKeyCode(KeyEvent::KEYCODE_HOME); 184 item1.SetDownTime(100); 185 item1.SetPressed(true); 186 KeyEvent2->AddKeyItem(item1); 187 ASSERT_TRUE(KeyEvent2->IsValid()); 188 } 189 190 /** 191 * @tc.name: KeyEventTest_OnCheckKeyEvent_006 192 * @tc.desc: Verify key event 193 * @tc.type: FUNC 194 * @tc.require: I5QSN3 195 */ 196 HWTEST_F(KeyEventTest, KeyEventTest_OnCheckKeyEvent_006, TestSize.Level1) 197 { 198 auto inputEvent = InputEvent::Create(); 199 ASSERT_NE(inputEvent, nullptr); 200 auto event1 = KeyEvent::from(inputEvent); 201 ASSERT_EQ(event1, nullptr); 202 auto keyEvent = KeyEvent::Create(); 203 ASSERT_NE(keyEvent, nullptr); 204 auto event2 = KeyEvent::Clone(keyEvent); 205 ASSERT_NE(event2, nullptr); 206 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BACK); 207 keyEvent->SetActionTime(100); 208 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 209 210 InputManager::GetInstance()->SimulateInputEvent(keyEvent); 211 keyEvent->ActionToString(KeyEvent::KEY_ACTION_DOWN); 212 keyEvent->KeyCodeToString(KeyEvent::KEYCODE_BACK); 213 KeyEvent::KeyItem item; 214 item.SetKeyCode(KeyEvent::KEYCODE_BACK); 215 item.SetDownTime(100); 216 item.SetPressed(true); 217 item.SetUnicode(0); 218 keyEvent->AddKeyItem(item); 219 ASSERT_TRUE(keyEvent->IsValid()); 220 std::vector<KeyEvent::KeyItem> items = keyEvent->GetKeyItems(); 221 TestUtil->DumpInputEvent(keyEvent); 222 } 223 224 /** 225 * @tc.name: KeyEventTest_GetFunctionKey_001 226 * @tc.desc: Set Numlock for keyevent to false 227 * @tc.type: FUNC 228 * @tc.require: I5HMCX 229 */ 230 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_001, TestSize.Level1) 231 { 232 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 233 ASSERT_NE(keyEvent, nullptr); 234 keyEvent->SetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY, false); 235 bool result = keyEvent->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY); 236 ASSERT_FALSE(result); 237 } 238 239 /** 240 * @tc.name: KeyEventTest_GetFunctionKey_002 241 * @tc.desc: Set Numlock for keyevent to true 242 * @tc.type: FUNC 243 * @tc.require: I5HMCX 244 */ 245 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_002, TestSize.Level1) 246 { 247 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 248 ASSERT_NE(keyEvent, nullptr); 249 keyEvent->SetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY, true); 250 bool result = keyEvent->GetFunctionKey(KeyEvent::NUM_LOCK_FUNCTION_KEY); 251 ASSERT_TRUE(result); 252 } 253 254 /** 255 * @tc.name: KeyEventTest_GetFunctionKey_003 256 * @tc.desc: Set Capslock for keyevent to false 257 * @tc.type: FUNC 258 * @tc.require: I5HMCX 259 */ 260 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_003, TestSize.Level1) 261 { 262 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 263 ASSERT_NE(keyEvent, nullptr); 264 keyEvent->SetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY, false); 265 bool result = keyEvent->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY); 266 ASSERT_FALSE(result); 267 } 268 269 /** 270 * @tc.name: KeyEventTest_GetFunctionKey_004 271 * @tc.desc: Set Capslock for keyevent to true 272 * @tc.type: FUNC 273 * @tc.require: I5HMCX 274 */ 275 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_004, TestSize.Level1) 276 { 277 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 278 ASSERT_NE(keyEvent, nullptr); 279 keyEvent->SetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY, true); 280 bool result = keyEvent->GetFunctionKey(KeyEvent::CAPS_LOCK_FUNCTION_KEY); 281 ASSERT_TRUE(result); 282 } 283 284 /** 285 * @tc.name: KeyEventTest_GetFunctionKey_005 286 * @tc.desc: Set Scrolllock for keyevent to false 287 * @tc.type: FUNC 288 * @tc.require: I5HMCX 289 */ 290 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_005, TestSize.Level1) 291 { 292 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 293 ASSERT_NE(keyEvent, nullptr); 294 keyEvent->SetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY, false); 295 bool result = keyEvent->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY); 296 ASSERT_FALSE(result); 297 } 298 299 /** 300 * @tc.name: KeyEventTest_GetFunctionKey_006 301 * @tc.desc: Set Scrolllock for keyevent to true 302 * @tc.type: FUNC 303 * @tc.require: I5HMCX 304 */ 305 HWTEST_F(KeyEventTest, KeyEventTest_GetFunctionKey_006, TestSize.Level1) 306 { 307 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 308 ASSERT_NE(keyEvent, nullptr); 309 keyEvent->SetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY, true); 310 bool result = keyEvent->GetFunctionKey(KeyEvent::SCROLL_LOCK_FUNCTION_KEY); 311 ASSERT_TRUE(result); 312 } 313 314 /** 315 * @tc.name: KeyEventTest_TransitionFunctionKey_001 316 * @tc.desc: Transition keycode to function key 317 * @tc.type: FUNC 318 * @tc.require: I5HMCX 319 */ 320 HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_001, TestSize.Level1) 321 { 322 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 323 ASSERT_NE(keyEvent, nullptr); 324 int32_t lockCode = keyEvent->TransitionFunctionKey(KeyEvent::KEYCODE_NUM_LOCK); 325 ASSERT_EQ(lockCode, KeyEvent::NUM_LOCK_FUNCTION_KEY); 326 } 327 328 /** 329 * @tc.name: KeyEventTest_TransitionFunctionKey_002 330 * @tc.desc: Transition keycode to function key 331 * @tc.type: FUNC 332 * @tc.require: I5HMCX 333 */ 334 HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_002, TestSize.Level1) 335 { 336 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 337 ASSERT_NE(keyEvent, nullptr); 338 int32_t lockCode = keyEvent->TransitionFunctionKey(KeyEvent::KEYCODE_SCROLL_LOCK); 339 ASSERT_EQ(lockCode, KeyEvent::SCROLL_LOCK_FUNCTION_KEY); 340 } 341 342 /** 343 * @tc.name: KeyEventTest_TransitionFunctionKey_003 344 * @tc.desc: Transition keycode to function key 345 * @tc.type: FUNC 346 * @tc.require: I5HMCX 347 */ 348 HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_003, TestSize.Level1) 349 { 350 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 351 ASSERT_NE(keyEvent, nullptr); 352 int32_t lockCode = keyEvent->TransitionFunctionKey(KeyEvent::KEYCODE_CAPS_LOCK); 353 ASSERT_EQ(lockCode, KeyEvent::CAPS_LOCK_FUNCTION_KEY); 354 } 355 356 /** 357 * @tc.name: KeyEventTest_TransitionFunctionKey_004 358 * @tc.desc: Transition not support keycode to function key 359 * @tc.type: FUNC 360 * @tc.require: I5HMCX 361 */ 362 HWTEST_F(KeyEventTest, KeyEventTest_TransitionFunctionKey_004, TestSize.Level1) 363 { 364 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 365 ASSERT_NE(keyEvent, nullptr); 366 int32_t lockCode = keyEvent->TransitionFunctionKey(KeyEvent::KEYCODE_A); 367 ASSERT_EQ(lockCode, KeyEvent::UNKNOWN_FUNCTION_KEY); 368 } 369 370 /** 371 * @tc.name: KeyEventTest_ReadFromParcel_001 372 * @tc.desc: Read from parcel 373 * @tc.type: FUNC 374 * @tc.require: 375 */ 376 HWTEST_F(KeyEventTest, KeyEventTest_ReadFromParcel_001, TestSize.Level1) 377 { 378 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 379 ASSERT_NE(keyEvent, nullptr); 380 keyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME); 381 keyEvent->SetActionTime(100); 382 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 383 keyEvent->ActionToString(KeyEvent::KEY_ACTION_DOWN); 384 keyEvent->KeyCodeToString(KeyEvent::KEYCODE_HOME); 385 KeyEvent::KeyItem item; 386 item.SetKeyCode(KeyEvent::KEYCODE_HOME); 387 item.SetDownTime(100); 388 item.SetPressed(true); 389 keyEvent->AddKeyItem(item); 390 MessageParcel data; 391 bool ret = keyEvent->WriteToParcel(data); 392 ASSERT_TRUE(ret); 393 ret = keyEvent->ReadFromParcel(data); 394 ASSERT_TRUE(ret); 395 } 396 397 /** 398 * @tc.name: KeyEventTest_ReadFromParcel_002 399 * @tc.desc: Read from parcel 400 * @tc.type: FUNC 401 * @tc.require: 402 */ 403 HWTEST_F(KeyEventTest, KeyEventTest_ReadFromParcel_002, TestSize.Level1) 404 { 405 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 406 ASSERT_NE(keyEvent, nullptr); 407 keyEvent->SetKeyCode(KeyEvent::KEYCODE_HOME); 408 keyEvent->SetActionTime(100); 409 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 410 keyEvent->ActionToString(KeyEvent::KEY_ACTION_DOWN); 411 keyEvent->KeyCodeToString(KeyEvent::KEYCODE_HOME); 412 KeyEvent::KeyItem item; 413 item.SetKeyCode(KeyEvent::KEYCODE_HOME); 414 item.SetDownTime(100); 415 item.SetPressed(true); 416 keyEvent->AddKeyItem(item); 417 MessageParcel data; 418 bool ret = keyEvent->WriteToParcel(data); 419 ASSERT_TRUE(ret); 420 std::shared_ptr<InputEvent> inputEvent = InputEvent::Create(); 421 ret = inputEvent->ReadFromParcel(data); 422 ASSERT_TRUE(ret); 423 int32_t keyCode; 424 ret = data.ReadInt32(keyCode); 425 ASSERT_TRUE(ret); 426 const int32_t keysSize = data.ReadInt32(); 427 ASSERT_FALSE(keysSize < 0); 428 for (int32_t i = 0; i < keysSize; ++i) { 429 KeyEvent::KeyItem keyItem = {}; 430 ret = keyItem.ReadFromParcel(data); 431 ASSERT_TRUE(ret); 432 } 433 } 434 435 /** 436 * @tc.name: KeyEventTest_ReadFromParcel_003 437 * @tc.desc: Verify keyoption read from parcel 438 * @tc.type: FUNC 439 * @tc.require: 440 */ 441 HWTEST_F(KeyEventTest, KeyEventTest_ReadFromParcel_003, TestSize.Level1) 442 { 443 std::set<int32_t> preKeys; 444 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 445 keyOption->SetPreKeys(preKeys); 446 MessageParcel data; 447 bool ret = keyOption->ReadFromParcel(data); 448 ASSERT_FALSE(ret); 449 preKeys.insert(0); 450 preKeys.insert(1); 451 keyOption->SetPreKeys(preKeys); 452 keyOption->SetFinalKey(0); 453 keyOption->SetFinalKeyDown(0); 454 keyOption->SetFinalKeyDownDuration(0); 455 keyOption->SetFinalKeyUpDelay(0); 456 keyOption->WriteToParcel(data); 457 ret = keyOption->ReadFromParcel(data); 458 ASSERT_TRUE(ret); 459 } 460 } // namespace MMI 461 } // namespace OHOS 462