diff --git a/BUILD.gn b/BUILD.gn index 034f27781d7d6d7127824b70b3d734b1c226516c..d23d0b274d205e7148a2a28ec3d393a05cf5f21d 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -211,6 +211,7 @@ group("mmi_tests") { "service/subscriber/test:mmi_subscriber_tests", "service/touch_event_normalize/test:TouchEventNormalizeTests", "service/touch_event_normalize/test:TouchGestureAdapterTest", + "service/window_manager/test:WindowManagerTests", "test/fuzztest:test", "test/unittest/interfaces:InputNativeHotkeyTest", "test/unittest/interfaces:InputNativeTest", diff --git a/frameworks/proxy/events/test/input_manager_test.cpp b/frameworks/proxy/events/test/input_manager_test.cpp index 2621e0a926d847dd0c245d3f6e3ba1a679ddfb67..e19364c91145ad43ff66cdae77b6ecdfc02cc71b 100644 --- a/frameworks/proxy/events/test/input_manager_test.cpp +++ b/frameworks/proxy/events/test/input_manager_test.cpp @@ -5907,5 +5907,58 @@ HWTEST_F(InputManagerTest, InputManagerTest_subscribeInputActive, TestSize.Level int32_t subscriberId = INVAID_VALUE; ASSERT_NO_FATAL_FAILURE(InputManager::GetInstance()->UnsubscribeInputActive(subscriberId)); } + +/* + * @tc.name: InputManagerTest_SwitchTouchTracking_001 + * @tc.desc: SwitchTouchTracking + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputManagerTest, InputManagerTest_SwitchTouchTracking_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + uid_t uid = ::getuid(); + constexpr uid_t accessibility { 1103 }; + ASSERT_EQ(::setuid(accessibility), RET_OK); + ASSERT_NO_FATAL_FAILURE(InputManager::GetInstance()->SwitchTouchTracking(true)); + auto ret = InputManager::GetInstance()->SwitchTouchTracking(true); + EXPECT_EQ(ret, RET_OK); + ::setuid(uid); +} + +/* + * @tc.name: InputManagerTest_SwitchTouchTracking_002 + * @tc.desc: SwitchTouchTracking + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputManagerTest, InputManagerTest_SwitchTouchTracking_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + uid_t uid = ::getuid(); + constexpr uid_t accessibility { 1103 }; + ASSERT_EQ(::setuid(accessibility), RET_OK); + ASSERT_NO_FATAL_FAILURE(InputManager::GetInstance()->SwitchTouchTracking(false)); + auto ret = InputManager::GetInstance()->SwitchTouchTracking(false); + EXPECT_EQ(ret, RET_OK); + ::setuid(uid); +} + +/* + * @tc.name: InputManagerTest_SwitchTouchTracking_003 + * @tc.desc: Only `accessibility` is allowed to call SwitchTouchTracking. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputManagerTest, InputManagerTest_SwitchTouchTracking_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + uid_t uid = ::getuid(); + constexpr uid_t root { 0 }; + ASSERT_EQ(::setuid(root), RET_OK); + auto ret = InputManager::GetInstance()->SwitchTouchTracking(true); + EXPECT_EQ(ret, PERMISSION_DENIED); + ::setuid(uid); +} } // namespace MMI } // namespace OHOS diff --git a/service/window_manager/test/BUILD.gn b/service/window_manager/test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..064a65b6382edb2f38322f33a33a745335527807 --- /dev/null +++ b/service/window_manager/test/BUILD.gn @@ -0,0 +1,211 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/test.gni") +import("../../../multimodalinput_mini.gni") + +module_output_path = "input/input" + +ohos_unittest("InputWindowsManagerTestWithMock") { + module_out_path = module_output_path + + configs = [ + "${mmi_path}:coverage_flags", + "${mmi_path}/common/anco/comm:mmi_anco_channel_config", + "${mmi_path}/service/connect_manager:mmi_connect_manager_config", + "${mmi_path}/service/filter:mmi_event_filter_config", + ] + + cflags = [ + "-Dprivate=public", + "-Dprotected=public", + ] + + branch_protector_ret = "pac_ret" + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + + include_dirs = [ + "${mmi_path}/interfaces/native/innerkits/common/include", + "${mmi_path}/interfaces/native/innerkits/proxy/include", + "${mmi_path}/service/app_state_manager/include", + "${mmi_path}/service/connect_manager/include", + "${mmi_path}/service/delegate_task/include", + "${mmi_path}/service/device_config/include", + "${mmi_path}/service/device_manager/include", + "${mmi_path}/service/device_state_manager/include", + "${mmi_path}/service/dfx/include", + "${mmi_path}/service/display_state_manager/include", + "${mmi_path}/service/event_dispatch/include", + "${mmi_path}/service/event_handler/include", + "${mmi_path}/service/filter/include", + "${mmi_path}/service/fingersense_wrapper/include", + "${mmi_path}/service/gesturesense_wrapper/include", + "${mmi_path}/service/hardware_cursor_pointer_manager/include", + "${mmi_path}/service/interceptor/include", + "${mmi_path}/service/joystick/include", + "${mmi_path}/service/key_command/include", + "${mmi_path}/service/key_event_normalize/include", + "${mmi_path}/service/libinput_adapter/include", + "${mmi_path}/service/module_loader/include", + "${mmi_path}/service/monitor/include", + "${mmi_path}/service/mouse_event_normalize/include", + "${mmi_path}/service/nap_process/include", + "${mmi_path}/service/subscriber/include", + "${mmi_path}/service/timer_manager/include", + "${mmi_path}/service/touch_event_normalize/include", + "${mmi_path}/service/window_manager/include", + "${mmi_path}/test/facility/mock/include", + "${mmi_path}/util/common/include", + "${mmi_path}/util/network/include", + "${mmi_path}/util/socket/include", + ] + + sources = [ + "${mmi_path}/frameworks/proxy/events/src/pointer_style.cpp", + "${mmi_path}/service/delegate_task/src/delegate_interface.cpp", + "${mmi_path}/service/device_manager/src/input_device_manager.cpp", + "${mmi_path}/service/dfx/src/api_duration_statistics.cpp", + "${mmi_path}/service/dfx/src/dfx_hisysevent.cpp", + "${mmi_path}/service/display_state_manager/src/display_event_monitor.cpp", + "${mmi_path}/service/event_dispatch/src/event_dispatch_handler.cpp", + "${mmi_path}/service/event_handler/src/anr_manager.cpp", + "${mmi_path}/service/event_handler/src/input_event_handler.cpp", + "${mmi_path}/service/fingersense_wrapper/src/fingersense_wrapper.cpp", + "${mmi_path}/service/key_command/src/setting_datashare.cpp", + "${mmi_path}/service/key_command/src/setting_observer.cpp", + "${mmi_path}/service/libinput_adapter/src/property_reader.cpp", + "${mmi_path}/service/module_loader/src/app_debug_listener.cpp", + "${mmi_path}/service/module_loader/src/multimodal_input_preferences_manager.cpp", + "${mmi_path}/service/module_loader/src/uds_server.cpp", + "${mmi_path}/service/timer_manager/src/timer_manager.cpp", + "${mmi_path}/service/window_manager/src/input_display_bind_helper.cpp", + "${mmi_path}/service/window_manager/src/input_windows_manager.cpp", + "${mmi_path}/service/window_manager/src/knuckle_drawing_manager.cpp", + "src/input_windows_manager_test_with_mock.cpp", + ] + + if (input_feature_pointer_drawing) { + sources += [ + "${mmi_path}/service/window_manager/src/pointer_drawing_manager.cpp", + "${mmi_path}/service/window_manager/src/pointer_renderer.cpp", + "${mmi_path}/service/window_manager/src/screen_pointer.cpp", + ] + } else { + sources += [ "${mmi_path}/service/window_manager/src/i_pointer_drawing_manager.cpp" ] + } + + if (input_feature_touch_drawing) { + sources += [ "${mmi_path}/service/window_manager/src/touch_drawing_manager.cpp" ] + } + + if (input_feature_mouse) { + sources += [ + "${mmi_path}/service/mouse_event_normalize/src/mouse_event_normalize.cpp", + "${mmi_path}/service/mouse_event_normalize/src/mouse_transform_processor.cpp", + ] + } + + if (input_feature_combination_key) { + sources += [ + "${mmi_path}/service/key_command/src/pull_throw_subscriber_handler.cpp", + ] + } + + if (input_feature_touchscreen && input_feature_monitor) { + sources += [ + "${mmi_path}/service/touch_event_normalize/src/touch_gesture_adapter.cpp", + "${mmi_path}/service/touch_event_normalize/src/touch_gesture_detector.cpp", + "${mmi_path}/service/touch_event_normalize/src/touch_gesture_manager.cpp", + ] + } + + if (input_ext_feature_anco) { + sources += [ + "${mmi_ext_path}/anco_uds_manager/src/anco_uds_manager.cpp", + "${mmi_ext_path}/anco_uds_manager/src/input_common_monitor.cpp", + "${mmi_ext_path}/anco_uds_manager/src/input_windows_manager_ext.cpp", + ] + } + + defines = input_default_defines + + if (defined(use_rosen_drawing) && use_rosen_drawing) { + defines += [ "USE_ROSEN_DRAWING" ] + } + + deps = [ + "${mmi_path}/service/connect_manager:multimodal_input_interface", + "${mmi_path}/service/filter:mmi_event_filter_proxy", + "${mmi_path}/util:libmmi-util", + ] + + if (input_ext_feature_anco) { + deps += [ "${mmi_path}/common/anco/comm:mmi_anco_channel_proxy" ] + } + + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_manager", + "ability_runtime:abilitykit_native", + "ability_runtime:abilitykit_native", + "ability_runtime:app_manager", + "ability_runtime:dataobs_manager", + "cJSON:cjson", + "c_utils:utils", + "call_manager:tel_call_manager_api", + "common_event_service:cesfwk_innerkits", + "config_policy:configpolicy_util", + "data_share:datashare_consumer", + "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", + "drivers_interface_display:libdisplay_composer_proxy_1.0", + "ffrt:libffrt", + "googletest:gmock_main", + "googletest:gtest_main", + "graphic_2d:2d_graphics", + "graphic_2d:libcomposer", + "graphic_2d:librender_service_client", + "graphic_2d:window_animation", + "hilog:libhilog", + "hisysevent:libhisysevent", + "hitrace:hitrace_meter", + "image_framework:image_native", + "init:libbeget_proxy", + "init:libbegetutil", + "ipc:ipc_single", + "libinput:libinput-third-mmi", + "napi:ace_napi", + "preferences:native_preferences", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + "window_manager:libwm_lite", + "window_manager:libwm", + "window_manager:libwsutils", + ] + + if (security_component_enable) { + external_deps += [ "security_component_manager:libsecurity_component_sdk" ] + } +} + +group("WindowManagerTests") { + testonly = true + + deps = [ + ":InputWindowsManagerTestWithMock", + ] +} diff --git a/service/window_manager/test/src/input_windows_manager_test_with_mock.cpp b/service/window_manager/test/src/input_windows_manager_test_with_mock.cpp new file mode 100644 index 0000000000000000000000000000000000000000..737a997a58755dd039e21b8df61a705f3ab3809c --- /dev/null +++ b/service/window_manager/test/src/input_windows_manager_test_with_mock.cpp @@ -0,0 +1,369 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "define_multimodal.h" +#include "input_event_handler.h" +#include "input_windows_manager.h" + +#undef MMI_LOG_TAG +#define MMI_LOG_TAG "InputWindowsManagerTestWithMock" + +namespace OHOS { +namespace MMI { +namespace { +constexpr int32_t FIRST_DISPLAY_ID { 1 }; +constexpr int32_t DISPLAY_WIDTH { 720 }; +constexpr int32_t DISPLAY_HEIGHT { 1280 }; +constexpr int32_t FIRST_DISPLAY_DPI { 240 }; +constexpr int32_t UPPER_WINDOW_ID { 1 }; +constexpr int32_t LOWER_WINDOW_ID { 2 }; +constexpr int32_t FIRST_POINTER_ID { 0 }; +constexpr int32_t SECOND_POINTER_ID { 1 }; +} + +using namespace testing; +using namespace testing::ext; + +void EventNormalizeHandler::HandleEvent(libinput_event* event, int64_t frameTime) {} + +#ifdef OHOS_BUILD_ENABLE_KEYBOARD +void EventNormalizeHandler::HandleKeyEvent(const std::shared_ptr keyEvent) {} +#endif // OHOS_BUILD_ENABLE_KEYBOARD + +#ifdef OHOS_BUILD_ENABLE_POINTER +void EventNormalizeHandler::HandlePointerEvent(const std::shared_ptr pointerEvent) {} +#endif // OHOS_BUILD_ENABLE_POINTER + +#ifdef OHOS_BUILD_ENABLE_TOUCH +void EventNormalizeHandler::HandleTouchEvent(const std::shared_ptr pointerEvent) +{ + if (nextHandler_ != nullptr) { + nextHandler_->HandleTouchEvent(pointerEvent); + } +} +#endif // OHOS_BUILD_ENABLE_TOUCH + +class InputEventCheater final : public IInputEventHandler { +public: + InputEventCheater() = default; + ~InputEventCheater() override = default; + +#ifdef OHOS_BUILD_ENABLE_KEYBOARD + void HandleKeyEvent(const std::shared_ptr keyEvent) override; +#endif // OHOS_BUILD_ENABLE_KEYBOARD +#ifdef OHOS_BUILD_ENABLE_POINTER + void HandlePointerEvent(const std::shared_ptr pointerEvent) override; +#endif // OHOS_BUILD_ENABLE_POINTER +#ifdef OHOS_BUILD_ENABLE_TOUCH + void HandleTouchEvent(const std::shared_ptr pointerEvent) override; +#endif // OHOS_BUILD_ENABLE_TOUCH + std::shared_ptr GetTouchEvent(); + +private: + std::shared_ptr touchEvent_; +}; + +#ifdef OHOS_BUILD_ENABLE_KEYBOARD +void InputEventCheater::HandleKeyEvent(const std::shared_ptr keyEvent) {} +#endif // OHOS_BUILD_ENABLE_KEYBOARD + +#ifdef OHOS_BUILD_ENABLE_POINTER +void InputEventCheater::HandlePointerEvent(const std::shared_ptr pointerEvent) {} +#endif // OHOS_BUILD_ENABLE_POINTER + +#ifdef OHOS_BUILD_ENABLE_TOUCH +void InputEventCheater::HandleTouchEvent(const std::shared_ptr pointerEvent) +{ + CHKPV(pointerEvent); + touchEvent_ = std::make_shared(*pointerEvent); +} +#endif // OHOS_BUILD_ENABLE_TOUCH + +std::shared_ptr InputEventCheater::GetTouchEvent() +{ + return touchEvent_; +} + +class InputWindowsManagerTestWithMock : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); + +private: + void SetupDisplayInfo(); + std::shared_ptr BuildTouchEvent001(); + std::shared_ptr BuildTouchEvent002(); +}; + +void InputWindowsManagerTestWithMock::SetUpTestCase() +{} + +void InputWindowsManagerTestWithMock::TearDownTestCase() +{} + +void InputWindowsManagerTestWithMock::SetUp() +{ + SetupDisplayInfo(); +} + +void InputWindowsManagerTestWithMock::TearDown() +{} + +void InputWindowsManagerTestWithMock::SetupDisplayInfo() +{ + DisplayGroupInfo displayGroupInfo; + displayGroupInfo.width = DISPLAY_WIDTH; + displayGroupInfo.height = DISPLAY_HEIGHT; + displayGroupInfo.focusWindowId = UPPER_WINDOW_ID; + + WindowInfo upperWin {}; + upperWin.id = UPPER_WINDOW_ID; + upperWin.area = Rect { + .x = 0, + .y = 0, + .width = DISPLAY_WIDTH, + .height = DISPLAY_HEIGHT / 2, + }; + upperWin.defaultHotAreas = { upperWin.area }; + upperWin.pointerHotAreas = { upperWin.area }; + upperWin.agentWindowId = UPPER_WINDOW_ID; + displayGroupInfo.windowsInfo.push_back(upperWin); + + WindowInfo lowerWin {}; + lowerWin.id = LOWER_WINDOW_ID; + lowerWin.area = Rect { + .x = 0, + .y = DISPLAY_HEIGHT / 2, + .width = DISPLAY_WIDTH, + .height = DISPLAY_HEIGHT / 2, + }; + lowerWin.defaultHotAreas = { lowerWin.area }; + lowerWin.pointerHotAreas = { lowerWin.area }; + lowerWin.agentWindowId = LOWER_WINDOW_ID; + lowerWin.action = WINDOW_UPDATE_ACTION::ADD_END; + displayGroupInfo.windowsInfo.push_back(lowerWin); + + DisplayInfo displayInfo {}; + displayInfo.id = FIRST_DISPLAY_ID; + displayInfo.x = 0; + displayInfo.y = 0; + displayInfo.width = DISPLAY_WIDTH; + displayInfo.height = DISPLAY_HEIGHT; + displayInfo.dpi = FIRST_DISPLAY_DPI; + displayInfo.name = "display 0"; + displayInfo.uniq = "default0"; + displayInfo.direction = DIRECTION0; + displayGroupInfo.displaysInfo.push_back(displayInfo); + + WIN_MGR->UpdateDisplayInfo(displayGroupInfo); +} + +std::shared_ptr InputWindowsManagerTestWithMock::BuildTouchEvent001() +{ + auto pointerEvent = PointerEvent::Create(); + CHKPP(pointerEvent); + int32_t touchX { 360 }; + int32_t touchY { 960 }; + + PointerEvent::PointerItem pointerItem {}; + pointerItem.SetPointerId(FIRST_POINTER_ID); + pointerItem.SetDisplayX(touchX); + pointerItem.SetDisplayY(touchY); + pointerItem.SetDisplayXPos(touchX); + pointerItem.SetDisplayYPos(touchY); + pointerItem.SetPressed(true); + pointerItem.SetTargetWindowId(UPPER_WINDOW_ID); + pointerEvent->AddPointerItem(pointerItem); + + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE); + pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); + pointerEvent->SetPointerId(FIRST_POINTER_ID); + pointerEvent->SetTargetWindowId(UPPER_WINDOW_ID); + return pointerEvent; +} + +std::shared_ptr InputWindowsManagerTestWithMock::BuildTouchEvent002() +{ + auto pointerEvent = PointerEvent::Create(); + CHKPP(pointerEvent); + int32_t touchX1 { 360 }; + int32_t touchY1 { 320 }; + + PointerEvent::PointerItem pointerItem {}; + pointerItem.SetPointerId(FIRST_POINTER_ID); + pointerItem.SetDisplayX(touchX1); + pointerItem.SetDisplayY(touchY1); + pointerItem.SetDisplayXPos(touchX1); + pointerItem.SetDisplayYPos(touchY1); + pointerItem.SetPressed(true); + pointerItem.SetTargetWindowId(UPPER_WINDOW_ID); + pointerEvent->AddPointerItem(pointerItem); + + int32_t touchX2 { 360 }; + int32_t touchY2 { 960 }; + + pointerItem.SetPointerId(SECOND_POINTER_ID); + pointerItem.SetDisplayX(touchX2); + pointerItem.SetDisplayY(touchY2); + pointerItem.SetDisplayXPos(touchX2); + pointerItem.SetDisplayYPos(touchY2); + pointerItem.SetPressed(true); + pointerItem.SetTargetWindowId(UPPER_WINDOW_ID); + pointerEvent->AddPointerItem(pointerItem); + + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE); + pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); + pointerEvent->SetPointerId(SECOND_POINTER_ID); + pointerEvent->SetTargetWindowId(UPPER_WINDOW_ID); + return pointerEvent; +} + +/** + * @tc.name: InputWindowsManagerTestWithMock_TouchTracking_001 + * @tc.desc: This feature will be disabled by default, so events will be dispatched to the window first touch on. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputWindowsManagerTestWithMock, InputWindowsManagerTestWithMock_TouchTracking_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + WIN_MGR->SwitchTouchTracking(false); + auto pointerEvent = BuildTouchEvent001(); + ASSERT_NE(pointerEvent, nullptr); + auto ret = WIN_MGR->UpdateTargetPointer(pointerEvent); + ASSERT_EQ(ret, RET_OK); + EXPECT_EQ(pointerEvent->GetTargetWindowId(), UPPER_WINDOW_ID); +} + +/** + * @tc.name: InputWindowsManagerTestWithMock_TouchTracking_002 + * @tc.desc: With this feature enabled, touch events will be dispatched to touched window accordingly. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputWindowsManagerTestWithMock, InputWindowsManagerTestWithMock_TouchTracking_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + WIN_MGR->SwitchTouchTracking(true); + auto pointerEvent = BuildTouchEvent001(); + ASSERT_NE(pointerEvent, nullptr); + auto ret = WIN_MGR->UpdateTargetPointer(pointerEvent); + ASSERT_EQ(ret, RET_OK); + EXPECT_EQ(pointerEvent->GetTargetWindowId(), LOWER_WINDOW_ID); +} + +/** + * @tc.name: InputWindowsManagerTestWithMock_TouchTracking_003 + * @tc.desc: Will skip touch events from accessibility. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputWindowsManagerTestWithMock, InputWindowsManagerTestWithMock_TouchTracking_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + WIN_MGR->SwitchTouchTracking(true); + auto pointerEvent = BuildTouchEvent001(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->AddFlag(InputEvent::EVENT_FLAG_ACCESSIBILITY); + + auto ret = WIN_MGR->UpdateTargetPointer(pointerEvent); + ASSERT_EQ(ret, RET_OK); + EXPECT_EQ(pointerEvent->GetTargetWindowId(), UPPER_WINDOW_ID); +} + +/** + * @tc.name: InputWindowsManagerTestWithMock_TouchTracking_004 + * @tc.desc: This feature only works for single touch. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputWindowsManagerTestWithMock, InputWindowsManagerTestWithMock_TouchTracking_004, TestSize.Level1) +{ + CALL_TEST_DEBUG; + WIN_MGR->SwitchTouchTracking(true); + auto pointerEvent = BuildTouchEvent002(); + ASSERT_NE(pointerEvent, nullptr); + auto ret = WIN_MGR->UpdateTargetPointer(pointerEvent); + ASSERT_EQ(ret, RET_OK); + EXPECT_EQ(pointerEvent->GetTargetWindowId(), UPPER_WINDOW_ID); +} + +/** + * @tc.name: InputWindowsManagerTestWithMock_TouchTracking_005 + * @tc.desc: With this feature enabled, when touch moves onto another window, MMI will dispatch 'CANCEL' to + * previous window, then dispatch 'DOWN' to current window. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputWindowsManagerTestWithMock, InputWindowsManagerTestWithMock_TouchTracking_005, TestSize.Level1) +{ + CALL_TEST_DEBUG; + InputHandler->eventNormalizeHandler_ = std::make_shared(); + auto cheater = std::make_shared(); + InputHandler->eventNormalizeHandler_->SetNext(cheater); + + WIN_MGR->SwitchTouchTracking(true); + auto pointerEvent = BuildTouchEvent001(); + ASSERT_NE(pointerEvent, nullptr); + auto ret = WIN_MGR->UpdateTargetPointer(pointerEvent); + ASSERT_EQ(ret, RET_OK); + + auto touchEvent = cheater->GetTouchEvent(); + ASSERT_NE(touchEvent, nullptr); + EXPECT_EQ(touchEvent->GetPointerAction(), PointerEvent::POINTER_ACTION_CANCEL); + EXPECT_EQ(touchEvent->GetTargetWindowId(), UPPER_WINDOW_ID); + + EXPECT_EQ(pointerEvent->GetPointerAction(), PointerEvent::POINTER_ACTION_DOWN); + EXPECT_EQ(pointerEvent->GetTargetWindowId(), LOWER_WINDOW_ID); +} + +/** + * @tc.name: InputWindowsManagerTestWithMock_TouchTracking_006 + * @tc.desc: With this feature enabled, until touch moves out of the window on which it presses down, + * MMI will dispatch touch events to the window. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(InputWindowsManagerTestWithMock, InputWindowsManagerTestWithMock_TouchTracking_006, TestSize.Level1) +{ + CALL_TEST_DEBUG; + InputHandler->eventNormalizeHandler_ = std::make_shared(); + auto cheater = std::make_shared(); + InputHandler->eventNormalizeHandler_->SetNext(cheater); + + WIN_MGR->SwitchTouchTracking(true); + auto pointerEvent = BuildTouchEvent001(); + ASSERT_NE(pointerEvent, nullptr); + + int32_t touchY { 480 }; + PointerEvent::PointerItem pointerItem {}; + ASSERT_TRUE(pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), pointerItem)); + pointerItem.SetDisplayY(touchY); + pointerItem.SetDisplayYPos(touchY); + pointerEvent->UpdatePointerItem(pointerEvent->GetPointerId(), pointerItem); + + auto ret = WIN_MGR->UpdateTargetPointer(pointerEvent); + ASSERT_EQ(ret, RET_OK); + auto touchEvent = cheater->GetTouchEvent(); + EXPECT_EQ(touchEvent, nullptr); + EXPECT_EQ(pointerEvent->GetPointerAction(), PointerEvent::POINTER_ACTION_MOVE); + EXPECT_EQ(pointerEvent->GetTargetWindowId(), UPPER_WINDOW_ID); +} +} // namespace MMI +} // namespace OHOS