1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 18 #include "i_input_event_consumer.h" 19 #include "input_handler_manager.h" 20 #include "mmi_log.h" 21 22 #undef MMI_LOG_TAG 23 #define MMI_LOG_TAG "InputHandlerManagerTest" 24 25 namespace OHOS { 26 namespace MMI { 27 namespace { 28 using namespace testing::ext; 29 constexpr int32_t TEN_FINGERS { 10 }; 30 constexpr int32_t THREE_FINGERS { 3 }; 31 constexpr int32_t FOUR_FINGERS { 4 }; 32 } // namespace 33 34 class InputHandlerManagerTest : public testing::Test { 35 public: SetUpTestCase(void)36 static void SetUpTestCase(void) {} TearDownTestCase(void)37 static void TearDownTestCase(void) {} 38 }; 39 40 class MyInputHandlerManager : public InputHandlerManager { 41 public: 42 MyInputHandlerManager() = default; 43 ~MyInputHandlerManager() override = default; 44 45 protected: GetHandlerType() const46 InputHandlerType GetHandlerType() const override 47 { 48 return InputHandlerType::INTERCEPTOR; 49 } 50 }; 51 52 class MYInputHandlerManager : public InputHandlerManager { 53 public: 54 MYInputHandlerManager() = default; 55 ~MYInputHandlerManager() override = default; 56 57 protected: GetHandlerType() const58 InputHandlerType GetHandlerType() const override 59 { 60 return InputHandlerType::MONITOR; 61 } 62 63 private: CheckMonitorValid(TouchGestureType type,int32_t fingers)64 bool CheckMonitorValid(TouchGestureType type, int32_t fingers) override 65 { 66 return true; 67 } 68 }; 69 70 /** 71 * @tc.name: InputHandlerManagerTest_FindHandler_001 72 * @tc.desc: 73 * @tc.type: FUNC 74 * @tc.require: 75 */ 76 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_FindHandler_001, TestSize.Level2) 77 { 78 MyInputHandlerManager manager; 79 int32_t handlerId = 1; 80 ASSERT_NO_FATAL_FAILURE(manager.FindHandler(handlerId)); 81 handlerId = -1; 82 ASSERT_NO_FATAL_FAILURE(manager.FindHandler(handlerId)); 83 } 84 85 /** 86 * @tc.name: InputHandlerManagerTest_AddMouseEventId_001 87 * @tc.desc: 88 * @tc.type: FUNC 89 * @tc.require: 90 */ 91 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_AddMouseEventId_001, TestSize.Level1) 92 { 93 MyInputHandlerManager manager; 94 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 95 ASSERT_NE(pointerEvent, nullptr); 96 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 97 ASSERT_NO_FATAL_FAILURE(manager.AddMouseEventId(pointerEvent)); 98 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 99 ASSERT_NO_FATAL_FAILURE(manager.AddMouseEventId(pointerEvent)); 100 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 101 ASSERT_NO_FATAL_FAILURE(manager.AddMouseEventId(pointerEvent)); 102 } 103 104 /** 105 * @tc.name: InputHandlerManagerTest_HasHandler_001 106 * @tc.desc: 107 * @tc.type: FUNC 108 * @tc.require: 109 */ 110 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_HasHandler_001, TestSize.Level1) 111 { 112 MyInputHandlerManager manager; 113 int32_t handlerId = 1; 114 ASSERT_NO_FATAL_FAILURE(manager.HasHandler(handlerId)); 115 handlerId = -1; 116 ASSERT_NO_FATAL_FAILURE(manager.HasHandler(handlerId)); 117 } 118 119 /** 120 * @tc.name: InputHandlerManagerTest_OnDispatchEventProcessed_001 121 * @tc.desc: 122 * @tc.type: FUNC 123 * @tc.require: 124 */ 125 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnDispatchEventProcessed_001, TestSize.Level3) 126 { 127 MyInputHandlerManager manager; 128 int32_t eventId = 1; 129 int64_t actionTime = 2; 130 ASSERT_NO_FATAL_FAILURE(manager.OnDispatchEventProcessed(eventId, actionTime)); 131 eventId = -1; 132 actionTime = -2; 133 ASSERT_NO_FATAL_FAILURE(manager.OnDispatchEventProcessed(eventId, actionTime)); 134 } 135 136 /** 137 * @tc.name: InputHandlerManagerTest_OnDispatchEventProcessed_002 138 * @tc.desc: Test the funcation OnDispatchEventProcessed 139 * @tc.type: FUNC 140 * @tc.require: 141 */ 142 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnDispatchEventProcessed_002, TestSize.Level1) 143 { 144 MyInputHandlerManager manager; 145 int32_t eventId = 2; 146 int64_t actionTime = 3; 147 manager.mouseEventIds_.insert(10); 148 ASSERT_NO_FATAL_FAILURE(manager.OnDispatchEventProcessed(eventId, actionTime)); 149 eventId = 10; 150 ASSERT_NO_FATAL_FAILURE(manager.OnDispatchEventProcessed(eventId, actionTime)); 151 } 152 153 /** 154 * @tc.name: InputHandlerManagerTest_GetNextId_001 155 * @tc.desc: Verify GetNextId 156 * @tc.type: FUNC 157 * @tc.require: 158 */ 159 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_GetNextId_001, TestSize.Level3) 160 { 161 MyInputHandlerManager manager; 162 manager.nextId_ = std::numeric_limits<int32_t>::max(); 163 int32_t result = manager.GetNextId(); 164 ASSERT_EQ(result, INVALID_HANDLER_ID); 165 } 166 167 /** 168 * @tc.name: InputHandlerManagerTest_GetNextId_002 169 * @tc.desc: Verify GetNextId 170 * @tc.type: FUNC 171 * @tc.require: 172 */ 173 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_GetNextId_002, TestSize.Level2) 174 { 175 MyInputHandlerManager manager; 176 manager.nextId_ = 5; 177 int32_t result = manager.GetNextId(); 178 ASSERT_EQ(result, 5); 179 } 180 181 /** 182 * @tc.name: InputHandlerManagerTest_FindHandler_002 183 * @tc.desc: Verify FindHandler 184 * @tc.type: FUNC 185 * @tc.require: 186 */ 187 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_FindHandler_002, TestSize.Level1) 188 { 189 MYInputHandlerManager manager; 190 int32_t handlerId = 1; 191 InputHandlerManager::Handler handler; 192 std::shared_ptr<IInputEventConsumer> consumer = nullptr; 193 handler.consumer_ = consumer; 194 manager.monitorHandlers_[handlerId] = handler; 195 std::shared_ptr<IInputEventConsumer> result = manager.FindHandler(handlerId); 196 ASSERT_EQ(result, consumer); 197 } 198 199 /** 200 * @tc.name: InputHandlerManagerTest_FindHandler_003 201 * @tc.desc: Verify FindHandler 202 * @tc.type: FUNC 203 * @tc.require: 204 */ 205 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_FindHandler_003, TestSize.Level2) 206 { 207 MYInputHandlerManager manager; 208 int32_t handlerId = 1; 209 std::shared_ptr<IInputEventConsumer> result = manager.FindHandler(handlerId); 210 ASSERT_EQ(result, nullptr); 211 } 212 213 /** 214 * @tc.name: InputHandlerManagerTest_FindHandler_004 215 * @tc.desc: Verify FindHandler 216 * @tc.type: FUNC 217 * @tc.require: 218 */ 219 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_FindHandler_004, TestSize.Level1) 220 { 221 MyInputHandlerManager manager; 222 int32_t handlerId = 1; 223 InputHandlerManager::Handler handler; 224 handler.handlerId_ = 1; 225 manager.interHandlers_.push_back(handler); 226 std::shared_ptr<IInputEventConsumer> result = manager.FindHandler(handlerId); 227 EXPECT_EQ(result, nullptr); 228 } 229 230 /** 231 * @tc.name: InputHandlerManagerTest_FindHandler_005 232 * @tc.desc: Verify FindHandler 233 * @tc.type: FUNC 234 * @tc.require: 235 */ 236 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_FindHandler_005, TestSize.Level1) 237 { 238 MyInputHandlerManager manager; 239 int32_t handlerId = 5; 240 InputHandlerManager::Handler handler; 241 handler.handlerId_ = 1; 242 manager.interHandlers_.push_back(handler); 243 std::shared_ptr<IInputEventConsumer> result = manager.FindHandler(handlerId); 244 EXPECT_EQ(result, nullptr); 245 } 246 247 /** 248 * @tc.name: InputHandlerManagerTest_OnDispatchEventProcessed_003 249 * @tc.desc: Verify OnDispatchEventProcessed 250 * @tc.type: FUNC 251 * @tc.require: 252 */ 253 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnDispatchEventProcessed_003, TestSize.Level2) 254 { 255 MyInputHandlerManager manager; 256 int32_t eventId = 4; 257 int64_t actionTime = 2; 258 manager.mouseEventIds_.insert(1); 259 manager.mouseEventIds_.insert(2); 260 manager.mouseEventIds_.insert(3); 261 ASSERT_NO_FATAL_FAILURE(manager.OnDispatchEventProcessed(eventId, actionTime)); 262 } 263 264 /** 265 * @tc.name: InputHandlerManagerTest_OnDispatchEventProcessed_004 266 * @tc.desc: Verify OnDispatchEventProcessed 267 * @tc.type: FUNC 268 * @tc.require: 269 */ 270 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnDispatchEventProcessed_004, TestSize.Level2) 271 { 272 MyInputHandlerManager manager; 273 int32_t eventId = 10; 274 int64_t actionTime = 2; 275 manager.mouseEventIds_.insert(1); 276 manager.mouseEventIds_.insert(2); 277 manager.mouseEventIds_.insert(3); 278 ASSERT_NO_FATAL_FAILURE(manager.OnDispatchEventProcessed(eventId, actionTime)); 279 } 280 281 /** 282 * @tc.name: InputHandlerManagerTest_OnDispatchEventProcessed_005 283 * @tc.desc: Verify OnDispatchEventProcessed 284 * @tc.type: FUNC 285 * @tc.require: 286 */ 287 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnDispatchEventProcessed_005, TestSize.Level1) 288 { 289 MyInputHandlerManager manager; 290 int32_t eventId = 1; 291 int64_t actionTime = 2; 292 manager.mouseEventIds_.insert(2); 293 manager.mouseEventIds_.insert(3); 294 ASSERT_NO_FATAL_FAILURE(manager.OnDispatchEventProcessed(eventId, actionTime)); 295 } 296 297 /** 298 * @tc.name: InputHandlerManagerTest_OnDispatchEventProcessed_006 299 * @tc.desc: Verify OnDispatchEventProcessed 300 * @tc.type: FUNC 301 * @tc.require: 302 */ 303 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnDispatchEventProcessed_006, TestSize.Level3) 304 { 305 MyInputHandlerManager manager; 306 int32_t eventId = 2; 307 int64_t actionTime = 2; 308 manager.mouseEventIds_.insert(1); 309 manager.mouseEventIds_.insert(2); 310 manager.mouseEventIds_.insert(3); 311 ASSERT_NO_FATAL_FAILURE(manager.OnDispatchEventProcessed(eventId, actionTime)); 312 } 313 314 /** 315 * @tc.name: InputHandlerManagerTest_CheckInputDeviceSource_001 316 * @tc.desc: Verify CheckInputDeviceSource 317 * @tc.type: FUNC 318 * @tc.require: 319 */ 320 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_CheckInputDeviceSource_001, TestSize.Level2) 321 { 322 MyInputHandlerManager manager; 323 uint32_t deviceTags = 4; 324 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 325 ASSERT_NE(pointerEvent, nullptr); 326 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 327 bool result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 328 EXPECT_TRUE(result); 329 deviceTags = 5; 330 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 331 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 332 EXPECT_TRUE(result); 333 334 deviceTags = 8; 335 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 336 EXPECT_TRUE(result); 337 338 deviceTags = 0; 339 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 340 EXPECT_FALSE(result); 341 } 342 343 /** 344 * @tc.name: InputHandlerManagerTest_CheckInputDeviceSource_002 345 * @tc.desc: Verify CheckInputDeviceSource 346 * @tc.type: FUNC 347 * @tc.require: 348 */ 349 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_CheckInputDeviceSource_002, TestSize.Level1) 350 { 351 MyInputHandlerManager manager; 352 uint32_t deviceTags = 2; 353 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 354 ASSERT_NE(pointerEvent, nullptr); 355 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 356 bool result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 357 EXPECT_TRUE(result); 358 deviceTags = 3; 359 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 360 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 361 EXPECT_TRUE(result); 362 deviceTags = 1; 363 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 364 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 365 EXPECT_FALSE(result); 366 } 367 368 /** 369 * @tc.name: InputHandlerManagerTest_CheckInputDeviceSource_003 370 * @tc.desc: Verify CheckInputDeviceSource 371 * @tc.type: FUNC 372 * @tc.require: 373 */ 374 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_CheckInputDeviceSource_003, TestSize.Level1) 375 { 376 MyInputHandlerManager manager; 377 uint32_t deviceTags = 2; 378 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 379 ASSERT_NE(pointerEvent, nullptr); 380 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK); 381 bool result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 382 EXPECT_FALSE(result); 383 deviceTags = 10; 384 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK); 385 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 386 EXPECT_FALSE(result); 387 } 388 389 /** 390 * @tc.name: InputHandlerManagerTest_CheckInputDeviceSource_005 391 * @tc.desc: Verify CheckInputDeviceSource 392 * @tc.type: FUNC 393 * @tc.require: 394 */ 395 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_CheckInputDeviceSource_005, TestSize.Level1) 396 { 397 MyInputHandlerManager manager; 398 uint32_t deviceTags = 2; 399 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 400 ASSERT_NE(pointerEvent, nullptr); 401 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 402 bool result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 403 EXPECT_TRUE(result); 404 deviceTags = 3; 405 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 406 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 407 EXPECT_TRUE(result); 408 deviceTags = 1; 409 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 410 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 411 EXPECT_FALSE(result); 412 } 413 414 /** 415 * @tc.name: InputHandlerManagerTest_RecoverPointerEvent 416 * @tc.desc: Test RecoverPointerEvent 417 * @tc.type: FUNC 418 * @tc.require: 419 */ 420 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_RecoverPointerEvent, TestSize.Level1) 421 { 422 CALL_TEST_DEBUG; 423 MYInputHandlerManager inputHdlMgr; 424 inputHdlMgr.lastPointerEvent_ = PointerEvent::Create(); 425 ASSERT_NE(inputHdlMgr.lastPointerEvent_, nullptr); 426 inputHdlMgr.lastPointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 427 std::initializer_list<int32_t> pointerActionEvents { 428 PointerEvent::POINTER_ACTION_DOWN, PointerEvent::POINTER_ACTION_UP}; 429 int32_t pointerActionEvent = PointerEvent::POINTER_ACTION_DOWN; 430 inputHdlMgr.lastPointerEvent_->SetPointerId(0); 431 PointerEvent::PointerItem item; 432 item.SetPointerId(1); 433 inputHdlMgr.lastPointerEvent_->AddPointerItem(item); 434 EXPECT_FALSE(inputHdlMgr.RecoverPointerEvent(pointerActionEvents, pointerActionEvent)); 435 436 inputHdlMgr.lastPointerEvent_->SetPointerId(1); 437 EXPECT_TRUE(inputHdlMgr.RecoverPointerEvent(pointerActionEvents, pointerActionEvent)); 438 439 inputHdlMgr.lastPointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE); 440 EXPECT_FALSE(inputHdlMgr.RecoverPointerEvent(pointerActionEvents, pointerActionEvent)); 441 } 442 443 /** 444 * @tc.name: InputHandlerManagerTest_OnDisconnected 445 * @tc.desc: Test OnDisconnected 446 * @tc.type: FUNC 447 * @tc.require: 448 */ 449 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnDisconnected, TestSize.Level3) 450 { 451 CALL_TEST_DEBUG; 452 MYInputHandlerManager inputHdlMgr; 453 inputHdlMgr.lastPointerEvent_ = PointerEvent::Create(); 454 ASSERT_NE(inputHdlMgr.lastPointerEvent_, nullptr); 455 inputHdlMgr.lastPointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_BEGIN); 456 inputHdlMgr.lastPointerEvent_->SetPointerId(1); 457 PointerEvent::PointerItem item; 458 item.SetPointerId(1); 459 inputHdlMgr.lastPointerEvent_->AddPointerItem(item); 460 EXPECT_NO_FATAL_FAILURE(inputHdlMgr.OnDisconnected()); 461 462 inputHdlMgr.lastPointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 463 EXPECT_NO_FATAL_FAILURE(inputHdlMgr.OnDisconnected()); 464 } 465 466 /** 467 * @tc.name: InputHandlerManagerTest_IsMatchGesture_001 468 * @tc.desc: Overrides the IsMatchGesture function branch 469 * @tc.type: FUNC 470 * @tc.require: 471 */ 472 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_IsMatchGesture_001, TestSize.Level1) 473 { 474 CALL_TEST_DEBUG; 475 MYInputHandlerManager inputHdlMgr; 476 InputHandlerManager::Handler handler; 477 handler.eventType_ = 0; 478 int32_t action = PointerEvent::TOUCH_ACTION_SWIPE_DOWN; 479 int32_t count = 1; 480 EXPECT_TRUE(inputHdlMgr.IsMatchGesture(handler, action, count)); 481 handler.eventType_ = HANDLE_EVENT_TYPE_TOUCH_GESTURE; 482 handler.handlerId_ = 100; 483 handler.gestureHandler_.gestureType = TOUCH_GESTURE_TYPE_SWIPE; 484 handler.gestureHandler_.fingers = 1; 485 inputHdlMgr.monitorHandlers_.insert(std::make_pair(50, handler)); 486 EXPECT_FALSE(inputHdlMgr.IsMatchGesture(handler, action, count)); 487 inputHdlMgr.monitorHandlers_.insert(std::make_pair(100, handler)); 488 EXPECT_TRUE(inputHdlMgr.IsMatchGesture(handler, action, count)); 489 action = PointerEvent::TOUCH_ACTION_SWIPE_UP; 490 handler.gestureHandler_.fingers = ALL_FINGER_COUNT; 491 inputHdlMgr.monitorHandlers_[1] = handler; 492 EXPECT_TRUE(inputHdlMgr.IsMatchGesture(handler, action, count)); 493 action = PointerEvent::TOUCH_ACTION_SWIPE_RIGHT; 494 EXPECT_TRUE(inputHdlMgr.IsMatchGesture(handler, action, count)); 495 action = PointerEvent::TOUCH_ACTION_SWIPE_LEFT; 496 EXPECT_TRUE(inputHdlMgr.IsMatchGesture(handler, action, count)); 497 action = PointerEvent::TOUCH_ACTION_PINCH_OPENED; 498 handler.gestureHandler_.gestureType = TOUCH_GESTURE_TYPE_PINCH; 499 handler.gestureHandler_.gestureState = false; 500 inputHdlMgr.monitorHandlers_[1] = handler; 501 EXPECT_FALSE(inputHdlMgr.IsMatchGesture(handler, action, count)); 502 action = PointerEvent::TOUCH_ACTION_PINCH_CLOSEED; 503 EXPECT_FALSE(inputHdlMgr.IsMatchGesture(handler, action, count)); 504 action = PointerEvent::TOUCH_ACTION_GESTURE_END; 505 EXPECT_TRUE(inputHdlMgr.IsMatchGesture(handler, action, count)); 506 action = PointerEvent::TOUCH_ACTION_GESTURE_END; 507 handler.gestureHandler_.gestureState = true; 508 inputHdlMgr.monitorHandlers_[1] = handler; 509 EXPECT_FALSE(inputHdlMgr.IsMatchGesture(handler, action, count)); 510 action = 0; 511 EXPECT_FALSE(inputHdlMgr.IsMatchGesture(handler, action, count)); 512 } 513 514 /** 515 * @tc.name: InputHandlerManagerTest_HasHandler_002 516 * @tc.desc: Test the funcation HasHandler 517 * @tc.type: FUNC 518 * @tc.require: 519 */ 520 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_HasHandler_002, TestSize.Level1) 521 { 522 MyInputHandlerManager manager; 523 int32_t handlerId = 2; 524 InputHandlerManager::Handler handler; 525 handler.handlerId_ = 2; 526 manager.interHandlers_.push_back(handler); 527 bool ret = manager.HasHandler(handlerId); 528 ASSERT_TRUE(ret); 529 handlerId = 3; 530 ret = manager.HasHandler(handlerId); 531 ASSERT_FALSE(ret); 532 } 533 534 /** 535 * @tc.name: InputHandlerManagerTest_CheckInputDeviceSource_004 536 * @tc.desc: Test the funcation CheckInputDeviceSource 537 * @tc.type: FUNC 538 * @tc.require: 539 */ 540 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_CheckInputDeviceSource_004, TestSize.Level2) 541 { 542 MyInputHandlerManager manager; 543 uint32_t deviceTags = 1; 544 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 545 ASSERT_NE(pointerEvent, nullptr); 546 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 547 bool result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 548 ASSERT_FALSE(result); 549 deviceTags = 2; 550 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 551 ASSERT_FALSE(result); 552 deviceTags = 4; 553 result = manager.CheckInputDeviceSource(pointerEvent, deviceTags); 554 ASSERT_TRUE(result); 555 } 556 557 /** 558 * @tc.name: InputHandlerManagerTest_IsPinchType_001 559 * @tc.desc: Test the funcation IsPinchType 560 * @tc.type: FUNC 561 * @tc.require: 562 */ 563 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_IsPinchType_001, TestSize.Level1) 564 { 565 MyInputHandlerManager manager; 566 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 567 ASSERT_NE(pointerEvent, nullptr); 568 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 569 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN); 570 bool ret = manager.IsPinchType(pointerEvent); 571 ASSERT_TRUE(ret); 572 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE); 573 ret = manager.IsPinchType(pointerEvent); 574 ASSERT_TRUE(ret); 575 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END); 576 ret = manager.IsPinchType(pointerEvent); 577 ASSERT_TRUE(ret); 578 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_DOWN); 579 ret = manager.IsPinchType(pointerEvent); 580 ASSERT_FALSE(ret); 581 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 582 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN); 583 ret = manager.IsPinchType(pointerEvent); 584 ASSERT_TRUE(ret); 585 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_UPDATE); 586 ret = manager.IsPinchType(pointerEvent); 587 ASSERT_TRUE(ret); 588 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_END); 589 ret = manager.IsPinchType(pointerEvent); 590 ASSERT_TRUE(ret); 591 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_BUTTON_UP); 592 ret = manager.IsPinchType(pointerEvent); 593 ASSERT_FALSE(ret); 594 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK); 595 ret = manager.IsPinchType(pointerEvent); 596 ASSERT_FALSE(ret); 597 } 598 599 /** 600 * @tc.name: InputHandlerManagerTest_IsRotateType_001 601 * @tc.desc: Test the funcation IsRotateType 602 * @tc.type: FUNC 603 * @tc.require: 604 */ 605 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_IsRotateType_001, TestSize.Level1) 606 { 607 MyInputHandlerManager manager; 608 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 609 ASSERT_NE(pointerEvent, nullptr); 610 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 611 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_ROTATE_BEGIN); 612 bool ret = manager.IsRotateType(pointerEvent); 613 ASSERT_TRUE(ret); 614 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_ROTATE_UPDATE); 615 ret = manager.IsRotateType(pointerEvent); 616 ASSERT_TRUE(ret); 617 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_ROTATE_END); 618 ret = manager.IsRotateType(pointerEvent); 619 ASSERT_TRUE(ret); 620 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_TRIPTAP); 621 ret = manager.IsRotateType(pointerEvent); 622 ASSERT_FALSE(ret); 623 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 624 ret = manager.IsRotateType(pointerEvent); 625 ASSERT_FALSE(ret); 626 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_ROTATE_UPDATE); 627 ret = manager.IsRotateType(pointerEvent); 628 ASSERT_FALSE(ret); 629 } 630 631 /** 632 * @tc.name: InputHandlerManagerTest_IsThreeFingersSwipeType_001 633 * @tc.desc: Test the funcation IsThreeFingersSwipeType 634 * @tc.type: FUNC 635 * @tc.require: 636 */ 637 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_IsThreeFingersSwipeType_001, TestSize.Level1) 638 { 639 MyInputHandlerManager manager; 640 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 641 ASSERT_NE(pointerEvent, nullptr); 642 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 643 pointerEvent->SetFingerCount(THREE_FINGERS); 644 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_BEGIN); 645 bool ret = manager.IsThreeFingersSwipeType(pointerEvent); 646 ASSERT_TRUE(ret); 647 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_UPDATE); 648 ret = manager.IsThreeFingersSwipeType(pointerEvent); 649 ASSERT_TRUE(ret); 650 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_END); 651 ret = manager.IsThreeFingersSwipeType(pointerEvent); 652 ASSERT_TRUE(ret); 653 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_ROTATE_BEGIN); 654 ret = manager.IsThreeFingersSwipeType(pointerEvent); 655 ASSERT_FALSE(ret); 656 pointerEvent->SetFingerCount(TEN_FINGERS); 657 ret = manager.IsThreeFingersSwipeType(pointerEvent); 658 ASSERT_FALSE(ret); 659 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK); 660 ret = manager.IsThreeFingersSwipeType(pointerEvent); 661 ASSERT_FALSE(ret); 662 } 663 664 /** 665 * @tc.name: InputHandlerManagerTest_IsFourFingersSwipeType_001 666 * @tc.desc: Test the funcation IsFourFingersSwipeType 667 * @tc.type: FUNC 668 * @tc.require: 669 */ 670 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_IsFourFingersSwipeType_001, TestSize.Level1) 671 { 672 MyInputHandlerManager manager; 673 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 674 ASSERT_NE(pointerEvent, nullptr); 675 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 676 pointerEvent->SetFingerCount(FOUR_FINGERS); 677 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_BEGIN); 678 bool ret = manager.IsFourFingersSwipeType(pointerEvent); 679 ASSERT_TRUE(ret); 680 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_UPDATE); 681 ret = manager.IsFourFingersSwipeType(pointerEvent); 682 ASSERT_TRUE(ret); 683 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_END); 684 ret = manager.IsFourFingersSwipeType(pointerEvent); 685 ASSERT_TRUE(ret); 686 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_ROTATE_BEGIN); 687 ret = manager.IsFourFingersSwipeType(pointerEvent); 688 ASSERT_FALSE(ret); 689 pointerEvent->SetFingerCount(TEN_FINGERS); 690 ret = manager.IsThreeFingersSwipeType(pointerEvent); 691 ASSERT_FALSE(ret); 692 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK); 693 ret = manager.IsFourFingersSwipeType(pointerEvent); 694 ASSERT_FALSE(ret); 695 } 696 697 /** 698 * @tc.name: InputHandlerManagerTest_IsThreeFingersTapType_001 699 * @tc.desc: Test the funcation IsThreeFingersTapType 700 * @tc.type: FUNC 701 * @tc.require: 702 */ 703 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_IsThreeFingersTapType_001, TestSize.Level1) 704 { 705 MyInputHandlerManager manager; 706 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 707 ASSERT_NE(pointerEvent, nullptr); 708 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 709 pointerEvent->SetFingerCount(THREE_FINGERS); 710 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_TRIPTAP); 711 bool ret = manager.IsThreeFingersTapType(pointerEvent); 712 ASSERT_TRUE(ret); 713 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_UPDATE); 714 ret = manager.IsThreeFingersTapType(pointerEvent); 715 ASSERT_FALSE(ret); 716 pointerEvent->SetFingerCount(TEN_FINGERS); 717 ret = manager.IsThreeFingersTapType(pointerEvent); 718 ASSERT_FALSE(ret); 719 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_JOYSTICK); 720 ret = manager.IsThreeFingersTapType(pointerEvent); 721 ASSERT_FALSE(ret); 722 } 723 724 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT 725 /** 726 * @tc.name: InputHandlerManagerTest_IsFingerprintType_001 727 * @tc.desc: Test the funcation IsFingerprintType 728 * @tc.type: FUNC 729 * @tc.require: 730 */ 731 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_IsFingerprintType_001, TestSize.Level1) 732 { 733 MyInputHandlerManager manager; 734 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 735 ASSERT_NE(pointerEvent, nullptr); 736 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 737 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_HOVER_EXIT); 738 bool ret = manager.IsFingerprintType(pointerEvent); 739 ASSERT_FALSE(ret); 740 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_FINGERPRINT); 741 ret = manager.IsFingerprintType(pointerEvent); 742 ASSERT_FALSE(ret); 743 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_FINGERPRINT_SLIDE); 744 ret = manager.IsFingerprintType(pointerEvent); 745 ASSERT_TRUE(ret); 746 747 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_FINGERPRINT_CLICK); 748 ret = manager.IsFingerprintType(pointerEvent); 749 ASSERT_TRUE(ret); 750 751 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_FINGERPRINT_CANCEL); 752 ret = manager.IsFingerprintType(pointerEvent); 753 ASSERT_TRUE(ret); 754 755 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_FINGERPRINT_HOLD); 756 ret = manager.IsFingerprintType(pointerEvent); 757 ASSERT_TRUE(ret); 758 759 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_FINGERPRINT_TOUCH); 760 ret = manager.IsFingerprintType(pointerEvent); 761 ASSERT_TRUE(ret); 762 } 763 #endif // OHOS_BUILD_ENABLE_FINGERPRINT 764 765 #ifdef OHOS_BUILD_ENABLE_X_KEY 766 /** 767 * @tc.name: InputHandlerManagerTest_IsXKeyType_001 768 * @tc.desc: Test the funcation IsXKeyType 769 * @tc.type: FUNC 770 * @tc.require: 771 */ 772 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_IsXKeyType_001, TestSize.Level1) 773 { 774 MyInputHandlerManager manager; 775 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 776 ASSERT_NE(pointerEvent, nullptr); 777 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 778 bool ret = manager.IsXKeyType(pointerEvent); 779 ASSERT_FALSE(ret); 780 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_X_KEY); 781 ret = manager.IsXKeyType(pointerEvent); 782 ASSERT_TRUE(ret); 783 } 784 #endif // OHOS_BUILD_ENABLE_X_KEY 785 786 /** 787 * @tc.name: InputHandlerManagerTest_CheckIfNeedAddToConsumerInfos_001 788 * @tc.desc: Test the funcation CheckIfNeedAddToConsumerInfos 789 * @tc.type: FUNC 790 * @tc.require: 791 */ 792 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_CheckIfNeedAddToConsumerInfos_001, TestSize.Level1) 793 { 794 MyInputHandlerManager manager; 795 InputHandlerManager::Handler handler; 796 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 797 ASSERT_NE(pointerEvent, nullptr); 798 799 handler.eventType_ = HANDLE_EVENT_TYPE_POINTER; 800 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 801 pointerEvent->SetFingerCount(THREE_FINGERS); 802 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_TRIPTAP); 803 bool ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 804 ASSERT_TRUE(ret); 805 806 handler.eventType_ = HANDLE_EVENT_TYPE_TOUCH_GESTURE; 807 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 808 ASSERT_TRUE(ret); 809 810 handler.eventType_ = HANDLE_EVENT_TYPE_SWIPEINWARD; 811 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 812 ASSERT_TRUE(ret); 813 814 handler.eventType_ = HANDLE_EVENT_TYPE_TOUCH; 815 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 816 ASSERT_FALSE(ret); 817 818 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 819 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 820 ASSERT_TRUE(ret); 821 822 handler.eventType_ = HANDLE_EVENT_TYPE_MOUSE; 823 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 824 ASSERT_FALSE(ret); 825 826 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 827 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 828 ASSERT_TRUE(ret); 829 } 830 831 /** 832 * @tc.name: InputHandlerManagerTest_CheckIfNeedAddToConsumerInfos_002 833 * @tc.desc: Test the funcation CheckIfNeedAddToConsumerInfos 834 * @tc.type: FUNC 835 * @tc.require: 836 */ 837 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_CheckIfNeedAddToConsumerInfos_002, TestSize.Level1) 838 { 839 MyInputHandlerManager manager; 840 InputHandlerManager::Handler handler; 841 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 842 ASSERT_NE(pointerEvent, nullptr); 843 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 844 pointerEvent->SetFingerCount(THREE_FINGERS); 845 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_TRIPTAP); 846 847 handler.eventType_ = HANDLE_EVENT_TYPE_PINCH; 848 auto ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 849 ASSERT_FALSE(ret); 850 851 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 852 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN); 853 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 854 ASSERT_TRUE(ret); 855 856 handler.eventType_ = HANDLE_EVENT_TYPE_THREEFINGERSSWIP; 857 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 858 ASSERT_FALSE(ret); 859 860 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_BEGIN); 861 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 862 ASSERT_TRUE(ret); 863 864 handler.eventType_ = HANDLE_EVENT_TYPE_FOURFINGERSSWIP; 865 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 866 ASSERT_FALSE(ret); 867 868 pointerEvent->SetFingerCount(FOUR_FINGERS); 869 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 870 ASSERT_TRUE(ret); 871 } 872 873 /** 874 * @tc.name: InputHandlerManagerTest_CheckIfNeedAddToConsumerInfos_003 875 * @tc.desc: Test the funcation CheckIfNeedAddToConsumerInfos 876 * @tc.type: FUNC 877 * @tc.require: 878 */ 879 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_CheckIfNeedAddToConsumerInfos_003, TestSize.Level1) 880 { 881 MyInputHandlerManager manager; 882 InputHandlerManager::Handler handler; 883 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 884 ASSERT_NE(pointerEvent, nullptr); 885 handler.eventType_ = HANDLE_EVENT_TYPE_ROTATE; 886 auto ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 887 ASSERT_FALSE(ret); 888 889 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 890 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_ROTATE_BEGIN); 891 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 892 ASSERT_TRUE(ret); 893 894 handler.eventType_ = HANDLE_EVENT_TYPE_THREEFINGERSTAP; 895 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 896 ASSERT_FALSE(ret); 897 898 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHPAD); 899 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_TRIPTAP); 900 pointerEvent->SetFingerCount(THREE_FINGERS); 901 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 902 ASSERT_TRUE(ret); 903 904 #ifdef OHOS_BUILD_ENABLE_FINGERPRINT 905 handler.eventType_ = HANDLE_EVENT_TYPE_FINGERPRINT; 906 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 907 ASSERT_FALSE(ret); 908 909 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_FINGERPRINT); 910 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_FINGERPRINT_HOLD); 911 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 912 ASSERT_TRUE(ret); 913 #endif 914 915 #ifdef OHOS_BUILD_ENABLE_X_KEY 916 handler.eventType_ = HANDLE_EVENT_TYPE_X_KEY; 917 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 918 ASSERT_TRUE(ret); 919 920 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_X_KEY); 921 ret = manager.CheckIfNeedAddToConsumerInfos(handler, pointerEvent); 922 ASSERT_TRUE(ret); 923 #endif 924 } 925 926 /** 927 * @tc.name: InputHandlerManagerTest_RemoveGestureMonitor_001 928 * @tc.desc: Test the funcation RemoveGestureMonitor 929 * @tc.type: FUNC 930 * @tc.require: 931 */ 932 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_RemoveGestureMonitor_001, TestSize.Level1) 933 { 934 MyInputHandlerManager manager; 935 int32_t handlerId = 0; 936 InputHandlerType handlerType = InputHandlerType::MONITOR; 937 auto ret = manager.RemoveGestureMonitor(handlerId, handlerType); 938 EXPECT_EQ(ret, RET_ERR); 939 } 940 941 /** 942 * @tc.name: InputHandlerManagerTest_AddGestureToLocal_001 943 * @tc.desc: Test the funcation AddGestureToLocal 944 * @tc.type: FUNC 945 * @tc.require: 946 */ 947 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_AddGestureToLocal_001, TestSize.Level1) 948 { 949 MyInputHandlerManager manager; 950 int32_t handlerId = 0; 951 HandleEventType eventType = HANDLE_EVENT_TYPE_KEY; 952 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_PINCH; 953 int32_t fingers = THREE_FINGERS; 954 std::shared_ptr<IInputEventConsumer> consumer = nullptr; 955 956 auto ret = manager.AddGestureToLocal(handlerId, eventType, gestureType, fingers, consumer); 957 EXPECT_EQ(ret, RET_ERR); 958 959 eventType = HANDLE_EVENT_TYPE_TOUCH_GESTURE; 960 ret = manager.AddGestureToLocal(handlerId, eventType, gestureType, fingers, consumer); 961 EXPECT_EQ(ret, RET_ERR); 962 } 963 964 /** 965 * @tc.name: InputHandlerManagerTest_AddGestureToLocal_002 966 * @tc.desc: Test the funcation AddGestureToLocal 967 * @tc.type: FUNC 968 * @tc.require: 969 */ 970 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_AddGestureToLocal_002, TestSize.Level1) 971 { 972 MYInputHandlerManager manager; 973 int32_t handlerId = 0; 974 HandleEventType eventType = HANDLE_EVENT_TYPE_TOUCH_GESTURE; 975 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_PINCH; 976 int32_t fingers = THREE_FINGERS; 977 std::shared_ptr<IInputEventConsumer> consumer = nullptr; 978 979 auto ret = manager.AddGestureToLocal(handlerId, eventType, gestureType, fingers, consumer); 980 EXPECT_EQ(ret, RET_OK); 981 982 ret = manager.AddGestureToLocal(handlerId, eventType, gestureType, fingers, consumer); 983 EXPECT_EQ(ret, RET_ERR); 984 985 fingers = FOUR_FINGERS; 986 ret = manager.AddGestureToLocal(handlerId, eventType, gestureType, fingers, consumer); 987 EXPECT_EQ(ret, RET_ERR); 988 989 handlerId++; 990 ret = manager.AddGestureToLocal(handlerId, eventType, gestureType, fingers, consumer); 991 EXPECT_EQ(ret, RET_OK); 992 993 handlerId++; 994 fingers = THREE_FINGERS; 995 gestureType = TOUCH_GESTURE_TYPE_SWIPE; 996 ret = manager.AddGestureToLocal(handlerId, eventType, gestureType, fingers, consumer); 997 EXPECT_EQ(ret, RET_OK); 998 } 999 1000 /** 1001 * @tc.name: InputHandlerManagerTest_AddLocal_001 1002 * @tc.desc: Test the funcation AddLocal 1003 * @tc.type: FUNC 1004 * @tc.require: 1005 */ 1006 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_AddLocal_001, TestSize.Level1) 1007 { 1008 MYInputHandlerManager manager; 1009 int32_t handlerId = 0; 1010 InputHandlerType handlerType = InputHandlerType::MONITOR; 1011 HandleEventType eventType = HANDLE_EVENT_TYPE_TOUCH_GESTURE; 1012 int32_t priority = 1; 1013 uint32_t deviceTags = 2; 1014 std::shared_ptr<IInputEventConsumer> consumer = nullptr; 1015 1016 auto ret = manager.AddLocal(handlerId, handlerType, eventType, priority, deviceTags, consumer); 1017 EXPECT_EQ(ret, RET_OK); 1018 1019 ret = manager.AddLocal(handlerId, handlerType, eventType, priority, deviceTags, consumer); 1020 EXPECT_EQ(ret, RET_ERR); 1021 } 1022 1023 /** 1024 * @tc.name: InputHandlerManagerTest_RemoveLocal_001 1025 * @tc.desc: Test the funcation RemoveLocal 1026 * @tc.type: FUNC 1027 * @tc.require: 1028 */ 1029 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_RemoveLocal_001, TestSize.Level1) 1030 { 1031 MYInputHandlerManager manager; 1032 InputHandlerManager::Handler handle; 1033 int32_t handlerId = 0; 1034 1035 manager.monitorHandlers_.emplace(handlerId, handle); 1036 InputHandlerType handlerType = InputHandlerType::MONITOR; 1037 uint32_t deviceTags = 2; 1038 auto ret = manager.RemoveLocal(handlerId, handlerType, deviceTags); 1039 EXPECT_EQ(ret, RET_ERR); 1040 } 1041 1042 #ifdef OHOS_BUILD_ENABLE_KEYBOARD 1043 /** 1044 * @tc.name: InputHandlerManagerTest_OnInputEvent_001 1045 * @tc.desc: Test the funcation OnInputEvent 1046 * @tc.type: FUNC 1047 * @tc.require: 1048 */ 1049 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnInputEvent_001, TestSize.Level1) 1050 { 1051 MYInputHandlerManager manager; 1052 InputHandlerManager::Handler handle; 1053 handle.eventType_ = 0; 1054 int32_t handlerId = 0; 1055 1056 manager.monitorHandlers_.emplace(handlerId, handle); 1057 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1058 ASSERT_NE(keyEvent, nullptr); 1059 uint32_t deviceTags = 2; 1060 EXPECT_NO_FATAL_FAILURE(manager.OnInputEvent(keyEvent, deviceTags)); 1061 } 1062 1063 /** 1064 * @tc.name: InputHandlerManagerTest_OnInputEvent_002 1065 * @tc.desc: Test the funcation OnInputEvent 1066 * @tc.type: FUNC 1067 * @tc.require: 1068 */ 1069 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnInputEvent_002, TestSize.Level1) 1070 { 1071 MyInputHandlerManager manager; 1072 InputHandlerManager::Handler handle; 1073 handle.eventType_ = 0; 1074 int32_t handlerId = 0; 1075 1076 manager.interHandlers_.push_back(handle); 1077 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 1078 ASSERT_NE(keyEvent, nullptr); 1079 uint32_t deviceTags = 2; 1080 EXPECT_NO_FATAL_FAILURE(manager.OnInputEvent(keyEvent, deviceTags)); 1081 } 1082 #endif 1083 1084 /** 1085 * @tc.name: InputHandlerManagerTest_GetConsumerInfos_001 1086 * @tc.desc: Test the funcation GetConsumerInfos 1087 * @tc.type: FUNC 1088 * @tc.require: 1089 */ 1090 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_GetConsumerInfos_001, TestSize.Level1) 1091 { 1092 MyInputHandlerManager manager; 1093 InputHandlerManager::Handler handle; 1094 handle.eventType_ = 0; 1095 handle.deviceTags_ = 0; 1096 int32_t handlerId = 0; 1097 1098 manager.interHandlers_.push_back(handle); 1099 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 1100 ASSERT_NE(pointerEvent, nullptr); 1101 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE); 1102 uint32_t deviceTags = 2; 1103 std::map<int32_t, std::shared_ptr<IInputEventConsumer>> consumerInfos; 1104 EXPECT_NO_FATAL_FAILURE(manager.GetConsumerInfos(pointerEvent, deviceTags, consumerInfos)); 1105 EXPECT_EQ(consumerInfos.size(), 0); 1106 1107 manager.interHandlers_.clear(); 1108 handle.eventType_ = HANDLE_EVENT_TYPE_POINTER; 1109 manager.interHandlers_.push_back(handle); 1110 1111 EXPECT_NO_FATAL_FAILURE(manager.GetConsumerInfos(pointerEvent, deviceTags, consumerInfos)); 1112 EXPECT_EQ(consumerInfos.size(), 0); 1113 manager.interHandlers_.clear(); 1114 handle.deviceTags_ = 2; 1115 manager.interHandlers_.push_back(handle); 1116 1117 EXPECT_NO_FATAL_FAILURE(manager.GetConsumerInfos(pointerEvent, deviceTags, consumerInfos)); 1118 EXPECT_EQ(consumerInfos.size(), 0); 1119 1120 deviceTags = 1; 1121 EXPECT_NO_FATAL_FAILURE(manager.GetConsumerInfos(pointerEvent, deviceTags, consumerInfos)); 1122 EXPECT_EQ(consumerInfos.size(), 0); 1123 } 1124 1125 /** 1126 * @tc.name: InputHandlerManagerTest_RegisterGestureMonitors_001 1127 * @tc.desc: Test the funcation RegisterGestureMonitors 1128 * @tc.type: FUNC 1129 * @tc.require: 1130 */ 1131 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_RegisterGestureMonitors_001, TestSize.Level1) 1132 { 1133 MyInputHandlerManager manager; 1134 InputHandlerManager::Handler handle; 1135 handle.eventType_ = 0; 1136 handle.deviceTags_ = 0; 1137 int32_t handlerId = 0; 1138 1139 manager.monitorHandlers_.emplace(handlerId, handle); 1140 EXPECT_NO_FATAL_FAILURE(manager.RegisterGestureMonitors()); 1141 1142 handlerId++; 1143 handle.eventType_ = HANDLE_EVENT_TYPE_TOUCH_GESTURE; 1144 manager.monitorHandlers_.emplace(handlerId, handle); 1145 EXPECT_NO_FATAL_FAILURE(manager.RegisterGestureMonitors()); 1146 } 1147 1148 /** 1149 * @tc.name: InputHandlerManagerTest_OnConnected_001 1150 * @tc.desc: Test the funcation OnConnected 1151 * @tc.type: FUNC 1152 * @tc.require: 1153 */ 1154 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnConnected_001, TestSize.Level1) 1155 { 1156 MYInputHandlerManager manager; 1157 EXPECT_NO_FATAL_FAILURE(manager.OnConnected()); 1158 1159 InputHandlerManager::Handler handle; 1160 handle.eventType_ = HANDLE_EVENT_TYPE_TOUCH_GESTURE; 1161 int32_t handlerId = 0; 1162 manager.monitorHandlers_.emplace(handlerId, handle); 1163 EXPECT_NO_FATAL_FAILURE(manager.OnConnected()); 1164 } 1165 1166 /** 1167 * @tc.name: InputHandlerManagerTest_monitorCallback_001 1168 * @tc.desc: Test the funcation monitorCallback_ 1169 * @tc.type: FUNC 1170 * @tc.require: 1171 */ 1172 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_monitorCallback_001, TestSize.Level1) 1173 { 1174 MYInputHandlerManager manager; 1175 int32_t eventId = 1; 1176 int64_t actionTime = 2; 1177 EXPECT_NO_FATAL_FAILURE(manager.monitorCallback_(eventId, actionTime)); 1178 EXPECT_NO_FATAL_FAILURE(manager.monitorCallbackConsume_(eventId, actionTime)); 1179 } 1180 1181 /** 1182 * @tc.name: InputHandlerManagerTest_OnInputEvent_other 1183 * @tc.desc: Test the funcation OnInputEvent 1184 * @tc.type: FUNC 1185 * @tc.require: 1186 */ 1187 HWTEST_F(InputHandlerManagerTest, InputHandlerManagerTest_OnInputEvent_other, TestSize.Level1) 1188 { 1189 MYInputHandlerManager manager; 1190 PointerEvent::PointerItem pointerItem; 1191 int32_t validPointerId = 0; 1192 pointerItem.SetPointerId(validPointerId); 1193 1194 auto pointerEvent = PointerEvent::Create(); 1195 pointerEvent->AddPointerItem(pointerItem); 1196 pointerEvent->SetPointerId(validPointerId); 1197 1198 uint32_t deviceTags = 0; 1199 EXPECT_NO_FATAL_FAILURE(manager.OnInputEvent(pointerEvent, deviceTags)); 1200 } 1201 } // namespace MMI 1202 } // namespace OHOS