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 <fstream> 17 #include <list> 18 #include <gtest/gtest.h> 19 20 #include "ability_manager_client.h" 21 #include "display_event_monitor.h" 22 #include "event_log_helper.h" 23 #include "key_option.h" 24 #include "key_gesture_manager.h" 25 #include "key_event.h" 26 #include "mmi_log.h" 27 #include "nap_process.h" 28 #include "switch_subscriber_handler.h" 29 #include "uds_server.h" 30 31 #undef MMI_LOG_TAG 32 #define MMI_LOG_TAG "KeyGestureManagerTest" 33 34 namespace OHOS { 35 namespace MMI { 36 namespace { 37 using namespace testing::ext; 38 constexpr int32_t INVALID_ENTITY_ID { -1 }; 39 constexpr size_t SINGLE_KEY_PRESSED { 1 }; 40 } // namespace 41 42 class KeyGestureManagerTest : public testing::Test { 43 public: SetUpTestCase(void)44 static void SetUpTestCase(void) {} TearDownTestCase(void)45 static void TearDownTestCase(void) {} 46 }; 47 48 class MyKeyGesture : public KeyGestureManager::KeyGesture { 49 public: 50 MyKeyGesture() = default; 51 ~MyKeyGesture() override = default; 52 IsWorking()53 bool IsWorking() override 54 { 55 return true; 56 } 57 ShouldIntercept(std::shared_ptr<KeyOption> keyOption) const58 bool ShouldIntercept(std::shared_ptr<KeyOption> keyOption) const override 59 { 60 return true; 61 } 62 Intercept(std::shared_ptr<KeyEvent> keyEvent)63 bool Intercept(std::shared_ptr<KeyEvent> keyEvent) override 64 { 65 return true; 66 } 67 Dump(std::ostringstream & output) const68 void Dump(std::ostringstream &output) const override 69 { 70 output << "MyKeyGesture"; 71 } 72 }; 73 74 /** 75 * @tc.name: KeyGestureManagerTest_Intercept_002 76 * @tc.desc: Test the funcation Intercept 77 * @tc.type: FUNC 78 * @tc.require: 79 */ 80 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_Intercept_002, TestSize.Level1) 81 { 82 CALL_TEST_DEBUG; 83 KeyGestureManager keyGestureManager; 84 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 85 ASSERT_NE(keyEvent, nullptr); 86 auto keyGesture1 = std::make_unique<MyKeyGesture>(); 87 auto keyGesture2 = std::make_unique<MyKeyGesture>(); 88 auto keyGesture3 = std::make_unique<MyKeyGesture>(); 89 keyGestureManager.keyGestures_.push_back(std::move(keyGesture1)); 90 keyGestureManager.keyGestures_.push_back(std::move(keyGesture2)); 91 keyGestureManager.keyGestures_.push_back(std::move(keyGesture3)); 92 EXPECT_FALSE(EventLogHelper::IsBetaVersion()); 93 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 94 EXPECT_TRUE(keyGestureManager.Intercept(keyEvent)); 95 } 96 97 /** 98 * @tc.name: KeyGestureManagerTest_TriggerHandlers_01 99 * @tc.desc: Test the funcation TriggerHandlers 100 * @tc.type: FUNC 101 * @tc.require: 102 */ 103 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_TriggerHandlers_01, TestSize.Level1) 104 { 105 CALL_TEST_DEBUG; 106 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 107 KeyGestureManager::Handler handler1(1, 10, 500, myCallback); 108 KeyGestureManager::Handler handler2(2, 20, 1000, myCallback); 109 KeyGestureManager::Handler handler3(3, 30, 1500, myCallback); 110 111 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 112 myKeyGesture->handlers_.push_back(handler1); 113 myKeyGesture->handlers_.push_back(handler2); 114 myKeyGesture->handlers_.push_back(handler3); 115 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 116 ASSERT_NE(keyEvent, nullptr); 117 118 std::set<int32_t> foregroundPids = myKeyGesture->GetForegroundPids(); 119 bool haveForeground = myKeyGesture->HaveForegroundHandler(foregroundPids); 120 EXPECT_FALSE(haveForeground); 121 ASSERT_NO_FATAL_FAILURE(myKeyGesture->TriggerHandlers(keyEvent)); 122 } 123 124 /** 125 * @tc.name: LongPressSingleKey_Dump_01 126 * @tc.desc: Test the funcation LongPressSingleKey_Dump 127 * @tc.type: FUNC 128 * @tc.require: 129 */ 130 HWTEST_F(KeyGestureManagerTest, LongPressSingleKey_Dump_01, TestSize.Level1) 131 { 132 CALL_TEST_DEBUG; 133 int32_t keyCode = 1; 134 KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode); 135 std::ostringstream output; 136 longPressSingleKey.keyCode_ = 2; 137 138 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 139 KeyGestureManager::Handler handler1(1, 10, 500, myCallback); 140 KeyGestureManager::Handler handler2(2, 20, 1000, myCallback); 141 KeyGestureManager::Handler handler3(3, 30, 1500, myCallback); 142 143 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 144 myKeyGesture->handlers_.push_back(handler1); 145 myKeyGesture->handlers_.push_back(handler2); 146 myKeyGesture->handlers_.push_back(handler3); 147 ASSERT_NO_FATAL_FAILURE(longPressSingleKey.Dump(output)); 148 } 149 150 /** 151 * @tc.name: LongPressCombinationKey_Dump_01 152 * @tc.desc: Test the funcation LongPressCombinationKey_Dump 153 * @tc.type: FUNC 154 * @tc.require: 155 */ 156 HWTEST_F(KeyGestureManagerTest, LongPressCombinationKey_Dump_01, TestSize.Level1) 157 { 158 CALL_TEST_DEBUG; 159 std::set<int32_t> keys = {1, 2, 3}; 160 KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys); 161 std::ostringstream output; 162 longPressCombinationKey.keys_ = {3, 4, 5, 6}; 163 ASSERT_NO_FATAL_FAILURE(longPressCombinationKey.Dump(output)); 164 165 longPressCombinationKey.keys_ = {}; 166 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 167 KeyGestureManager::Handler handler1(1, 10, 500, myCallback); 168 KeyGestureManager::Handler handler2(2, 20, 1000, myCallback); 169 KeyGestureManager::Handler handler3(3, 30, 1500, myCallback); 170 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 171 myKeyGesture->handlers_.push_back(handler1); 172 myKeyGesture->handlers_.push_back(handler2); 173 myKeyGesture->handlers_.push_back(handler3); 174 ASSERT_NO_FATAL_FAILURE(longPressCombinationKey.Dump(output)); 175 } 176 177 /** 178 * @tc.name: KeyGestureManagerTest_Intercept_01 179 * @tc.desc: Test the funcation Intercept 180 * @tc.type: FUNC 181 * @tc.require: 182 */ 183 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_Intercept_01, TestSize.Level1) 184 { 185 CALL_TEST_DEBUG; 186 KeyGestureManager keyGestureManager; 187 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 188 ASSERT_NE(keyEvent, nullptr); 189 bool ret = keyGestureManager.Intercept(keyEvent); 190 EXPECT_FALSE(ret); 191 } 192 193 /** 194 * @tc.name: KeyGestureManagerTest_RemoveKeyGesture_01 195 * @tc.desc: Test the funcation RemoveKeyGesture 196 * @tc.type: FUNC 197 * @tc.require: 198 */ 199 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_RemoveKeyGesture_01, TestSize.Level1) 200 { 201 CALL_TEST_DEBUG; 202 KeyGestureManager keyGestureManager; 203 int32_t id = 1; 204 ASSERT_NO_FATAL_FAILURE(keyGestureManager.RemoveKeyGesture(id)); 205 } 206 207 /** 208 * @tc.name: KeyGestureManagerTest_RemoveKeyGesture_02 209 * @tc.desc: Test the funcation RemoveKeyGesture 210 * @tc.type: FUNC 211 * @tc.require: 212 */ 213 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_RemoveKeyGesture_02, TestSize.Level1) 214 { 215 CALL_TEST_DEBUG; 216 KeyGestureManager keyGestureManager; 217 int32_t id = -2; 218 ASSERT_NO_FATAL_FAILURE(keyGestureManager.RemoveKeyGesture(id)); 219 } 220 221 /** 222 * @tc.name: KeyGestureManagerTest_AddKeyGesture_01 223 * @tc.desc: Test the funcation AddKeyGesture 224 * @tc.type: FUNC 225 * @tc.require: 226 */ 227 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_AddKeyGesture_01, TestSize.Level1) 228 { 229 CALL_TEST_DEBUG; 230 KeyGestureManager keyGestureManager; 231 int32_t pid = 1; 232 std::shared_ptr<KeyOption> keyOption = nullptr; __anonf55d8a680202(std::shared_ptr<KeyEvent> event) 233 auto callback = [](std::shared_ptr<KeyEvent> event) {}; 234 int32_t result = keyGestureManager.AddKeyGesture(pid, keyOption, callback); 235 EXPECT_EQ(result, INVALID_ENTITY_ID); 236 } 237 238 /** 239 * @tc.name: KeyGestureManagerTest_ShouldIntercept_01 240 * @tc.desc: Test the funcation ShouldIntercept 241 * @tc.type: FUNC 242 * @tc.require: 243 */ 244 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_ShouldIntercept_01, TestSize.Level1) 245 { 246 CALL_TEST_DEBUG; 247 KeyGestureManager keyGestureManager; 248 std::shared_ptr<KeyOption> keyOption = nullptr; 249 bool result = keyGestureManager.ShouldIntercept(keyOption); 250 EXPECT_FALSE(result); 251 } 252 253 /** 254 * @tc.name: KeyGestureManagerTest_Intercept_02 255 * @tc.desc: Test the funcation ShouldIntercept 256 * @tc.type: FUNC 257 * @tc.require: 258 */ 259 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_Intercept_02, TestSize.Level1) 260 { 261 CALL_TEST_DEBUG; 262 int32_t keyCode = 1; 263 KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode); 264 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 265 ASSERT_NE(keyEvent, nullptr); 266 keyEvent->keyCode_ = 2; 267 longPressSingleKey.keyCode_ = 2; 268 keyEvent->keyAction_ = KeyEvent::KEY_ACTION_DOWN; 269 270 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 271 myKeyGesture->active_ = true; 272 bool ret = longPressSingleKey.Intercept(keyEvent); 273 EXPECT_TRUE(ret); 274 275 myKeyGesture->active_ = true; 276 bool ret2 = longPressSingleKey.Intercept(keyEvent); 277 EXPECT_TRUE(ret2); 278 } 279 280 /** 281 * @tc.name: KeyGestureManagerTest_Intercept_03 282 * @tc.desc: Test the funcation ShouldIntercept 283 * @tc.type: FUNC 284 * @tc.require: 285 */ 286 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_Intercept_03, TestSize.Level1) 287 { 288 CALL_TEST_DEBUG; 289 int32_t keyCode = 1; 290 KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode); 291 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 292 ASSERT_NE(keyEvent, nullptr); 293 keyEvent->keyCode_ = 3; 294 longPressSingleKey.keyCode_ = 2; 295 keyEvent->keyAction_ = KeyEvent::KEY_ACTION_DOWN; 296 bool ret = longPressSingleKey.Intercept(keyEvent); 297 EXPECT_FALSE(ret); 298 } 299 300 /** 301 * @tc.name: KeyGestureManagerTest_Intercept_04 302 * @tc.desc: Test the funcation ShouldIntercept 303 * @tc.type: FUNC 304 * @tc.require: 305 */ 306 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_Intercept_04, TestSize.Level1) 307 { 308 CALL_TEST_DEBUG; 309 int32_t keyCode = 1; 310 KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode); 311 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 312 ASSERT_NE(keyEvent, nullptr); 313 keyEvent->keyCode_ = 2; 314 longPressSingleKey.keyCode_ = 2; 315 keyEvent->keyAction_ = KeyEvent::KEY_ACTION_UP; 316 bool ret = longPressSingleKey.Intercept(keyEvent); 317 EXPECT_FALSE(ret); 318 } 319 320 /** 321 * @tc.name: KeyGestureManagerTest_Intercept_05 322 * @tc.desc: Test the funcation ShouldIntercept 323 * @tc.type: FUNC 324 * @tc.require: 325 */ 326 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_Intercept_05, TestSize.Level1) 327 { 328 CALL_TEST_DEBUG; 329 int32_t keyCode = 1; 330 KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode); 331 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 332 ASSERT_NE(keyEvent, nullptr); 333 keyEvent->keyCode_ = 3; 334 longPressSingleKey.keyCode_ = 2; 335 keyEvent->keyAction_ = KeyEvent::KEY_ACTION_UP; 336 bool ret = longPressSingleKey.Intercept(keyEvent); 337 EXPECT_FALSE(ret); 338 } 339 340 /** 341 * @tc.name: KeyGestureManagerTest_Intercept_06 342 * @tc.desc: Test the funcation ShouldIntercept 343 * @tc.type: FUNC 344 * @tc.require: 345 */ 346 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_Intercept_06, TestSize.Level1) 347 { 348 CALL_TEST_DEBUG; 349 int32_t keyCode = 1; 350 KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode); 351 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 352 ASSERT_NE(keyEvent, nullptr); 353 keyEvent->keyCode_ = 3; 354 longPressSingleKey.keyCode_ = 2; 355 keyEvent->keyAction_ = KeyEvent::KEY_ACTION_UP; 356 357 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 358 myKeyGesture->active_ = true; 359 bool ret = longPressSingleKey.Intercept(keyEvent); 360 EXPECT_FALSE(ret); 361 362 myKeyGesture->active_ = false; 363 bool ret2 = longPressSingleKey.Intercept(keyEvent); 364 EXPECT_FALSE(ret2); 365 } 366 367 /** 368 * @tc.name: KeyGestureManagerTest_IsWorking_01 369 * @tc.desc: Test the funcation ShouldIntercept 370 * @tc.type: FUNC 371 * @tc.require: 372 */ 373 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_IsWorking_01, TestSize.Level1) 374 { 375 CALL_TEST_DEBUG; 376 KeyGestureManager::PullUpAccessibility pullUpAccessibility; 377 DISPLAY_MONITOR->screenStatus_ = EventFwk::CommonEventSupportTest::COMMON_EVENT_SCREEN_OFF; 378 bool ret = pullUpAccessibility.IsWorking(); 379 EXPECT_FALSE(ret); 380 } 381 382 /** 383 * @tc.name: KeyGestureManagerTest_IsWorking_02 384 * @tc.desc: Test the funcation ShouldIntercept 385 * @tc.type: FUNC 386 * @tc.require: 387 */ 388 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_IsWorking_02, TestSize.Level1) 389 { 390 CALL_TEST_DEBUG; 391 KeyGestureManager::PullUpAccessibility pullUpAccessibility; 392 DISPLAY_MONITOR->screenStatus_ = EventFwk::CommonEventSupportTest::COMMON_EVENT_SCREEN_ON; 393 DISPLAY_MONITOR->isScreenLocked_ = true; 394 bool ret = pullUpAccessibility.IsWorking(); 395 EXPECT_FALSE(ret); 396 } 397 398 /** 399 * @tc.name: KeyGestureManagerTest_IsWorking_03 400 * @tc.desc: Test the funcation ShouldIntercept 401 * @tc.type: FUNC 402 * @tc.require: 403 */ 404 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_IsWorking_03, TestSize.Level1) 405 { 406 CALL_TEST_DEBUG; 407 KeyGestureManager::PullUpAccessibility pullUpAccessibility; 408 DISPLAY_MONITOR->screenStatus_ = EventFwk::CommonEventSupportTest::COMMON_EVENT_SCREEN_ON; 409 DISPLAY_MONITOR->isScreenLocked_ = false; 410 bool ret = pullUpAccessibility.IsWorking(); 411 EXPECT_FALSE(ret); 412 } 413 414 /** 415 * @tc.name: KeyGestureManagerTest_OnTriggerAll_01 416 * @tc.desc: Test the funcation OnTriggerAll 417 * @tc.type: FUNC 418 * @tc.require: 419 */ 420 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_OnTriggerAll_01, TestSize.Level1) 421 { 422 CALL_TEST_DEBUG; 423 KeyGestureManager::PullUpAccessibility pullUpAccessibility; 424 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 425 ASSERT_NE(keyEvent, nullptr); 426 ASSERT_NO_FATAL_FAILURE(pullUpAccessibility.OnTriggerAll(keyEvent)); 427 } 428 429 /** 430 * @tc.name: KeyGestureManagerTest_RecognizeGesture_01 431 * @tc.desc: Test the funcation RecognizeGesture 432 * @tc.type: FUNC 433 * @tc.require: 434 */ 435 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_RecognizeGesture_01, TestSize.Level1) 436 { 437 CALL_TEST_DEBUG; 438 std::set<int32_t> keys = {1, 2, 3}; 439 KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys); 440 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 441 ASSERT_NE(keyEvent, nullptr); 442 443 std::vector<int32_t> pressedKeys = {1}; 444 EXPECT_TRUE(pressedKeys.size() == SINGLE_KEY_PRESSED); 445 bool ret = longPressCombinationKey.RecognizeGesture(keyEvent); 446 EXPECT_FALSE(ret); 447 } 448 449 /** 450 * @tc.name: KeyGestureManagerTest_RecognizeGesture_02 451 * @tc.desc: Test the funcation RecognizeGesture 452 * @tc.type: FUNC 453 * @tc.require: 454 */ 455 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_RecognizeGesture_02, TestSize.Level1) 456 { 457 CALL_TEST_DEBUG; 458 std::set<int32_t> keys = { 1, 2, 3 }; 459 KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys); 460 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 461 ASSERT_NE(keyEvent, nullptr); 462 463 std::vector<int32_t> pressedKeys = { 2, 3, 4 }; 464 EXPECT_FALSE(pressedKeys.size() == SINGLE_KEY_PRESSED); 465 bool ret = longPressCombinationKey.RecognizeGesture(keyEvent); 466 EXPECT_FALSE(ret); 467 } 468 469 /** 470 * @tc.name: KeyGestureManagerTest_TriggerAll_01 471 * @tc.desc: Test the funcation TriggerAll 472 * @tc.type: FUNC 473 * @tc.require: 474 */ 475 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_TriggerAll_01, TestSize.Level1) 476 { 477 CALL_TEST_DEBUG; 478 std::set<int32_t> keys = { 1, 2, 3 }; 479 KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys); 480 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 481 ASSERT_NE(keyEvent, nullptr); 482 ASSERT_NO_FATAL_FAILURE(longPressCombinationKey.TriggerAll(keyEvent)); 483 } 484 485 /** 486 * @tc.name: KeyGestureManagerTest_RunPending_01 487 * @tc.desc: Test the funcation RunPending 488 * @tc.type: FUNC 489 * @tc.require: 490 */ 491 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_RunPending_01, TestSize.Level1) 492 { 493 CALL_TEST_DEBUG; 494 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 495 KeyGestureManager::Handler handler(1, 2, 3000, myCallback); 496 497 handler.keyEvent_ = nullptr; 498 ASSERT_NO_FATAL_FAILURE(handler.RunPending()); 499 } 500 501 /** 502 * @tc.name: KeyGestureManagerTest_RunPending_02 503 * @tc.desc: Test the funcation RunPending 504 * @tc.type: FUNC 505 * @tc.require: 506 */ 507 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_RunPending_02, TestSize.Level1) 508 { 509 CALL_TEST_DEBUG; 510 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 511 KeyGestureManager::Handler handler(1, 2, 3000, myCallback); 512 513 handler.keyEvent_ = KeyEvent::Create(); 514 ASSERT_NE(handler.keyEvent_, nullptr); 515 ASSERT_NO_FATAL_FAILURE(handler.RunPending()); 516 } 517 518 /** 519 * @tc.name: KeyGestureManagerTest_ResetTimer_01 520 * @tc.desc: Test the funcation ResetTimer 521 * @tc.type: FUNC 522 * @tc.require: 523 */ 524 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_ResetTimer_01, TestSize.Level1) 525 { 526 CALL_TEST_DEBUG; 527 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 528 KeyGestureManager::Handler handler(1, 2, 3000, myCallback); 529 handler.timerId_ = 1; 530 ASSERT_NO_FATAL_FAILURE(handler.ResetTimer()); 531 } 532 533 /** 534 * @tc.name: KeyGestureManagerTest_ResetTimer_02 535 * @tc.desc: Test the funcation ResetTimer 536 * @tc.type: FUNC 537 * @tc.require: 538 */ 539 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_ResetTimer_02, TestSize.Level1) 540 { 541 CALL_TEST_DEBUG; 542 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 543 KeyGestureManager::Handler handler(1, 2, 3000, myCallback); 544 handler.timerId_ = -2; 545 ASSERT_NO_FATAL_FAILURE(handler.ResetTimer()); 546 } 547 548 /** 549 * @tc.name: KeyGestureManagerTest_RunPendingHandlers_01 550 * @tc.desc: Test the funcation RunPendingHandlers 551 * @tc.type: FUNC 552 * @tc.require: 553 */ 554 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_RunPendingHandlers_01, TestSize.Level1) 555 { 556 CALL_TEST_DEBUG; 557 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 558 KeyGestureManager::Handler handler1(1, 10, 500, myCallback); 559 KeyGestureManager::Handler handler2(2, 20, 1000, myCallback); 560 KeyGestureManager::Handler handler3(3, 30, 1500, myCallback); 561 562 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 563 myKeyGesture->handlers_.push_back(handler1); 564 myKeyGesture->handlers_.push_back(handler2); 565 myKeyGesture->handlers_.push_back(handler3); 566 567 std::set<int32_t> foregroundPids = myKeyGesture->GetForegroundPids(); 568 bool haveForeground = myKeyGesture->HaveForegroundHandler(foregroundPids); 569 EXPECT_FALSE(haveForeground); 570 571 int32_t keyCode = 1; 572 KeyGestureManager::LongPressSingleKey longPressSingleKey(keyCode); 573 ASSERT_NO_FATAL_FAILURE(longPressSingleKey.RunPendingHandlers()); 574 } 575 576 /** 577 * @tc.name: KeyGestureManagerTest_RunHandler_01 578 * @tc.desc: Test the funcation RunHandler 579 * @tc.type: FUNC 580 * @tc.require: 581 */ 582 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_RunHandler_01, TestSize.Level1) 583 { 584 CALL_TEST_DEBUG; 585 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 586 KeyGestureManager::Handler handler1(1, 10, 500, myCallback); 587 KeyGestureManager::Handler handler2(2, 20, 1000, myCallback); 588 KeyGestureManager::Handler handler3(3, 30, 1500, myCallback); 589 590 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 591 myKeyGesture->handlers_.push_back(handler1); 592 myKeyGesture->handlers_.push_back(handler2); 593 myKeyGesture->handlers_.push_back(handler3); 594 595 int32_t handlerId = 1; 596 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 597 ASSERT_NE(keyEvent, nullptr); 598 ASSERT_NO_FATAL_FAILURE(myKeyGesture->RunHandler(handlerId, keyEvent)); 599 600 handlerId = 5; 601 ASSERT_NO_FATAL_FAILURE(myKeyGesture->RunHandler(handlerId, keyEvent)); 602 } 603 604 /** 605 * @tc.name: LongPressCombinationKey_Intercept_01 606 * @tc.desc: Test the funcation RecognizeGesture 607 * @tc.type: FUNC 608 * @tc.require: 609 */ 610 HWTEST_F(KeyGestureManagerTest, LongPressCombinationKey_Intercept_01, TestSize.Level1) 611 { 612 CALL_TEST_DEBUG; 613 std::set<int32_t> keys = {1, 2, 3}; 614 KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys); 615 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 616 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 617 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 618 ASSERT_NE(keyEvent, nullptr); 619 620 keyEvent->keyCode_ = 3; 621 longPressCombinationKey.keys_ = {2, 3, 4}; 622 keyEvent->keyAction_ = KeyEvent::KEY_ACTION_DOWN; 623 myKeyGesture->active_ = true; 624 EXPECT_FALSE(EventLogHelper::IsBetaVersion()); 625 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 626 bool ret = longPressCombinationKey.Intercept(keyEvent); 627 EXPECT_FALSE(ret); 628 myKeyGesture->active_ = false; 629 EXPECT_TRUE(myKeyGesture->IsWorking()); 630 631 KeyGestureManager::Handler handler1(1, 10, 500, myCallback); 632 KeyGestureManager::Handler handler2(2, 20, 1000, myCallback); 633 KeyGestureManager::Handler handler3(3, 30, 1500, myCallback); 634 myKeyGesture->handlers_.push_back(handler1); 635 myKeyGesture->handlers_.push_back(handler2); 636 myKeyGesture->handlers_.push_back(handler3); 637 EXPECT_FALSE(myKeyGesture->handlers_.empty()); 638 bool ret2 = longPressCombinationKey.Intercept(keyEvent); 639 EXPECT_FALSE(ret2); 640 } 641 642 /** 643 * @tc.name: LongPressCombinationKey_Intercept_02 644 * @tc.desc: Test the funcation RecognizeGesture 645 * @tc.type: FUNC 646 * @tc.require: 647 */ 648 HWTEST_F(KeyGestureManagerTest, LongPressCombinationKey_Intercept_02, TestSize.Level1) 649 { 650 CALL_TEST_DEBUG; 651 std::set<int32_t> keys = {1, 2, 3}; 652 KeyGestureManager::LongPressCombinationKey longPressCombinationKey(keys); 653 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 654 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 655 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 656 ASSERT_NE(keyEvent, nullptr); 657 658 keyEvent->keyCode_ = 5; 659 longPressCombinationKey.keys_ = {2, 3, 4}; 660 keyEvent->keyAction_ = KeyEvent::KEY_ACTION_UP; 661 myKeyGesture->active_ = true; 662 bool ret = longPressCombinationKey.Intercept(keyEvent); 663 EXPECT_FALSE(ret); 664 665 myKeyGesture->active_ = false; 666 bool ret2 = longPressCombinationKey.Intercept(keyEvent); 667 EXPECT_FALSE(ret2); 668 } 669 670 /** 671 * @tc.name: KeyGestureManagerTest_NotifyHandlers_01 672 * @tc.desc: Test the funcation NotifyHandlers 673 * @tc.type: FUNC 674 * @tc.require: 675 */ 676 HWTEST_F(KeyGestureManagerTest, KeyGestureManagerTest_NotifyHandlers_01, TestSize.Level1) 677 { 678 CALL_TEST_DEBUG; 679 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 680 ASSERT_NE(keyEvent, nullptr); 681 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 682 KeyGestureManager::Handler handler1(1, 10, 500, myCallback); 683 KeyGestureManager::Handler handler2(2, 20, 1000, myCallback); 684 KeyGestureManager::Handler handler3(3, 30, 1500, myCallback); 685 686 std::shared_ptr<MyKeyGesture> myKeyGesture = std::make_shared<MyKeyGesture>(); 687 myKeyGesture->handlers_.push_back(handler1); 688 myKeyGesture->handlers_.push_back(handler2); 689 myKeyGesture->handlers_.push_back(handler3); 690 691 std::set<int32_t> foregroundPids = myKeyGesture->GetForegroundPids(); 692 bool haveForeground = myKeyGesture->HaveForegroundHandler(foregroundPids); 693 EXPECT_FALSE(haveForeground); 694 ASSERT_NO_FATAL_FAILURE(myKeyGesture->NotifyHandlers(keyEvent)); 695 } 696 } // namespace MMI 697 } // namespace OHOS