1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #define private public 16 #define protected public 17 18 #include <gtest/gtest.h> 19 20 #include "anr_manager.h" 21 #include "define_multimodal.h" 22 #include "event_dispatch_handler.h" 23 #include "i_input_windows_manager.h" 24 #include "input_event_handler.h" 25 26 #undef protected 27 #undef private 28 namespace OHOS { 29 namespace MMI { 30 namespace { 31 using namespace testing::ext; 32 constexpr int32_t UID_ROOT { 0 }; 33 static constexpr char PROGRAM_NAME[] { "uds_sesion_test" }; 34 int32_t g_moduleType { 3 }; 35 int32_t g_pid { 0 }; 36 int32_t g_writeFd { -1 }; 37 } // namespace 38 39 class EventDispatchTest : public testing::Test { 40 public: SetUpTestCase(void)41 static void SetUpTestCase(void) {} TearDownTestCase(void)42 static void TearDownTestCase(void) {} 43 }; 44 45 /** 46 * @tc.name: EventDispatchTest_SearchWindow_001 47 * @tc.desc: Test the function SearchWindow 48 * @tc.type: FUNC 49 * @tc.require: 50 */ 51 HWTEST_F(EventDispatchTest, EventDispatchTest_SearchWindow_001, TestSize.Level1) 52 { 53 EventDispatchHandler edh; 54 WindowInfo info; 55 auto windowInfo1 = std::make_shared<WindowInfo>(info); 56 windowInfo1->id = 1; 57 auto windowInfo2 = std::make_shared<WindowInfo>(info); 58 windowInfo2->id = 2; 59 auto windowInfo3 = std::make_shared<WindowInfo>(info); 60 windowInfo3->id = 3; 61 auto windowInfo4 = std::make_shared<WindowInfo>(info); 62 windowInfo4->id = 4; 63 std::vector<std::shared_ptr<WindowInfo>> windowList; 64 windowList.push_back(windowInfo1); 65 windowList.push_back(windowInfo2); 66 windowList.push_back(windowInfo3); 67 EXPECT_TRUE(edh.SearchWindow(windowList, windowInfo2)); 68 EXPECT_TRUE(edh.SearchWindow(windowList, windowInfo3)); 69 EXPECT_FALSE(edh.SearchWindow(windowList, windowInfo4)); 70 } 71 72 /** 73 * @tc.name: EventDispatchTest_DispatchKeyEvent_01 74 * @tc.desc: Test DispatchKeyEvent 75 * @tc.type: FUNC 76 * @tc.require: 77 */ 78 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEvent_01, TestSize.Level1) 79 { 80 EventDispatchHandler dispatch; 81 UDSServer udsServer; 82 int32_t fd; 83 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 84 ASSERT_NE(keyEvent, nullptr); 85 86 int32_t currentTime = dispatch.currentTime_; 87 int32_t eventTime = dispatch.eventTime_; 88 int32_t INTERVAL_TIME = 3000; 89 currentTime = 6000; 90 eventTime = 1000; 91 EXPECT_TRUE(currentTime - eventTime > INTERVAL_TIME); 92 fd = -1; 93 int32_t ret = dispatch.DispatchKeyEvent(fd, udsServer, keyEvent); 94 EXPECT_EQ(ret, RET_ERR); 95 } 96 97 /** 98 * @tc.name: EventDispatchTest_DispatchKeyEvent_02 99 * @tc.desc: Test DispatchKeyEvent 100 * @tc.type: FUNC 101 * @tc.require: 102 */ 103 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEvent_02, TestSize.Level1) 104 { 105 EventDispatchHandler dispatch; 106 UDSServer udsServer; 107 int32_t fd; 108 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 109 ASSERT_NE(keyEvent, nullptr); 110 111 int32_t currentTime = dispatch.currentTime_; 112 int32_t eventTime = dispatch.eventTime_; 113 int32_t INTERVAL_TIME = 3000; 114 currentTime = 2000; 115 eventTime = 1000; 116 EXPECT_FALSE(currentTime - eventTime > INTERVAL_TIME); 117 fd = 1; 118 int32_t ret = dispatch.DispatchKeyEvent(fd, udsServer, keyEvent); 119 EXPECT_EQ(ret, RET_ERR); 120 } 121 122 /** 123 * @tc.name: EventDispatchTest_DispatchKeyEvent_03 124 * @tc.desc: Test DispatchKeyEvent 125 * @tc.type: FUNC 126 * @tc.require: 127 */ 128 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEvent_03, TestSize.Level1) 129 { 130 EventDispatchHandler dispatch; 131 UDSServer udsServer; 132 int32_t fd = 2; 133 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 134 ASSERT_NE(keyEvent, nullptr); 135 auto currentTime = GetSysClockTime(); 136 auto session = udsServer.GetSession(fd); 137 138 bool ret1 = ANRMgr->TriggerANR(ANR_DISPATCH, currentTime, session); 139 EXPECT_FALSE(ret1); 140 int32_t ret2 = dispatch.DispatchKeyEvent(fd, udsServer, keyEvent); 141 EXPECT_EQ(ret2, RET_ERR); 142 } 143 144 /** 145 * @tc.name: EventDispatchTest_DispatchKeyEvent_04 146 * @tc.desc: Test DispatchKeyEvent 147 * @tc.type: FUNC 148 * @tc.require: 149 */ 150 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEvent_04, TestSize.Level1) 151 { 152 EventDispatchHandler dispatch; 153 UDSServer udsServer; 154 int32_t fd = -1; 155 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 156 ASSERT_NE(keyEvent, nullptr); 157 158 int32_t currentTime = dispatch.currentTime_; 159 int32_t eventTime = dispatch.eventTime_; 160 int32_t INTERVAL_TIME = 3000; 161 currentTime = 2000; 162 eventTime = 1000; 163 EXPECT_FALSE(currentTime - eventTime > INTERVAL_TIME); 164 165 auto currentTime1 = GetSysClockTime(); 166 auto session = udsServer.GetSession(fd); 167 bool ret1 = ANRMgr->TriggerANR(ANR_DISPATCH, currentTime1, session); 168 EXPECT_FALSE(ret1); 169 int32_t ret2 = dispatch.DispatchKeyEvent(fd, udsServer, keyEvent); 170 EXPECT_EQ(ret2, RET_ERR); 171 } 172 173 /** 174 * @tc.name: EventDispatchTest_DispatchKeyEvent_05 175 * @tc.desc: Test DispatchKeyEvent 176 * @tc.type: FUNC 177 * @tc.require: 178 */ 179 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEvent_05, TestSize.Level1) 180 { 181 EventDispatchHandler dispatch; 182 UDSServer udsServer; 183 int32_t fd = 2; 184 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 185 ASSERT_NE(keyEvent, nullptr); 186 auto currentTime = GetSysClockTime(); 187 auto session = udsServer.GetSession(fd); 188 bool ret1 = ANRMgr->TriggerANR(ANR_DISPATCH, currentTime, session); 189 EXPECT_FALSE(ret1); 190 NetPacket pkt(MmiMessageId::INVALID); 191 EXPECT_FALSE(pkt.ChkRWError()); 192 EXPECT_FALSE(udsServer.SendMsg(fd, pkt)); 193 int32_t ret2 = dispatch.DispatchKeyEvent(fd, udsServer, keyEvent); 194 EXPECT_EQ(ret2, RET_ERR); 195 } 196 197 /** 198 * @tc.name: FilterInvalidPointerItem_01 199 * @tc.desc: Test the function FilterInvalidPointerItem 200 * @tc.type: FUNC 201 * @tc.require: 202 */ 203 HWTEST_F(EventDispatchTest, FilterInvalidPointerItem_01, TestSize.Level1) 204 { 205 EventDispatchHandler eventdispatchhandler; 206 int32_t fd = 1; 207 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 208 ASSERT_NE(pointerEvent, nullptr); 209 210 std::vector<int32_t> pointerIdList; 211 pointerEvent->pointerId_ = 3; 212 pointerIdList.push_back(pointerEvent->pointerId_); 213 pointerEvent->pointerId_ = 5; 214 pointerIdList.push_back(pointerEvent->pointerId_); 215 EXPECT_TRUE(pointerIdList.size() > 1); 216 217 PointerEvent::PointerItem pointeritem; 218 pointeritem.SetWindowX(10); 219 pointeritem.SetWindowY(20); 220 pointeritem.SetTargetWindowId(2); 221 int32_t id = 1; 222 EXPECT_FALSE(pointerEvent->GetPointerItem(id, pointeritem)); 223 224 pointeritem.targetWindowId_ = 3; 225 auto itemPid = WIN_MGR->GetWindowPid(pointeritem.targetWindowId_); 226 EXPECT_FALSE(itemPid >= 0); 227 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(pointerEvent, fd)); 228 } 229 230 /** 231 * @tc.name: EventDispatchTest_AddFlagToEsc001 232 * @tc.desc: Test AddFlagToEsc 233 * @tc.type: FUNC 234 * @tc.require: 235 */ 236 HWTEST_F(EventDispatchTest, EventDispatchTest_AddFlagToEsc001, TestSize.Level0) 237 { 238 EventDispatchHandler dispatch; 239 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 240 ASSERT_NE(keyEvent, nullptr); 241 keyEvent->SetKeyCode(KeyEvent::KEYCODE_ESCAPE); 242 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 243 KeyEvent::KeyItem item; 244 keyEvent->AddPressedKeyItems(item); 245 EXPECT_EQ(keyEvent->GetKeyItems().size(), 1); 246 247 EXPECT_EQ(dispatch.escToBackFlag_, false); 248 dispatch.AddFlagToEsc(keyEvent); 249 EXPECT_EQ(dispatch.escToBackFlag_, true); 250 int32_t ret1 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 251 EXPECT_EQ(ret1, false); 252 253 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 254 dispatch.AddFlagToEsc(keyEvent); 255 EXPECT_EQ(dispatch.escToBackFlag_, false); 256 int32_t ret2 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 257 EXPECT_EQ(ret2, true); 258 259 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 260 dispatch.AddFlagToEsc(keyEvent); 261 EXPECT_EQ(dispatch.escToBackFlag_, true); 262 int32_t ret3 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 263 EXPECT_EQ(ret3, false); 264 265 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 266 dispatch.AddFlagToEsc(keyEvent); 267 EXPECT_EQ(dispatch.escToBackFlag_, false); 268 int32_t ret4 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 269 EXPECT_EQ(ret4, true); 270 } 271 272 /** 273 * @tc.name: EventDispatchTest_AddFlagToEsc002 274 * @tc.desc: Test AddFlagToEsc 275 * @tc.type: FUNC 276 * @tc.require: 277 */ 278 HWTEST_F(EventDispatchTest, EventDispatchTest_AddFlagToEsc002, TestSize.Level1) 279 { 280 EventDispatchHandler dispatch; 281 std::shared_ptr<KeyEvent> keyEvent = nullptr; 282 dispatch.AddFlagToEsc(keyEvent); 283 EXPECT_EQ(keyEvent, nullptr); 284 285 keyEvent = KeyEvent::Create(); 286 ASSERT_NE(keyEvent, nullptr); 287 keyEvent->SetKeyCode(KeyEvent::KEYCODE_A); 288 dispatch.AddFlagToEsc(keyEvent); 289 int32_t ret = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 290 EXPECT_EQ(ret, false); 291 EXPECT_EQ(dispatch.escToBackFlag_, false); 292 293 keyEvent->SetKeyCode(KeyEvent::KEYCODE_ESCAPE); 294 dispatch.AddFlagToEsc(keyEvent); 295 int32_t ret1 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 296 EXPECT_EQ(ret1, false); 297 EXPECT_EQ(dispatch.escToBackFlag_, false); 298 299 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 300 keyEvent->AddFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 301 EXPECT_TRUE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE)); 302 dispatch.AddFlagToEsc(keyEvent); 303 EXPECT_EQ(dispatch.escToBackFlag_, true); 304 int32_t ret2 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 305 EXPECT_EQ(ret2, false); 306 307 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 308 keyEvent->AddFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 309 EXPECT_TRUE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE)); 310 EXPECT_EQ(dispatch.escToBackFlag_, true); 311 dispatch.AddFlagToEsc(keyEvent); 312 EXPECT_EQ(dispatch.escToBackFlag_, true); 313 int32_t ret3 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 314 EXPECT_EQ(ret3, true); 315 } 316 317 /** 318 * @tc.name: EventDispatchTest_AddFlagToEsc003 319 * @tc.desc: Test AddFlagToEsc 320 * @tc.type: FUNC 321 * @tc.require: 322 */ 323 HWTEST_F(EventDispatchTest, EventDispatchTest_AddFlagToEsc003, TestSize.Level1) 324 { 325 EventDispatchHandler dispatch; 326 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 327 ASSERT_NE(keyEvent, nullptr); 328 keyEvent->SetKeyCode(KeyEvent::KEYCODE_ESCAPE); 329 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 330 KeyEvent::KeyItem item1; 331 KeyEvent::KeyItem item2; 332 keyEvent->AddPressedKeyItems(item1); 333 keyEvent->AddPressedKeyItems(item2); 334 EXPECT_EQ(keyEvent->GetKeyItems().size(), 2); 335 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE)); 336 337 dispatch.escToBackFlag_ = true; 338 dispatch.AddFlagToEsc(keyEvent); 339 int32_t ret1 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 340 EXPECT_EQ(ret1, false); 341 EXPECT_EQ(dispatch.escToBackFlag_, true); 342 343 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 344 EXPECT_EQ(keyEvent->GetKeyItems().size(), 2); 345 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE)); 346 347 dispatch.escToBackFlag_ = true; 348 dispatch.AddFlagToEsc(keyEvent); 349 int32_t ret2 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 350 EXPECT_EQ(ret2, false); 351 EXPECT_EQ(dispatch.escToBackFlag_, true); 352 } 353 354 /** 355 * @tc.name: EventDispatchTest_AddFlagToEsc004 356 * @tc.desc: Test AddFlagToEsc 357 * @tc.type: FUNC 358 * @tc.require: 359 */ 360 HWTEST_F(EventDispatchTest, EventDispatchTest_AddFlagToEsc004, TestSize.Level1) 361 { 362 EventDispatchHandler dispatch; 363 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 364 ASSERT_NE(keyEvent, nullptr); 365 keyEvent->SetKeyCode(KeyEvent::KEYCODE_ESCAPE); 366 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 367 KeyEvent::KeyItem item; 368 keyEvent->AddPressedKeyItems(item); 369 EXPECT_EQ(keyEvent->GetKeyItems().size(), 1); 370 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE)); 371 372 dispatch.escToBackFlag_ = false; 373 dispatch.AddFlagToEsc(keyEvent); 374 int32_t ret1 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 375 EXPECT_EQ(ret1, false); 376 EXPECT_EQ(dispatch.escToBackFlag_, false); 377 378 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 379 EXPECT_FALSE(keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE)); 380 381 dispatch.escToBackFlag_ = false; 382 dispatch.AddFlagToEsc(keyEvent); 383 int32_t ret2 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 384 EXPECT_EQ(ret2, false); 385 EXPECT_EQ(dispatch.escToBackFlag_, false); 386 } 387 388 /** 389 * @tc.name: EventDispatchTest_DispatchKeyEventPid_01 390 * @tc.desc: Test DispatchKeyEventPid 391 * @tc.type: FUNC 392 * @tc.require: 393 */ 394 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEventPid_01, TestSize.Level1) 395 { 396 EventDispatchHandler dispatch; 397 UDSServer udsServer; 398 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 399 ASSERT_NE(keyEvent, nullptr); 400 std::vector<std::pair<int32_t, TargetInfo>> vecTarget; 401 402 TargetInfo target1; 403 target1.privacyMode = SecureFlag::PRIVACY_MODE; 404 target1.id = 1; 405 target1.agentWindowId = 3; 406 vecTarget.push_back(std::make_pair(1, target1)); 407 408 TargetInfo target2; 409 target2.privacyMode = SecureFlag::PRIVACY_MODE; 410 target2.id = 2; 411 target2.agentWindowId = 5; 412 vecTarget.push_back(std::make_pair(2, target2)); 413 414 int32_t ret = dispatch.DispatchKeyEventPid(udsServer, keyEvent); 415 EXPECT_EQ(ret, RET_OK); 416 } 417 418 /** 419 * @tc.name: EventDispatchTest_DispatchKeyEventPid_02 420 * @tc.desc: Test DispatchKeyEventPid 421 * @tc.type: FUNC 422 * @tc.require: 423 */ 424 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEventPid_02, TestSize.Level1) 425 { 426 EventDispatchHandler dispatch; 427 UDSServer udsServer; 428 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 429 ASSERT_NE(keyEvent, nullptr); 430 std::vector<std::pair<int32_t, TargetInfo>> vecTarget; 431 432 TargetInfo target1; 433 target1.privacyMode = SecureFlag::DEFAULT_MODE; 434 target1.id = 2; 435 target1.agentWindowId = 5; 436 vecTarget.push_back(std::make_pair(1, target1)); 437 438 TargetInfo target2; 439 target2.privacyMode = SecureFlag::DEFAULT_MODE; 440 target2.id = 3; 441 target2.agentWindowId = 6; 442 vecTarget.push_back(std::make_pair(2, target2)); 443 444 int32_t ret = dispatch.DispatchKeyEventPid(udsServer, keyEvent); 445 EXPECT_EQ(ret, RET_OK); 446 } 447 448 /** 449 * @tc.name: DispatchPointerEventInner_01 450 * @tc.desc: Test DispatchKeyEvent 451 * @tc.type: FUNC 452 * @tc.require: 453 */ 454 HWTEST_F(EventDispatchTest, DispatchPointerEventInner_01, TestSize.Level1) 455 { 456 EventDispatchHandler dispatch; 457 UDSServer udsServer; 458 int32_t fd = 2; 459 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 460 ASSERT_NE(pointerEvent, nullptr); 461 auto currentTime = GetSysClockTime(); 462 auto session = udsServer.GetSession(fd); 463 bool ret = ANRMgr->TriggerANR(ANR_DISPATCH, currentTime, session); 464 EXPECT_FALSE(ret); 465 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 466 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 467 } 468 469 /** 470 * @tc.name: DispatchPointerEventInner_02 471 * @tc.desc: Test DispatchKeyEvent 472 * @tc.type: FUNC 473 * @tc.require: 474 */ 475 HWTEST_F(EventDispatchTest, DispatchPointerEventInner_02, TestSize.Level1) 476 { 477 EventDispatchHandler dispatch; 478 UDSServer udsServer; 479 int32_t fd = 3; 480 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 481 ASSERT_NE(pointerEvent, nullptr); 482 auto currentTime = GetSysClockTime(); 483 auto session = udsServer.GetSession(fd); 484 bool ret = ANRMgr->TriggerANR(ANR_DISPATCH, currentTime, session); 485 EXPECT_FALSE(ret); 486 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 487 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 488 } 489 490 /** 491 * @tc.name: DispatchPointerEventInner_03 492 * @tc.desc: Test DispatchKeyEvent 493 * @tc.type: FUNC 494 * @tc.require: 495 */ 496 HWTEST_F(EventDispatchTest, DispatchPointerEventInner_03, TestSize.Level1) 497 { 498 EventDispatchHandler dispatch; 499 UDSServer udsServer; 500 int32_t fd = 3; 501 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 502 ASSERT_NE(pointerEvent, nullptr); 503 auto currentTime = GetSysClockTime(); 504 auto session = udsServer.GetSession(fd); 505 bool ret = ANRMgr->TriggerANR(ANR_DISPATCH, currentTime, session); 506 EXPECT_FALSE(ret); 507 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_DOWN; 508 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 509 } 510 511 /** 512 * @tc.name: DispatchPointerEventInner_04 513 * @tc.desc: Test DispatchKeyEvent 514 * @tc.type: FUNC 515 * @tc.require: 516 */ 517 HWTEST_F(EventDispatchTest, DispatchPointerEventInner_04, TestSize.Level1) 518 { 519 EventDispatchHandler dispatch; 520 UDSServer udsServer; 521 int32_t fd = 3; 522 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 523 ASSERT_NE(pointerEvent, nullptr); 524 auto currentTime = GetSysClockTime(); 525 auto session = udsServer.GetSession(fd); 526 bool ret = ANRMgr->TriggerANR(ANR_DISPATCH, currentTime, session); 527 EXPECT_FALSE(ret); 528 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_UP; 529 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 530 } 531 532 /** 533 * @tc.name: DispatchPointerEventInner_05 534 * @tc.desc: Test DispatchKeyEvent 535 * @tc.type: FUNC 536 * @tc.require: 537 */ 538 HWTEST_F(EventDispatchTest, DispatchPointerEventInner_05, TestSize.Level1) 539 { 540 EventDispatchHandler dispatch; 541 UDSServer udsServer; 542 int32_t fd = 3; 543 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 544 ASSERT_NE(pointerEvent, nullptr); 545 auto currentTime = GetSysClockTime(); 546 auto session = udsServer.GetSession(fd); 547 bool ret = ANRMgr->TriggerANR(ANR_DISPATCH, currentTime, session); 548 EXPECT_FALSE(ret); 549 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE; 550 551 NetPacket pkt(MmiMessageId::INVALID); 552 EXPECT_FALSE(udsServer.SendMsg(fd, pkt)); 553 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 554 } 555 556 /** 557 * @tc.name: EventDispatchTest_HandleTouchEvent_001 558 * @tc.desc: Test the function HandleTouchEvent 559 * @tc.type: FUNC 560 * @tc.require: 561 */ 562 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleTouchEvent_001, TestSize.Level1) 563 { 564 EventDispatchHandler eventdispatchhandler; 565 int32_t eventType = 3; 566 std::shared_ptr<PointerEvent> sharedPointerEvent = std::make_shared<PointerEvent>(eventType); 567 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleTouchEvent(sharedPointerEvent)); 568 } 569 570 /** 571 * @tc.name: EventDispatchTest_FilterInvalidPointerItem_001 572 * @tc.desc: Test the function FilterInvalidPointerItem 573 * @tc.type: FUNC 574 * @tc.require: 575 */ 576 HWTEST_F(EventDispatchTest, EventDispatchTest_FilterInvalidPointerItem_001, TestSize.Level1) 577 { 578 EventDispatchHandler eventdispatchhandler; 579 int32_t fd = 1; 580 int32_t eventType = 3; 581 std::shared_ptr<PointerEvent> sharedPointerEvent = std::make_shared<PointerEvent>(eventType); 582 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(sharedPointerEvent, fd)); 583 } 584 585 /** 586 * @tc.name: EventDispatchTest_FilterInvalidPointerItem_002 587 * @tc.desc: Test the function FilterInvalidPointerItem 588 * @tc.type: FUNC 589 * @tc.require: 590 */ 591 HWTEST_F(EventDispatchTest, EventDispatchTest_FilterInvalidPointerItem_002, TestSize.Level1) 592 { 593 EventDispatchHandler eventdispatchhandler; 594 int32_t fd = 1; 595 int32_t eventType = 3; 596 std::shared_ptr<PointerEvent> sharedPointerEvent = std::make_shared<PointerEvent>(eventType); 597 EXPECT_NE(sharedPointerEvent, nullptr); 598 599 std::vector<int32_t> pointerIdList; 600 pointerIdList.push_back(1); 601 pointerIdList.push_back(2); 602 EXPECT_TRUE(pointerIdList.size() > 1); 603 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(sharedPointerEvent, fd)); 604 } 605 606 /** 607 * @tc.name: EventDispatchTest_FilterInvalidPointerItem_003 608 * @tc.desc: Test the function FilterInvalidPointerItem 609 * @tc.type: FUNC 610 * @tc.require: 611 */ 612 HWTEST_F(EventDispatchTest, EventDispatchTest_FilterInvalidPointerItem_003, TestSize.Level1) 613 { 614 EventDispatchHandler eventdispatchhandler; 615 int32_t fd = 1; 616 int32_t eventType = 3; 617 std::shared_ptr<PointerEvent> sharedPointerEvent = std::make_shared<PointerEvent>(eventType); 618 EXPECT_NE(sharedPointerEvent, nullptr); 619 620 std::vector<int32_t> pointerIdList; 621 pointerIdList.push_back(1); 622 pointerIdList.push_back(2); 623 pointerIdList.push_back(3); 624 EXPECT_TRUE(pointerIdList.size() > 1); 625 626 int32_t itemPid = 5; 627 EXPECT_TRUE(itemPid >= 0); 628 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(sharedPointerEvent, fd)); 629 } 630 631 /** 632 * @tc.name: EventDispatchTest_HandleMultiWindowPointerEvent_001 633 * @tc.desc: Test HandleMultiWindowPointerEvent 634 * @tc.type: FUNC 635 * @tc.require: 636 */ 637 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleMultiWindowPointerEvent_001, TestSize.Level1) 638 { 639 EventDispatchHandler eventdispatchhandler; 640 int32_t eventType = 3; 641 std::shared_ptr<PointerEvent> point = std::make_shared<PointerEvent>(eventType); 642 EXPECT_NE(point, nullptr); 643 644 std::vector<int32_t> windowIds; 645 windowIds.push_back(1); 646 windowIds.push_back(2); 647 windowIds.push_back(3); 648 649 PointerEvent::PointerItem pointerItem; 650 pointerItem.SetWindowX(10); 651 pointerItem.SetWindowY(20); 652 pointerItem.SetTargetWindowId(2); 653 654 std::optional<WindowInfo> windowInfo; 655 windowInfo = std::nullopt; 656 EXPECT_TRUE(windowInfo == std::nullopt); 657 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 658 } 659 660 /** 661 * @tc.name: EventDispatchTest_HandleMultiWindowPointerEvent_002 662 * @tc.desc: Test HandleMultiWindowPointerEvent 663 * @tc.type: FUNC 664 * @tc.require: 665 */ 666 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleMultiWindowPointerEvent_002, TestSize.Level1) 667 { 668 EventDispatchHandler eventdispatchhandler; 669 int32_t eventType = 2; 670 std::shared_ptr<PointerEvent> point = std::make_shared<PointerEvent>(eventType); 671 EXPECT_NE(point, nullptr); 672 673 std::vector<int32_t> windowIds; 674 windowIds.push_back(1); 675 windowIds.push_back(2); 676 windowIds.push_back(3); 677 678 PointerEvent::PointerItem pointerItem; 679 pointerItem.SetWindowX(20); 680 pointerItem.SetWindowY(30); 681 pointerItem.SetTargetWindowId(3); 682 683 std::optional<WindowInfo> windowInfo; 684 EXPECT_TRUE(windowInfo->transform.empty()); 685 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 686 } 687 688 /** 689 * @tc.name: EventDispatchTest_HandleMultiWindowPointerEvent_003 690 * @tc.desc: Test HandleMultiWindowPointerEvent 691 * @tc.type: FUNC 692 * @tc.require: 693 */ 694 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleMultiWindowPointerEvent_003, TestSize.Level1) 695 { 696 EventDispatchHandler eventdispatchhandler; 697 int32_t eventType = 5; 698 std::shared_ptr<PointerEvent> point = std::make_shared<PointerEvent>(eventType); 699 EXPECT_NE(point, nullptr); 700 point->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 701 702 std::vector<int32_t> windowIds; 703 windowIds.push_back(1); 704 windowIds.push_back(2); 705 windowIds.push_back(3); 706 707 PointerEvent::PointerItem pointerItem; 708 pointerItem.SetWindowX(30); 709 pointerItem.SetWindowY(40); 710 pointerItem.SetTargetWindowId(5); 711 712 std::optional<WindowInfo> windowInfo; 713 windowInfo = std::nullopt; 714 int32_t windowId = 2; 715 bool ret = eventdispatchhandler.ReissueEvent(point, windowId, windowInfo); 716 EXPECT_FALSE(ret); 717 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 718 } 719 720 /** 721 * @tc.name: EventDispatchTest_HandleMultiWindowPointerEvent_004 722 * @tc.desc: Test HandleMultiWindowPointerEvent 723 * @tc.type: FUNC 724 * @tc.require: 725 */ 726 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleMultiWindowPointerEvent_004, TestSize.Level1) 727 { 728 EventDispatchHandler eventdispatchhandler; 729 int32_t eventType = 6; 730 std::shared_ptr<PointerEvent> point = std::make_shared<PointerEvent>(eventType); 731 EXPECT_NE(point, nullptr); 732 point->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 733 point->pointerId_ = 2; 734 735 std::vector<int32_t> windowIds; 736 windowIds.push_back(1); 737 windowIds.push_back(2); 738 windowIds.push_back(3); 739 740 PointerEvent::PointerItem pointerItem; 741 pointerItem.SetWindowX(40); 742 pointerItem.SetWindowY(50); 743 pointerItem.SetTargetWindowId(5); 744 745 std::optional<WindowInfo> windowInfo; 746 windowInfo = std::nullopt; 747 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 748 } 749 750 /** 751 * @tc.name: EventDispatchTest_HandleMultiWindowPointerEvent_005 752 * @tc.desc: Test HandleMultiWindowPointerEvent 753 * @tc.type: FUNC 754 * @tc.require: 755 */ 756 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleMultiWindowPointerEvent_005, TestSize.Level1) 757 { 758 EventDispatchHandler eventdispatchhandler; 759 int32_t eventType = 6; 760 std::shared_ptr<PointerEvent> point = std::make_shared<PointerEvent>(eventType); 761 EXPECT_NE(point, nullptr); 762 point->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_UP; 763 764 std::vector<int32_t> windowIds; 765 windowIds.push_back(1); 766 windowIds.push_back(2); 767 windowIds.push_back(3); 768 769 PointerEvent::PointerItem pointerItem; 770 pointerItem.SetWindowX(45); 771 pointerItem.SetWindowY(55); 772 pointerItem.SetTargetWindowId(3); 773 774 std::optional<WindowInfo> windowInfo; 775 windowInfo = std::nullopt; 776 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 777 } 778 779 /** 780 * @tc.name: EventDispatchTest_HandleMultiWindowPointerEvent_006 781 * @tc.desc: Test HandleMultiWindowPointerEvent 782 * @tc.type: FUNC 783 * @tc.require: 784 */ 785 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleMultiWindowPointerEvent_006, TestSize.Level1) 786 { 787 EventDispatchHandler eventdispatchhandler; 788 int32_t eventType = 6; 789 std::shared_ptr<PointerEvent> point = std::make_shared<PointerEvent>(eventType); 790 EXPECT_NE(point, nullptr); 791 point->pointerAction_ = PointerEvent::POINTER_ACTION_CANCEL; 792 793 std::vector<int32_t> windowIds; 794 windowIds.push_back(1); 795 windowIds.push_back(2); 796 windowIds.push_back(3); 797 798 PointerEvent::PointerItem pointerItem; 799 pointerItem.SetWindowX(35); 800 pointerItem.SetWindowY(50); 801 pointerItem.SetTargetWindowId(2); 802 803 std::optional<WindowInfo> windowInfo; 804 windowInfo = std::nullopt; 805 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 806 } 807 808 /** 809 * @tc.name: EventDispatchTest_NotifyPointerEventToRS_001 810 * @tc.desc: Test the function NotifyPointerEventToRS 811 * @tc.type: FUNC 812 * @tc.require: 813 */ 814 HWTEST_F(EventDispatchTest, EventDispatchTest_NotifyPointerEventToRS_001, TestSize.Level1) 815 { 816 EventDispatchHandler eventdispatchhandler; 817 int32_t action = 1; 818 std::string name = "ExampleProgram"; 819 uint32_t processId = 12345; 820 int32_t touchCnt = 0; 821 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.NotifyPointerEventToRS(action, name, processId, touchCnt)); 822 } 823 824 /** 825 * @tc.name: EventDispatchTest_HandlePointerEventInner_001 826 * @tc.desc: Test the function HandlePointerEventInner 827 * @tc.type: FUNC 828 * @tc.require: 829 */ 830 HWTEST_F(EventDispatchTest, EventDispatchTest_HandlePointerEventInner_001, TestSize.Level1) 831 { 832 EventDispatchHandler eventdispatchhandler; 833 int32_t eventType = 3; 834 PointerEvent* pointerEvent = new PointerEvent(eventType); 835 std::shared_ptr<PointerEvent> sharedPointerEvent(pointerEvent); 836 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandlePointerEventInner(sharedPointerEvent)); 837 } 838 839 /** 840 * @tc.name: EventDispatchTest_HandlePointerEventInner_002 841 * @tc.desc: Test the function HandlePointerEventInner 842 * @tc.type: FUNC 843 * @tc.require: 844 */ 845 HWTEST_F(EventDispatchTest, EventDispatchTest_HandlePointerEventInner_002, TestSize.Level1) 846 { 847 EventDispatchHandler eventdispatchhandler; 848 int32_t eventType = 3; 849 std::shared_ptr<PointerEvent> point = std::make_shared<PointerEvent>(eventType); 850 EXPECT_NE(point, nullptr); 851 std::vector<int32_t> windowIds; 852 windowIds.push_back(1); 853 windowIds.push_back(2); 854 EXPECT_FALSE(windowIds.empty()); 855 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandlePointerEventInner(point)); 856 } 857 858 /** 859 * @tc.name: EventDispatchTest_HandlePointerEventInner_003 860 * @tc.desc: Test the function HandlePointerEventInner 861 * @tc.type: FUNC 862 * @tc.require: 863 */ 864 HWTEST_F(EventDispatchTest, EventDispatchTest_HandlePointerEventInner_003, TestSize.Level1) 865 { 866 EventDispatchHandler eventdispatchhandler; 867 int32_t eventType = 3; 868 std::shared_ptr<PointerEvent> pointerEvent = std::make_shared<PointerEvent>(eventType); 869 EXPECT_NE(pointerEvent, nullptr); 870 pointerEvent->SetPointerId(100); 871 PointerEvent::PointerItem pointerItem; 872 pointerItem.SetPointerId(100); 873 pointerEvent->AddPointerItem(pointerItem); 874 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandlePointerEventInner(pointerEvent)); 875 } 876 877 #ifdef OHOS_BUILD_ENABLE_ONE_HAND_MODE 878 /** 879 * @tc.name: EventDispatchTest_ResetDisplayXY_001 880 * @tc.desc: Test the function ResetDisplayXY 881 * @tc.type: FUNC 882 * @tc.require: 883 */ 884 HWTEST_F(EventDispatchTest, EventDispatchTest_ResetDisplayXY_001, TestSize.Level1) 885 { 886 EventDispatchHandler eventdispatchhandler; 887 int32_t eventType = 3; 888 std::shared_ptr<PointerEvent> pointerEvent = std::make_shared<PointerEvent>(eventType); 889 EXPECT_NE(pointerEvent, nullptr); 890 pointerEvent->SetPointerId(100); 891 pointerEvent->SetFixedMode(PointerEvent::FixedMode::AUTO); 892 PointerEvent::PointerItem pointerItem; 893 pointerItem.SetPointerId(100); 894 pointerEvent->AddPointerItem(pointerItem); 895 eventdispatchhandler.currentXY_.fixed = true;; 896 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.ResetDisplayXY(pointerEvent)); 897 } 898 899 /** 900 * @tc.name: EventDispatchTest_ResetDisplayXY_002 901 * @tc.desc: Test the function ResetDisplayXY 902 * @tc.type: FUNC 903 * @tc.require: 904 */ 905 HWTEST_F(EventDispatchTest, EventDispatchTest_ResetDisplayXY_002, TestSize.Level1) 906 { 907 EventDispatchHandler eventdispatchhandler; 908 int32_t eventType = 3; 909 std::shared_ptr<PointerEvent> pointerEvent = std::make_shared<PointerEvent>(eventType); 910 EXPECT_NE(pointerEvent, nullptr); 911 pointerEvent->SetPointerId(100); 912 pointerEvent->SetFixedMode(PointerEvent::FixedMode::AUTO); 913 PointerEvent::PointerItem pointerItem; 914 pointerItem.SetPointerId(100); 915 pointerEvent->AddPointerItem(pointerItem); 916 eventdispatchhandler.currentXY_.fixed = false;; 917 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.ResetDisplayXY(pointerEvent)); 918 } 919 920 /** 921 * @tc.name: EventDispatchTest_ResetDisplayXY_003 922 * @tc.desc: Test the function ResetDisplayXY 923 * @tc.type: FUNC 924 * @tc.require: 925 */ 926 HWTEST_F(EventDispatchTest, EventDispatchTest_ResetDisplayXY_003, TestSize.Level1) 927 { 928 EventDispatchHandler eventdispatchhandler; 929 int32_t eventType = 3; 930 std::shared_ptr<PointerEvent> pointerEvent = std::make_shared<PointerEvent>(eventType); 931 EXPECT_NE(pointerEvent, nullptr); 932 pointerEvent->SetPointerId(100); 933 pointerEvent->SetFixedMode(PointerEvent::FixedMode::NORMAL); 934 PointerEvent::PointerItem pointerItem; 935 pointerItem.SetPointerId(100); 936 pointerEvent->AddPointerItem(pointerItem); 937 eventdispatchhandler.currentXY_.fixed = false;; 938 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.ResetDisplayXY(pointerEvent)); 939 } 940 941 /** 942 * @tc.name: EventDispatchTest_ResetDisplayXY_004 943 * @tc.desc: Test the function ResetDisplayXY 944 * @tc.type: FUNC 945 * @tc.require: 946 */ 947 HWTEST_F(EventDispatchTest, EventDispatchTest_ResetDisplayXY_004, TestSize.Level1) 948 { 949 EventDispatchHandler eventdispatchhandler; 950 int32_t eventType = 3; 951 std::shared_ptr<PointerEvent> pointerEvent = std::make_shared<PointerEvent>(eventType); 952 EXPECT_NE(pointerEvent, nullptr); 953 pointerEvent->SetPointerId(100); 954 pointerEvent->SetFixedMode(PointerEvent::FixedMode::NORMAL); 955 PointerEvent::PointerItem pointerItem; 956 pointerItem.SetPointerId(100); 957 pointerEvent->AddPointerItem(pointerItem); 958 eventdispatchhandler.currentXY_.fixed = true;; 959 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.ResetDisplayXY(pointerEvent)); 960 } 961 962 /** 963 * @tc.name: EventDispatchTest_ResetDisplayXY_005 964 * @tc.desc: Test the function ResetDisplayXY 965 * @tc.type: FUNC 966 * @tc.require: 967 */ 968 HWTEST_F(EventDispatchTest, EventDispatchTest_ResetDisplayXY_005, TestSize.Level1) 969 { 970 EventDispatchHandler eventdispatchhandler; 971 int32_t eventType = 3; 972 std::shared_ptr<PointerEvent> pointerEvent = std::make_shared<PointerEvent>(eventType); 973 EXPECT_NE(pointerEvent, nullptr); 974 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.ResetDisplayXY(pointerEvent)); 975 } 976 #endif // OHOS_BUILD_ENABLE_ONE_HAND_MODE 977 978 /** 979 * @tc.name: EventDispatchTest_DispatchKeyEventPid_001 980 * @tc.desc: Test the function DispatchKeyEventPid 981 * @tc.type: FUNC 982 * @tc.require: 983 */ 984 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEventPid_001, TestSize.Level1) 985 { 986 EventDispatchHandler eventdispatchhandler; 987 UDSServer udsServer; 988 int32_t keyevent = 3; 989 KeyEvent* keyEvent = new KeyEvent(keyevent); 990 std::shared_ptr<KeyEvent> sharedKeyEvent(keyEvent); 991 int32_t ret = eventdispatchhandler.DispatchKeyEventPid(udsServer, sharedKeyEvent); 992 EXPECT_EQ(ret, RET_OK); 993 } 994 995 /** 996 * @tc.name: EventDispatchTest_AcquireEnableMark 997 * @tc.desc: Test Acquire Enable Mark 998 * @tc.type: FUNC 999 * @tc.require: 1000 */ 1001 HWTEST_F(EventDispatchTest, EventDispatchTest_AcquireEnableMark, TestSize.Level1) 1002 { 1003 EventDispatchHandler dispatch; 1004 std::shared_ptr<PointerEvent> event = PointerEvent::Create(); 1005 ASSERT_NE(event, nullptr); 1006 event->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE); 1007 ASSERT_FALSE(dispatch.AcquireEnableMark(event)); 1008 event->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1009 ASSERT_TRUE(dispatch.AcquireEnableMark(event)); 1010 } 1011 1012 /** 1013 * @tc.name: EventDispatchTest_DispatchPointerEventInner_001 1014 * @tc.desc: Test Dispatch Pointer Event Inner 1015 * @tc.type: FUNC 1016 * @tc.require: 1017 */ 1018 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_001, TestSize.Level1) 1019 { 1020 EventDispatchHandler dispatch; 1021 int32_t fd = -1; 1022 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1023 ASSERT_NE(pointerEvent, nullptr); 1024 dispatch.eventTime_ = 1000; 1025 pointerEvent->SetActionTime(5000); 1026 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 1027 } 1028 1029 /** 1030 * @tc.name: EventDispatchTest_DispatchPointerEventInner_002 1031 * @tc.desc: Test Dispatch Pointer Event Inner 1032 * @tc.type: FUNC 1033 * @tc.require: 1034 */ 1035 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_002, TestSize.Level1) 1036 { 1037 EventDispatchHandler dispatch; 1038 int32_t fd = -1; 1039 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1040 ASSERT_NE(pointerEvent, nullptr); 1041 int32_t currentTime = dispatch.currentTime_; 1042 int32_t eventTime = dispatch.eventTime_; 1043 int32_t INTERVAL_TIME = 3000; 1044 currentTime = 6000; 1045 eventTime = 1000; 1046 EXPECT_TRUE(currentTime - eventTime > INTERVAL_TIME); 1047 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 1048 } 1049 1050 /** 1051 * @tc.name: EventDispatchTest_DispatchPointerEventInner_003 1052 * @tc.desc: Test Dispatch Pointer Event Inner 1053 * @tc.type: FUNC 1054 * @tc.require: 1055 */ 1056 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_003, TestSize.Level1) 1057 { 1058 EventDispatchHandler dispatch; 1059 int32_t fd = 1; 1060 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1061 ASSERT_NE(point, nullptr); 1062 int32_t pointerAction; 1063 pointerAction = PointerEvent::POINTER_ACTION_DOWN; 1064 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(point, fd)); 1065 } 1066 1067 /** 1068 * @tc.name: EventDispatchTest_DispatchPointerEventInner_004 1069 * @tc.desc: Test Dispatch Pointer Event Inner 1070 * @tc.type: FUNC 1071 * @tc.require: 1072 */ 1073 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_004, TestSize.Level1) 1074 { 1075 EventDispatchHandler dispatch; 1076 SessionPtr sess = nullptr; 1077 int32_t fd = 1; 1078 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1079 ASSERT_NE(pointerEvent, nullptr); 1080 1081 int32_t type = 0; 1082 int64_t time = 3000; 1083 sess = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid); 1084 bool ret = ANRMgr->TriggerANR(type, time, sess); 1085 EXPECT_FALSE(ret); 1086 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 1087 } 1088 1089 /** 1090 * @tc.name: EventDispatchTest_DispatchPointerEventInner_005 1091 * @tc.desc: Test Dispatch Pointer Event Inner 1092 * @tc.type: FUNC 1093 * @tc.require: 1094 */ 1095 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_005, TestSize.Level1) 1096 { 1097 EventDispatchHandler dispatch; 1098 SessionPtr sess = nullptr; 1099 int32_t fd = 1; 1100 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1101 ASSERT_NE(pointerEvent, nullptr); 1102 1103 int32_t type = 0; 1104 int64_t time = 3000; 1105 sess = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid); 1106 bool ret = ANRMgr->TriggerANR(type, time, sess); 1107 EXPECT_FALSE(ret); 1108 1109 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 1110 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 1111 } 1112 1113 /** 1114 * @tc.name: EventDispatchTest_DispatchPointerEventInner_006 1115 * @tc.desc: Test Dispatch Pointer Event Inner 1116 * @tc.type: FUNC 1117 * @tc.require: 1118 */ 1119 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_006, TestSize.Level1) 1120 { 1121 EventDispatchHandler dispatch; 1122 SessionPtr sess = nullptr; 1123 int32_t fd = 2; 1124 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1125 ASSERT_NE(pointerEvent, nullptr); 1126 1127 int32_t type = 0; 1128 int64_t time = 3000; 1129 sess = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid); 1130 bool ret = ANRMgr->TriggerANR(type, time, sess); 1131 EXPECT_FALSE(ret); 1132 1133 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 1134 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 1135 } 1136 1137 /** 1138 * @tc.name: EventDispatchTest_DispatchPointerEventInner_007 1139 * @tc.desc: Test Dispatch Pointer Event Inner 1140 * @tc.type: FUNC 1141 * @tc.require: 1142 */ 1143 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_007, TestSize.Level1) 1144 { 1145 EventDispatchHandler dispatch; 1146 SessionPtr sess = nullptr; 1147 int32_t fd = 2; 1148 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1149 ASSERT_NE(pointerEvent, nullptr); 1150 1151 int32_t type = 0; 1152 int64_t time = 3000; 1153 sess = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid); 1154 bool ret = ANRMgr->TriggerANR(type, time, sess); 1155 EXPECT_FALSE(ret); 1156 1157 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_DOWN; 1158 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 1159 } 1160 1161 /** 1162 * @tc.name: EventDispatchTest_DispatchPointerEventInner_008 1163 * @tc.desc: Test Dispatch Pointer Event Inner 1164 * @tc.type: FUNC 1165 * @tc.require: 1166 */ 1167 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_008, TestSize.Level1) 1168 { 1169 EventDispatchHandler dispatch; 1170 SessionPtr sess = nullptr; 1171 int32_t fd = 2; 1172 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1173 ASSERT_NE(pointerEvent, nullptr); 1174 1175 int32_t type = 0; 1176 int64_t time = 3000; 1177 sess = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid); 1178 bool ret = ANRMgr->TriggerANR(type, time, sess); 1179 EXPECT_FALSE(ret); 1180 1181 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_UP; 1182 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 1183 } 1184 1185 /** 1186 * @tc.name: EventDispatchTest_DispatchPointerEventInner_009 1187 * @tc.desc: Test Dispatch Pointer Event Inner 1188 * @tc.type: FUNC 1189 * @tc.require: 1190 */ 1191 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_009, TestSize.Level1) 1192 { 1193 EventDispatchHandler dispatch; 1194 SessionPtr sess = nullptr; 1195 int32_t fd = 2; 1196 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1197 ASSERT_NE(pointerEvent, nullptr); 1198 1199 int32_t type = 0; 1200 int64_t time = 3000; 1201 sess = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid); 1202 bool ret = ANRMgr->TriggerANR(type, time, sess); 1203 EXPECT_FALSE(ret); 1204 1205 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE; 1206 ASSERT_NO_FATAL_FAILURE(dispatch.DispatchPointerEventInner(pointerEvent, fd)); 1207 } 1208 1209 /** 1210 * @tc.name: EventDispatchTest_DispatchKeyEventPid_002 1211 * @tc.desc: Test Dispatch Key Event Pid 1212 * @tc.type: FUNC 1213 * @tc.require: 1214 */ 1215 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEventPid_002, TestSize.Level1) 1216 { 1217 EventDispatchHandler dispatch; 1218 UDSServer udsServer; 1219 std::shared_ptr<KeyEvent> KeyEvent = KeyEvent::Create(); 1220 ASSERT_NE(KeyEvent, nullptr); 1221 dispatch.eventTime_ = 1000; 1222 KeyEvent->SetActionTime(5000); 1223 ASSERT_EQ(dispatch.DispatchKeyEventPid(udsServer, KeyEvent), RET_OK); 1224 } 1225 1226 /** 1227 * @tc.name: EventDispatchTest_DispatchKeyEventPid_003 1228 * @tc.desc: Test DispatchKeyEventPid 1229 * @tc.type: FUNC 1230 * @tc.require: 1231 */ 1232 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEventPid_003, TestSize.Level1) 1233 { 1234 EventDispatchHandler dispatch; 1235 UDSServer udsServer; 1236 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1237 ASSERT_NE(keyEvent, nullptr); 1238 int32_t currentTime = dispatch.currentTime_; 1239 int32_t eventTime = dispatch.eventTime_; 1240 int32_t INTERVAL_TIME = 3000; 1241 currentTime = 6000; 1242 eventTime = 1000; 1243 EXPECT_TRUE(currentTime - eventTime > INTERVAL_TIME); 1244 int32_t ret = dispatch.DispatchKeyEventPid(udsServer, keyEvent); 1245 EXPECT_EQ(ret, RET_OK); 1246 } 1247 1248 /** 1249 * @tc.name: EventDispatchTest_DispatchKeyEventPid_004 1250 * @tc.desc: Test DispatchKeyEventPid 1251 * @tc.type: FUNC 1252 * @tc.require: 1253 */ 1254 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEventPid_004, TestSize.Level1) 1255 { 1256 EventDispatchHandler dispatch; 1257 UDSServer udsServer; 1258 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1259 ASSERT_NE(keyEvent, nullptr); 1260 1261 NetPacket pkt(MmiMessageId::INVALID); 1262 EXPECT_FALSE(pkt.ChkRWError()); 1263 int32_t ret = dispatch.DispatchKeyEventPid(udsServer, keyEvent); 1264 EXPECT_EQ(ret, RET_OK); 1265 } 1266 1267 /** 1268 * @tc.name: EventDispatchTest_DispatchKeyEventPid_005 1269 * @tc.desc: Test DispatchKeyEventPid 1270 * @tc.type: FUNC 1271 * @tc.require: 1272 */ 1273 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEventPid_005, TestSize.Level1) 1274 { 1275 EventDispatchHandler dispatch; 1276 UDSServer udsServer; 1277 SessionPtr sess = nullptr; 1278 std::shared_ptr<KeyEvent> KeyEvent = KeyEvent::Create(); 1279 ASSERT_NE(KeyEvent, nullptr); 1280 dispatch.eventTime_ = 1000; 1281 KeyEvent->SetActionTime(2000); 1282 1283 int32_t type = 0; 1284 int64_t time = 2000; 1285 sess = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid); 1286 bool ret = ANRMgr->TriggerANR(type, time, sess); 1287 EXPECT_FALSE(ret); 1288 1289 ASSERT_EQ(dispatch.DispatchKeyEventPid(udsServer, KeyEvent), RET_OK); 1290 } 1291 1292 /** 1293 * @tc.name: EventDispatchTest_ReissueEvent_001 1294 * @tc.desc: Test ReissueEvent 1295 * @tc.type: FUNC 1296 * @tc.require: 1297 */ 1298 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_001, TestSize.Level1) 1299 { 1300 EventDispatchHandler dispatch; 1301 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1302 ASSERT_NE(point, nullptr); 1303 point->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 1304 int32_t windowId = 100; 1305 std::optional<WindowInfo> windowInfo = std::nullopt; 1306 bool result = dispatch.ReissueEvent(point, windowId, windowInfo); 1307 EXPECT_FALSE(result); 1308 } 1309 1310 /** 1311 * @tc.name: EventDispatchTest_ReissueEvent_002 1312 * @tc.desc: Test ReissueEvent 1313 * @tc.type: FUNC 1314 * @tc.require: 1315 */ 1316 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_002, TestSize.Level1) 1317 { 1318 EventDispatchHandler dispatch; 1319 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1320 ASSERT_NE(point, nullptr); 1321 point->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 1322 int32_t windowId = 100; 1323 std::optional<WindowInfo> windowInfo = std::nullopt; 1324 bool result = dispatch.ReissueEvent(point, windowId, windowInfo); 1325 EXPECT_FALSE(result); 1326 } 1327 1328 /** 1329 * @tc.name: EventDispatchTest_ReissueEvent_003 1330 * @tc.desc: Test ReissueEvent 1331 * @tc.type: FUNC 1332 * @tc.require: 1333 */ 1334 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_003, TestSize.Level1) 1335 { 1336 EventDispatchHandler handler; 1337 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1338 ASSERT_NE(point, nullptr); 1339 point->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 1340 int32_t windowId = 1; 1341 point->pointerId_ = 1; 1342 point->SetPointerId(point->pointerId_); 1343 std::optional<WindowInfo> windowInfo = std::nullopt; 1344 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1345 windowInfo1->id = 1; 1346 handler.cancelEventList_[1].push_back(windowInfo1); 1347 bool result = handler.ReissueEvent(point, windowId, windowInfo); 1348 EXPECT_TRUE(result); 1349 } 1350 1351 /** 1352 * @tc.name: EventDispatchTest_ReissueEvent_004 1353 * @tc.desc: Test ReissueEvent 1354 * @tc.type: FUNC 1355 * @tc.require: 1356 */ 1357 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_004, TestSize.Level1) 1358 { 1359 EventDispatchHandler handler; 1360 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1361 ASSERT_NE(point, nullptr); 1362 point->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 1363 int32_t windowId = 1; 1364 point->pointerId_ = 1; 1365 point->SetPointerId(point->pointerId_); 1366 std::optional<WindowInfo> windowInfo = std::nullopt; 1367 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1368 windowInfo1->id = 1; 1369 handler.cancelEventList_[1].push_back(windowInfo1); 1370 bool result = handler.ReissueEvent(point, windowId, windowInfo); 1371 EXPECT_FALSE(result); 1372 } 1373 1374 /** 1375 * @tc.name: EventDispatchTest_ReissueEvent_005 1376 * @tc.desc: Test ReissueEvent 1377 * @tc.type: FUNC 1378 * @tc.require: 1379 */ 1380 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_005, TestSize.Level1) 1381 { 1382 EventDispatchHandler dispatch; 1383 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1384 ASSERT_NE(point, nullptr); 1385 point->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 1386 int32_t windowId = 100; 1387 std::optional<WindowInfo> windowInfo = std::make_optional<WindowInfo>(); 1388 ASSERT_NE(windowInfo, std::nullopt); 1389 point->pointerId_ = 1; 1390 point->SetPointerId(point->pointerId_); 1391 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1392 windowInfo1->id = 1; 1393 dispatch.cancelEventList_[1].push_back(windowInfo1); 1394 bool result = dispatch.ReissueEvent(point, windowId, windowInfo); 1395 EXPECT_TRUE(result); 1396 } 1397 1398 /** 1399 * @tc.name: EventDispatchTest_ReissueEvent_006 1400 * @tc.desc: Test ReissueEvent 1401 * @tc.type: FUNC 1402 * @tc.require: 1403 */ 1404 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_006, TestSize.Level1) 1405 { 1406 EventDispatchHandler dispatch; 1407 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1408 ASSERT_NE(point, nullptr); 1409 point->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 1410 int32_t windowId = 100; 1411 std::optional<WindowInfo> windowInfo = std::make_optional<WindowInfo>(); 1412 ASSERT_NE(windowInfo, std::nullopt); 1413 point->pointerId_ = 5; 1414 point->SetPointerId(point->pointerId_); 1415 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1416 windowInfo1->id = 1; 1417 dispatch.cancelEventList_[1].push_back(windowInfo1); 1418 bool result = dispatch.ReissueEvent(point, windowId, windowInfo); 1419 EXPECT_TRUE(result); 1420 } 1421 1422 /** 1423 * @tc.name: EventDispatchTest_ReissueEvent_007 1424 * @tc.desc: Test ReissueEvent 1425 * @tc.type: FUNC 1426 * @tc.require: 1427 */ 1428 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_007, TestSize.Level1) 1429 { 1430 EventDispatchHandler dispatch; 1431 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1432 ASSERT_NE(point, nullptr); 1433 point->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 1434 int32_t windowId = 100; 1435 std::optional<WindowInfo> windowInfo = std::make_optional<WindowInfo>(); 1436 ASSERT_NE(windowInfo, std::nullopt); 1437 point->pointerId_ = 1; 1438 point->SetPointerId(point->pointerId_); 1439 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1440 windowInfo1->id = 1; 1441 dispatch.cancelEventList_[1].push_back(windowInfo1); 1442 bool result = dispatch.ReissueEvent(point, windowId, windowInfo); 1443 EXPECT_FALSE(result); 1444 } 1445 1446 /** 1447 * @tc.name: EventDispatchTest_ReissueEvent_008 1448 * @tc.desc: Test ReissueEvent 1449 * @tc.type: FUNC 1450 * @tc.require: 1451 */ 1452 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_008, TestSize.Level1) 1453 { 1454 EventDispatchHandler dispatch; 1455 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1456 ASSERT_NE(point, nullptr); 1457 point->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 1458 int32_t windowId = 100; 1459 std::optional<WindowInfo> windowInfo = std::make_optional<WindowInfo>(); 1460 ASSERT_NE(windowInfo, std::nullopt); 1461 point->pointerId_ = 5; 1462 point->SetPointerId(point->pointerId_); 1463 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1464 windowInfo1->id = 1; 1465 dispatch.cancelEventList_[1].push_back(windowInfo1); 1466 bool result = dispatch.ReissueEvent(point, windowId, windowInfo); 1467 EXPECT_FALSE(result); 1468 } 1469 1470 /** 1471 * @tc.name: EventDispatchTest_ReissueEvent_009 1472 * @tc.desc: Test ReissueEvent 1473 * @tc.type: FUNC 1474 * @tc.require: 1475 */ 1476 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_009, TestSize.Level1) 1477 { 1478 EventDispatchHandler dispatch; 1479 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1480 ASSERT_NE(point, nullptr); 1481 point->pointerAction_ = PointerEvent::POINTER_ACTION_CANCEL; 1482 int32_t windowId = 100; 1483 std::optional<WindowInfo> windowInfo = std::make_optional<WindowInfo>(); 1484 ASSERT_NE(windowInfo, std::nullopt); 1485 point->pointerId_ = 5; 1486 point->SetPointerId(point->pointerId_); 1487 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1488 windowInfo1->id = 1; 1489 dispatch.cancelEventList_[1].push_back(windowInfo1); 1490 bool result = dispatch.ReissueEvent(point, windowId, windowInfo); 1491 EXPECT_FALSE(result); 1492 } 1493 1494 /** 1495 * @tc.name: EventDispatchTest_ReissueEvent_010 1496 * @tc.desc: Test ReissueEvent 1497 * @tc.type: FUNC 1498 * @tc.require: 1499 */ 1500 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_010, TestSize.Level1) 1501 { 1502 EventDispatchHandler dispatch; 1503 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1504 ASSERT_NE(point, nullptr); 1505 point->pointerAction_ = PointerEvent::POINTER_ACTION_CANCEL; 1506 int32_t windowId = 100; 1507 std::optional<WindowInfo> windowInfo = std::make_optional<WindowInfo>(); 1508 ASSERT_NE(windowInfo, std::nullopt); 1509 point->pointerId_ = 1; 1510 point->SetPointerId(point->pointerId_); 1511 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1512 windowInfo1->id = 1; 1513 dispatch.cancelEventList_[1].push_back(windowInfo1); 1514 bool result = dispatch.ReissueEvent(point, windowId, windowInfo); 1515 EXPECT_FALSE(result); 1516 } 1517 1518 /** 1519 * @tc.name: EventDispatchTest_ReissueEvent_011 1520 * @tc.desc: Test ReissueEvent 1521 * @tc.type: FUNC 1522 * @tc.require: 1523 */ 1524 HWTEST_F(EventDispatchTest, EventDispatchTest_ReissueEvent_011, TestSize.Level1) 1525 { 1526 EventDispatchHandler dispatch; 1527 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1528 ASSERT_NE(point, nullptr); 1529 point->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE; 1530 int32_t windowId = 100; 1531 std::optional<WindowInfo> windowInfo = std::make_optional<WindowInfo>(); 1532 ASSERT_NE(windowInfo, std::nullopt); 1533 point->pointerId_ = 1; 1534 point->SetPointerId(point->pointerId_); 1535 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1536 windowInfo1->id = 1; 1537 dispatch.cancelEventList_[1].push_back(windowInfo1); 1538 bool result = dispatch.ReissueEvent(point, windowId, windowInfo); 1539 EXPECT_TRUE(result); 1540 } 1541 1542 /** 1543 * @tc.name: EventDispatchTest_SearchCancelList_001 1544 * @tc.desc: Test SearchCancelList 1545 * @tc.type: FUNC 1546 * @tc.require: 1547 */ 1548 HWTEST_F(EventDispatchTest, EventDispatchTest_SearchCancelList_001, TestSize.Level1) 1549 { 1550 EventDispatchHandler handler; 1551 int32_t pointerId = 1; 1552 int32_t windowId = 2; 1553 std::shared_ptr<WindowInfo> result = handler.SearchCancelList(pointerId, windowId); 1554 ASSERT_EQ(result, nullptr); 1555 } 1556 1557 /** 1558 * @tc.name: EventDispatchTest_SearchCancelList_002 1559 * @tc.desc: Test SearchCancelList 1560 * @tc.type: FUNC 1561 * @tc.require: 1562 */ 1563 HWTEST_F(EventDispatchTest, EventDispatchTest_SearchCancelList_002, TestSize.Level1) 1564 { 1565 EventDispatchHandler handler; 1566 int32_t pointerId = 5; 1567 int32_t windowId = 2; 1568 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1569 windowInfo1->id = 1; 1570 handler.cancelEventList_[1].push_back(windowInfo1); 1571 std::shared_ptr<WindowInfo> result = handler.SearchCancelList(pointerId, windowId); 1572 ASSERT_EQ(result, nullptr); 1573 } 1574 1575 /** 1576 * @tc.name: EventDispatchTest_SearchCancelList_003 1577 * @tc.desc: Test SearchCancelList 1578 * @tc.type: FUNC 1579 * @tc.require: 1580 */ 1581 HWTEST_F(EventDispatchTest, EventDispatchTest_SearchCancelList_003, TestSize.Level1) 1582 { 1583 EventDispatchHandler handler; 1584 int32_t pointerId = 1; 1585 int32_t windowId = 1; 1586 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 1587 windowInfo1->id = 1; 1588 handler.cancelEventList_[1].push_back(windowInfo1); 1589 std::shared_ptr<WindowInfo> result = handler.SearchCancelList(pointerId, windowId); 1590 ASSERT_NE(result, nullptr); 1591 } 1592 1593 /** 1594 * @tc.name: EventDispatchTest_FilterInvalidPointerItem_004 1595 * @tc.desc: Test the function FilterInvalidPointerItem 1596 * @tc.type: FUNC 1597 * @tc.require: 1598 */ 1599 HWTEST_F(EventDispatchTest, EventDispatchTest_FilterInvalidPointerItem_004, TestSize.Level1) 1600 { 1601 EventDispatchHandler eventdispatchhandler; 1602 int32_t fd = 1; 1603 int32_t eventType = 3; 1604 EXPECT_EQ(InputHandler->udsServer_, nullptr); 1605 auto udsServer = std::make_unique<UDSServer>(); 1606 InputHandler->udsServer_ = udsServer.get(); 1607 EXPECT_NE(InputHandler->udsServer_, nullptr); 1608 std::shared_ptr<PointerEvent> sharedPointerEvent = std::make_shared<PointerEvent>(eventType); 1609 EXPECT_NE(sharedPointerEvent, nullptr); 1610 std::vector<int32_t> pointerIdList; 1611 EXPECT_FALSE(pointerIdList.size() > 1); 1612 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(sharedPointerEvent, fd)); 1613 InputHandler->udsServer_ = nullptr; 1614 } 1615 1616 /** 1617 * @tc.name: EventDispatchTest_FilterInvalidPointerItem_005 1618 * @tc.desc: Test the function FilterInvalidPointerItem 1619 * @tc.type: FUNC 1620 * @tc.require: 1621 */ 1622 HWTEST_F(EventDispatchTest, EventDispatchTest_FilterInvalidPointerItem_005, TestSize.Level1) 1623 { 1624 EventDispatchHandler eventdispatchhandler; 1625 PointerEvent::PointerItem testPointerItem; 1626 EXPECT_EQ(InputHandler->udsServer_, nullptr); 1627 auto udsServer = std::make_unique<UDSServer>(); 1628 InputHandler->udsServer_ = udsServer.get(); 1629 EXPECT_NE(InputHandler->udsServer_, nullptr); 1630 int32_t fd = 1; 1631 int32_t eventType = 3; 1632 std::shared_ptr<PointerEvent> event = std::make_shared<PointerEvent>(eventType); 1633 event->pointers_.push_back(PointerEvent::PointerItem()); 1634 event->pointers_.push_back(PointerEvent::PointerItem()); 1635 std::vector<int32_t> pointerIds = event->GetPointerIds(); 1636 ASSERT_TRUE(pointerIds.size() > 1); 1637 event->AddPointerItem(testPointerItem); 1638 int32_t testPointerId = 1; 1639 testPointerItem.SetPointerId(testPointerId); 1640 event->AddPointerItem(testPointerItem); 1641 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(event, fd)); 1642 InputHandler->udsServer_ = nullptr; 1643 } 1644 1645 /** 1646 * @tc.name: EventDispatchTest_FilterInvalidPointerItem_006 1647 * @tc.desc: Test the function FilterInvalidPointerItem 1648 * @tc.type: FUNC 1649 * @tc.require: 1650 */ 1651 HWTEST_F(EventDispatchTest, EventDispatchTest_FilterInvalidPointerItem_006, TestSize.Level1) 1652 { 1653 EventDispatchHandler eventdispatchhandler; 1654 PointerEvent::PointerItem testPointerItem; 1655 EXPECT_EQ(InputHandler->udsServer_, nullptr); 1656 auto udsServer = std::make_unique<UDSServer>(); 1657 InputHandler->udsServer_ = udsServer.get(); 1658 EXPECT_NE(InputHandler->udsServer_, nullptr); 1659 int32_t fd = 1; 1660 int32_t eventType = 3; 1661 std::shared_ptr<PointerEvent> event = std::make_shared<PointerEvent>(eventType); 1662 event->pointers_.push_back(PointerEvent::PointerItem()); 1663 event->pointers_.push_back(PointerEvent::PointerItem()); 1664 std::vector<int32_t> pointerIds = event->GetPointerIds(); 1665 ASSERT_TRUE(pointerIds.size() > 1); 1666 event->AddPointerItem(testPointerItem); 1667 int32_t testPointerId = 1; 1668 testPointerItem.SetPointerId(testPointerId + 1); 1669 event->AddPointerItem(testPointerItem); 1670 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(event, fd)); 1671 InputHandler->udsServer_ = nullptr; 1672 } 1673 1674 /** 1675 * @tc.name: EventDispatchTest_FilterInvalidPointerItem_007 1676 * @tc.desc: Test the function FilterInvalidPointerItem 1677 * @tc.type: FUNC 1678 * @tc.require: 1679 */ 1680 HWTEST_F(EventDispatchTest, EventDispatchTest_FilterInvalidPointerItem_007, TestSize.Level1) 1681 { 1682 EventDispatchHandler eventdispatchhandler; 1683 int32_t fd = 1; 1684 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1685 ASSERT_NE(pointerEvent, nullptr); 1686 EXPECT_EQ(InputHandler->udsServer_, nullptr); 1687 auto udsServer = std::make_unique<UDSServer>(); 1688 InputHandler->udsServer_ = udsServer.get(); 1689 EXPECT_NE(InputHandler->udsServer_, nullptr); 1690 PointerEvent::PointerItem testPointerItem; 1691 testPointerItem.pointerId_ = -1; 1692 pointerEvent->pointers_.push_back(testPointerItem); 1693 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(pointerEvent, fd)); 1694 testPointerItem.pressed_ = false; 1695 testPointerItem.SetDisplayX(50); 1696 testPointerItem.SetDisplayY(100); 1697 pointerEvent->pointers_.push_back(testPointerItem); 1698 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(pointerEvent, fd)); 1699 InputHandler->udsServer_ = nullptr; 1700 } 1701 1702 /** 1703 * @tc.name: EventDispatchTest_HandleMultiWindowPointerEvent_007 1704 * @tc.desc: Test the function HandleMultiWindowPointerEvent 1705 * @tc.type: FUNC 1706 * @tc.require: 1707 */ 1708 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleMultiWindowPointerEvent_007, TestSize.Level1) 1709 { 1710 EventDispatchHandler eventdispatchhandler; 1711 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1712 ASSERT_NE(point, nullptr); 1713 PointerEvent::PointerItem pointerItem; 1714 pointerItem.SetWindowX(35); 1715 pointerItem.SetWindowY(50); 1716 pointerItem.SetTargetWindowId(2); 1717 point->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 1718 point->pointerId_ = 1; 1719 std::shared_ptr<WindowInfo> windowInfo = std::make_shared<WindowInfo>(); 1720 windowInfo->id = 5; 1721 eventdispatchhandler.cancelEventList_[1].push_back(windowInfo); 1722 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 1723 windowInfo->id = 1; 1724 eventdispatchhandler.cancelEventList_[2].push_back(windowInfo); 1725 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 1726 point->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE; 1727 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 1728 point->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 1729 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 1730 point->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_UP; 1731 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 1732 point->pointerAction_ = PointerEvent::POINTER_ACTION_CANCEL; 1733 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 1734 } 1735 1736 /** 1737 * @tc.name: EventDispatchTest_DispatchPointerEventInner_010 1738 * @tc.desc: Test the function DispatchPointerEventInner 1739 * @tc.type: FUNC 1740 * @tc.require: 1741 */ 1742 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchPointerEventInner_010, TestSize.Level1) 1743 { 1744 EventDispatchHandler eventDispatchHandler; 1745 int32_t fd = 2; 1746 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1747 ASSERT_NE(pointerEvent, nullptr); 1748 UDSServer udsServer; 1749 InputHandler->udsServer_ = &udsServer; 1750 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid); 1751 udsServer.sessionsMap_.insert(std::make_pair(fd, session)); 1752 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 1753 ASSERT_NO_FATAL_FAILURE(eventDispatchHandler.DispatchPointerEventInner(pointerEvent, fd)); 1754 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 1755 ASSERT_NO_FATAL_FAILURE(eventDispatchHandler.DispatchPointerEventInner(pointerEvent, fd)); 1756 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_DOWN; 1757 ASSERT_NO_FATAL_FAILURE(eventDispatchHandler.DispatchPointerEventInner(pointerEvent, fd)); 1758 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_UP; 1759 ASSERT_NO_FATAL_FAILURE(eventDispatchHandler.DispatchPointerEventInner(pointerEvent, fd)); 1760 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW; 1761 ASSERT_NO_FATAL_FAILURE(eventDispatchHandler.DispatchPointerEventInner(pointerEvent, fd)); 1762 pointerEvent->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE; 1763 ASSERT_NO_FATAL_FAILURE(eventDispatchHandler.DispatchPointerEventInner(pointerEvent, fd)); 1764 fd = -2; 1765 ASSERT_NO_FATAL_FAILURE(eventDispatchHandler.DispatchPointerEventInner(pointerEvent, fd)); 1766 fd = 5; 1767 udsServer.sessionsMap_.insert(std::make_pair(5, session)); 1768 ASSERT_NO_FATAL_FAILURE(eventDispatchHandler.DispatchPointerEventInner(pointerEvent, fd)); 1769 } 1770 1771 /** 1772 * @tc.name: EventDispatchTest_DispatchKeyEventPid_006 1773 * @tc.desc: Test the function DispatchKeyEventPid 1774 * @tc.type: FUNC 1775 * @tc.require: 1776 */ 1777 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEventPid_006, TestSize.Level1) 1778 { 1779 EventDispatchHandler eventDispatchHandler; 1780 UDSServer udsServer; 1781 std::shared_ptr<KeyEvent> KeyEvent = KeyEvent::Create(); 1782 ASSERT_NE(KeyEvent, nullptr); 1783 ASSERT_EQ(eventDispatchHandler.DispatchKeyEventPid(udsServer, KeyEvent), RET_OK); 1784 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, g_moduleType, g_writeFd, UID_ROOT, g_pid); 1785 udsServer.sessionsMap_.insert(std::make_pair(-1, session)); 1786 StreamBuffer streamBuffer; 1787 streamBuffer.rwErrorStatus_ = CircleStreamBuffer::ErrorStatus::ERROR_STATUS_READ; 1788 eventDispatchHandler.DispatchKeyEventPid(udsServer, KeyEvent); 1789 streamBuffer.rwErrorStatus_ = CircleStreamBuffer::ErrorStatus::ERROR_STATUS_READ; 1790 ASSERT_EQ(eventDispatchHandler.DispatchKeyEventPid(udsServer, KeyEvent), RET_OK); 1791 } 1792 1793 /** 1794 * @tc.name: DispatchPointerEventInner_06 1795 * @tc.desc: Test the funcation DispatchKeyEvent 1796 * @tc.type: FUNC 1797 * @tc.require: 1798 */ 1799 HWTEST_F(EventDispatchTest, DispatchPointerEventInner_06, TestSize.Level1) 1800 { 1801 EventDispatchHandler handler; 1802 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1803 ASSERT_NE(point, nullptr); 1804 int32_t fd = -5; 1805 auto inputEvent = InputEvent::Create(); 1806 ASSERT_NE(inputEvent, nullptr); 1807 inputEvent->actionTime_ = 3100; 1808 handler.eventTime_ = 10; 1809 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1810 inputEvent->actionTime_ = 200; 1811 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1812 fd = 5; 1813 bool status = true; 1814 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, 1, 1, 100, 100); 1815 session->SetTokenType(TokenType::TOKEN_HAP); 1816 session->SetAnrStatus(0, status); 1817 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1818 status = false; 1819 point->pointerAction_ = PointerEvent::POINTER_ACTION_DOWN; 1820 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1821 point->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 1822 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1823 point->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_DOWN; 1824 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1825 point->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_UP; 1826 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1827 point->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_MOVE; 1828 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1829 point->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE; 1830 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1831 point->pointerAction_ = PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW; 1832 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1833 point->pointerAction_ = PointerEvent::POINTER_ACTION_AXIS_END; 1834 ASSERT_NO_FATAL_FAILURE(handler.DispatchPointerEventInner(point, fd)); 1835 } 1836 1837 /** 1838 * @tc.name: EventDispatchTest_DispatchKeyEvent_001 1839 * @tc.desc: Test the funcation DispatchKeyEvent 1840 * @tc.type: FUNC 1841 * @tc.require: 1842 */ 1843 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEvent_001, TestSize.Level1) 1844 { 1845 EventDispatchHandler handler; 1846 int32_t fd = -2; 1847 UDSServer udsServer; 1848 std::shared_ptr<KeyEvent> key = KeyEvent::Create(); 1849 ASSERT_NE(key, nullptr); 1850 auto inputEvent = InputEvent::Create(); 1851 ASSERT_NE(inputEvent, nullptr); 1852 inputEvent->actionTime_ = 4000; 1853 handler.eventTime_ = 200; 1854 int32_t ret = handler.DispatchKeyEvent(fd, udsServer, key); 1855 EXPECT_EQ(ret, RET_ERR); 1856 inputEvent->actionTime_ = 2000; 1857 ret = handler.DispatchKeyEvent(fd, udsServer, key); 1858 EXPECT_EQ(ret, RET_ERR); 1859 fd = 9; 1860 bool status = true; 1861 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, 1, 1, 100, 100); 1862 session->SetTokenType(TokenType::TOKEN_HAP); 1863 session->SetAnrStatus(0, status); 1864 ret = handler.DispatchKeyEvent(fd, udsServer, key); 1865 EXPECT_EQ(ret, RET_ERR); 1866 status = false; 1867 StreamBuffer streamBuffer; 1868 streamBuffer.rwErrorStatus_ = CircleStreamBuffer::ErrorStatus::ERROR_STATUS_READ; 1869 ret = handler.DispatchKeyEvent(fd, udsServer, key); 1870 EXPECT_EQ(ret, RET_ERR); 1871 streamBuffer.rwErrorStatus_ = CircleStreamBuffer::ErrorStatus::ERROR_STATUS_OK; 1872 udsServer.pid_ = 1; 1873 ret = handler.DispatchKeyEvent(fd, udsServer, key); 1874 EXPECT_EQ(ret, RET_ERR); 1875 udsServer.pid_ = -1; 1876 ret = handler.DispatchKeyEvent(fd, udsServer, key); 1877 EXPECT_EQ(ret, RET_ERR); 1878 } 1879 1880 /** 1881 * @tc.name: EventDispatchTest_FilterInvalidPointerItem_008 1882 * @tc.desc: Test the function FilterInvalidPointerItem 1883 * @tc.type: FUNC 1884 * @tc.require: 1885 */ 1886 HWTEST_F(EventDispatchTest, EventDispatchTest_FilterInvalidPointerItem_008, TestSize.Level1) 1887 { 1888 EventDispatchHandler eventdispatchhandler; 1889 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1890 ASSERT_NE(pointerEvent, nullptr); 1891 int32_t fd = 10; 1892 PointerEvent::PointerItem item1; 1893 item1.pointerId_ = 1; 1894 item1.pressed_ = true; 1895 item1.SetDisplayX(10); 1896 item1.SetDisplayY(20); 1897 pointerEvent->pointers_.push_back(item1); 1898 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(pointerEvent, fd)); 1899 PointerEvent::PointerItem item2; 1900 item2.pointerId_ = 2; 1901 item2.pressed_ = false; 1902 item2.SetDisplayX(20); 1903 item2.SetDisplayY(30); 1904 item2.targetWindowId_ = 1; 1905 pointerEvent->pointers_.push_back(item2); 1906 UDSServer udsServer; 1907 udsServer.pid_ = 1; 1908 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(pointerEvent, fd)); 1909 udsServer.pid_ = -1; 1910 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(pointerEvent, fd)); 1911 } 1912 1913 /** 1914 * @tc.name: EventDispatchTest_HandleMultiWindowPointerEvent_008 1915 * @tc.desc: Test the function HandleMultiWindowPointerEvent 1916 * @tc.type: FUNC 1917 * @tc.require: 1918 */ 1919 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleMultiWindowPointerEvent_008, TestSize.Level1) 1920 { 1921 EventDispatchHandler eventdispatchhandler; 1922 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 1923 ASSERT_NE(point, nullptr); 1924 PointerEvent::PointerItem pointerItem; 1925 pointerItem.SetWindowX(1); 1926 pointerItem.SetWindowY(2); 1927 pointerItem.SetTargetWindowId(3); 1928 point->pointerAction_ = PointerEvent::POINTER_ACTION_UP; 1929 point->pointerId_ = 3; 1930 std::shared_ptr<WindowInfo> windowInfo = std::make_shared<WindowInfo>(); 1931 windowInfo->id = 3; 1932 eventdispatchhandler.cancelEventList_[1].push_back(windowInfo); 1933 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 1934 windowInfo->id = 1; 1935 eventdispatchhandler.cancelEventList_[2].push_back(windowInfo); 1936 point->pointerAction_ = PointerEvent::POINTER_ACTION_MOVE; 1937 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 1938 point->pointerAction_ = PointerEvent::POINTER_ACTION_CANCEL; 1939 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 1940 } 1941 1942 /** 1943 * @tc.name: EventDispatchTest_DispatchKeyEvent_002 1944 * @tc.desc: Test the funcation DispatchKeyEvent 1945 * @tc.type: FUNC 1946 * @tc.require: 1947 */ 1948 HWTEST_F(EventDispatchTest, EventDispatchTest_DispatchKeyEvent_002, TestSize.Level1) 1949 { 1950 EventDispatchHandler handler; 1951 int32_t fd = 1; 1952 UDSServer udsServer; 1953 std::shared_ptr<KeyEvent> key = KeyEvent::Create(); 1954 ASSERT_NE(key, nullptr); 1955 SessionPtr session = std::make_shared<UDSSession>(PROGRAM_NAME, 1, 1, 100, 100); 1956 session->tokenType_ = 0; 1957 session->isAnrProcess_.insert(std::make_pair(1, true)); 1958 int32_t ret = handler.DispatchKeyEvent(fd, udsServer, key); 1959 EXPECT_EQ(ret, RET_ERR); 1960 fd = 2; 1961 session->isAnrProcess_.insert(std::make_pair(2, false)); 1962 ret = handler.DispatchKeyEvent(fd, udsServer, key); 1963 EXPECT_EQ(ret, RET_ERR); 1964 } 1965 1966 #ifdef OHOS_BUILD_ENABLE_ONE_HAND_MODE 1967 /** 1968 * @tc.name: EventDispatchTest_UpdateDisplayXY_001 1969 * @tc.desc: Test the function UpdateDisplayXY 1970 * @tc.type: FUNC 1971 * @tc.require: 1972 */ 1973 HWTEST_F(EventDispatchTest, EventDispatchTest_UpdateDisplayXY_001, TestSize.Level1) 1974 { 1975 CALL_TEST_DEBUG; 1976 EventDispatchHandler handler; 1977 auto pointerEvent = PointerEvent::Create(); 1978 pointerEvent = nullptr; 1979 ASSERT_NO_FATAL_FAILURE(handler.UpdateDisplayXY(pointerEvent)); 1980 } 1981 1982 /** 1983 * @tc.name: EventDispatchTest_UpdateDisplayXY_002 1984 * @tc.desc: Test the function UpdateDisplayXY 1985 * @tc.type: FUNC 1986 * @tc.require: 1987 */ 1988 HWTEST_F(EventDispatchTest, EventDispatchTest_UpdateDisplayXY_002, TestSize.Level1) 1989 { 1990 CALL_TEST_DEBUG; 1991 EventDispatchHandler handler; 1992 auto pointerEvent = PointerEvent::Create(); 1993 int32_t pointerId = 3; 1994 pointerEvent->SetPointerId(pointerId); 1995 PointerEvent::PointerItem pointerItem; 1996 pointerItem.SetPointerId(2); 1997 pointerEvent->AddPointerItem(pointerItem); 1998 ASSERT_NO_FATAL_FAILURE(handler.UpdateDisplayXY(pointerEvent)); 1999 } 2000 2001 /** 2002 * @tc.name: EventDispatchTest_UpdateDisplayXY_003 2003 * @tc.desc: Test the function UpdateDisplayXY 2004 * @tc.type: FUNC 2005 * @tc.require: 2006 */ 2007 HWTEST_F(EventDispatchTest, EventDispatchTest_UpdateDisplayXY_003, TestSize.Level1) 2008 { 2009 CALL_TEST_DEBUG; 2010 EventDispatchHandler handler; 2011 auto pointerEvent = PointerEvent::Create(); 2012 int32_t pointerId = 3; 2013 int32_t displayId = 1; 2014 int32_t windowId = 2; 2015 pointerEvent->SetPointerId(pointerId); 2016 PointerEvent::PointerItem pointerItem; 2017 pointerItem.SetPointerId(pointerId); 2018 pointerEvent->AddPointerItem(pointerItem); 2019 pointerEvent->SetTargetDisplayId(displayId); 2020 pointerItem.SetTargetWindowId(windowId); 2021 ASSERT_NO_FATAL_FAILURE(handler.UpdateDisplayXY(pointerEvent)); 2022 } 2023 2024 /** 2025 * @tc.name: EventDispatchTest_UpdateDisplayXY_004 2026 * @tc.desc: Test the function UpdateDisplayXY 2027 * @tc.type: FUNC 2028 * @tc.require: 2029 */ 2030 HWTEST_F(EventDispatchTest, EventDispatchTest_UpdateDisplayXY_004, TestSize.Level1) 2031 { 2032 CALL_TEST_DEBUG; 2033 EventDispatchHandler handler; 2034 auto pointerEvent = PointerEvent::Create(); 2035 int32_t pointerId = 3; 2036 int32_t displayId = 1; 2037 int32_t windowId = 2; 2038 pointerEvent->SetPointerId(pointerId); 2039 PointerEvent::PointerItem pointerItem; 2040 pointerItem.SetPointerId(pointerId); 2041 pointerEvent->AddPointerItem(pointerItem); 2042 pointerEvent->SetTargetDisplayId(displayId); 2043 pointerItem.SetTargetWindowId(windowId); 2044 pointerEvent->SetFixedMode(PointerEvent::FixedMode::AUTO); 2045 ASSERT_NO_FATAL_FAILURE(handler.UpdateDisplayXY(pointerEvent)); 2046 } 2047 2048 /** 2049 * @tc.name: EventDispatchTest_UpdateDisplayXY_005 2050 * @tc.desc: Test the function UpdateDisplayXY 2051 * @tc.type: FUNC 2052 * @tc.require: 2053 */ 2054 HWTEST_F(EventDispatchTest, EventDispatchTest_UpdateDisplayXY_005, TestSize.Level1) 2055 { 2056 CALL_TEST_DEBUG; 2057 EventDispatchHandler handler; 2058 auto pointerEvent = PointerEvent::Create(); 2059 int32_t pointerId = 3; 2060 int32_t displayId = 1; 2061 int32_t windowId = 2; 2062 pointerEvent->SetPointerId(pointerId); 2063 PointerEvent::PointerItem pointerItem; 2064 pointerItem.SetPointerId(pointerId); 2065 pointerEvent->AddPointerItem(pointerItem); 2066 pointerEvent->SetTargetDisplayId(displayId); 2067 pointerItem.SetTargetWindowId(windowId); 2068 pointerEvent->SetFixedMode(PointerEvent::FixedMode::NORMAL); 2069 ASSERT_NO_FATAL_FAILURE(handler.UpdateDisplayXY(pointerEvent)); 2070 } 2071 #endif // OHOS_BUILD_ENABLE_ONE_HAND_MODE 2072 /** 2073 * @tc.name: EventDispatchTest_SendWindowStateError_001 2074 * @tc.desc: Test the funcation SendWindowStateError 2075 * @tc.type: FUNC 2076 * @tc.require: 2077 */ 2078 HWTEST_F(EventDispatchTest, EventDispatchTest_SendWindowStateError_001, TestSize.Level1) 2079 { 2080 EventDispatchHandler eventdispatchhandler; 2081 int32_t fd = 1; 2082 int32_t windowId = 3; 2083 auto udsServer = std::make_unique<UDSServer>(); 2084 InputHandler->udsServer_ = udsServer.get(); 2085 EXPECT_NE(InputHandler->udsServer_, nullptr); 2086 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.SendWindowStateError(fd, windowId)); 2087 InputHandler->udsServer_ = nullptr; 2088 } 2089 2090 /** 2091 * @tc.name: EventDispatchTest_GetClientFd_001 2092 * @tc.desc: Test the funcation GetClientFd 2093 * @tc.type: FUNC 2094 * @tc.require: 2095 */ 2096 HWTEST_F(EventDispatchTest, EventDispatchTest_GetClientFd_001, TestSize.Level1) 2097 { 2098 EventDispatchHandler eventdispatchhandler; 2099 int32_t pid = 1; 2100 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 2101 point->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 2102 point->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 2103 EXPECT_EQ(eventdispatchhandler.GetClientFd(pid, point), INVALID_FD); 2104 } 2105 /** 2106 * @tc.name: EventDispatchTest_GetClientFd_002 2107 * @tc.desc: Test the funcation GetClientFd 2108 * @tc.type: FUNC 2109 * @tc.require: 2110 */ 2111 HWTEST_F(EventDispatchTest, EventDispatchTest_GetClientFd_002, TestSize.Level1) 2112 { 2113 EventDispatchHandler eventdispatchhandler; 2114 int32_t pid = 1; 2115 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 2116 point->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 2117 point->SetSourceType(PointerEvent::SOURCE_TYPE_CROWN); 2118 EXPECT_EQ(eventdispatchhandler.GetClientFd(pid, point), INVALID_FD); 2119 } 2120 /** 2121 * @tc.name: EventDispatchTest_GetClientFd_003 2122 * @tc.desc: Test the funcation GetClientFd 2123 * @tc.type: FUNC 2124 * @tc.require: 2125 */ 2126 HWTEST_F(EventDispatchTest, EventDispatchTest_GetClientFd_003, TestSize.Level1) 2127 { 2128 EventDispatchHandler eventdispatchhandler; 2129 int32_t pid = 1; 2130 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 2131 point->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL); 2132 EXPECT_EQ(eventdispatchhandler.GetClientFd(pid, point), INVALID_FD); 2133 } 2134 2135 /** 2136 * @tc.name: EventDispatchTest_GetClientFd_004 2137 * @tc.desc: Test the funcation GetClientFd 2138 * @tc.type: FUNC 2139 * @tc.require: 2140 */ 2141 HWTEST_F(EventDispatchTest, EventDispatchTest_GetClientFd_004, TestSize.Level1) 2142 { 2143 EventDispatchHandler eventdispatchhandler; 2144 int32_t pid = 0; 2145 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 2146 point->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 2147 point->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 2148 EXPECT_EQ(eventdispatchhandler.GetClientFd(pid, point), INVALID_FD); 2149 } 2150 /** 2151 * @tc.name: EventDispatchTest_GetClientFd_005 2152 * @tc.desc: Test the funcation GetClientFd 2153 * @tc.type: FUNC 2154 * @tc.require: 2155 */ 2156 HWTEST_F(EventDispatchTest, EventDispatchTest_GetClientFd_005, TestSize.Level1) 2157 { 2158 EventDispatchHandler eventdispatchhandler; 2159 int32_t pid = 0; 2160 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 2161 point->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 2162 point->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 2163 EXPECT_EQ(eventdispatchhandler.GetClientFd(pid, point), INVALID_FD); 2164 } 2165 2166 /** 2167 * @tc.name: EventDispatchTest_GetClientFd_006 2168 * @tc.desc: Test the funcation GetClientFd 2169 * @tc.type: FUNC 2170 * @tc.require: 2171 */ 2172 HWTEST_F(EventDispatchTest, EventDispatchTest_GetClientFd_006, TestSize.Level1) 2173 { 2174 EventDispatchHandler eventdispatchhandler; 2175 int32_t pid = 1; 2176 std::shared_ptr<PointerEvent> point = PointerEvent::Create(); 2177 point->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 2178 point->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 2179 EXPECT_EQ(eventdispatchhandler.GetClientFd(pid, point), INVALID_FD); 2180 } 2181 2182 /** 2183 * @tc.name: EventDispatchTest_HandleKeyEvent_001 2184 * @tc.desc: Test the function HandleKeyEvent 2185 * @tc.type: FUNC 2186 * @tc.require: 2187 */ 2188 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleKeyEvent_001, TestSize.Level1) 2189 { 2190 EventDispatchHandler eventdispatchhandler; 2191 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 2192 ASSERT_NE(keyEvent, nullptr); 2193 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleKeyEvent(keyEvent)); 2194 } 2195 2196 /** 2197 * @tc.name: EventDispatchTest_HandleKeyEvent_002 2198 * @tc.desc: Test the function HandleKeyEvent with AddFlagToEsc 2199 * @tc.type: FUNC 2200 * @tc.require: 2201 */ 2202 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleKeyEvent_002, TestSize.Level1) 2203 { 2204 EventDispatchHandler dispatch; 2205 std::shared_ptr<KeyEvent> keyEvent = nullptr; 2206 dispatch.HandleKeyEvent(keyEvent); 2207 EXPECT_EQ(keyEvent, nullptr); 2208 keyEvent = KeyEvent::Create(); 2209 ASSERT_NE(keyEvent, nullptr); 2210 2211 KeyEvent::KeyItem item; 2212 keyEvent->AddPressedKeyItems(item); 2213 EXPECT_EQ(keyEvent->GetKeyItems().size(), 1); 2214 2215 keyEvent->SetKeyCode(KeyEvent::KEYCODE_ESCAPE); 2216 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2217 EXPECT_EQ(dispatch.escToBackFlag_, false); 2218 dispatch.HandleKeyEvent(keyEvent); 2219 EXPECT_EQ(dispatch.escToBackFlag_, false); 2220 int32_t ret1 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 2221 EXPECT_EQ(ret1, false); 2222 2223 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_UP); 2224 dispatch.HandleKeyEvent(keyEvent); 2225 EXPECT_EQ(dispatch.escToBackFlag_, false); 2226 int32_t ret2 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 2227 EXPECT_EQ(ret2, false); 2228 2229 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_DOWN); 2230 dispatch.HandleKeyEvent(keyEvent); 2231 EXPECT_EQ(dispatch.escToBackFlag_, false); 2232 int32_t ret3 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 2233 EXPECT_EQ(ret3, false); 2234 2235 keyEvent->SetKeyAction(KeyEvent::KEY_ACTION_CANCEL); 2236 dispatch.HandleKeyEvent(keyEvent); 2237 EXPECT_EQ(dispatch.escToBackFlag_, false); 2238 int32_t ret4 = keyEvent->HasFlag(InputEvent::EVENT_FLAG_KEYBOARD_ESCAPE); 2239 EXPECT_EQ(ret4, false); 2240 } 2241 2242 /** 2243 * @tc.name: EventDispatchTest_HandlePointerEvent_001 2244 * @tc.desc: Test the function HandlePointerEvent 2245 * @tc.type: FUNC 2246 * @tc.require: 2247 */ 2248 HWTEST_F(EventDispatchTest, EventDispatchTest_HandlePointerEvent_001, TestSize.Level1) 2249 { 2250 EventDispatchHandler eventdispatchhandler; 2251 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 2252 ASSERT_NE(pointerEvent, nullptr); 2253 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandlePointerEvent(pointerEvent)); 2254 } 2255 2256 /** 2257 * @tc.name: EventDispatchTest_FilterInvalidPointerItem_010 2258 * @tc.desc: Test the function FilterInvalidPointerItem 2259 * @tc.type: FUNC 2260 * @tc.require: 2261 */ 2262 HWTEST_F(EventDispatchTest, EventDispatchTest_FilterInvalidPointerItem_010, TestSize.Level1) 2263 { 2264 EventDispatchHandler eventdispatchhandler; 2265 int32_t fd = 1; 2266 int32_t eventType = 3; 2267 std::shared_ptr<PointerEvent> pointerEvent = std::make_shared<PointerEvent>(eventType); 2268 2269 std::vector<int32_t> pointerIdList; 2270 pointerEvent->pointerId_ = 3; 2271 pointerIdList.push_back(pointerEvent->pointerId_); 2272 pointerEvent->pointerId_ = 5; 2273 pointerIdList.push_back(pointerEvent->pointerId_); 2274 EXPECT_TRUE(pointerIdList.size() > 1); 2275 2276 PointerEvent::PointerItem pointeritem; 2277 pointeritem.SetWindowX(10); 2278 pointeritem.SetWindowY(20); 2279 pointeritem.SetTargetWindowId(2); 2280 int32_t id = 1; 2281 EXPECT_FALSE(pointerEvent->GetPointerItem(id, pointeritem)); 2282 2283 pointeritem.targetWindowId_ = 3; 2284 auto itemPid = WIN_MGR->GetWindowPid(pointeritem.targetWindowId_); 2285 EXPECT_FALSE(itemPid >= 0); 2286 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.FilterInvalidPointerItem(pointerEvent, fd)); 2287 } 2288 2289 /** 2290 * @tc.name: EventDispatchTest_SearchCancelList_004 2291 * @tc.desc: Test SearchCancelList 2292 * @tc.type: FUNC 2293 * @tc.require: 2294 */ 2295 HWTEST_F(EventDispatchTest, EventDispatchTest_SearchCancelList_004, TestSize.Level1) 2296 { 2297 EventDispatchHandler handler; 2298 int32_t pointerId = 1; 2299 int32_t windowId = 1; 2300 std::shared_ptr<WindowInfo> result = handler.SearchCancelList(pointerId, windowId); 2301 ASSERT_EQ(result, nullptr); 2302 } 2303 2304 /** 2305 * @tc.name: EventDispatchTest_HandleMultiWindowPointerEvent_009 2306 * @tc.desc: Test HandleMultiWindowPointerEvent 2307 * @tc.type: FUNC 2308 * @tc.require: 2309 */ 2310 HWTEST_F(EventDispatchTest, EventDispatchTest_HandleMultiWindowPointerEvent_009, TestSize.Level1) 2311 { 2312 EventDispatchHandler eventdispatchhandler; 2313 int32_t eventType = 3; 2314 std::shared_ptr<PointerEvent> point = std::make_shared<PointerEvent>(eventType); 2315 EXPECT_NE(point, nullptr); 2316 2317 std::vector<int32_t> windowIds; 2318 windowIds.push_back(1); 2319 windowIds.push_back(2); 2320 windowIds.push_back(3); 2321 2322 PointerEvent::PointerItem pointerItem; 2323 pointerItem.SetWindowX(10); 2324 pointerItem.SetWindowY(20); 2325 pointerItem.SetTargetWindowId(2); 2326 2327 int32_t pointerId = 1; 2328 int32_t windowId = 1; 2329 std::shared_ptr<WindowInfo> windowInfo1 = std::make_shared<WindowInfo>(); 2330 windowInfo1->id = 1; 2331 eventdispatchhandler.cancelEventList_[1].push_back(windowInfo1); 2332 auto windowInfo = eventdispatchhandler.SearchCancelList(pointerId, windowId); 2333 ASSERT_NO_FATAL_FAILURE(eventdispatchhandler.HandleMultiWindowPointerEvent(point, pointerItem)); 2334 } 2335 } // namespace MMI 2336 } // namespace OHOS 2337