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