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 19 #include <gtest/gtest.h> 20 21 #include "key_option.h" 22 #include "key_subscriber_handler.h" 23 #include "call_manager_client.h" 24 #include "common_event_data.h" 25 #include "common_event_manager.h" 26 #include "common_event_support.h" 27 #include "device_event_monitor.h" 28 #include "input_event_handler.h" 29 #include "key_event.h" 30 #include "mmi_log.h" 31 #include "nap_process.h" 32 #include "switch_subscriber_handler.h" 33 #include "uds_server.h" 34 #include "want.h" 35 #include "event_log_helper.h" 36 37 #undef MMI_LOG_TAG 38 #define MMI_LOG_TAG "KeyCommandHandlerTest" 39 40 namespace OHOS { 41 namespace MMI { 42 namespace { 43 using namespace testing::ext; 44 const std::string PROGRAM_NAME = "uds_session_test"; 45 constexpr int32_t MODULE_TYPE = 1; 46 constexpr int32_t UDS_FD = 1; 47 constexpr int32_t UDS_UID = 100; 48 constexpr int32_t UDS_PID = 100; 49 constexpr int32_t REMOVE_OBSERVER { -2 }; 50 constexpr int32_t UNOBSERVED { -1 }; 51 constexpr int32_t ACTIVE_EVENT { 2 }; 52 } // namespace 53 54 class KeySubscriberHandlerTest : public testing::Test { 55 public: SetUpTestCase(void)56 static void SetUpTestCase(void) {} TearDownTestCase(void)57 static void TearDownTestCase(void) {} 58 }; 59 60 /** 61 * @tc.name: KeySubscriberHandlerTest_HandleKeyEvent_001 62 * @tc.desc: Test HandleKeyEvent 63 * @tc.type: FUNC 64 * @tc.require: 65 */ 66 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyEvent_001, TestSize.Level1) 67 { 68 CALL_DEBUG_ENTER; 69 KeySubscriberHandler handler; 70 KeyEvent::KeyItem item; 71 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 72 ASSERT_NE(keyEvent, nullptr); 73 handler.enableCombineKey_ = false; 74 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 75 item.SetKeyCode(KeyEvent::KEYCODE_A); 76 keyEvent->AddKeyItem(item); 77 item.SetKeyCode(KeyEvent::KEYCODE_B); 78 keyEvent->AddKeyItem(item); 79 EXPECT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 80 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent)); 81 82 handler.enableCombineKey_ = true; 83 handler.hasEventExecuting_ = true; 84 handler.keyEvent_ = KeyEvent::Create(); 85 ASSERT_NE(handler.keyEvent_, nullptr); 86 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 87 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_UP); 88 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 89 item.SetKeyCode(KeyEvent::KEYCODE_A); 90 handler.keyEvent_->AddKeyItem(item); 91 item.SetKeyCode(KeyEvent::KEYCODE_B); 92 handler.keyEvent_->AddKeyItem(item); 93 EXPECT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 94 EXPECT_FALSE(EventLogHelper::IsBetaVersion()); 95 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 96 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyEvent(keyEvent)); 97 } 98 99 /** 100 * @tc.name: KeySubscriberHandlerTest_DumpSubscriber_001 101 * @tc.desc: Test DumpSubscriber 102 * @tc.type: FUNC 103 * @tc.require: 104 */ 105 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_DumpSubscriber_001, TestSize.Level1) 106 { 107 CALL_TEST_DEBUG; 108 KeySubscriberHandler handler; 109 int32_t fd = 1; 110 SessionPtr sess; 111 auto keyOption = std::make_shared<KeyOption>(); 112 keyOption->preKeys_.insert(10); 113 keyOption->preKeys_.insert(20); 114 keyOption->preKeys_.insert(30); 115 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 116 ASSERT_NO_FATAL_FAILURE(handler.DumpSubscriber(fd, subscriber)); 117 } 118 119 /** 120 * @tc.name: InputWindowsManagerTest_UnsubscribeKeyEvent_001 121 * @tc.desc: Test UnsubscribeKeyEvent 122 * @tc.type: FUNC 123 * @tc.require: 124 */ 125 HWTEST_F(KeySubscriberHandlerTest, InputWindowsManagerTest_UnsubscribeKeyEvent_001, TestSize.Level1) 126 { 127 CALL_TEST_DEBUG; 128 KeySubscriberHandler keySubscriberHandler; 129 auto keyEvent = KeyEvent::Create(); 130 ASSERT_NE(keyEvent, nullptr); 131 keySubscriberHandler.HandleKeyEvent(keyEvent); 132 auto pointerEvent = PointerEvent::Create(); 133 keySubscriberHandler.HandlePointerEvent(pointerEvent); 134 keySubscriberHandler.HandleTouchEvent(pointerEvent); 135 keySubscriberHandler.RemoveSubscriberKeyUpTimer(1); 136 std::vector<std::string> args = {}; 137 keySubscriberHandler.Dump(1, args); 138 UDSServer udsServer; 139 SessionPtr sess = udsServer.GetSessionByPid(1); 140 std::shared_ptr<KeyOption> keyOption = nullptr; 141 ASSERT_EQ(keySubscriberHandler.SubscribeKeyEvent(sess, -1, keyOption), -1); 142 SessionPtr sessPtr = nullptr; 143 ASSERT_NE(keySubscriberHandler.UnsubscribeKeyEvent(sessPtr, -1), 0); 144 ASSERT_NE(keySubscriberHandler.UnsubscribeKeyEvent(sess, 1), 0); 145 } 146 147 /** 148 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_001 149 * @tc.desc: Test IsEnableCombineKey 150 * @tc.type: FUNC 151 * @tc.require: 152 */ 153 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_001, TestSize.Level1) 154 { 155 CALL_TEST_DEBUG; 156 KeySubscriberHandler keySubscriberHandler; 157 keySubscriberHandler.EnableCombineKey(false); 158 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 159 CHKPV(keyEvent); 160 KeyEvent::KeyItem item; 161 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 162 keyEvent->AddKeyItem(item); 163 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 164 keySubscriberHandler.HandleKeyEvent(keyEvent); 165 ASSERT_EQ(keySubscriberHandler.EnableCombineKey(true), RET_OK); 166 } 167 168 /** 169 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_002 170 * @tc.desc: Test IsEnableCombineKey 171 * @tc.type: FUNC 172 * @tc.require: 173 */ 174 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_002, TestSize.Level1) 175 { 176 CALL_TEST_DEBUG; 177 KeySubscriberHandler keySubscriberHandler; 178 keySubscriberHandler.EnableCombineKey(false); 179 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 180 CHKPV(keyEvent); 181 KeyEvent::KeyItem item1; 182 item1.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 183 keyEvent->AddKeyItem(item1); 184 KeyEvent::KeyItem item2; 185 item2.SetKeyCode(KeyEvent::KEYCODE_L); 186 keyEvent->AddKeyItem(item2); 187 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 188 ASSERT_EQ(keySubscriberHandler.EnableCombineKey(true), RET_OK); 189 } 190 191 /** 192 * @tc.name: KeySubscriberHandlerTest_EnableCombineKey_001 193 * @tc.desc: Test enable combineKey 194 * @tc.type: FUNC 195 * @tc.require: 196 */ 197 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_EnableCombineKey_001, TestSize.Level1) 198 { 199 CALL_TEST_DEBUG; 200 KeySubscriberHandler keySubscriberHandler; 201 ASSERT_EQ(keySubscriberHandler.EnableCombineKey(true), RET_OK); 202 } 203 204 /** 205 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_001 206 * @tc.desc: Test subscribe keyEvent 207 * @tc.type: FUNC 208 * @tc.require: 209 */ 210 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_001, TestSize.Level1) 211 { 212 CALL_DEBUG_ENTER; 213 KeySubscriberHandler handler; 214 SessionPtr sess; 215 auto keyOption = std::make_shared<KeyOption>(); 216 int32_t ret = handler.SubscribeKeyEvent(sess, -1, keyOption); 217 ASSERT_EQ(ret, RET_ERR); 218 ret = handler.SubscribeKeyEvent(nullptr, 1, keyOption); 219 ASSERT_NE(ret, RET_OK); 220 ret = handler.SubscribeKeyEvent(sess, 1, keyOption); 221 ASSERT_NE(ret, RET_OK); 222 } 223 224 /** 225 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriber_001 226 * @tc.desc: Test remove subscriber 227 * @tc.type: FUNC 228 * @tc.require: 229 */ 230 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriber_001, TestSize.Level1) 231 { 232 CALL_DEBUG_ENTER; 233 KeySubscriberHandler handler; 234 SessionPtr sess; 235 int32_t ret = handler.RemoveSubscriber(sess, 1); 236 ASSERT_EQ(ret, RET_ERR); 237 ret = handler.RemoveSubscriber(nullptr, 1); 238 ASSERT_EQ(ret, RET_ERR); 239 } 240 241 /** 242 * @tc.name: KeySubscriberHandlerTest_IsEqualKeyOption_001 243 * @tc.desc: Test is equal keyOption 244 * @tc.type: FUNC 245 * @tc.require: 246 */ 247 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualKeyOption_001, TestSize.Level1) 248 { 249 CALL_DEBUG_ENTER; 250 KeySubscriberHandler handler; 251 auto newOption = std::make_shared<KeyOption>(); 252 auto oldOption = std::make_shared<KeyOption>(); 253 newOption->SetPreKeys({1, 2, 3}); 254 oldOption->SetPreKeys({4, 5, 6}); 255 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 256 newOption->SetFinalKey(1); 257 oldOption->SetFinalKey(2); 258 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 259 newOption->SetFinalKeyDown(true); 260 oldOption->SetFinalKeyDown(false); 261 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 262 newOption->SetFinalKeyDownDuration(100); 263 oldOption->SetFinalKeyDownDuration(200); 264 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 265 newOption->SetFinalKeyUpDelay(100); 266 oldOption->SetFinalKeyUpDelay(200); 267 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 268 newOption->SetPreKeys({1, 2, 3}); 269 oldOption->SetPreKeys({1, 2, 3}); 270 newOption->SetFinalKey(1); 271 oldOption->SetFinalKey(1); 272 newOption->SetFinalKeyDown(true); 273 oldOption->SetFinalKeyDown(true); 274 newOption->SetFinalKeyDownDuration(100); 275 oldOption->SetFinalKeyDownDuration(100); 276 newOption->SetFinalKeyUpDelay(100); 277 oldOption->SetFinalKeyUpDelay(100); 278 ASSERT_TRUE(handler.IsEqualKeyOption(newOption, oldOption)); 279 } 280 281 /** 282 * @tc.name: KeySubscriberHandlerTest_IsPreKeysMatch_001 283 * @tc.desc: Test is preKeys match 284 * @tc.type: FUNC 285 * @tc.require: 286 */ 287 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsPreKeysMatch_001, TestSize.Level1) 288 { 289 CALL_DEBUG_ENTER; 290 KeySubscriberHandler handler; 291 std::set<int32_t> preKeys; 292 std::vector<int32_t> pressedKeys = {1, 2, 3}; 293 ASSERT_TRUE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 294 preKeys = {1, 2, 3}; 295 ASSERT_TRUE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 296 pressedKeys = {1, 2, 3, 4}; 297 ASSERT_FALSE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 298 pressedKeys = {1, 2, 3}; 299 preKeys = {1, 2, 3, 4}; 300 ASSERT_FALSE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 301 } 302 303 /** 304 * @tc.name: KeySubscriberHandlerTest_IsEqualPreKeys_001 305 * @tc.desc: Test is equal preKeys 306 * @tc.type: FUNC 307 * @tc.require: 308 */ 309 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualPreKeys_001, TestSize.Level1) 310 { 311 CALL_TEST_DEBUG; 312 KeySubscriberHandler handler; 313 std::set<int32_t> preKeys = {1, 2, 3}; 314 std::set<int32_t> pressedKeys = {4, 5, 6}; 315 ASSERT_FALSE(handler.IsEqualPreKeys(preKeys, pressedKeys)); 316 pressedKeys = {1, 2, 3}; 317 ASSERT_TRUE(handler.IsEqualPreKeys(preKeys, pressedKeys)); 318 pressedKeys = {1, 2}; 319 ASSERT_FALSE(handler.IsEqualPreKeys(preKeys, pressedKeys)); 320 } 321 322 /** 323 * @tc.name: KeySubscriberHandlerTest_IsMatchForegroundPid_001 324 * @tc.desc: Test is match foreground pid 325 * @tc.type: FUNC 326 * @tc.require: 327 */ 328 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsMatchForegroundPid_001, TestSize.Level1) 329 { 330 CALL_TEST_DEBUG; 331 KeySubscriberHandler handler; 332 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subs; 333 std::set<int32_t> foregroundPids = {1, 2, 3}; 334 ASSERT_FALSE(handler.IsMatchForegroundPid(subs, foregroundPids)); 335 } 336 337 /** 338 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownSubscriber_001 339 * @tc.desc: Test notify key down subscriber 340 * @tc.type: FUNC 341 * @tc.require: 342 */ 343 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownSubscriber_001, TestSize.Level1) 344 { 345 CALL_TEST_DEBUG; 346 KeySubscriberHandler handler; 347 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 348 auto keyOption = std::make_shared<KeyOption>(); 349 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 350 bool handled = false; 351 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownSubscriber(keyEvent, keyOption, subscribers, handled)); 352 keyEvent = nullptr; 353 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownSubscriber(keyEvent, keyOption, subscribers, handled)); 354 } 355 356 /** 357 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownRightNow_001 358 * @tc.desc: Test notify key down right now 359 * @tc.type: FUNC 360 * @tc.require: 361 */ 362 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownRightNow_001, TestSize.Level1) 363 { 364 CALL_TEST_DEBUG; 365 KeySubscriberHandler handler; 366 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 367 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 368 bool handled = false; 369 handler.NotifyKeyDownRightNow(keyEvent, subscribers, handled); 370 ASSERT_FALSE(handled); 371 } 372 373 /** 374 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownDelay_001 375 * @tc.desc: Test notify key down delay 376 * @tc.type: FUNC 377 * @tc.require: 378 */ 379 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownDelay_001, TestSize.Level1) 380 { 381 CALL_DEBUG_ENTER; 382 KeySubscriberHandler handler; 383 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 384 CHKPV(keyEvent); 385 KeyEvent::KeyItem item; 386 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 387 keyEvent->AddKeyItem(item); 388 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 389 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 390 bool handled = false; 391 handler.NotifyKeyDownDelay(keyEvent, subscribers, handled); 392 ASSERT_FALSE(handled); 393 } 394 395 /** 396 * @tc.name: KeySubscriberHandlerTest_ClearTimer_001 397 * @tc.desc: Test clear timer 398 * @tc.type: FUNC 399 * @tc.require: 400 */ 401 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_ClearTimer_001, TestSize.Level1) 402 { 403 CALL_DEBUG_ENTER; 404 KeySubscriberHandler handler; 405 SessionPtr sess; 406 std::shared_ptr<KeyOption> keyOption; 407 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 408 subscriber->timerId_ = -1; 409 handler.ClearTimer(subscriber); 410 ASSERT_EQ(subscriber->timerId_, -1); 411 subscriber->timerId_ = 1; 412 handler.ClearTimer(subscriber); 413 ASSERT_EQ(subscriber->timerId_, -1); 414 } 415 416 /** 417 * @tc.name: KeySubscriberHandlerTest_InitSessionDeleteCallback_001 418 * @tc.desc: Test init session delete callback 419 * @tc.type: FUNC 420 * @tc.require: 421 */ 422 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_InitSessionDeleteCallback_001, TestSize.Level1) 423 { 424 CALL_DEBUG_ENTER; 425 KeySubscriberHandler handler; 426 handler.callbackInitialized_ = true; 427 ASSERT_TRUE(handler.InitSessionDeleteCallback()); 428 handler.callbackInitialized_ = false; 429 ASSERT_FALSE(handler.InitSessionDeleteCallback()); 430 } 431 432 /** 433 * @tc.name: KeySubscriberHandlerTest_HandleKeyDown_001 434 * @tc.desc: Test handle key down 435 * @tc.type: FUNC 436 * @tc.require: 437 */ 438 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_001, TestSize.Level1) 439 { 440 CALL_DEBUG_ENTER; 441 KeySubscriberHandler handler; 442 auto result = handler.HandleKeyDown(nullptr); 443 ASSERT_FALSE(result); 444 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 445 CHKPV(keyEvent); 446 result = handler.HandleKeyDown(keyEvent); 447 ASSERT_FALSE(result); 448 } 449 450 /** 451 * @tc.name: KeySubscriberHandlerTest_RemoveKeyCode_001 452 * @tc.desc: Test remove key code 453 * @tc.type: FUNC 454 * @tc.require: 455 */ 456 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyCode_001, TestSize.Level1) 457 { 458 CALL_TEST_DEBUG; 459 KeySubscriberHandler handler; 460 std::vector<int32_t> keyCodes; 461 handler.RemoveKeyCode(1, keyCodes); 462 ASSERT_TRUE(keyCodes.empty()); 463 keyCodes = {2, 3, 4}; 464 handler.RemoveKeyCode(1, keyCodes); 465 ASSERT_EQ(keyCodes, (std::vector<int32_t>{2, 3, 4})); 466 keyCodes = {1, 2, 3}; 467 ASSERT_EQ(keyCodes, (std::vector<int32_t>{1, 2, 3})); 468 } 469 470 /** 471 * @tc.name: KeySubscriberHandlerTest_AddSubscriber_001 472 * @tc.desc: Test add subscriber 473 * @tc.type: FUNC 474 * @tc.require: 475 */ 476 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddSubscriber_001, TestSize.Level1) 477 { 478 CALL_TEST_DEBUG; 479 KeySubscriberHandler handler; 480 SessionPtr sess; 481 std::shared_ptr<KeyOption> keyOption; 482 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 483 std::shared_ptr<KeyOption> option = std::make_shared<KeyOption>(); 484 handler.AddSubscriber(subscriber, option); 485 auto it = handler.subscriberMap_.find(option); 486 ASSERT_EQ(it->second.size(), 1); 487 ASSERT_EQ(it->second.front(), subscriber); 488 auto newSubscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 489 handler.AddSubscriber(newSubscriber, option); 490 ASSERT_EQ(it->second.size(), 2); 491 ASSERT_EQ(it->second.back(), newSubscriber); 492 } 493 494 /** 495 * @tc.name: KeySubscriberHandlerTest_IsFunctionKey_001 496 * @tc.desc: Test is function key 497 * @tc.type: FUNC 498 * @tc.require: 499 */ 500 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsFunctionKey_001, TestSize.Level1) 501 { 502 CALL_TEST_DEBUG; 503 KeySubscriberHandler handler; 504 auto keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 505 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 506 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_BRIGHTNESS_UP); 507 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 508 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_MUTE); 509 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 510 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_SWITCHVIDEOMODE); 511 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 512 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_WLAN); 513 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 514 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_CONFIG); 515 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 516 keyEvent = std::make_shared<KeyEvent>(KeyEvent::KEYCODE_A); 517 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 518 } 519 520 /** 521 * @tc.name: KeySubscriberHandlerTest_CloneKeyEvent_001 522 * @tc.desc: Test clone key event 523 * @tc.type: FUNC 524 * @tc.require: 525 */ 526 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_CloneKeyEvent_001, TestSize.Level1) 527 { 528 CALL_TEST_DEBUG; 529 KeySubscriberHandler handler; 530 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 531 ASSERT_NE(keyEvent, nullptr); 532 ASSERT_TRUE(handler.CloneKeyEvent(keyEvent)); 533 handler.keyEvent_ = nullptr; 534 ASSERT_TRUE(handler.CloneKeyEvent(keyEvent)); 535 } 536 537 /** 538 * @tc.name: KeySubscriberHandlerTest_NotifyKeyUpSubscriber_001 539 * @tc.desc: Test notify key up subscriber 540 * @tc.type: FUNC 541 * @tc.require: 542 */ 543 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyUpSubscriber_001, TestSize.Level1) 544 { 545 CALL_TEST_DEBUG; 546 KeySubscriberHandler handler; 547 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 548 ASSERT_NE(keyEvent, nullptr); 549 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 550 bool handled = false; 551 handler.NotifyKeyUpSubscriber(keyEvent, subscribers, handled); 552 ASSERT_FALSE(handled); 553 handler.isForegroundExits_ = false; 554 handler.NotifyKeyUpSubscriber(keyEvent, subscribers, handled); 555 ASSERT_FALSE(handled); 556 handler.isForegroundExits_ = true; 557 handler.foregroundPids_.clear(); 558 handler.NotifyKeyUpSubscriber(keyEvent, subscribers, handled); 559 ASSERT_FALSE(handled); 560 } 561 562 /** 563 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKeySwipe_001 564 * @tc.desc: Test is enable combine key swipe 565 * @tc.type: FUNC 566 * @tc.require: 567 */ 568 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKeySwipe_001, TestSize.Level1) 569 { 570 CALL_TEST_DEBUG; 571 KeySubscriberHandler handler; 572 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 573 ASSERT_NE(keyEvent, nullptr); 574 KeyEvent::KeyItem item; 575 item.SetKeyCode(KeyEvent::KEYCODE_CTRL_LEFT); 576 keyEvent->AddKeyItem(item); 577 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CTRL_LEFT); 578 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 579 item.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 580 keyEvent->AddKeyItem(item); 581 keyEvent->SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 582 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 583 item.SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 584 keyEvent->AddKeyItem(item); 585 keyEvent->SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 586 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 587 item.SetKeyCode(KeyEvent::KEYCODE_CTRL_RIGHT); 588 keyEvent->AddKeyItem(item); 589 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CTRL_RIGHT); 590 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 591 item.SetKeyCode(KeyEvent::KEYCODE_A); 592 keyEvent->AddKeyItem(item); 593 keyEvent->SetKeyCode(KeyEvent::KEYCODE_A); 594 ASSERT_TRUE(handler.IsEnableCombineKeySwipe(keyEvent)); 595 } 596 597 /** 598 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_001 599 * @tc.desc: Test on subscribe key event 600 * @tc.type: FUNC 601 * @tc.require: 602 */ 603 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_001, TestSize.Level1) 604 { 605 CALL_TEST_DEBUG; 606 KeySubscriberHandler handler; 607 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 608 ASSERT_NE(keyEvent, nullptr); 609 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 610 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 611 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 612 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 613 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 614 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 615 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 616 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 617 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 618 handler.OnSubscribeKeyEvent(keyEvent); 619 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 620 } 621 622 /** 623 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete_001 624 * @tc.desc: Test onSession delete 625 * @tc.type: FUNC 626 * @tc.require: 627 */ 628 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_001, TestSize.Level1) 629 { 630 CALL_TEST_DEBUG; 631 KeySubscriberHandler handler; 632 UDSServer udsServer; 633 auto keyOption = std::make_shared<KeyOption>(); 634 SessionPtr sess = udsServer.GetSessionByPid(1); 635 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>>subscriberMap_; 636 auto newSubscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 637 auto newSubscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 638 auto newSubscriber3 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 639 subscriberMap_.push_back(newSubscriber1); 640 subscriberMap_.push_back(newSubscriber2); 641 subscriberMap_.push_back(newSubscriber3); 642 handler.OnSessionDelete(sess); 643 for (auto& sub : subscriberMap_) { 644 ASSERT_EQ(sub->sess_, nullptr); 645 } 646 } 647 648 /** 649 * @tc.name: KeySubscriberHandlerTest_ClearSubscriberTimer_001 650 * @tc.desc: Test clear subscriber timer 651 * @tc.type: FUNC 652 * @tc.require: 653 */ 654 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_ClearSubscriberTimer_001, TestSize.Level1) 655 { 656 CALL_TEST_DEBUG; 657 KeySubscriberHandler handler; 658 SessionPtr sess; 659 std::shared_ptr<KeyOption> keyOption; 660 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 661 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 662 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 663 subscribers.push_back(subscriber1); 664 subscribers.push_back(subscriber2); 665 ASSERT_NO_FATAL_FAILURE(handler.ClearSubscriberTimer(subscribers)); 666 } 667 668 /** 669 * @tc.name: KeySubscriberHandlerTest_OnTimer_001 670 * @tc.desc: Test OnTimer 671 * @tc.type: FUNC 672 * @tc.require: 673 */ 674 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnTimer_001, TestSize.Level1) 675 { 676 CALL_TEST_DEBUG; 677 KeySubscriberHandler handler; 678 SessionPtr sess; 679 std::shared_ptr<KeyOption> keyOption; 680 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 681 subscriber->keyEvent_.reset(); 682 handler.OnTimer(subscriber); 683 ASSERT_EQ(subscriber->keyEvent_, nullptr); 684 } 685 686 /** 687 * @tc.name: KeySubscriberHandlerTest_SubscriberNotifyNap_001 688 * @tc.desc: Test SubscriberNotifyNap 689 * @tc.type: FUNC 690 * @tc.require: 691 */ 692 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_001, TestSize.Level1) 693 { 694 CALL_TEST_DEBUG; 695 KeySubscriberHandler handler; 696 SessionPtr sess; 697 std::shared_ptr<KeyOption> keyOption; 698 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 699 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 700 } 701 702 /** 703 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_001 704 * @tc.desc: Test HandleKeyUp 705 * @tc.type: FUNC 706 * @tc.require: 707 */ 708 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_001, TestSize.Level1) 709 { 710 CALL_TEST_DEBUG; 711 KeySubscriberHandler handler; 712 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 713 ASSERT_NE(keyEvent, nullptr); 714 KeyEvent::KeyItem item; 715 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 716 keyEvent->AddKeyItem(item); 717 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 718 bool handled = handler.HandleKeyUp(keyEvent); 719 EXPECT_FALSE(handled); 720 } 721 722 /** 723 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_001 724 * @tc.desc: Test NotifySubscriber 725 * @tc.type: FUNC 726 * @tc.require: 727 */ 728 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_001, TestSize.Level1) 729 { 730 CALL_TEST_DEBUG; 731 KeySubscriberHandler handler; 732 SessionPtr sess; 733 std::shared_ptr<KeyOption> keyOption; 734 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 735 ASSERT_NE(keyEvent, nullptr); 736 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 737 KeyEvent::KeyItem item; 738 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 739 keyEvent->AddKeyItem(item); 740 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 741 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 742 } 743 744 /** 745 * @tc.name: KeySubscriberHandlerTest_HandleKeyCancel_001 746 * @tc.desc: Test HandleKeyCancel 747 * @tc.type: FUNC 748 * @tc.require: 749 */ 750 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyCancel_001, TestSize.Level1) 751 { 752 CALL_TEST_DEBUG; 753 KeySubscriberHandler handler; 754 UDSServer udsServer; 755 SessionPtr sess = udsServer.GetSessionByPid(1); 756 auto keyOption = std::make_shared<KeyOption>(); 757 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 758 ASSERT_NE(keyEvent, nullptr); 759 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>>subscriberMap_; 760 auto newSubscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 761 auto newSubscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 762 subscriberMap_.push_back(newSubscriber1); 763 subscriberMap_.push_back(newSubscriber2); 764 EXPECT_FALSE(handler.HandleKeyCancel(keyEvent)); 765 } 766 767 /** 768 * @tc.name: KeySubscriberHandlerTest_PrintKeyOption_001 769 * @tc.desc: Test PrintKeyOption 770 * @tc.type: FUNC 771 * @tc.require: 772 */ 773 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_PrintKeyOption_001, TestSize.Level1) 774 { 775 CALL_TEST_DEBUG; 776 KeySubscriberHandler handler; 777 auto keyOption = std::make_shared<KeyOption>(); 778 keyOption->SetFinalKey(1); 779 keyOption->SetFinalKeyDown(true); 780 keyOption->SetFinalKeyDownDuration(1000); 781 keyOption->SetPreKeys({1, 2, 3}); 782 ASSERT_NO_FATAL_FAILURE(handler.PrintKeyOption(keyOption)); 783 } 784 785 /** 786 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_001 787 * @tc.desc: Test HandleKeyUpWithDelay 788 * @tc.type: FUNC 789 * @tc.require: 790 */ 791 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_001, TestSize.Level1) 792 { 793 CALL_TEST_DEBUG; 794 KeySubscriberHandler handler; 795 SessionPtr sess; 796 auto keyOption = std::make_shared<KeyOption>(); 797 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 798 ASSERT_NE(keyEvent, nullptr); 799 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 800 keyOption->SetFinalKeyUpDelay(0); 801 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 802 keyOption->SetFinalKeyUpDelay(-1); 803 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 804 keyOption->SetFinalKeyUpDelay(1); 805 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 806 } 807 808 /** 809 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_002 810 * @tc.desc: Test HandleKeyUpWithDelay 811 * @tc.type: FUNC 812 * @tc.require: 813 */ 814 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_002, TestSize.Level1) 815 { 816 CALL_TEST_DEBUG; 817 KeySubscriberHandler handler; 818 SessionPtr sess; 819 auto keyOption = std::make_shared<KeyOption>(); 820 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 821 ASSERT_NE(keyEvent, nullptr); 822 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 823 824 subscriber->keyOption_->finalKeyUpDelay_ = -2; 825 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 826 } 827 828 /** 829 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_003 830 * @tc.desc: Test HandleKeyUpWithDelay 831 * @tc.type: FUNC 832 * @tc.require: 833 */ 834 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_003, TestSize.Level1) 835 { 836 CALL_TEST_DEBUG; 837 KeySubscriberHandler handler; 838 SessionPtr sess; 839 auto keyOption = std::make_shared<KeyOption>(); 840 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 841 ASSERT_NE(keyEvent, nullptr); 842 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 843 844 subscriber->keyOption_->finalKeyUpDelay_ = 1; 845 EXPECT_TRUE(handler.AddTimer(subscriber, keyEvent)); 846 ASSERT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 847 } 848 849 /** 850 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_001 851 * @tc.desc: Test ring mute 852 * @tc.type: FUNC 853 * @tc.require: 854 */ 855 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_001, TestSize.Level1) 856 { 857 CALL_TEST_DEBUG; 858 KeySubscriberHandler keySubscriberHandler; 859 OHOS::EventFwk::Want want; 860 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 861 OHOS::EventFwk::CommonEventData data; 862 data.SetWant(want); 863 int callState = 0; 864 DEVICE_MONITOR->SetCallState(data, callState); 865 866 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 867 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 868 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 869 } 870 871 /** 872 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_002 873 * @tc.desc: Test ring mute 874 * @tc.type: FUNC 875 * @tc.require: 876 */ 877 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_002, TestSize.Level1) 878 { 879 CALL_TEST_DEBUG; 880 KeySubscriberHandler keySubscriberHandler; 881 OHOS::EventFwk::Want want; 882 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 883 OHOS::EventFwk::CommonEventData data; 884 data.SetWant(want); 885 int callState = 0; 886 DEVICE_MONITOR->SetCallState(data, callState); 887 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 888 data.SetWant(want); 889 callState = 0; 890 DEVICE_MONITOR->SetCallState(data, callState); 891 892 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 893 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 894 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 895 } 896 897 /** 898 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_003 899 * @tc.desc: Test ring mute 900 * @tc.type: FUNC 901 * @tc.require: 902 */ 903 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_003, TestSize.Level1) 904 { 905 CALL_TEST_DEBUG; 906 KeySubscriberHandler keySubscriberHandler; 907 OHOS::EventFwk::Want want; 908 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 909 OHOS::EventFwk::CommonEventData data; 910 data.SetWant(want); 911 int callState = 0; 912 DEVICE_MONITOR->SetCallState(data, callState); 913 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 914 data.SetWant(want); 915 callState = 0; 916 DEVICE_MONITOR->SetCallState(data, callState); 917 918 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 919 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 920 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 921 } 922 923 /** 924 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_004 925 * @tc.desc: Test ring mute 926 * @tc.type: FUNC 927 * @tc.require: 928 */ 929 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_004, TestSize.Level1) 930 { 931 CALL_TEST_DEBUG; 932 KeySubscriberHandler keySubscriberHandler; 933 OHOS::EventFwk::Want want; 934 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 935 OHOS::EventFwk::CommonEventData data; 936 data.SetWant(want); 937 int callState = 0; 938 DEVICE_MONITOR->SetCallState(data, callState); 939 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 940 data.SetWant(want); 941 callState = 0; 942 DEVICE_MONITOR->SetCallState(data, callState); 943 944 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 945 keyEvent->SetKeyCode(KeyEvent::KEYCODE_F1); 946 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 947 } 948 949 /** 950 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_005 951 * @tc.desc: Test ring mute 952 * @tc.type: FUNC 953 * @tc.require: 954 */ 955 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_005, TestSize.Level1) 956 { 957 CALL_TEST_DEBUG; 958 KeySubscriberHandler keySubscriberHandler; 959 OHOS::EventFwk::Want want; 960 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 961 OHOS::EventFwk::CommonEventData data; 962 data.SetWant(want); 963 int callState = 0; 964 DEVICE_MONITOR->SetCallState(data, callState); 965 966 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 967 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 968 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 969 } 970 971 /** 972 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_006 973 * @tc.desc: Test ring mute 974 * @tc.type: FUNC 975 * @tc.require: 976 */ 977 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_006, TestSize.Level1) 978 { 979 CALL_TEST_DEBUG; 980 KeySubscriberHandler keySubscriberHandler; 981 OHOS::EventFwk::Want want; 982 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 983 OHOS::EventFwk::CommonEventData data; 984 data.SetWant(want); 985 int callState = 0; 986 DEVICE_MONITOR->SetCallState(data, callState); 987 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 988 data.SetWant(want); 989 callState = 0; 990 DEVICE_MONITOR->SetCallState(data, callState); 991 992 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 993 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 994 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 995 } 996 997 /** 998 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_007 999 * @tc.desc: Test ring mute 1000 * @tc.type: FUNC 1001 * @tc.require: 1002 */ 1003 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_007, TestSize.Level1) 1004 { 1005 CALL_TEST_DEBUG; 1006 KeySubscriberHandler keySubscriberHandler; 1007 OHOS::EventFwk::Want want; 1008 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 1009 OHOS::EventFwk::CommonEventData data; 1010 data.SetWant(want); 1011 int callState = 0; 1012 DEVICE_MONITOR->SetCallState(data, callState); 1013 1014 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1015 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1016 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1017 } 1018 1019 /** 1020 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_008 1021 * @tc.desc: Test ring mute 1022 * @tc.type: FUNC 1023 * @tc.require: 1024 */ 1025 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_008, TestSize.Level1) 1026 { 1027 CALL_TEST_DEBUG; 1028 KeySubscriberHandler keySubscriberHandler; 1029 1030 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1031 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 1032 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1033 } 1034 1035 /** 1036 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_009 1037 * @tc.desc: Test ring mute 1038 * @tc.type: FUNC 1039 * @tc.require: 1040 */ 1041 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_009, TestSize.Level1) 1042 { 1043 CALL_TEST_DEBUG; 1044 KeySubscriberHandler keySubscriberHandler; 1045 1046 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1047 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 1048 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1049 } 1050 1051 /** 1052 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_002 1053 * @tc.desc: Test subscribe keyEvent 1054 * @tc.type: FUNC 1055 * @tc.require: 1056 */ 1057 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_002, TestSize.Level1) 1058 { 1059 CALL_DEBUG_ENTER; 1060 KeySubscriberHandler handler; 1061 int32_t subscribeId = 1; 1062 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1063 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1064 std::set<int32_t> preKeys; 1065 preKeys.insert(1); 1066 keyOption->SetPreKeys(preKeys); 1067 ASSERT_EQ(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_OK); 1068 1069 preKeys.insert(2); 1070 preKeys.insert(3); 1071 preKeys.insert(4); 1072 preKeys.insert(5); 1073 preKeys.insert(6); 1074 keyOption->SetPreKeys(preKeys); 1075 ASSERT_EQ(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_ERR); 1076 } 1077 1078 /** 1079 * @tc.name: KeySubscriberHandlerTest_IsEqualKeyOption 1080 * @tc.desc: Test Is Equal KeyOption 1081 * @tc.type: FUNC 1082 * @tc.require: 1083 */ 1084 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEqualKeyOption, TestSize.Level1) 1085 { 1086 CALL_DEBUG_ENTER; 1087 KeySubscriberHandler handler; 1088 std::shared_ptr<KeyOption> newOption = std::make_shared<KeyOption>(); 1089 std::shared_ptr<KeyOption> oldOption = std::make_shared<KeyOption>(); 1090 std::set<int32_t> preKeys; 1091 std::set<int32_t> pressedKeys; 1092 preKeys.insert(1); 1093 pressedKeys.insert(1); 1094 newOption->SetPreKeys(preKeys); 1095 oldOption->SetPreKeys(pressedKeys); 1096 newOption->SetFinalKey(1); 1097 oldOption->SetFinalKey(2); 1098 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1099 1100 oldOption->SetFinalKey(1); 1101 newOption->SetFinalKeyDown(true); 1102 oldOption->SetFinalKeyDown(false); 1103 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1104 oldOption->SetFinalKeyDown(true); 1105 1106 newOption->SetFinalKeyDownDuration(100); 1107 oldOption->SetFinalKeyDownDuration(150); 1108 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1109 oldOption->SetFinalKeyDownDuration(100); 1110 1111 newOption->SetFinalKeyUpDelay(100); 1112 oldOption->SetFinalKeyUpDelay(150); 1113 ASSERT_FALSE(handler.IsEqualKeyOption(newOption, oldOption)); 1114 oldOption->SetFinalKeyUpDelay(100); 1115 ASSERT_TRUE(handler.IsEqualKeyOption(newOption, oldOption)); 1116 } 1117 1118 /** 1119 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_003 1120 * @tc.desc: Test Is Enable CombineKey 1121 * @tc.type: FUNC 1122 * @tc.require: 1123 */ 1124 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_003, TestSize.Level1) 1125 { 1126 CALL_DEBUG_ENTER; 1127 KeySubscriberHandler handler; 1128 KeyEvent::KeyItem item; 1129 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1130 handler.enableCombineKey_ = false; 1131 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 1132 item.SetKeyCode(KeyEvent::KEYCODE_A); 1133 keyEvent->AddKeyItem(item); 1134 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1135 1136 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1137 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1138 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1139 1140 item.SetKeyCode(KeyEvent::KEYCODE_B); 1141 keyEvent->AddKeyItem(item); 1142 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 1143 1144 keyEvent->SetKeyCode(KeyEvent::KEYCODE_DPAD_RIGHT); 1145 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 1146 1147 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1148 ASSERT_FALSE(handler.IsEnableCombineKey(keyEvent)); 1149 } 1150 1151 /** 1152 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_004 1153 * @tc.desc: Test Is Enable CombineKey 1154 * @tc.type: FUNC 1155 * @tc.require: 1156 */ 1157 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_004, TestSize.Level1) 1158 { 1159 CALL_DEBUG_ENTER; 1160 KeySubscriberHandler handler; 1161 KeyEvent::KeyItem item; 1162 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1163 ASSERT_NE(keyEvent, nullptr); 1164 handler.enableCombineKey_ = false; 1165 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1166 item.SetKeyCode(KeyEvent::KEYCODE_L); 1167 keyEvent->AddKeyItem(item); 1168 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1169 } 1170 1171 /** 1172 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_005 1173 * @tc.desc: Test Is Enable CombineKey 1174 * @tc.type: FUNC 1175 * @tc.require: 1176 */ 1177 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_005, TestSize.Level1) 1178 { 1179 CALL_DEBUG_ENTER; 1180 KeySubscriberHandler handler; 1181 KeyEvent::KeyItem item; 1182 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1183 ASSERT_NE(keyEvent, nullptr); 1184 handler.enableCombineKey_ = false; 1185 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1186 item.SetKeyCode(KeyEvent::KEYCODE_META_LEFT); 1187 keyEvent->AddKeyItem(item); 1188 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1189 } 1190 1191 /** 1192 * @tc.name: KeySubscriberHandlerTest_IsEnableCombineKey_006 1193 * @tc.desc: Test Is Enable CombineKey 1194 * @tc.type: FUNC 1195 * @tc.require: 1196 */ 1197 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsEnableCombineKey_006, TestSize.Level1) 1198 { 1199 CALL_DEBUG_ENTER; 1200 KeySubscriberHandler handler; 1201 KeyEvent::KeyItem item; 1202 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1203 ASSERT_NE(keyEvent, nullptr); 1204 handler.enableCombineKey_ = false; 1205 keyEvent->SetKeyCode(KeyEvent::KEYCODE_L); 1206 item.SetKeyCode(KeyEvent::KEYCODE_META_RIGHT); 1207 keyEvent->AddKeyItem(item); 1208 ASSERT_TRUE(handler.IsEnableCombineKey(keyEvent)); 1209 } 1210 1211 /** 1212 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriber 1213 * @tc.desc: Test Remove Subscriber 1214 * @tc.type: FUNC 1215 * @tc.require: 1216 */ 1217 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriber, TestSize.Level1) 1218 { 1219 CALL_DEBUG_ENTER; 1220 KeySubscriberHandler handler; 1221 int32_t subscribeId = 2; 1222 int32_t id = 1; 1223 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1224 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1225 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1226 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1227 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1228 subscriberList.push_back(subscriber); 1229 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1230 ASSERT_EQ(handler.RemoveSubscriber(session, subscribeId), RET_ERR); 1231 subscribeId = 1; 1232 ASSERT_EQ(handler.RemoveSubscriber(session, subscribeId), RET_OK); 1233 } 1234 1235 /** 1236 * @tc.name: KeySubscriberHandlerTest_IsFunctionKey 1237 * @tc.desc: Test IsFunctionKey 1238 * @tc.type: FUNC 1239 * @tc.require: 1240 */ 1241 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsFunctionKey, TestSize.Level1) 1242 { 1243 CALL_DEBUG_ENTER; 1244 KeySubscriberHandler handler; 1245 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1246 ASSERT_NE(keyEvent, nullptr); 1247 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_UP); 1248 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1249 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 1250 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1251 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 1252 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1253 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_MUTE); 1254 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1255 keyEvent->SetKeyCode(KeyEvent::KEYCODE_MUTE); 1256 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1257 keyEvent->SetKeyCode(KeyEvent::KEYCODE_SWITCHVIDEOMODE); 1258 ASSERT_TRUE(handler.IsFunctionKey(keyEvent)); 1259 keyEvent->SetKeyCode(KeyEvent::KEYCODE_WLAN); 1260 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 1261 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CONFIG); 1262 ASSERT_FALSE(handler.IsFunctionKey(keyEvent)); 1263 } 1264 1265 /** 1266 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent 1267 * @tc.desc: Test OnSubscribeKeyEvent 1268 * @tc.type: FUNC 1269 * @tc.require: 1270 */ 1271 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent, TestSize.Level1) 1272 { 1273 CALL_DEBUG_ENTER; 1274 KeySubscriberHandler handler; 1275 KeyEvent::KeyItem item; 1276 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1277 ASSERT_NE(keyEvent, nullptr); 1278 handler.enableCombineKey_ = false; 1279 keyEvent->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 1280 item.SetKeyCode(KeyEvent::KEYCODE_A); 1281 keyEvent->AddKeyItem(item); 1282 item.SetKeyCode(KeyEvent::KEYCODE_B); 1283 keyEvent->AddKeyItem(item); 1284 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 1285 1286 handler.enableCombineKey_ = true; 1287 handler.hasEventExecuting_ = true; 1288 handler.keyEvent_ = KeyEvent::Create(); 1289 ASSERT_NE(handler.keyEvent_, nullptr); 1290 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_BRIGHTNESS_DOWN); 1291 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1292 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1293 item.SetKeyCode(KeyEvent::KEYCODE_A); 1294 handler.keyEvent_->AddKeyItem(item); 1295 item.SetKeyCode(KeyEvent::KEYCODE_B); 1296 handler.keyEvent_->AddKeyItem(item); 1297 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 1298 1299 handler.hasEventExecuting_ = false; 1300 handler.needSkipPowerKeyUp_ = true; 1301 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1302 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 1303 1304 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UNKNOWN); 1305 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 1306 } 1307 1308 /** 1309 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete 1310 * @tc.desc: Test OnSessionDelete 1311 * @tc.type: FUNC 1312 * @tc.require: 1313 */ 1314 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete, TestSize.Level1) 1315 { 1316 CALL_DEBUG_ENTER; 1317 KeySubscriberHandler handler; 1318 int32_t id = 1; 1319 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1320 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1321 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1322 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1323 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1324 subscriberList.push_back(subscriber); 1325 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1326 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1327 ASSERT_NO_FATAL_FAILURE(handler.OnSessionDelete(sess)); 1328 ASSERT_NO_FATAL_FAILURE(handler.OnSessionDelete(session)); 1329 } 1330 1331 /** 1332 * @tc.name: KeySubscriberHandlerTest_IsPreKeysMatch 1333 * @tc.desc: Test IsPreKeysMatch 1334 * @tc.type: FUNC 1335 * @tc.require: 1336 */ 1337 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsPreKeysMatch, TestSize.Level1) 1338 { 1339 CALL_DEBUG_ENTER; 1340 KeySubscriberHandler handler; 1341 std::set<int32_t> preKeys; 1342 std::vector<int32_t> pressedKeys; 1343 preKeys.insert(KeyEvent::KEYCODE_A); 1344 pressedKeys.push_back(KeyEvent::KEYCODE_B); 1345 ASSERT_FALSE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 1346 preKeys.clear(); 1347 pressedKeys.clear(); 1348 preKeys.insert(KeyEvent::KEYCODE_C); 1349 pressedKeys.push_back(KeyEvent::KEYCODE_C); 1350 ASSERT_TRUE(handler.IsPreKeysMatch(preKeys, pressedKeys)); 1351 } 1352 1353 /** 1354 * @tc.name: KeySubscriberHandlerTest_IsMatchForegroundPid 1355 * @tc.desc: Test Is Match Foreground Pid 1356 * @tc.type: FUNC 1357 * @tc.require: 1358 */ 1359 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsMatchForegroundPid, TestSize.Level1) 1360 { 1361 CALL_DEBUG_ENTER; 1362 KeySubscriberHandler handler; 1363 int32_t id = 1; 1364 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1365 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1366 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1367 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1368 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1369 std::set<int32_t> foregroundPids; 1370 subscriberList.push_back(subscriber); 1371 foregroundPids.insert(1); 1372 ASSERT_FALSE(handler.IsMatchForegroundPid(subscriberList, foregroundPids)); 1373 1374 foregroundPids.insert(100); 1375 ASSERT_TRUE(handler.IsMatchForegroundPid(subscriberList, foregroundPids)); 1376 } 1377 1378 /** 1379 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownSubscriber 1380 * @tc.desc: Test Notify Key Down Subscriber 1381 * @tc.type: FUNC 1382 * @tc.require: 1383 */ 1384 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownSubscriber, TestSize.Level1) 1385 { 1386 CALL_DEBUG_ENTER; 1387 KeySubscriberHandler handler; 1388 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1389 ASSERT_NE(keyEvent, nullptr); 1390 int32_t id = 1; 1391 bool handled = false; 1392 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1393 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1394 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1395 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1396 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1397 subscriberList.push_back(subscriber); 1398 keyOption->SetFinalKeyDownDuration(100); 1399 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownSubscriber(keyEvent, keyOption, subscriberList, handled)); 1400 } 1401 1402 /** 1403 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownRightNow 1404 * @tc.desc: Test Notify Key Down Right Now 1405 * @tc.type: FUNC 1406 * @tc.require: 1407 */ 1408 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownRightNow, TestSize.Level1) 1409 { 1410 CALL_DEBUG_ENTER; 1411 KeySubscriberHandler handler; 1412 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1413 ASSERT_NE(keyEvent, nullptr); 1414 int32_t id = 1; 1415 bool handled = false; 1416 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1417 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1418 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1419 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1420 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1421 subscriberList.push_back(subscriber); 1422 handler.isForegroundExits_ = true; 1423 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownRightNow(keyEvent, subscriberList, handled)); 1424 1425 handler.isForegroundExits_ = false; 1426 handler.foregroundPids_.insert(UDS_PID); 1427 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1428 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownRightNow(keyEvent, subscriberList, handled)); 1429 } 1430 1431 /** 1432 * @tc.name: KeySubscriberHandlerTest_NotifyKeyDownDelay 1433 * @tc.desc: Test Notify KeyDown Delay 1434 * @tc.type: FUNC 1435 * @tc.require: 1436 */ 1437 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyDownDelay, TestSize.Level1) 1438 { 1439 CALL_DEBUG_ENTER; 1440 KeySubscriberHandler handler; 1441 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1442 ASSERT_NE(keyEvent, nullptr); 1443 int32_t id = 1; 1444 bool handled = false; 1445 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1446 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1447 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1448 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1449 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1450 subscriber->timerId_ = 1; 1451 subscriberList.push_back(subscriber); 1452 handler.isForegroundExits_ = true; 1453 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownDelay(keyEvent, subscriberList, handled)); 1454 1455 handler.isForegroundExits_ = false; 1456 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1457 handler.foregroundPids_.insert(UDS_PID); 1458 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyDownDelay(keyEvent, subscriberList, handled)); 1459 } 1460 1461 /** 1462 * @tc.name: KeySubscriberHandlerTest_NotifyKeyUpSubscriber 1463 * @tc.desc: Test Notify KeyUp Subscriber 1464 * @tc.type: FUNC 1465 * @tc.require: 1466 */ 1467 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifyKeyUpSubscriber, TestSize.Level1) 1468 { 1469 CALL_DEBUG_ENTER; 1470 KeySubscriberHandler handler; 1471 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1472 ASSERT_NE(keyEvent, nullptr); 1473 int32_t id = 1; 1474 bool handled = false; 1475 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1476 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1477 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1478 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1479 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1480 subscriber->timerId_ = 1; 1481 keyOption->SetFinalKeyUpDelay(1000); 1482 subscriberList.push_back(subscriber); 1483 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyUpSubscriber(keyEvent, subscriberList, handled)); 1484 handler.isForegroundExits_ = true; 1485 handler.foregroundPids_.insert(UDS_PID); 1486 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyUpSubscriber(keyEvent, subscriberList, handled)); 1487 handler.foregroundPids_.erase(UDS_PID); 1488 ASSERT_NO_FATAL_FAILURE(handler.NotifyKeyUpSubscriber(keyEvent, subscriberList, handled)); 1489 } 1490 1491 /** 1492 * @tc.name: KeySubscriberHandlerTest_OnTimer 1493 * @tc.desc: Test OnTimer 1494 * @tc.type: FUNC 1495 * @tc.require: 1496 */ 1497 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnTimer, TestSize.Level1) 1498 { 1499 KeySubscriberHandler handler; 1500 int32_t id = 1; 1501 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1502 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1503 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1504 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1505 ASSERT_EQ(subscriber->keyEvent_, nullptr); 1506 ASSERT_NO_FATAL_FAILURE(handler.OnTimer(subscriber)); 1507 subscriber->keyEvent_ = KeyEvent::Create(); 1508 ASSERT_NE(subscriber->keyEvent_, nullptr); 1509 ASSERT_NO_FATAL_FAILURE(handler.OnTimer(subscriber)); 1510 } 1511 1512 /** 1513 * @tc.name: KeySubscriberHandlerTest_IsKeyEventSubscribed 1514 * @tc.desc: Test IsKeyEventSubscribed 1515 * @tc.type: FUNC 1516 * @tc.require: 1517 */ 1518 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsKeyEventSubscribed, TestSize.Level1) 1519 { 1520 KeySubscriberHandler handler; 1521 int32_t id = 1; 1522 int32_t keyCode = KeyEvent::KEYCODE_ALT_LEFT; 1523 int32_t trrigerType = KeyEvent::KEY_ACTION_DOWN; 1524 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1525 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1526 keyOption->SetFinalKeyDown(false); 1527 keyOption->SetFinalKey(KeyEvent::KEYCODE_CTRL_LEFT); 1528 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1529 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1530 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1531 subscriberList.push_back(subscriber); 1532 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1533 ASSERT_FALSE(handler.IsKeyEventSubscribed(keyCode, trrigerType)); 1534 1535 for (auto &iter : handler.subscriberMap_) { 1536 iter.first->SetFinalKeyDown(true); 1537 } 1538 keyCode = KeyEvent::KEYCODE_CTRL_LEFT; 1539 ASSERT_TRUE(handler.IsKeyEventSubscribed(keyCode, trrigerType)); 1540 } 1541 1542 /** 1543 * @tc.name: KeySubscriberHandlerTest_RemoveKeyCode 1544 * @tc.desc: Test RemoveKeyCode 1545 * @tc.type: FUNC 1546 * @tc.require: 1547 */ 1548 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyCode, TestSize.Level1) 1549 { 1550 KeySubscriberHandler handler; 1551 int32_t keyCode = KeyEvent::KEYCODE_A; 1552 std::vector<int32_t> keyCodes { KeyEvent::KEYCODE_A, KeyEvent::KEYCODE_B }; 1553 ASSERT_NO_FATAL_FAILURE(handler.RemoveKeyCode(keyCode, keyCodes)); 1554 keyCode = KeyEvent::KEYCODE_C; 1555 ASSERT_NO_FATAL_FAILURE(handler.RemoveKeyCode(keyCode, keyCodes)); 1556 } 1557 1558 /** 1559 * @tc.name: KeySubscriberHandlerTest_IsRepeatedKeyEvent 1560 * @tc.desc: Test IsRepeatedKeyEvent 1561 * @tc.type: FUNC 1562 * @tc.require: 1563 */ 1564 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_IsRepeatedKeyEvent, TestSize.Level1) 1565 { 1566 KeySubscriberHandler handler; 1567 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1568 ASSERT_NE(keyEvent, nullptr); 1569 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1570 handler.keyEvent_ = KeyEvent::Create(); 1571 ASSERT_NE(keyEvent, nullptr); 1572 handler.hasEventExecuting_ = true; 1573 handler.keyEvent_->SetKeyCode(KeyEvent::KEYCODE_A); 1574 keyEvent->SetKeyCode(KeyEvent::KEYCODE_B); 1575 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1576 keyEvent->SetKeyCode(KeyEvent::KEYCODE_A); 1577 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1578 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 1579 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1580 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 1581 KeyEvent::KeyItem item; 1582 item.SetKeyCode(KeyEvent::KEYCODE_A); 1583 handler.keyEvent_->AddKeyItem(item); 1584 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1585 item.SetKeyCode(KeyEvent::KEYCODE_B); 1586 keyEvent->AddKeyItem(item); 1587 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1588 item.SetKeyCode(KeyEvent::KEYCODE_B); 1589 handler.keyEvent_->AddKeyItem(item); 1590 item.SetKeyCode(KeyEvent::KEYCODE_D); 1591 keyEvent->AddKeyItem(item); 1592 ASSERT_FALSE(handler.IsRepeatedKeyEvent(keyEvent)); 1593 } 1594 1595 /** 1596 * @tc.name: KeySubscriberHandlerTest_RemoveSubscriberKeyUpTimer 1597 * @tc.desc: Test RemoveSubscriberKeyUpTimer 1598 * @tc.type: FUNC 1599 * @tc.require: 1600 */ 1601 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveSubscriberKeyUpTimer, TestSize.Level1) 1602 { 1603 KeySubscriberHandler handler; 1604 int32_t keyCode = KeyEvent::KEYCODE_A; 1605 int32_t id = 1; 1606 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1607 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1608 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1609 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1610 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> subscriberList; 1611 subscriber->timerId_ = -1; 1612 subscriberList.push_back(subscriber); 1613 subscriber->timerId_ = 1; 1614 subscriber->keyOption_->SetFinalKey(KeyEvent::KEYCODE_A); 1615 subscriberList.push_back(subscriber); 1616 handler.subscriberMap_.insert(std::make_pair(keyOption, subscriberList)); 1617 ASSERT_NO_FATAL_FAILURE(handler.RemoveSubscriberKeyUpTimer(keyCode)); 1618 } 1619 1620 /** 1621 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_010 1622 * @tc.desc: Test the funcation HandleRingMute 1623 * @tc.type: FUNC 1624 * @tc.require: 1625 */ 1626 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_010, TestSize.Level1) 1627 { 1628 CALL_TEST_DEBUG; 1629 KeySubscriberHandler handler; 1630 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1631 ASSERT_NE(keyEvent, nullptr); 1632 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_DOWN); 1633 OHOS::EventFwk::Want want; 1634 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 1635 OHOS::EventFwk::CommonEventData data; 1636 data.SetWant(want); 1637 int32_t callState = 0; 1638 DEVICE_MONITOR->SetCallState(data, callState); 1639 DeviceEventMonitor monitor; 1640 monitor.hasHandleRingMute_ = false; 1641 bool ret = handler.HandleRingMute(keyEvent); 1642 ASSERT_FALSE(ret); 1643 monitor.hasHandleRingMute_ = true; 1644 ret = handler.HandleRingMute(keyEvent); 1645 ASSERT_FALSE(ret); 1646 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1647 ret = handler.HandleRingMute(keyEvent); 1648 ASSERT_FALSE(ret); 1649 want.SetParam("state", StateType::CALL_STATUS_ALERTING); 1650 data.SetWant(want); 1651 DEVICE_MONITOR->SetCallState(data, callState); 1652 ret = handler.HandleRingMute(keyEvent); 1653 ASSERT_FALSE(ret); 1654 } 1655 1656 /** 1657 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_002 1658 * @tc.desc: Test the funcation OnSubscribeKeyEvent 1659 * @tc.type: FUNC 1660 * @tc.require: 1661 */ 1662 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_002, TestSize.Level1) 1663 { 1664 CALL_TEST_DEBUG; 1665 KeySubscriberHandler handler; 1666 OHOS::EventFwk::Want want; 1667 want.SetParam("state", StateType::CALL_STATUS_DISCONNECTED); 1668 OHOS::EventFwk::CommonEventData data; 1669 data.SetWant(want); 1670 int callState = 0; 1671 DEVICE_MONITOR->SetCallState(data, callState); 1672 want.SetParam("state", StateType::CALL_STATUS_INCOMING); 1673 data.SetWant(want); 1674 callState = 0; 1675 DEVICE_MONITOR->SetCallState(data, callState); 1676 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1677 keyEvent->SetKeyCode(KeyEvent::KEYCODE_VOLUME_UP); 1678 bool ret = handler.OnSubscribeKeyEvent(keyEvent); 1679 ASSERT_FALSE(ret); 1680 } 1681 1682 /** 1683 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_003 1684 * @tc.desc: Test the funcation OnSubscribeKeyEvent 1685 * @tc.type: FUNC 1686 * @tc.require: 1687 */ 1688 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_003, TestSize.Level1) 1689 { 1690 CALL_TEST_DEBUG; 1691 KeySubscriberHandler handler; 1692 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1693 ASSERT_NE(keyEvent, nullptr); 1694 handler.needSkipPowerKeyUp_ = true; 1695 KeyEvent::KeyItem item; 1696 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 1697 keyEvent->AddKeyItem(item); 1698 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1699 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 1700 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 1701 } 1702 1703 /** 1704 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_002 1705 * @tc.desc: Test the funcation NotifySubscriber 1706 * @tc.type: FUNC 1707 * @tc.require: 1708 */ 1709 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_002, TestSize.Level1) 1710 { 1711 CALL_TEST_DEBUG; 1712 KeySubscriberHandler handler; 1713 SessionPtr sess; 1714 std::shared_ptr<KeyOption> keyOption; 1715 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1716 ASSERT_NE(keyEvent, nullptr); 1717 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1718 KeyEvent::KeyItem item; 1719 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 1720 keyEvent->AddKeyItem(item); 1721 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 1722 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 1723 } 1724 1725 /** 1726 * @tc.name: KeySubscriberHandlerTest_AddTimer_001 1727 * @tc.desc: Test the funcation AddTimer 1728 * @tc.type: FUNC 1729 * @tc.require: 1730 */ 1731 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddTimer_001, TestSize.Level1) 1732 { 1733 CALL_TEST_DEBUG; 1734 KeySubscriberHandler handler; 1735 int32_t id = 1; 1736 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 1737 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 1738 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 1739 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 1740 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1741 ASSERT_NE(keyEvent, nullptr); 1742 subscriber->timerId_ = 1; 1743 bool ret = handler.AddTimer(subscriber, keyEvent); 1744 ASSERT_TRUE(ret); 1745 subscriber->timerId_ = -1; 1746 keyOption->isFinalKeyDown_ = true; 1747 ret = handler.AddTimer(subscriber, keyEvent); 1748 ASSERT_TRUE(ret); 1749 keyOption->isFinalKeyDown_ = false; 1750 ret = handler.AddTimer(subscriber, keyEvent); 1751 ASSERT_TRUE(ret); 1752 } 1753 1754 /** 1755 * @tc.name: KeySubscriberHandlerTest_HandleKeyDown_002 1756 * @tc.desc: Test the funcation HandleKeyDown 1757 * @tc.type: FUNC 1758 * @tc.require: 1759 */ 1760 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_002, TestSize.Level1) 1761 { 1762 CALL_DEBUG_ENTER; 1763 KeySubscriberHandler handler; 1764 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1765 ASSERT_NE(keyEvent, nullptr); 1766 auto keyOption = std::make_shared<KeyOption>(); 1767 keyOption->isFinalKeyDown_ = false; 1768 SessionPtr sess; 1769 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1770 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1771 subscribers.push_back(subscriber); 1772 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1773 bool ret = handler.HandleKeyDown(keyEvent); 1774 ASSERT_FALSE(ret); 1775 keyOption->isFinalKeyDown_ = true; 1776 keyOption->finalKey_ = true; 1777 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1778 subscribers.push_back(subscriber); 1779 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1780 KeyEvent::KeyItem item; 1781 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 1782 keyEvent->AddKeyItem(item); 1783 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1784 ret = handler.HandleKeyDown(keyEvent); 1785 ASSERT_FALSE(ret); 1786 keyOption->finalKey_ = false; 1787 std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1788 subscribers.push_back(subscriber); 1789 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1790 ret = handler.HandleKeyDown(keyEvent); 1791 ASSERT_FALSE(ret); 1792 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 1793 ret = handler.HandleKeyDown(keyEvent); 1794 ASSERT_FALSE(ret); 1795 } 1796 1797 /** 1798 * @tc.name: KeySubscriberHandlerTest_HandleKeyUp_002 1799 * @tc.desc: Test the funcation HandleKeyUp 1800 * @tc.type: FUNC 1801 * @tc.require: 1802 */ 1803 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUp_002, TestSize.Level1) 1804 { 1805 CALL_DEBUG_ENTER; 1806 KeySubscriberHandler handler; 1807 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1808 ASSERT_NE(keyEvent, nullptr); 1809 auto keyOption = std::make_shared<KeyOption>(); 1810 keyOption->isFinalKeyDown_ = true; 1811 SessionPtr sess; 1812 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1813 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 1814 subscribers.push_back(subscriber); 1815 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1816 bool ret = handler.HandleKeyUp(keyEvent); 1817 ASSERT_FALSE(ret); 1818 keyOption->isFinalKeyDown_ = false; 1819 keyOption->finalKey_ = -1; 1820 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1821 subscribers.push_back(subscriber); 1822 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1823 ret = handler.HandleKeyUp(keyEvent); 1824 ASSERT_FALSE(ret); 1825 keyOption->finalKey_ = 0; 1826 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1827 subscribers.push_back(subscriber); 1828 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1829 ret = handler.HandleKeyUp(keyEvent); 1830 ASSERT_FALSE(ret); 1831 std::set<int32_t> preKeys; 1832 std::vector<int32_t> pressedKeys = {1, 2, 3}; 1833 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1834 subscribers.push_back(subscriber); 1835 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1836 ret = handler.HandleKeyUp(keyEvent); 1837 ASSERT_FALSE(ret); 1838 pressedKeys = {1, 2, 3}; 1839 preKeys = {1, 2, 3, 4}; 1840 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 1841 subscribers.push_back(subscriber); 1842 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 1843 ret = handler.HandleKeyUp(keyEvent); 1844 ASSERT_FALSE(ret); 1845 } 1846 1847 /** 1848 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_01 1849 * @tc.desc: Test the funcation HandleRingMute 1850 * @tc.type: FUNC 1851 * @tc.require: 1852 */ 1853 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_01, TestSize.Level1) 1854 { 1855 CALL_TEST_DEBUG; 1856 KeySubscriberHandler handler; 1857 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1858 ASSERT_NE(keyEvent, nullptr); 1859 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 1860 DeviceEventMonitor monitor; 1861 monitor.callState_ = StateType::CALL_STATUS_INCOMING; 1862 bool ret = handler.HandleRingMute(keyEvent); 1863 ASSERT_FALSE(ret); 1864 handler.HandleRingMute(keyEvent); 1865 monitor.hasHandleRingMute_ = false; 1866 ret = handler.HandleRingMute(keyEvent); 1867 ASSERT_FALSE(ret); 1868 monitor.hasHandleRingMute_ = true; 1869 ret = handler.HandleRingMute(keyEvent); 1870 ASSERT_FALSE(ret); 1871 monitor.callState_ = StateType::CALL_STATUS_DIALING; 1872 ret = handler.HandleRingMute(keyEvent); 1873 ASSERT_FALSE(ret); 1874 } 1875 1876 /** 1877 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_02 1878 * @tc.desc: Test ring mute 1879 * @tc.type: FUNC 1880 * @tc.require: 1881 */ 1882 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_02, TestSize.Level1) 1883 { 1884 CALL_TEST_DEBUG; 1885 KeySubscriberHandler keySubscriberHandler; 1886 1887 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1888 ASSERT_NE(keyEvent, nullptr); 1889 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1890 1891 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1892 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1893 callManagerClientPtr = nullptr; 1894 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1895 } 1896 1897 /** 1898 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_03 1899 * @tc.desc: Test ring mute 1900 * @tc.type: FUNC 1901 * @tc.require: 1902 */ 1903 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_03, TestSize.Level1) 1904 { 1905 CALL_TEST_DEBUG; 1906 KeySubscriberHandler keySubscriberHandler; 1907 1908 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1909 ASSERT_NE(keyEvent, nullptr); 1910 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1911 1912 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1913 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1914 EXPECT_NE(callManagerClientPtr, nullptr); 1915 DEVICE_MONITOR->hasHandleRingMute_ = false; 1916 auto ret = callManagerClientPtr->MuteRinger(); 1917 EXPECT_NE(ret, ERR_OK); 1918 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1919 } 1920 1921 /** 1922 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_04 1923 * @tc.desc: Test ring mute 1924 * @tc.type: FUNC 1925 * @tc.require: 1926 */ 1927 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_04, TestSize.Level1) 1928 { 1929 CALL_TEST_DEBUG; 1930 KeySubscriberHandler keySubscriberHandler; 1931 1932 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1933 ASSERT_NE(keyEvent, nullptr); 1934 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1935 1936 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1937 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1938 EXPECT_NE(callManagerClientPtr, nullptr); 1939 DEVICE_MONITOR->hasHandleRingMute_ = false; 1940 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 1941 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1942 } 1943 1944 /** 1945 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_05 1946 * @tc.desc: Test ring mute 1947 * @tc.type: FUNC 1948 * @tc.require: 1949 */ 1950 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_05, TestSize.Level1) 1951 { 1952 CALL_TEST_DEBUG; 1953 KeySubscriberHandler keySubscriberHandler; 1954 1955 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1956 ASSERT_NE(keyEvent, nullptr); 1957 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 1958 1959 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1960 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1961 EXPECT_NE(callManagerClientPtr, nullptr); 1962 DEVICE_MONITOR->hasHandleRingMute_ = false; 1963 keyEvent->keyCode_ = KeyEvent::KEYCODE_CALL; 1964 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1965 } 1966 1967 /** 1968 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_06 1969 * @tc.desc: Test ring mute 1970 * @tc.type: FUNC 1971 * @tc.require: 1972 */ 1973 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_06, TestSize.Level1) 1974 { 1975 CALL_TEST_DEBUG; 1976 KeySubscriberHandler keySubscriberHandler; 1977 1978 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1979 ASSERT_NE(keyEvent, nullptr); 1980 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 1981 1982 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 1983 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 1984 EXPECT_NE(callManagerClientPtr, nullptr); 1985 DEVICE_MONITOR->hasHandleRingMute_ = true; 1986 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 1987 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 1988 } 1989 1990 /** 1991 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_07 1992 * @tc.desc: Test ring mute 1993 * @tc.type: FUNC 1994 * @tc.require: 1995 */ 1996 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_07, TestSize.Level1) 1997 { 1998 CALL_TEST_DEBUG; 1999 KeySubscriberHandler keySubscriberHandler; 2000 2001 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2002 ASSERT_NE(keyEvent, nullptr); 2003 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 2004 2005 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2006 auto callManagerClientPtr = DelayedSingleton<OHOS::Telephony::CallManagerClient>::GetInstance(); 2007 EXPECT_NE(callManagerClientPtr, nullptr); 2008 DEVICE_MONITOR->hasHandleRingMute_ = true; 2009 keyEvent->keyCode_ = KeyEvent::KEYCODE_CAMERA; 2010 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2011 } 2012 2013 /** 2014 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_08 2015 * @tc.desc: Test ring mute 2016 * @tc.type: FUNC 2017 * @tc.require: 2018 */ 2019 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_08, TestSize.Level1) 2020 { 2021 CALL_TEST_DEBUG; 2022 KeySubscriberHandler keySubscriberHandler; 2023 2024 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2025 ASSERT_NE(keyEvent, nullptr); 2026 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2027 2028 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2029 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr = nullptr; 2030 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2031 } 2032 2033 /** 2034 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_09 2035 * @tc.desc: Test ring mute 2036 * @tc.type: FUNC 2037 * @tc.require: 2038 */ 2039 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_09, TestSize.Level1) 2040 { 2041 CALL_TEST_DEBUG; 2042 KeySubscriberHandler keySubscriberHandler; 2043 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2044 ASSERT_NE(keyEvent, nullptr); 2045 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2046 2047 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2048 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr; 2049 callManagerClientPtr = std::make_shared<OHOS::Telephony::CallManagerClient>(); 2050 EXPECT_NE(callManagerClientPtr, nullptr); 2051 DEVICE_MONITOR->hasHandleRingMute_ = false; 2052 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2053 } 2054 2055 /** 2056 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_10 2057 * @tc.desc: Test ring mute 2058 * @tc.type: FUNC 2059 * @tc.require: 2060 */ 2061 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_10, TestSize.Level1) 2062 { 2063 CALL_TEST_DEBUG; 2064 KeySubscriberHandler keySubscriberHandler; 2065 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2066 ASSERT_NE(keyEvent, nullptr); 2067 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2068 2069 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2070 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr; 2071 callManagerClientPtr = std::make_shared<OHOS::Telephony::CallManagerClient>(); 2072 EXPECT_NE(callManagerClientPtr, nullptr); 2073 DEVICE_MONITOR->hasHandleRingMute_ = true; 2074 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 2075 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2076 } 2077 2078 /** 2079 * @tc.name: KeySubscriberHandlerTest_HandleRingMute_11 2080 * @tc.desc: Test ring mute 2081 * @tc.type: FUNC 2082 * @tc.require: 2083 */ 2084 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleRingMute_11, TestSize.Level1) 2085 { 2086 CALL_TEST_DEBUG; 2087 KeySubscriberHandler keySubscriberHandler; 2088 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2089 ASSERT_NE(keyEvent, nullptr); 2090 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_DOWN; 2091 2092 DEVICE_MONITOR->callState_ = StateType::CALL_STATUS_INCOMING; 2093 std::shared_ptr<OHOS::Telephony::CallManagerClient> callManagerClientPtr; 2094 callManagerClientPtr = std::make_shared<OHOS::Telephony::CallManagerClient>(); 2095 EXPECT_NE(callManagerClientPtr, nullptr); 2096 DEVICE_MONITOR->hasHandleRingMute_ = true; 2097 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 2098 ASSERT_FALSE(keySubscriberHandler.HandleRingMute(keyEvent)); 2099 } 2100 2101 /** 2102 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_01 2103 * @tc.desc: Test AddKeyGestureSubscriber 2104 * @tc.type: FUNC 2105 * @tc.require: 2106 */ 2107 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_01, TestSize.Level1) 2108 { 2109 CALL_TEST_DEBUG; 2110 KeySubscriberHandler handler; 2111 SessionPtr sess; 2112 std::shared_ptr<KeyOption> keyOption; 2113 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2114 subscriber->timerId_ = -1; 2115 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption)); 2116 } 2117 2118 /** 2119 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_02 2120 * @tc.desc: Test AddKeyGestureSubscriber 2121 * @tc.type: FUNC 2122 * @tc.require: 2123 */ 2124 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_02, TestSize.Level1) 2125 { 2126 CALL_TEST_DEBUG; 2127 KeySubscriberHandler handler; 2128 SessionPtr sess; 2129 std::shared_ptr<KeyOption> keyOption; 2130 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 2131 subscriber->timerId_ = 1; 2132 2133 auto keyOption1 = std::make_shared<KeyOption>(); 2134 keyOption1->SetFinalKey(1); 2135 keyOption1->SetFinalKeyDown(true); 2136 auto keyOption2 = std::make_shared<KeyOption>(); 2137 keyOption2->SetFinalKey(1); 2138 keyOption2->SetFinalKeyDown(true); 2139 2140 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2141 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2142 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2143 subscribers.push_back(subscriber1); 2144 subscribers.push_back(subscriber2); 2145 handler.keyGestures_.insert({keyOption2, subscribers}); 2146 2147 for (auto &iter : handler.keyGestures_) { 2148 EXPECT_TRUE(handler.IsEqualKeyOption(keyOption1, iter.first)); 2149 } 2150 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption1)); 2151 } 2152 2153 /** 2154 * @tc.name: KeySubscriberHandlerTest_AddKeyGestureSubscriber_03 2155 * @tc.desc: Test AddKeyGestureSubscriber 2156 * @tc.type: FUNC 2157 * @tc.require: 2158 */ 2159 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddKeyGestureSubscriber_03, TestSize.Level1) 2160 { 2161 CALL_TEST_DEBUG; 2162 KeySubscriberHandler handler; 2163 SessionPtr sess; 2164 std::shared_ptr<KeyOption> keyOption; 2165 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(3, sess, keyOption); 2166 subscriber->timerId_ = 2; 2167 2168 auto keyOption1 = std::make_shared<KeyOption>(); 2169 keyOption1->SetFinalKey(2); 2170 keyOption1->SetFinalKeyDown(true); 2171 auto keyOption2 = std::make_shared<KeyOption>(); 2172 keyOption2->SetFinalKey(1); 2173 keyOption2->SetFinalKeyDown(false); 2174 2175 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2176 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2177 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2178 subscribers.push_back(subscriber1); 2179 subscribers.push_back(subscriber2); 2180 handler.keyGestures_.insert({keyOption2, subscribers}); 2181 2182 for (auto &iter : handler.keyGestures_) { 2183 EXPECT_FALSE(handler.IsEqualKeyOption(keyOption1, iter.first)); 2184 } 2185 ASSERT_NO_FATAL_FAILURE(handler.AddKeyGestureSubscriber(subscriber, keyOption1)); 2186 } 2187 2188 /** 2189 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_01 2190 * @tc.desc: Test RemoveKeyGestureSubscriber 2191 * @tc.type: FUNC 2192 * @tc.require: 2193 */ 2194 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_01, TestSize.Level1) 2195 { 2196 CALL_TEST_DEBUG; 2197 KeySubscriberHandler handler; 2198 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2199 EXPECT_NE(sess, nullptr); 2200 2201 auto keyOption1 = std::make_shared<KeyOption>(); 2202 keyOption1->SetFinalKey(2); 2203 keyOption1->SetFinalKeyDown(true); 2204 auto keyOption2 = std::make_shared<KeyOption>(); 2205 keyOption2->SetFinalKey(1); 2206 keyOption2->SetFinalKeyDown(false); 2207 2208 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2209 std::shared_ptr<KeyOption> keyOption; 2210 auto subscriber1 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2211 auto subscriber2 = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(2, sess, keyOption); 2212 subscribers.push_back(subscriber1); 2213 subscribers.push_back(subscriber2); 2214 handler.keyGestures_.insert({keyOption2, subscribers}); 2215 2216 int32_t subscribeId = 3; 2217 for (auto &iter : handler.keyGestures_) { 2218 for (auto innerIter = iter.second.begin(); innerIter != iter.second.end(); ++innerIter) { 2219 auto subscriber = *innerIter; 2220 EXPECT_TRUE(subscriber->id_ != subscribeId); 2221 EXPECT_FALSE(subscriber->sess_ != sess); 2222 } 2223 int32_t ret = handler.RemoveKeyGestureSubscriber(sess, subscribeId); 2224 EXPECT_EQ(ret, RET_ERR); 2225 } 2226 } 2227 2228 /** 2229 * @tc.name: InputWindowsManagerTest_UnsubscribeKeyEvent_01 2230 * @tc.desc: Test UnsubscribeKeyEvent 2231 * @tc.type: FUNC 2232 * @tc.require: 2233 */ 2234 HWTEST_F(KeySubscriberHandlerTest, InputWindowsManagerTest_UnsubscribeKeyEvent_01, TestSize.Level1) 2235 { 2236 CALL_TEST_DEBUG; 2237 KeySubscriberHandler keySubscriberHandler; 2238 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2239 EXPECT_NE(sess, nullptr); 2240 int32_t subscribeId = 2; 2241 int32_t ret1 = keySubscriberHandler.RemoveSubscriber(sess, subscribeId); 2242 EXPECT_EQ(ret1, RET_ERR); 2243 int32_t ret2 = keySubscriberHandler.UnsubscribeKeyEvent(sess, subscribeId); 2244 EXPECT_EQ(ret2, RET_ERR); 2245 } 2246 2247 /** 2248 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_01 2249 * @tc.desc: Test NotifySubscriber 2250 * @tc.type: FUNC 2251 * @tc.require: 2252 */ 2253 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_01, TestSize.Level1) 2254 { 2255 CALL_TEST_DEBUG; 2256 KeySubscriberHandler handler; 2257 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2258 EXPECT_NE(sess, nullptr); 2259 std::shared_ptr<KeyOption> keyOption; 2260 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2261 EXPECT_NE(keyEvent, nullptr); 2262 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2263 EXPECT_NE(subscriber, nullptr); 2264 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 2265 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2266 } 2267 2268 /** 2269 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_02 2270 * @tc.desc: Test NotifySubscriber 2271 * @tc.type: FUNC 2272 * @tc.require: 2273 */ 2274 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_02, TestSize.Level1) 2275 { 2276 CALL_TEST_DEBUG; 2277 KeySubscriberHandler handler; 2278 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2279 EXPECT_NE(sess, nullptr); 2280 std::shared_ptr<KeyOption> keyOption; 2281 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2282 EXPECT_NE(keyEvent, nullptr); 2283 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2284 EXPECT_NE(subscriber, nullptr); 2285 keyEvent->keyCode_ = KeyEvent::KEYCODE_VOLUME_UP; 2286 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2287 } 2288 2289 /** 2290 * @tc.name: KeySubscriberHandlerTest_OnSubscribeKeyEvent_004 2291 * @tc.desc: Test the funcation OnSubscribeKeyEvent 2292 * @tc.type: FUNC 2293 * @tc.require: 2294 */ 2295 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSubscribeKeyEvent_004, TestSize.Level1) 2296 { 2297 CALL_DEBUG_ENTER; 2298 KeySubscriberHandler handler; 2299 KeyEvent::KeyItem item; 2300 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2301 ASSERT_NE(keyEvent, nullptr); 2302 handler.enableCombineKey_ = false; 2303 keyEvent->SetKeyCode(KeyEvent::KEY_ACTION_UP); 2304 item.SetKeyCode(KeyEvent::KEYCODE_O); 2305 keyEvent->AddKeyItem(item); 2306 item.SetKeyCode(KeyEvent::KEYCODE_P); 2307 keyEvent->AddKeyItem(item); 2308 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 2309 handler.enableCombineKey_ = true; 2310 handler.hasEventExecuting_ = true; 2311 handler.keyEvent_ = KeyEvent::Create(); 2312 ASSERT_NE(handler.keyEvent_, nullptr); 2313 handler.keyEvent_->SetKeyCode(KeyEvent::KEY_ACTION_UP); 2314 handler.keyEvent_->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2315 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2316 item.SetKeyCode(KeyEvent::KEYCODE_O); 2317 handler.keyEvent_->AddKeyItem(item); 2318 item.SetKeyCode(KeyEvent::KEYCODE_P); 2319 handler.keyEvent_->AddKeyItem(item); 2320 ASSERT_TRUE(handler.OnSubscribeKeyEvent(keyEvent)); 2321 handler.hasEventExecuting_ = false; 2322 handler.needSkipPowerKeyUp_ = true; 2323 keyEvent->SetKeyCode(KeyEvent::KEY_ACTION_CANCEL); 2324 ASSERT_FALSE(handler.OnSubscribeKeyEvent(keyEvent)); 2325 } 2326 2327 /** 2328 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_003 2329 * @tc.desc: Test the funcation NotifySubscriber 2330 * @tc.type: FUNC 2331 * @tc.require: 2332 */ 2333 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_003, TestSize.Level1) 2334 { 2335 CALL_TEST_DEBUG; 2336 KeySubscriberHandler handler; 2337 SessionPtr sess; 2338 std::shared_ptr<KeyOption> keyOption; 2339 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2340 ASSERT_NE(keyEvent, nullptr); 2341 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2342 KeyEvent::KeyItem item; 2343 item.SetKeyCode(KeyEvent::KEYCODE_POWER); 2344 keyEvent->AddKeyItem(item); 2345 keyEvent->SetKeyCode(KeyEvent::KEYCODE_POWER); 2346 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2347 item.SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2348 keyEvent->AddKeyItem(item); 2349 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2350 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2351 } 2352 2353 /** 2354 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_004 2355 * @tc.desc: Test NotifySubscriber 2356 * @tc.type: FUNC 2357 * @tc.require: 2358 */ 2359 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_004, TestSize.Level1) 2360 { 2361 CALL_TEST_DEBUG; 2362 KeySubscriberHandler handler; 2363 SessionPtr sess; 2364 std::shared_ptr<KeyOption> keyOption; 2365 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2366 ASSERT_NE(keyEvent, nullptr); 2367 2368 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2369 ASSERT_NE(subscriber, nullptr); 2370 2371 keyEvent->keyCode_ = KeyEvent::KEYCODE_POWER; 2372 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2373 } 2374 2375 /** 2376 * @tc.name: KeySubscriberHandlerTest_NotifySubscriber_005 2377 * @tc.desc: Test NotifySubscriber 2378 * @tc.type: FUNC 2379 * @tc.require: 2380 */ 2381 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_NotifySubscriber_005, TestSize.Level1) 2382 { 2383 CALL_TEST_DEBUG; 2384 KeySubscriberHandler handler; 2385 SessionPtr sess; 2386 std::shared_ptr<KeyOption> keyOption; 2387 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2388 ASSERT_NE(keyEvent, nullptr); 2389 2390 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2391 ASSERT_NE(subscriber, nullptr); 2392 keyEvent->keyCode_ = KeyEvent::KEYCODE_CAMERA; 2393 EXPECT_FALSE(EventLogHelper::IsBetaVersion()); 2394 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_PRIVACY_MODE)); 2395 2396 NetPacket pkt(MmiMessageId::ON_SUBSCRIBE_KEY); 2397 EXPECT_FALSE(pkt.ChkRWError()); 2398 ASSERT_NO_FATAL_FAILURE(handler.NotifySubscriber(keyEvent, subscriber)); 2399 } 2400 2401 /** 2402 * @tc.name: KeySubscriberHandlerTest_AddTimer_002 2403 * @tc.desc: Test the funcation AddTimer 2404 * @tc.type: FUNC 2405 * @tc.require: 2406 */ 2407 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_AddTimer_002, TestSize.Level1) 2408 { 2409 CALL_TEST_DEBUG; 2410 KeySubscriberHandler handler; 2411 int32_t id = 3; 2412 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2413 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2414 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2415 std::make_shared<KeySubscriberHandler::Subscriber>(id, session, keyOption); 2416 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2417 ASSERT_NE(keyEvent, nullptr); 2418 subscriber->timerId_ = 5; 2419 bool ret = handler.AddTimer(subscriber, keyEvent); 2420 ASSERT_TRUE(ret); 2421 subscriber->timerId_ = -5; 2422 keyOption->isFinalKeyDown_ = true; 2423 keyOption->finalKeyDownDuration_ = -5; 2424 ret = handler.AddTimer(subscriber, keyEvent); 2425 ASSERT_TRUE(ret); 2426 keyOption->finalKeyDownDuration_ = 5; 2427 ret = handler.AddTimer(subscriber, keyEvent); 2428 ASSERT_TRUE(ret); 2429 keyOption->isFinalKeyDown_ = false; 2430 keyOption->finalKeyUpDelay_ = -5; 2431 ret = handler.AddTimer(subscriber, keyEvent); 2432 ASSERT_TRUE(ret); 2433 keyOption->finalKeyUpDelay_ = 5; 2434 ret = handler.AddTimer(subscriber, keyEvent); 2435 ASSERT_TRUE(ret); 2436 } 2437 2438 /** 2439 * @tc.name: KeySubscriberHandlerTest_HandleKeyDown_003 2440 * @tc.desc: Test the funcation HandleKeyDown 2441 * @tc.type: FUNC 2442 * @tc.require: 2443 */ 2444 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyDown_003, TestSize.Level1) 2445 { 2446 CALL_DEBUG_ENTER; 2447 KeySubscriberHandler handler; 2448 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2449 ASSERT_NE(keyEvent, nullptr); 2450 auto keyOption = std::make_shared<KeyOption>(); 2451 keyOption->isFinalKeyDown_ = true; 2452 keyEvent->keyCode_ = 1; 2453 SessionPtr sess; 2454 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2455 std::list<std::shared_ptr<OHOS::MMI::KeySubscriberHandler::Subscriber>> subscribers; 2456 subscribers.push_back(subscriber); 2457 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 2458 keyOption->finalKey_ = 5; 2459 bool ret = handler.HandleKeyDown(keyEvent); 2460 ASSERT_FALSE(ret); 2461 keyOption->finalKey_ = 1; 2462 subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2463 subscribers.push_back(subscriber); 2464 handler.subscriberMap_.insert(std::make_pair(keyOption, subscribers)); 2465 KeyEvent::KeyItem item; 2466 item.SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2467 keyEvent->AddKeyItem(item); 2468 keyEvent->SetKeyCode(KeyEvent::KEYCODE_CAMERA); 2469 ret = handler.HandleKeyDown(keyEvent); 2470 ASSERT_FALSE(ret); 2471 } 2472 2473 /** 2474 * @tc.name: KeySubscriberHandlerTest_SubscriberNotifyNap_002 2475 * @tc.desc: Test the funcation SubscriberNotifyNap 2476 * @tc.type: FUNC 2477 * @tc.require: 2478 */ 2479 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_002, TestSize.Level1) 2480 { 2481 CALL_TEST_DEBUG; 2482 KeySubscriberHandler handler; 2483 SessionPtr sess; 2484 std::shared_ptr<KeyOption> keyOption; 2485 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2486 NapProcess napProcess; 2487 napProcess.napClientPid_ = REMOVE_OBSERVER; 2488 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2489 napProcess.napClientPid_ = UNOBSERVED; 2490 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2491 napProcess.napClientPid_ = 10; 2492 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2493 } 2494 2495 /** 2496 * @tc.name: KeySubscriberHandlerTest_SubscriberNotifyNap_003 2497 * @tc.desc: Test the funcation SubscriberNotifyNap 2498 * @tc.type: FUNC 2499 * @tc.require: 2500 */ 2501 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscriberNotifyNap_003, TestSize.Level1) 2502 { 2503 CALL_TEST_DEBUG; 2504 KeySubscriberHandler handler; 2505 SessionPtr sess; 2506 std::shared_ptr<KeyOption> keyOption; 2507 auto subscriber = std::make_shared<OHOS::MMI::KeySubscriberHandler::Subscriber>(1, sess, keyOption); 2508 ASSERT_NE(subscriber, nullptr); 2509 2510 NapProcess napProcess; 2511 napProcess.napClientPid_ = ACTIVE_EVENT; 2512 OHOS::MMI::NapProcess::NapStatusData napData; 2513 napData.pid = 2; 2514 napData.uid = 3; 2515 napData.bundleName = "programName"; 2516 EXPECT_FALSE(napProcess.IsNeedNotify(napData)); 2517 ASSERT_NO_FATAL_FAILURE(handler.SubscriberNotifyNap(subscriber)); 2518 } 2519 2520 /** 2521 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_003 2522 * @tc.desc: Test subscribe keyEvent 2523 * @tc.type: FUNC 2524 * @tc.require: 2525 */ 2526 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_003, TestSize.Level1) 2527 { 2528 CALL_TEST_DEBUG; 2529 KeySubscriberHandler handler; 2530 int32_t subscribeId = 1; 2531 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2532 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2533 std::set<int32_t> preKeys = { 2017, 2018, 2019, 2072, 2046 }; 2534 keyOption->SetPreKeys(preKeys); 2535 EXPECT_EQ(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_ERR); 2536 } 2537 2538 /** 2539 * @tc.name: KeySubscriberHandlerTest_SubscribeKeyEvent_004 2540 * @tc.desc: Test subscribe keyEvent 2541 * @tc.type: FUNC 2542 * @tc.require: 2543 */ 2544 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_SubscribeKeyEvent_004, TestSize.Level1) 2545 { 2546 CALL_TEST_DEBUG; 2547 KeySubscriberHandler handler; 2548 int32_t subscribeId = 1; 2549 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2550 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2551 keyOption->SetFinalKey(2072); 2552 keyOption->SetFinalKeyDown(true); 2553 keyOption->SetFinalKeyDownDuration(100); 2554 EXPECT_EQ(handler.SubscribeKeyEvent(sess, subscribeId, keyOption), RET_OK); 2555 } 2556 2557 /** 2558 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber 2559 * @tc.desc: Test RemoveKeyGestureSubscriber 2560 * @tc.type: FUNC 2561 * @tc.require: 2562 */ 2563 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber, TestSize.Level1) 2564 { 2565 CALL_TEST_DEBUG; 2566 KeySubscriberHandler handler; 2567 int32_t subscribeId = 1; 2568 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2569 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2570 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2571 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2572 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2573 listSub.push_back(subscriber); 2574 subscribeId = 2; 2575 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2576 EXPECT_EQ(handler.RemoveKeyGestureSubscriber(sess, subscribeId), RET_ERR); 2577 } 2578 2579 /** 2580 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_001 2581 * @tc.desc: Test RemoveKeyGestureSubscriber 2582 * @tc.type: FUNC 2583 * @tc.require: 2584 */ 2585 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_001, TestSize.Level1) 2586 { 2587 CALL_TEST_DEBUG; 2588 KeySubscriberHandler handler; 2589 int32_t subscribeId = 1; 2590 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2591 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2592 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2593 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2594 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2595 listSub.push_back(subscriber); 2596 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2597 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2598 EXPECT_EQ(handler.RemoveKeyGestureSubscriber(session, subscribeId), RET_ERR); 2599 } 2600 2601 /** 2602 * @tc.name: KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_002 2603 * @tc.desc: Test RemoveKeyGestureSubscriber 2604 * @tc.type: FUNC 2605 * @tc.require: 2606 */ 2607 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_RemoveKeyGestureSubscriber_002, TestSize.Level1) 2608 { 2609 CALL_TEST_DEBUG; 2610 KeySubscriberHandler handler; 2611 int32_t subscribeId = 1; 2612 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2613 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2614 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2615 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2616 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2617 listSub.push_back(subscriber); 2618 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2619 EXPECT_EQ(handler.RemoveKeyGestureSubscriber(sess, subscribeId), RET_OK); 2620 } 2621 2622 /** 2623 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete_002 2624 * @tc.desc: Test OnSessionDelete 2625 * @tc.type: FUNC 2626 * @tc.require: 2627 */ 2628 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_002, TestSize.Level1) 2629 { 2630 CALL_TEST_DEBUG; 2631 KeySubscriberHandler handler; 2632 int32_t subscribeId = 1; 2633 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2634 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2635 2636 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2637 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2638 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2639 listSub.push_back(subscriber); 2640 2641 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2642 std::shared_ptr<KeySubscriberHandler::Subscriber> keySubscriber = 2643 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, session, keyOption); 2644 listSub.push_back(keySubscriber); 2645 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2646 EXPECT_NO_FATAL_FAILURE(handler.OnSessionDelete(session)); 2647 } 2648 2649 /** 2650 * @tc.name: KeySubscriberHandlerTest_OnSessionDelete_003 2651 * @tc.desc: Test OnSessionDelete 2652 * @tc.type: FUNC 2653 * @tc.require: 2654 */ 2655 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_OnSessionDelete_003, TestSize.Level1) 2656 { 2657 CALL_TEST_DEBUG; 2658 KeySubscriberHandler handler; 2659 int32_t subscribeId = 1; 2660 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2661 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2662 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2663 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2664 std::list<std::shared_ptr<KeySubscriberHandler::Subscriber>> listSub; 2665 handler.keyGestures_.insert(std::make_pair(keyOption, listSub)); 2666 EXPECT_NO_FATAL_FAILURE(handler.OnSessionDelete(sess)); 2667 } 2668 2669 /** 2670 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_03 2671 * @tc.desc: Test HandleKeyUpWithDelay 2672 * @tc.type: FUNC 2673 * @tc.require: 2674 */ 2675 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_03, TestSize.Level1) 2676 { 2677 CALL_TEST_DEBUG; 2678 KeySubscriberHandler handler; 2679 int32_t subscribeId = 1; 2680 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2681 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2682 keyOption->SetFinalKeyUpDelay(-1); 2683 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2684 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2685 std::shared_ptr<KeyEvent> keyEvent = nullptr; 2686 EXPECT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 2687 } 2688 2689 /** 2690 * @tc.name: KeySubscriberHandlerTest_HandleKeyUpWithDelay_04 2691 * @tc.desc: Test HandleKeyUpWithDelay 2692 * @tc.type: FUNC 2693 * @tc.require: 2694 */ 2695 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_HandleKeyUpWithDelay_04, TestSize.Level1) 2696 { 2697 CALL_TEST_DEBUG; 2698 KeySubscriberHandler handler; 2699 int32_t subscribeId = 1; 2700 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2701 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2702 keyOption->SetFinalKeyUpDelay(100); 2703 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2704 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2705 std::shared_ptr<KeyEvent> keyEvent = nullptr; 2706 EXPECT_NO_FATAL_FAILURE(handler.HandleKeyUpWithDelay(keyEvent, subscriber)); 2707 } 2708 2709 /** 2710 * @tc.name: KeySubscriberHandlerTest_DumpSubscriber 2711 * @tc.desc: Test DumpSubscriber 2712 * @tc.type: FUNC 2713 * @tc.require: 2714 */ 2715 HWTEST_F(KeySubscriberHandlerTest, KeySubscriberHandlerTest_DumpSubscriber, TestSize.Level1) 2716 { 2717 CALL_TEST_DEBUG; 2718 KeySubscriberHandler handler; 2719 int32_t subscribeId = 1; 2720 SessionPtr sess = std::make_shared<UDSSession>(PROGRAM_NAME, MODULE_TYPE, UDS_FD, UDS_UID, UDS_PID); 2721 std::shared_ptr<KeyOption> keyOption = std::make_shared<KeyOption>(); 2722 keyOption->SetFinalKeyUpDelay(100); 2723 std::shared_ptr<KeySubscriberHandler::Subscriber> subscriber = 2724 std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, keyOption); 2725 int32_t fd = 100; 2726 EXPECT_NO_FATAL_FAILURE(handler.DumpSubscriber(fd, subscriber)); 2727 2728 std::shared_ptr<KeyOption> option = std::make_shared<KeyOption>(); 2729 std::set<int32_t> preKeys = { 2020, 2021 }; 2730 option->SetPreKeys(preKeys); 2731 subscriber = std::make_shared<KeySubscriberHandler::Subscriber>(subscribeId, sess, option); 2732 EXPECT_NO_FATAL_FAILURE(handler.DumpSubscriber(fd, subscriber)); 2733 } 2734 } // namespace MMI 2735 } // namespace OHOS 2736