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 <gtest/gtest.h> 17 18 #include "util.h" 19 20 #include "ability_manager_client.h" 21 #include "common_event_support.h" 22 #include "display_event_monitor.h" 23 #include "event_log_helper.h" 24 #include "gesturesense_wrapper.h" 25 #include "input_event_handler.h" 26 #include "input_handler_type.h" 27 #include "input_windows_manager.h" 28 #include "key_command_handler.h" 29 #include "mmi_log.h" 30 #include "multimodal_event_handler.h" 31 #include "multimodal_input_preferences_manager.h" 32 #include "stylus_key_handler.h" 33 #include "system_info.h" 34 35 #undef MMI_LOG_TAG 36 #define MMI_LOG_TAG "KeyCmdHandleRepeatKeyTest" 37 38 namespace OHOS { 39 namespace MMI { 40 namespace { 41 using namespace testing::ext; 42 const std::string SOS_BUNDLE_NAME { "com.hmos.emergencycommunication" }; 43 } // namespace 44 class KeyCmdHandleRepeatKeyTest : public testing::Test { 45 public: SetUpTestCase(void)46 static void SetUpTestCase(void) {} TearDownTestCase(void)47 static void TearDownTestCase(void) {} 48 }; 49 50 /** 51 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_001 52 * @tc.desc: Test if (keyEvent->GetKeyCode() != item.keyCode) 53 * @tc.type: FUNC 54 * @tc.require: 55 */ 56 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_001, TestSize.Level1) 57 { 58 CALL_TEST_DEBUG; 59 KeyCommandHandler handler; 60 RepeatKey repeatKey; 61 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 62 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 63 ASSERT_NE(keyEvent, nullptr); 64 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 65 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 66 67 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 68 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 69 } 70 71 /** 72 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_002 73 * @tc.desc: Test if (!isDownStart_) 74 * @tc.type: FUNC 75 * @tc.require: 76 */ 77 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_002, TestSize.Level1) 78 { 79 CALL_TEST_DEBUG; 80 KeyCommandHandler handler; 81 RepeatKey repeatKey; 82 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 83 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 84 ASSERT_NE(keyEvent, nullptr); 85 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 86 handler.isDownStart_ = false; 87 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 88 89 handler.isDownStart_ = true; 90 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 91 } 92 93 /** 94 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_003 95 * @tc.desc: Test if (keyEvent->GetKeyAction() != KeyEvent::KEY_ACTION_DOWN || 96 * (count_ > maxCount_ && keyEvent->GetKeyCode() == KeyEvent::KEYCODE_POWER)) 97 * @tc.type: FUNC 98 * @tc.require: 99 */ 100 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_003, TestSize.Level1) 101 { 102 CALL_TEST_DEBUG; 103 KeyCommandHandler handler; 104 RepeatKey repeatKey; 105 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 106 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 107 ASSERT_NE(keyEvent, nullptr); 108 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 109 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 110 handler.isDownStart_ = true; 111 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 112 } 113 114 /** 115 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_004 116 * @tc.desc: Test if (keyEvent->GetKeyAction() != KeyEvent::KEY_ACTION_DOWN || 117 * (count_ > maxCount_ && keyEvent->GetKeyCode() == KeyEvent::KEYCODE_POWER)) 118 * @tc.type: FUNC 119 * @tc.require: 120 */ 121 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_004, TestSize.Level1) 122 { 123 CALL_TEST_DEBUG; 124 KeyCommandHandler handler; 125 RepeatKey repeatKey; 126 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 127 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 128 ASSERT_NE(keyEvent, nullptr); 129 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 130 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 131 handler.count_ = 5; 132 handler.maxCount_ = 0; 133 handler.isDownStart_ = true; 134 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 135 } 136 137 /** 138 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_005 139 * @tc.desc: Test if (keyEvent->GetKeyAction() != KeyEvent::KEY_ACTION_DOWN || 140 * (count_ > maxCount_ && keyEvent->GetKeyCode() == KeyEvent::KEYCODE_POWER)) 141 * @tc.type: FUNC 142 * @tc.require: 143 */ 144 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_005, TestSize.Level1) 145 { 146 CALL_TEST_DEBUG; 147 KeyCommandHandler handler; 148 RepeatKey repeatKey; 149 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 150 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 151 ASSERT_NE(keyEvent, nullptr); 152 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 153 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 154 handler.count_ = 0; 155 handler.maxCount_ = 0; 156 handler.isDownStart_ = true; 157 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 158 } 159 160 /** 161 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_006 162 * @tc.desc: Test if (isDownStart_) 163 * @tc.type: FUNC 164 * @tc.require: 165 */ 166 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_006, TestSize.Level1) 167 { 168 CALL_TEST_DEBUG; 169 KeyCommandHandler handler; 170 RepeatKey repeatKey; 171 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 172 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 173 ASSERT_NE(keyEvent, nullptr); 174 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 175 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 176 handler.isDownStart_ = true; 177 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 178 } 179 180 /** 181 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_007 182 * @tc.desc: Test if (it == repeatKeyCountMap_.end()) 183 * @tc.type: FUNC 184 * @tc.require: 185 */ 186 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_007, TestSize.Level1) 187 { 188 CALL_TEST_DEBUG; 189 KeyCommandHandler handler; 190 RepeatKey repeatKey; 191 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 192 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 193 ASSERT_NE(keyEvent, nullptr); 194 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 195 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 196 handler.isDownStart_ = true; 197 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 198 } 199 200 /** 201 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_008 202 * @tc.desc: Test if (it == repeatKeyCountMap_.end()) 203 * @tc.type: FUNC 204 * @tc.require: 205 */ 206 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_008, TestSize.Level1) 207 { 208 CALL_TEST_DEBUG; 209 KeyCommandHandler handler; 210 RepeatKey repeatKey; 211 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 212 repeatKey.times = 2; 213 repeatKey.ability.bundleName = "bundleName"; 214 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 215 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 216 ASSERT_NE(keyEvent, nullptr); 217 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 218 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 219 handler.isDownStart_ = true; 220 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 221 } 222 223 /** 224 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_009 225 * @tc.desc: Test if (item.ability.bundleName != SOS_BUNDLE_NAME || 226 * downActionTime_ - lastVolumeDownActionTime_ > SOS_INTERVAL_TIMES) 227 * @tc.type: FUNC 228 * @tc.require: 229 */ 230 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_009, TestSize.Level1) 231 { 232 CALL_TEST_DEBUG; 233 KeyCommandHandler handler; 234 RepeatKey repeatKey; 235 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 236 repeatKey.times = 2; 237 repeatKey.ability.bundleName = "bundleName"; 238 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 239 ASSERT_NE(keyEvent, nullptr); 240 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 241 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 242 handler.isDownStart_ = true; 243 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 244 } 245 246 /** 247 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_010 248 * @tc.desc: Test if (item.ability.bundleName != SOS_BUNDLE_NAME || 249 * downActionTime_ - lastVolumeDownActionTime_ > SOS_INTERVAL_TIMES) 250 * @tc.type: FUNC 251 * @tc.require: 252 */ 253 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_010, TestSize.Level1) 254 { 255 CALL_TEST_DEBUG; 256 KeyCommandHandler handler; 257 RepeatKey repeatKey; 258 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 259 repeatKey.times = 2; 260 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 261 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 262 ASSERT_NE(keyEvent, nullptr); 263 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 264 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 265 handler.isDownStart_ = true; 266 handler.downActionTime_ = 400000; 267 handler.lastVolumeDownActionTime_ = 0; 268 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 269 } 270 271 /** 272 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_011 273 * @tc.desc: Test if (item.ability.bundleName != SOS_BUNDLE_NAME || 274 * downActionTime_ - lastVolumeDownActionTime_ > SOS_INTERVAL_TIMES) 275 * @tc.type: FUNC 276 * @tc.require: 277 */ 278 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_011, TestSize.Level1) 279 { 280 CALL_TEST_DEBUG; 281 KeyCommandHandler handler; 282 RepeatKey repeatKey; 283 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 284 repeatKey.times = 2; 285 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 286 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 287 ASSERT_NE(keyEvent, nullptr); 288 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 289 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 290 handler.isDownStart_ = true; 291 handler.downActionTime_ = 0; 292 handler.lastVolumeDownActionTime_ = 0; 293 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 294 } 295 296 /** 297 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_012 298 * @tc.desc: Test if (repeatKeyCountMap_[item.ability.bundleName] == item.times) 299 * @tc.type: FUNC 300 * @tc.require: 301 */ 302 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_012, TestSize.Level1) 303 { 304 CALL_TEST_DEBUG; 305 KeyCommandHandler handler; 306 RepeatKey repeatKey; 307 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 308 repeatKey.times = 2; 309 repeatKey.delay = 0; 310 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 311 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 312 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 313 ASSERT_NE(keyEvent, nullptr); 314 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 315 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 316 handler.isDownStart_ = true; 317 handler.downActionTime_ = 10; 318 handler.lastDownActionTime_ = 0; 319 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 320 } 321 322 /** 323 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_013 324 * @tc.desc: Test if (repeatKeyCountMap_[item.ability.bundleName] == item.times) 325 * @tc.type: FUNC 326 * @tc.require: 327 */ 328 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_013, TestSize.Level1) 329 { 330 CALL_TEST_DEBUG; 331 KeyCommandHandler handler; 332 RepeatKey repeatKey; 333 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 334 repeatKey.times = 2; 335 repeatKey.delay = 20; 336 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 337 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 338 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 339 ASSERT_NE(keyEvent, nullptr); 340 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 341 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 342 handler.isDownStart_ = true; 343 handler.downActionTime_ = 10; 344 handler.lastDownActionTime_ = 0; 345 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 346 } 347 348 /** 349 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_014 350 * @tc.desc: Test if (!item.statusConfig.empty()) 351 * @tc.type: FUNC 352 * @tc.require: 353 */ 354 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_014, TestSize.Level1) 355 { 356 CALL_TEST_DEBUG; 357 KeyCommandHandler handler; 358 RepeatKey repeatKey; 359 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 360 repeatKey.times = 2; 361 repeatKey.delay = 0; 362 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 363 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 364 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 365 ASSERT_NE(keyEvent, nullptr); 366 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 367 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 368 handler.isDownStart_ = true; 369 handler.downActionTime_ = 10; 370 handler.lastDownActionTime_ = 0; 371 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 372 } 373 374 /** 375 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_015 376 * @tc.desc: Test if (!item.statusConfig.empty()) 377 * @tc.type: FUNC 378 * @tc.require: 379 */ 380 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_015, TestSize.Level1) 381 { 382 CALL_TEST_DEBUG; 383 KeyCommandHandler handler; 384 RepeatKey repeatKey; 385 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 386 repeatKey.times = 2; 387 repeatKey.delay = 0; 388 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 389 repeatKey.statusConfig = "test"; 390 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 391 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 392 ASSERT_NE(keyEvent, nullptr); 393 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 394 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 395 handler.isDownStart_ = true; 396 handler.downActionTime_ = 10; 397 handler.lastDownActionTime_ = 0; 398 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 399 } 400 401 /** 402 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_016 403 * @tc.desc: Test if (ret != RET_OK) 404 * @tc.type: FUNC 405 * @tc.require: 406 */ 407 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_016, TestSize.Level1) 408 { 409 CALL_TEST_DEBUG; 410 KeyCommandHandler handler; 411 RepeatKey repeatKey; 412 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 413 repeatKey.times = 2; 414 repeatKey.delay = 0; 415 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 416 repeatKey.statusConfig = "test"; 417 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 418 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 419 ASSERT_NE(keyEvent, nullptr); 420 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 421 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 422 handler.isDownStart_ = true; 423 handler.downActionTime_ = 10; 424 handler.lastDownActionTime_ = 0; 425 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 426 } 427 428 /** 429 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_017 430 * @tc.desc: Test if (ret != RET_OK) 431 * @tc.type: FUNC 432 * @tc.require: 433 */ 434 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_017, TestSize.Level1) 435 { 436 CALL_TEST_DEBUG; 437 KeyCommandHandler handler; 438 RepeatKey repeatKey; 439 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 440 repeatKey.times = 2; 441 repeatKey.delay = 0; 442 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 443 repeatKey.statusConfig = ""; 444 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 445 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 446 ASSERT_NE(keyEvent, nullptr); 447 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 448 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 449 handler.isDownStart_ = true; 450 handler.downActionTime_ = 10; 451 handler.lastDownActionTime_ = 0; 452 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 453 } 454 455 /** 456 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_018 457 * @tc.desc: Test if (repeatKeyMaxTimes_.find(item.keyCode) != repeatKeyMaxTimes_.end()) 458 * @tc.type: FUNC 459 * @tc.require: 460 */ 461 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_018, TestSize.Level1) 462 { 463 CALL_TEST_DEBUG; 464 KeyCommandHandler handler; 465 RepeatKey repeatKey; 466 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 467 repeatKey.times = 2; 468 repeatKey.delay = 0; 469 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 470 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 471 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 472 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 473 ASSERT_NE(keyEvent, nullptr); 474 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 475 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 476 handler.isDownStart_ = true; 477 handler.downActionTime_ = 10; 478 handler.lastDownActionTime_ = 0; 479 handler.repeatKeyMaxTimes_.clear(); 480 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 481 } 482 483 /** 484 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_019 485 * @tc.desc: Test if (repeatKeyMaxTimes_.find(item.keyCode) != repeatKeyMaxTimes_.end()) 486 * @tc.type: FUNC 487 * @tc.require: 488 */ 489 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_019, TestSize.Level1) 490 { 491 CALL_TEST_DEBUG; 492 KeyCommandHandler handler; 493 RepeatKey repeatKey; 494 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 495 repeatKey.times = 2; 496 repeatKey.delay = 0; 497 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 498 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 499 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 500 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 501 ASSERT_NE(keyEvent, nullptr); 502 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 503 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 504 handler.isDownStart_ = true; 505 handler.downActionTime_ = 10; 506 handler.lastDownActionTime_ = 0; 507 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 2); 508 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 509 } 510 511 /** 512 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_020 513 * @tc.desc: Test if (item.times < repeatKeyMaxTimes_[item.keyCode]) 514 * @tc.type: FUNC 515 * @tc.require: 516 */ 517 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_020, TestSize.Level1) 518 { 519 CALL_TEST_DEBUG; 520 KeyCommandHandler handler; 521 RepeatKey repeatKey; 522 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 523 repeatKey.times = 2; 524 repeatKey.delay = 0; 525 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 526 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 527 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 528 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 529 ASSERT_NE(keyEvent, nullptr); 530 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 531 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 532 handler.isDownStart_ = true; 533 handler.downActionTime_ = 10; 534 handler.lastDownActionTime_ = 0; 535 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 2); 536 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 537 } 538 539 /** 540 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_021 541 * @tc.desc: Test if (item.times < repeatKeyMaxTimes_[item.keyCode]) 542 * @tc.type: FUNC 543 * @tc.require: 544 */ 545 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_021, TestSize.Level1) 546 { 547 CALL_TEST_DEBUG; 548 KeyCommandHandler handler; 549 RepeatKey repeatKey; 550 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 551 repeatKey.times = 2; 552 repeatKey.delay = 0; 553 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 554 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 555 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 556 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 557 ASSERT_NE(keyEvent, nullptr); 558 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 559 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 560 handler.isDownStart_ = true; 561 handler.downActionTime_ = 10; 562 handler.lastDownActionTime_ = 0; 563 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 3); 564 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 565 } 566 567 /** 568 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_022 569 * @tc.desc: Test if (count_ > item.times && repeatKeyMaxTimes_.find(item.keyCode) != repeatKeyMaxTimes_.end() && 570 * repeatKeyTimerIds_.find(item.ability.bundleName) != repeatKeyTimerIds_.end()) 571 * @tc.type: FUNC 572 * @tc.require: 573 */ 574 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_022, TestSize.Level1) 575 { 576 CALL_TEST_DEBUG; 577 KeyCommandHandler handler; 578 RepeatKey repeatKey; 579 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 580 repeatKey.times = 2; 581 repeatKey.delay = 20; 582 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 583 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 584 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 585 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 586 ASSERT_NE(keyEvent, nullptr); 587 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 588 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 589 handler.isDownStart_ = true; 590 handler.downActionTime_ = 10; 591 handler.lastDownActionTime_ = 0; 592 handler.count_ = 3; 593 handler.maxCount_ = 100; 594 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 3); 595 handler.repeatKeyTimerIds_.emplace(repeatKey.ability.bundleName, 1); 596 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 597 } 598 599 /** 600 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_023 601 * @tc.desc: Test if (count_ > item.times && repeatKeyMaxTimes_.find(item.keyCode) != repeatKeyMaxTimes_.end() && 602 * repeatKeyTimerIds_.find(item.ability.bundleName) != repeatKeyTimerIds_.end()) 603 * @tc.type: FUNC 604 * @tc.require: 605 */ 606 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_023, TestSize.Level1) 607 { 608 CALL_TEST_DEBUG; 609 KeyCommandHandler handler; 610 RepeatKey repeatKey; 611 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 612 repeatKey.times = 2; 613 repeatKey.delay = 20; 614 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 615 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 616 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 617 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 618 ASSERT_NE(keyEvent, nullptr); 619 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 620 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 621 handler.isDownStart_ = true; 622 handler.downActionTime_ = 10; 623 handler.lastDownActionTime_ = 0; 624 handler.count_ = 0; 625 handler.maxCount_ = 100; 626 handler.repeatKeyMaxTimes_.clear(); 627 handler.repeatKeyTimerIds_.clear(); 628 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 629 } 630 631 /** 632 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_024 633 * @tc.desc: Test if (count_ > item.times && repeatKeyMaxTimes_.find(item.keyCode) != repeatKeyMaxTimes_.end() && 634 * repeatKeyTimerIds_.find(item.ability.bundleName) != repeatKeyTimerIds_.end()) 635 * @tc.type: FUNC 636 * @tc.require: 637 */ 638 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_024, TestSize.Level1) 639 { 640 CALL_TEST_DEBUG; 641 KeyCommandHandler handler; 642 RepeatKey repeatKey; 643 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 644 repeatKey.times = 2; 645 repeatKey.delay = 20; 646 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 647 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 648 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 649 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 650 ASSERT_NE(keyEvent, nullptr); 651 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 652 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 653 handler.isDownStart_ = true; 654 handler.downActionTime_ = 10; 655 handler.lastDownActionTime_ = 0; 656 handler.count_ = 3; 657 handler.maxCount_ = 100; 658 handler.repeatKeyMaxTimes_.clear(); 659 handler.repeatKeyTimerIds_.emplace(repeatKey.ability.bundleName, 1); 660 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 661 } 662 663 /** 664 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_025 665 * @tc.desc: Test if (count_ > item.times && repeatKeyMaxTimes_.find(item.keyCode) != repeatKeyMaxTimes_.end() && 666 * repeatKeyTimerIds_.find(item.ability.bundleName) != repeatKeyTimerIds_.end()) 667 * @tc.type: FUNC 668 * @tc.require: 669 */ 670 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_025, TestSize.Level1) 671 { 672 CALL_TEST_DEBUG; 673 KeyCommandHandler handler; 674 RepeatKey repeatKey; 675 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 676 repeatKey.times = 2; 677 repeatKey.delay = 20; 678 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 679 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 680 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 681 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 682 ASSERT_NE(keyEvent, nullptr); 683 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 684 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 685 handler.isDownStart_ = true; 686 handler.downActionTime_ = 10; 687 handler.lastDownActionTime_ = 0; 688 handler.count_ = 3; 689 handler.maxCount_ = 100; 690 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 3); 691 handler.repeatKeyTimerIds_.clear(); 692 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 693 } 694 695 /** 696 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_026 697 * @tc.desc: Test if (count_ < repeatKeyMaxTimes_[item.keyCode] && repeatKeyTimerIds_[item.ability.bundleName] >= 0) 698 * @tc.type: FUNC 699 * @tc.require: 700 */ 701 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_026, TestSize.Level1) 702 { 703 CALL_TEST_DEBUG; 704 KeyCommandHandler handler; 705 RepeatKey repeatKey; 706 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 707 repeatKey.times = 2; 708 repeatKey.delay = 20; 709 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 710 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 711 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 712 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 713 ASSERT_NE(keyEvent, nullptr); 714 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 715 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 716 handler.isDownStart_ = true; 717 handler.downActionTime_ = 10; 718 handler.lastDownActionTime_ = 0; 719 handler.count_ = 3; 720 handler.maxCount_ = 100; 721 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 4); 722 handler.repeatKeyTimerIds_.emplace(repeatKey.ability.bundleName, 1); 723 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 724 } 725 726 /** 727 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_027 728 * @tc.desc: Test if (count_ < repeatKeyMaxTimes_[item.keyCode] && repeatKeyTimerIds_[item.ability.bundleName] >= 0) 729 * @tc.type: FUNC 730 * @tc.require: 731 */ 732 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_027, TestSize.Level1) 733 { 734 CALL_TEST_DEBUG; 735 KeyCommandHandler handler; 736 RepeatKey repeatKey; 737 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 738 repeatKey.times = 2; 739 repeatKey.delay = 20; 740 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 741 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 742 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 743 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 744 ASSERT_NE(keyEvent, nullptr); 745 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 746 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 747 handler.isDownStart_ = true; 748 handler.downActionTime_ = 10; 749 handler.lastDownActionTime_ = 0; 750 handler.count_ = 4; 751 handler.maxCount_ = 100; 752 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 3); 753 handler.repeatKeyTimerIds_.emplace(repeatKey.ability.bundleName, 1); 754 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 755 } 756 757 /** 758 * @tc.name: KeyCmdHandleRepeatKeyTest_HandleRepeatKey_028 759 * @tc.desc: Test if (count_ < repeatKeyMaxTimes_[item.keyCode] && repeatKeyTimerIds_[item.ability.bundleName] >= 0) 760 * @tc.type: FUNC 761 * @tc.require: 762 */ 763 HWTEST_F(KeyCmdHandleRepeatKeyTest, KeyCmdHandleRepeatKeyTest_HandleRepeatKey_028, TestSize.Level1) 764 { 765 CALL_TEST_DEBUG; 766 KeyCommandHandler handler; 767 RepeatKey repeatKey; 768 repeatKey.keyCode = KeyEvent::KEYCODE_POWER; 769 repeatKey.times = 2; 770 repeatKey.delay = 20; 771 repeatKey.ability.bundleName = SOS_BUNDLE_NAME; 772 repeatKey.statusConfig = "POWER_KEY_DOUBLE_CLICK_FOR_WALLET"; 773 handler.repeatKeyCountMap_.emplace(repeatKey.ability.bundleName, 2); 774 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 775 ASSERT_NE(keyEvent, nullptr); 776 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 777 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 778 handler.isDownStart_ = true; 779 handler.downActionTime_ = 10; 780 handler.lastDownActionTime_ = 0; 781 handler.count_ = 4; 782 handler.maxCount_ = 100; 783 handler.repeatKeyMaxTimes_.emplace(KeyEvent::KEYCODE_POWER, 3); 784 handler.repeatKeyTimerIds_.emplace(repeatKey.ability.bundleName, -1); 785 ASSERT_NO_FATAL_FAILURE(handler.HandleRepeatKey(repeatKey, keyEvent)); 786 } 787 } // namespace MMI 788 } // namespace OHOS