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