From e339534be1df760e6746e4b6032d80102a57b357 Mon Sep 17 00:00:00 2001 From: wuzhihuitmac Date: Wed, 25 Jun 2025 14:44:49 +0800 Subject: [PATCH] Load touch drawing dynamically(part 2) Signed-off-by: wuzhihuitmac Change-Id: I4bbdbdaac7eea334b8b1f3f0a99ef3335fd2931e --- BUILD.gn | 5 +- service/BUILD.gn | 51 - .../test/touch_drawing_handler_test.cpp | 1658 +++++++++++++++++ .../test/touch_drawing_manager_ai_test.cpp | 681 ------- 4 files changed, 1659 insertions(+), 736 deletions(-) create mode 100644 service/window_manager/test/touch_drawing_handler_test.cpp delete mode 100644 service/window_manager/test/touch_drawing_manager_ai_test.cpp diff --git a/BUILD.gn b/BUILD.gn index d3c8dec2ea..66c12aa84a 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -239,10 +239,7 @@ group("mmi_tests") { } if (input_feature_touch_drawing) { - deps += [ - "service:TouchDrawingManagerAiTest", - "service:TouchDrawingManagerTest", - ] + deps += [ "service:TouchDrawingManagerTest" ] } if (drivers_interface_rtos_extra_enable) { diff --git a/service/BUILD.gn b/service/BUILD.gn index b1aa8dad4a..41dbf924a3 100644 --- a/service/BUILD.gn +++ b/service/BUILD.gn @@ -1124,57 +1124,6 @@ ohos_unittest("PointerDrawingManagerExTest") { ] } -ohos_unittest("TouchDrawingManagerAiTest") { - module_out_path = module_output_path - - configs = [ - "${mmi_path}:coverage_flags", - ":libmmi_server_config", - ] - - cflags = [ - "-Dprivate=public", - "-Dprotected=public", - ] - - branch_protector_ret = "pac_ret" - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false - blocklist = "./ipc_blocklist.txt" - } - - sources = [ "window_manager/test/touch_drawing_manager_ai_test.cpp" ] - - deps = [ - "${mmi_path}/service:libmmi-server", - "${mmi_path}/test/facility/mock:mmi_mock_sources", - "${mmi_path}/util:libmmi-util", - ] - - external_deps = [ - "ability_runtime:dataobs_manager", - "cJSON:cjson", - "c_utils:utils", - "drivers_interface_display:libdisplay_composer_hdi_impl_1.2", - "drivers_interface_display:libdisplay_composer_proxy_1.0", - "googletest:gmock_main", - "googletest:gtest_main", - "graphic_2d:2d_graphics", - "graphic_2d:librender_service_base", - "graphic_2d:librender_service_client", - "graphic_2d:window_animation", - "hilog:libhilog", - "image_framework:image_native", - "init:libbegetutil", - "ipc:ipc_core", - "libinput:libinput-third-mmi", - "window_manager:libwm", - "window_manager:libwsutils", - ] -} - ohos_unittest("TouchDrawingManagerTest") { module_out_path = module_output_path diff --git a/service/window_manager/test/touch_drawing_handler_test.cpp b/service/window_manager/test/touch_drawing_handler_test.cpp new file mode 100644 index 0000000000..fef5ef7186 --- /dev/null +++ b/service/window_manager/test/touch_drawing_handler_test.cpp @@ -0,0 +1,1658 @@ +/* + * 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 +#include + +#include "mmi_log.h" +#include "pointer_event.h" +#ifndef USE_ROSEN_DRAWING +#define USE_ROSEN_DRAWING +#endif +#include "touch_drawing_handler.h" +#include "window_info.h" + +#undef MMI_LOG_TAG +#define MMI_LOG_TAG "TouchDrawingHandlerTest" + +namespace OHOS { +namespace MMI { +namespace { +using namespace testing::ext; +} // namespace + +#ifdef USE_ROSEN_DRAWING +using RosenRecordingCanvas = Rosen::Drawing::RecordingCanvas; +#else +using RosenRecordingCanvas = Rosen::RSRecordingCanvas; +#endif // USE_ROSEN_DRAWING + +class TouchDrawingHandlerTest : public testing::Test { +public: + static void SetUpTestCase(void) {}; + static void TearDownTestCase(void) {}; + void SetUp(void) {}; +}; + +/** + * @tc.name: TouchDrawingHandlerTest_RecordLabelsInfo + * @tc.desc: Test RecordLabelsInfo + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_RecordLabelsInfo, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawMgr; + touchDrawMgr.pointerEvent_ = PointerEvent::Create(); + ASSERT_NE(touchDrawMgr.pointerEvent_, nullptr); + PointerEvent::PointerItem item; + item.SetPointerId(0); + item.SetPressed(true); + item.SetDisplayX(100); + item.SetDisplayY(100); + touchDrawMgr.pointerEvent_->AddPointerItem(item); + touchDrawMgr.pointerEvent_->SetPointerId(0); + touchDrawMgr.currentPointerId_ = 1; + EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); + + touchDrawMgr.currentPointerId_ = 0; + touchDrawMgr.isFirstDownAction_ = true; + touchDrawMgr.lastPointerItem_.push_back(item); + touchDrawMgr.pointerEvent_->SetActionTime(150); + touchDrawMgr.lastActionTime_ = 300; + EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); + + touchDrawMgr.pointerEvent_->SetActionTime(50); + touchDrawMgr.lastActionTime_ = 50; + EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); + + item.SetPressed(false); + touchDrawMgr.isFirstDownAction_ = false; + touchDrawMgr.pointerEvent_->SetPointerId(10); + touchDrawMgr.pointerEvent_->UpdatePointerItem(0, item); + EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); +} + +/** + * @tc.name: TouchDrawingHandlerTest_TouchDrawHandler + * @tc.desc: Test TouchDrawHandler + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_TouchDrawHandler, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawMgr; + std::shared_ptr pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + PointerEvent::PointerItem item; + touchDrawMgr.bubbleMode_.isShow = true; + touchDrawMgr.stopRecord_ = false; + touchDrawMgr.pointerMode_.isShow = true; + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); + pointerEvent->AddPointerItem(item); + EXPECT_NO_FATAL_FAILURE(touchDrawMgr.TouchDrawHandler(pointerEvent)); + + touchDrawMgr.bubbleMode_.isShow = false; + touchDrawMgr.pointerMode_.isShow = false; + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); + EXPECT_NO_FATAL_FAILURE(touchDrawMgr.TouchDrawHandler(pointerEvent)); +} + +/** + * @tc.name: TouchDrawingHandlerTest_UpdateDisplayInfo_001 + * @tc.desc: Test UpdateDisplayInfo + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_UpdateDisplayInfo_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawMgr; + DisplayInfo displayInfo; + displayInfo.direction = Direction::DIRECTION0; + touchDrawMgr.displayInfo_.direction = Direction::DIRECTION0; + displayInfo.width = 700; + displayInfo.height = 500; + EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo)); + + displayInfo.direction = Direction::DIRECTION180; + touchDrawMgr.displayInfo_.direction = Direction::DIRECTION180; + EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo)); + + displayInfo.direction = Direction::DIRECTION270; + touchDrawMgr.displayInfo_.direction = Direction::DIRECTION270; + EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo)); +} + +/** + * @tc.name: TouchDrawingHandlerTest_UpdateDisplayInfo_002 + * @tc.desc: Test UpdateDisplayInfo + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_UpdateDisplayInfo_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + DisplayInfo displayInfo; + displayInfo.direction = Direction::DIRECTION0; + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION0; + displayInfo.width = 700; + displayInfo.height = 500; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); + displayInfo.direction = Direction::DIRECTION180; + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION180; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); + displayInfo.direction = Direction::DIRECTION270; + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION270; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); + displayInfo.screenCombination = ScreenCombination::SCREEN_MAIN; + touchDrawingHandler.displayInfo_.screenCombination = ScreenCombination::SCREEN_MAIN; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); + displayInfo.uniqueId = 1; + touchDrawingHandler.displayInfo_.uniqueId = 2; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); + Rosen::RSSurfaceNodeConfig surfaceNodeConfig; + surfaceNodeConfig.SurfaceNodeName = "touch window"; + Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; + touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdateBubbleData_001 + * @tc.desc: Test UpdateBubbleData + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateBubbleData_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateBubbleData(true)); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdateBubbleData_002 + * @tc.desc: Test UpdateBubbleData + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateBubbleData_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateBubbleData(false)); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdateBubbleData_003 + * @tc.desc: Test UpdateBubbleData + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateBubbleData_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + Rosen::RSSurfaceNodeConfig surfaceNodeConfig; + surfaceNodeConfig.SurfaceNodeName = "touch window"; + Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; + touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); + ASSERT_NE(touchDrawingHandler.surfaceNode_, nullptr); + touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.bubbleCanvasNode_, nullptr); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateBubbleData(false)); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateBubbleData(true)); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationScreen_001 + * @tc.desc: Test RotationScreen + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isChangedRotation_ = true; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + touchDrawingHandler.pointerMode_.isShow = true; + touchDrawingHandler.bubbleMode_.isShow = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationScreen_002 + * @tc.desc: Test RotationScreen + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isChangedRotation_ = false; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + touchDrawingHandler.pointerMode_.isShow = true; + touchDrawingHandler.bubbleMode_.isShow = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationScreen_003 + * @tc.desc: Test RotationScreen + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isChangedRotation_ = true; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION90; + touchDrawingHandler.pointerMode_.isShow = true; + touchDrawingHandler.bubbleMode_.isShow = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationScreen_004 + * @tc.desc: Test RotationScreen + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_004, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isChangedRotation_ = true; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + touchDrawingHandler.pointerMode_.isShow = false; + touchDrawingHandler.bubbleMode_.isShow = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationScreen_005 + * @tc.desc: Test RotationScreen + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_005, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isChangedRotation_ = true; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + touchDrawingHandler.pointerMode_.isShow = true; + touchDrawingHandler.bubbleMode_.isShow = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationScreen_006 + * @tc.desc: Test RotationScreen + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_006, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isChangedRotation_ = false; + touchDrawingHandler.isChangedMode_ = true; + touchDrawingHandler.pointerMode_.isShow = true; + touchDrawingHandler.bubbleMode_.isShow = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationScreen_007 + * @tc.desc: Test RotationScreen + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_007, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isChangedRotation_ = false; + touchDrawingHandler.isChangedMode_ = true; + touchDrawingHandler.pointerMode_.isShow = false; + touchDrawingHandler.bubbleMode_.isShow = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationScreen_008 + * @tc.desc: Test RotationScreen + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_008, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isChangedRotation_ = false; + touchDrawingHandler.isChangedMode_ = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationScreen_009 + * @tc.desc: Test RotationScreen + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_009, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isChangedRotation_ = false; + touchDrawingHandler.isChangedMode_ = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); + + touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.trackerCanvasNode_, nullptr); + touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.crosshairCanvasNode_, nullptr); + touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.bubbleCanvasNode_, nullptr); + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.labelsCanvasNode_, nullptr); + touchDrawingHandler.isChangedRotation_ = true; + touchDrawingHandler.isChangedMode_ = true; + touchDrawingHandler.pointerMode_.isShow = true; + touchDrawingHandler.bubbleMode_.isShow = true; + PointerEvent::PointerItem item; + touchDrawingHandler.lastPointerItem_.push_back(item); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); + + touchDrawingHandler.lastPointerItem_.clear(); + touchDrawingHandler.stopRecord_ = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); + + touchDrawingHandler.bubbleMode_.isShow = false; + touchDrawingHandler.stopRecord_ = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); + + touchDrawingHandler.pointerMode_.isShow = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); +} + +/** + * @tc.name: TouchDrawingManagerTest_AddCanvasNode_001 + * @tc.desc: Test AddCanvasNode + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_AddCanvasNode_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + Rosen::RSSurfaceNodeConfig surfaceNodeConfig; + surfaceNodeConfig.SurfaceNodeName = "touch window"; + Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; + touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); + + std::shared_ptr canvasNode = nullptr; + bool isTrackerNode = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.AddCanvasNode(canvasNode, isTrackerNode)); +} + +/** + * @tc.name: TouchDrawingManagerTest_AddCanvasNode_002 + * @tc.desc: Test AddCanvasNode + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_AddCanvasNode_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + Rosen::RSSurfaceNodeConfig surfaceNodeConfig; + surfaceNodeConfig.SurfaceNodeName = "touch window"; + Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; + touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); + + std::shared_ptr canvasNode = nullptr; + bool isTrackerNode = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.AddCanvasNode(canvasNode, isTrackerNode)); +} + +/** + * @tc.name: TouchDrawingManagerTest_AddCanvasNode_003 + * @tc.desc: Test AddCanvasNode + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_AddCanvasNode_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + Rosen::RSSurfaceNodeConfig surfaceNodeConfig; + surfaceNodeConfig.SurfaceNodeName = "touch window"; + Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; + touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); + std::shared_ptr canvasNode = Rosen::RSCanvasNode::Create(); + ASSERT_NE(canvasNode, nullptr); + bool isTrackerNode = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.AddCanvasNode(canvasNode, isTrackerNode)); + + canvasNode = nullptr; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.AddCanvasNode(canvasNode, isTrackerNode)); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_001 + * @tc.desc: Test RotationCanvasNode + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + std::shared_ptr canvasNode = Rosen::RSCanvasNode::Create(); + ASSERT_NE(canvasNode, nullptr); + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION90; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_002 + * @tc.desc: Test RotationCanvasNode + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + std::shared_ptr canvasNode = Rosen::RSCanvasNode::Create(); + ASSERT_NE(canvasNode, nullptr); + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION270; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_003 + * @tc.desc: Test RotationCanvasNode + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + std::shared_ptr canvasNode = Rosen::RSCanvasNode::Create(); + ASSERT_NE(canvasNode, nullptr); + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION180; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_004 + * @tc.desc: Test RotationCanvasNode + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_004, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + std::shared_ptr canvasNode = Rosen::RSCanvasNode::Create(); + ASSERT_NE(canvasNode, nullptr); + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); +} + +/** + * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_005 + * @tc.desc: Test RotationCanvasNode + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_005, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + std::shared_ptr canvasNode = Rosen::RSCanvasNode::Create(); + ASSERT_NE(canvasNode, nullptr); + touchDrawingHandler.displayInfo_.width = 720; + touchDrawingHandler.displayInfo_.height = 1800; + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION90; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION270; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION180; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); + touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); +} + +/** + * @tc.name: TouchDrawingHandlerTest_RotationCanvas_001 + * @tc.desc: Test RotationCanvas + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_RotationCanvas_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + int32_t width = 720; + int32_t height = 1800; + touchDrawingHandler.displayInfo_.width = 300; + touchDrawingHandler.displayInfo_.height = 100; + Direction direction = Direction::DIRECTION90; + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + auto canvas = static_cast( + touchDrawingHandler.labelsCanvasNode_->BeginRecording(width, height)); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); + direction = Direction::DIRECTION180; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); + direction = Direction::DIRECTION270; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); + direction = Direction::DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); +} + +/** + * @tc.name: TouchDrawingHandlerTest_RotationCanvas_002 + * @tc.desc: Test RotationCanvas + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_RotationCanvas_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + int32_t width = 300; + int32_t height = 100; + Direction direction = Direction::DIRECTION90; + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + auto canvas = static_cast( + touchDrawingHandler.labelsCanvasNode_->BeginRecording(width, height)); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); + direction = Direction::DIRECTION180; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); + direction = Direction::DIRECTION270; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); + direction = Direction::DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); +} + +/** + * @tc.name: TouchDrawingManagerTest_CreateTouchWindow_001 + * @tc.desc: Test CreateTouchWindow + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_CreateTouchWindow_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + Rosen::RSSurfaceNodeConfig surfaceNodeConfig; + surfaceNodeConfig.SurfaceNodeName = "touch window"; + Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; + touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); +} + +/** + * @tc.name: TouchDrawingHandlerTest_CreateTouchWindow_002 + * @tc.desc: Test CreateTouchWindow + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_CreateTouchWindow_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.surfaceNode_ = nullptr; + touchDrawingHandler.scaleW_ = 100; + touchDrawingHandler.scaleH_ = 500; + touchDrawingHandler.displayInfo_.id = 1000; + touchDrawingHandler.displayInfo_.displayMode = DisplayMode::FULL; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); +} + +/** + * @tc.name: TouchDrawingHandlerTest_CreateTouchWindow_003 + * @tc.desc: Test CreateTouchWindow + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_CreateTouchWindow_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.surfaceNode_ = nullptr; + touchDrawingHandler.scaleW_ = 100; + touchDrawingHandler.scaleH_ = 500; + touchDrawingHandler.displayInfo_.id = 1000; + touchDrawingHandler.displayInfo_.displayMode = DisplayMode::UNKNOWN; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); +} + +/** + * @tc.name: TouchDrawingHandlerTest_CreateTouchWindow_004 + * @tc.desc: Test CreateTouchWindow + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_CreateTouchWindow_004, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + Rosen::RSSurfaceNodeConfig surfaceNodeConfig; + surfaceNodeConfig.SurfaceNodeName = "touch window"; + Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; + touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); + ASSERT_NE(touchDrawingHandler.surfaceNode_, nullptr); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); + touchDrawingHandler.surfaceNode_ = nullptr; + touchDrawingHandler.scaleW_ = 0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); + touchDrawingHandler.scaleW_ = 100; + touchDrawingHandler.scaleH_ = 0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); + touchDrawingHandler.scaleH_ = 500; + touchDrawingHandler.displayInfo_.id = 1000; + touchDrawingHandler.displayInfo_.displayMode = DisplayMode::MAIN; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DestoryTouchWindow_001 + * @tc.desc: Test DestoryTouchWindow + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DestoryTouchWindow_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.bubbleMode_.isShow = true; + touchDrawingHandler.pointerMode_.isShow = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DestoryTouchWindow()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DestoryTouchWindow_002 + * @tc.desc: Test DestoryTouchWindow + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DestoryTouchWindow_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.bubbleMode_.isShow = false; + touchDrawingHandler.pointerMode_.isShow = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DestoryTouchWindow()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DestoryTouchWindow_003 + * @tc.desc: Test DestoryTouchWindow + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DestoryTouchWindow_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.bubbleMode_.isShow = false; + touchDrawingHandler.pointerMode_.isShow = false; + Rosen::RSSurfaceNodeConfig surfaceNodeConfig; + surfaceNodeConfig.SurfaceNodeName = "touch window"; + Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; + touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DestoryTouchWindow()); +} + +/** + * @tc.name: TouchDrawingHandlerTest_DrawBubbleHandler + * @tc.desc: Test DrawBubbleHandler + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_DrawBubbleHandler, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); + ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); + touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.bubbleCanvasNode_, nullptr); + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); + + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawBubbleHandler_001 + * @tc.desc: Test DrawBubbleHandler + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubbleHandler_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + auto pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN); + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = pointerEvent; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawBubbleHandler_002 + * @tc.desc: Test DrawBubbleHandler + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubbleHandler_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + auto pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP); + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = pointerEvent; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawBubbleHandler_003 + * @tc.desc: Test DrawBubbleHandler + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubbleHandler_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + auto pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = pointerEvent; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawBubble_001 + * @tc.desc: Test DrawBubble + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubble_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawBubble_002 + * @tc.desc: Test DrawBubble + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubble_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + auto pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); + + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = pointerEvent; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); +} + +/** + * @tc.name: TouchDrawingHandlerTest_DrawBubble_001 + * @tc.desc: Test DrawBubble + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_DrawBubble_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); + touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); + ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); + + int32_t pointerId { 1 }; + PointerEvent::PointerItem item {}; + item.SetPointerId(pointerId); + touchDrawingHandler.pointerEvent_->SetPointerId(pointerId); + touchDrawingHandler.pointerEvent_->AddPointerItem(item); + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); +} + +/** + * @tc.name: TouchDrawingHandlerTest_DrawBubble_002 + * @tc.desc: Test DrawBubble + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_DrawBubble_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); + touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); + ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); + + PointerEvent::PointerItem item; + item.SetPointerId(1); + touchDrawingHandler.pointerEvent_->AddPointerItem(item); + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); + item.SetPointerId(2); + touchDrawingHandler.pointerEvent_->SetPointerId(2); + touchDrawingHandler.pointerEvent_->AddPointerItem(item); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawBubble_003 + * @tc.desc: Test DrawBubble + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubble_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); + touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); + ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); + PointerEvent::PointerItem item; + item.SetPointerId(1); + touchDrawingHandler.pointerEvent_->AddPointerItem(item); + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); + item.SetPointerId(2); + touchDrawingHandler.pointerEvent_->SetPointerId(2); + touchDrawingHandler.pointerEvent_->AddPointerItem(item); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawPointerPositionHandler_001 + * @tc.desc: Test DrawPointerPositionHandler + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawPointerPositionHandler_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawPointerPositionHandler()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawPointerPositionHandler_002 + * @tc.desc: Test DrawPointerPositionHandler + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawPointerPositionHandler_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + auto pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); + + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = pointerEvent; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawPointerPositionHandler()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawPointerPositionHandler_003 + * @tc.desc: Test DrawPointerPositionHandler + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawPointerPositionHandler_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); + touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); + ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); + touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.trackerCanvasNode_, nullptr); + touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.crosshairCanvasNode_, nullptr); + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.labelsCanvasNode_, nullptr); + PointerEvent::PointerItem item; + item.SetDisplayX(300); + item.SetDisplayY(500); + item.SetPointerId(100); + touchDrawingHandler.scaleW_ = 720; + touchDrawingHandler.scaleH_ = 1800; + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); + touchDrawingHandler.pointerEvent_->SetPointerId(100); + touchDrawingHandler.pointerEvent_->AddPointerItem(item); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawPointerPositionHandler()); + + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawPointerPositionHandler()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawTracker_001 + * @tc.desc: Test DrawTracker + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawTracker_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + int32_t x = 10; + int32_t y = 10; + int32_t pointerId = 0; + TouchDrawingHandler touchDrawingHandler; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawTracker(x, y, pointerId)); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawTracker_002 + * @tc.desc: Test DrawTracker + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawTracker_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + int32_t x = 11; + int32_t y = 11; + int32_t pointerId = 5; + TouchDrawingHandler touchDrawingHandler; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawTracker(x, y, pointerId)); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawTracker_003 + * @tc.desc: Test DrawTracker + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawTracker_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + int32_t x = 100; + int32_t y = 300; + int32_t pointerId = 10; + PointerEvent::PointerItem item; + item.SetPointerId(10); + item.SetDisplayX(100); + item.SetDisplayY(300); + touchDrawingHandler.isDownAction_ = true; + touchDrawingHandler.xVelocity_ = 200; + touchDrawingHandler.yVelocity_ = 400; + touchDrawingHandler.lastPointerItem_.push_back(item); + touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.trackerCanvasNode_, nullptr); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawTracker(x, y, pointerId)); + + pointerId = 20; + touchDrawingHandler.isDownAction_ = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawTracker(x, y, pointerId)); +} + + +/** + * @tc.name: TouchDrawingManagerTest_DrawCrosshairs_001 + * @tc.desc: Test DrawCrosshairs + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawCrosshairs_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + int32_t x = 11; + int32_t y = 11; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.crosshairCanvasNode_ == nullptr) { + touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); + } + ASSERT_NE(touchDrawingHandler.crosshairCanvasNode_, nullptr); + auto canvas = static_cast( + touchDrawingHandler.crosshairCanvasNode_->BeginRecording(touchDrawingHandler.displayInfo_.width, + touchDrawingHandler.displayInfo_.height)); + ASSERT_NE(canvas, nullptr); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawCrosshairs(canvas, x, y)); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawCrosshairs_002 + * @tc.desc: Test DrawCrosshairs + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawCrosshairs_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + int32_t x = 11; + int32_t y = 11; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.crosshairCanvasNode_ == nullptr) { + touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); + } + auto canvas = static_cast( + touchDrawingHandler.crosshairCanvasNode_->BeginRecording(touchDrawingHandler.displayInfo_.width, + touchDrawingHandler.displayInfo_.height)); + ASSERT_NE(canvas, nullptr); + touchDrawingHandler.displayInfo_.direction = DIRECTION90; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawCrosshairs(canvas, x, y)); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawCrosshairs_003 + * @tc.desc: Test DrawCrosshairs + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawCrosshairs_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + int32_t x = 11; + int32_t y = 11; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.crosshairCanvasNode_ == nullptr) { + touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); + } + auto canvas = static_cast( + touchDrawingHandler.crosshairCanvasNode_->BeginRecording(touchDrawingHandler.displayInfo_.width, + touchDrawingHandler.displayInfo_.height)); + ASSERT_NE(canvas, nullptr); + touchDrawingHandler.displayInfo_.direction = DIRECTION270; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawCrosshairs(canvas, x, y)); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawLabels_001 + * @tc.desc: Test DrawLabels + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.isDownAction_ = true; + touchDrawingHandler.displayInfo_.direction = DIRECTION90; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawLabels_002 + * @tc.desc: Test DrawLabels + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + touchDrawingHandler.isDownAction_ = true; + touchDrawingHandler.displayInfo_.direction = DIRECTION180; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawLabels_003 + * @tc.desc: Test DrawLabels + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + touchDrawingHandler.isDownAction_ = true; + touchDrawingHandler.displayInfo_.direction = DIRECTION270; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawLabels_004 + * @tc.desc: Test DrawLabels + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_004, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + touchDrawingHandler.isDownAction_ = true; + touchDrawingHandler.displayInfo_.direction = DIRECTION270; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawLabels_005 + * @tc.desc: Test DrawLabels + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_005, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.labelsCanvasNode_, nullptr); + PointerEvent::PointerItem item; + touchDrawingHandler.currentPointerCount_ = 10; + touchDrawingHandler.maxPointerCount_ = 20; + touchDrawingHandler.scaleW_ = 30; + touchDrawingHandler.scaleH_ = 50; + touchDrawingHandler.xVelocity_ = 30; + touchDrawingHandler.yVelocity_ = 50; + touchDrawingHandler.pressure_ = 10; + touchDrawingHandler.rectTopPosition_ = 100; + touchDrawingHandler.itemRectW_ = 100.0; + touchDrawingHandler.isDownAction_ = true; + touchDrawingHandler.lastPointerItem_.push_back(item); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); + touchDrawingHandler.isDownAction_ = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); + touchDrawingHandler.lastPointerItem_.clear(); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); +} + +/** + * @tc.name: TouchDrawingHandlerTest_UpdatePointerPosition_001 + * @tc.desc: Test UpdatePointerPosition + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_UpdatePointerPosition_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); + ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); + PointerEvent::PointerItem item; + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); + touchDrawingHandler.pointerEvent_->SetPointerId(10); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); + touchDrawingHandler.lastPointerItem_.push_back(item); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); +} + +/** + * @tc.name: TouchDrawingHandlerTest_UpdatePointerPosition_002 + * @tc.desc: Test UpdatePointerPosition + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_UpdatePointerPosition_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); + ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); + PointerEvent::PointerItem item; + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); + touchDrawingHandler.pointerEvent_->SetPointerId(10); + item.SetPointerId(20); + touchDrawingHandler.lastPointerItem_.push_back(item); + item.SetPointerId(10); + touchDrawingHandler.lastPointerItem_.push_back(item); + touchDrawingHandler.currentPointerId_ = 10; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); + touchDrawingHandler.lastPointerItem_.clear(); + touchDrawingHandler.currentPointerId_ = 50; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); + touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_003 + * @tc.desc: Test UpdatePointerPosition + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdatePointerPosition_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + auto pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->SetPointerId(5); + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); + + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = pointerEvent; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_004 + * @tc.desc: Test UpdatePointerPosition + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdatePointerPosition_004, TestSize.Level1) +{ + CALL_TEST_DEBUG; + auto pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->SetPointerId(5); + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); + + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = pointerEvent; + touchDrawingHandler.currentPointerId_ = 5; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_005 + * @tc.desc: Test UpdatePointerPosition + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdatePointerPosition_005, TestSize.Level1) +{ + CALL_TEST_DEBUG; + auto pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->SetPointerId(0); + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); + + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = pointerEvent; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_006 + * @tc.desc: Test UpdatePointerPosition + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdatePointerPosition_006, TestSize.Level1) +{ + CALL_TEST_DEBUG; + auto pointerEvent = PointerEvent::Create(); + ASSERT_NE(pointerEvent, nullptr); + pointerEvent->SetPointerId(0); + pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); + + PointerEvent::PointerItem item; + item.SetPointerId(0); + item.SetPressed(true); + + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.pointerEvent_ = pointerEvent; + touchDrawingHandler.lastPointerItem_.emplace_back(item); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdateLastPointerItem_001 + * @tc.desc: Test UpdateLastPointerItem + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateLastPointerItem_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + PointerEvent::PointerItem item; + item.SetPressed(false); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLastPointerItem(item)); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdateLastPointerItem_002 + * @tc.desc: Test UpdateLastPointerItem + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateLastPointerItem_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + PointerEvent::PointerItem item; + item.SetPressed(true); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLastPointerItem(item)); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdateLastPointerItem_003 + * @tc.desc: Test UpdateLastPointerItem + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateLastPointerItem_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + PointerEvent::PointerItem item; + item.SetPressed(false); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLastPointerItem(item)); + item.SetPressed(true); + item.SetPointerId(10); + touchDrawingHandler.lastPointerItem_.push_back(item); + item.SetPointerId(20); + touchDrawingHandler.lastPointerItem_.push_back(item); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLastPointerItem(item)); +} + +/** + * @tc.name: TouchDrawingManagerTest_RemovePointerPosition_001 + * @tc.desc: Test RemovePointerPosition + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RemovePointerPosition_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + Rosen::RSSurfaceNodeConfig surfaceNodeConfig; + surfaceNodeConfig.SurfaceNodeName = "touch window"; + Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; + touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RemovePointerPosition()); +} + +/** + * @tc.name: TouchDrawingManagerTest_ClearTracker_001 + * @tc.desc: Test ClearTracker + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ClearTracker_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.trackerCanvasNode_ == nullptr) { + touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); +} + +/** + * @tc.name: TouchDrawingManagerTest_ClearTracker_002 + * @tc.desc: Test ClearTracker + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ClearTracker_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.trackerCanvasNode_ == nullptr) { + touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + touchDrawingHandler.lastPointerItem_.clear(); + touchDrawingHandler.isDownAction_ = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); +} + +/** + * @tc.name: TouchDrawingManagerTest_ClearTracker_003 + * @tc.desc: Test ClearTracker + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ClearTracker_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.trackerCanvasNode_ == nullptr) { + touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + PointerEvent::PointerItem item; + item.SetPointerId(0); + item.SetDisplayY(200); + touchDrawingHandler.lastPointerItem_.emplace_back(item); + touchDrawingHandler.isDownAction_ = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); +} + +/** + * @tc.name: TouchDrawingManagerTest_ClearTracker_004 + * @tc.desc: Test ClearTracker + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ClearTracker_004, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); + ASSERT_NE(touchDrawingHandler.trackerCanvasNode_, nullptr); + touchDrawingHandler.scaleW_ = 300; + touchDrawingHandler.scaleH_ = 500; + touchDrawingHandler.isDownAction_ = true; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); + touchDrawingHandler.isDownAction_ = false; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); +} + +/** + * @tc.name: TouchDrawingManagerTest_UpdateLabels_001 + * @tc.desc: Test UpdateLabels + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateLabels_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLabels(true)); +} + +/** + * @tc.name: TouchDrawingHandlerTest_IsValidAction + * @tc.desc: Test IsValidAction + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_IsValidAction, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + int32_t action = PointerEvent::POINTER_ACTION_DOWN; + EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); + action = PointerEvent::POINTER_ACTION_PULL_DOWN; + EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); + action = PointerEvent::POINTER_ACTION_MOVE; + EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); + action = PointerEvent::POINTER_ACTION_PULL_MOVE; + EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); + action = PointerEvent::POINTER_ACTION_UP; + EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); + action = PointerEvent::POINTER_ACTION_PULL_UP; + EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); + action = PointerEvent::POINTER_ACTION_CANCEL; + EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); + action = PointerEvent::POINTER_ACTION_UNKNOWN; + EXPECT_FALSE(touchDrawingHandler.IsValidAction(action)); + int32_t unknownAction { 100 }; + EXPECT_FALSE(touchDrawingHandler.IsValidAction(unknownAction)); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawRectItem_001 + * @tc.desc: Test DrawRectItem + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawRectItem_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + RosenRecordingCanvas *canvas = nullptr; + std::string text; + Rosen::Drawing::Rect rect {}; + Rosen::Drawing::Color color {}; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawRectItem(canvas, text, rect, color)); +} + +/** + * @tc.name: TouchDrawingManagerTest_DrawRectItem_002 + * @tc.desc: Test DrawRectItem + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawRectItem_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); + } + auto canvas = static_cast( + touchDrawingHandler.labelsCanvasNode_->BeginRecording(touchDrawingHandler.displayInfo_.width, + touchDrawingHandler.displayInfo_.height)); + ASSERT_NE(canvas, nullptr); + std::string text = "test"; + Rosen::Drawing::Rect rect { 1, 1, 10, 10 }; + Rosen::Drawing::Color color = Rosen::Drawing::Color::ColorQuadSetARGB(192, 255, 255, 255); + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawRectItem(canvas, text, rect, color)); + touchDrawingHandler.labelsCanvasNode_->FinishRecording(); + Rosen::RSTransaction::FlushImplicitTransaction(); +} + +/** + * @tc.name: TouchDrawingManagerTest_Snapshot_001 + * @tc.desc: Test Snapshot + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_Snapshot_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + touchDrawingHandler.isChangedRotation_ = true; + touchDrawingHandler.displayInfo_.direction = DIRECTION90; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.Snapshot()); +} + +/** + * @tc.name: TouchDrawingManagerTest_Snapshot_002 + * @tc.desc: Test Snapshot + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_Snapshot_002, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + touchDrawingHandler.isChangedRotation_ = true; + touchDrawingHandler.displayInfo_.direction = DIRECTION180; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.Snapshot()); +} + +/** + * @tc.name: TouchDrawingManagerTest_Snapshot_003 + * @tc.desc: Test Snapshot + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_Snapshot_003, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { + touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); + } + touchDrawingHandler.isChangedRotation_ = true; + touchDrawingHandler.displayInfo_.direction = DIRECTION270; + touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; + EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.Snapshot()); +} + +/** + * @tc.name: TouchDrawingManagerTest_InitLabels_001 + * @tc.desc: Test InitLabels + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_InitLabels_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + touchDrawingHandler.InitLabels(); + EXPECT_EQ(touchDrawingHandler.isFirstDownAction_, true); + EXPECT_EQ(touchDrawingHandler.isDownAction_, true); + EXPECT_EQ(touchDrawingHandler.maxPointerCount_, 0); +} + +/** + * @tc.name: TouchDrawingManagerTest_ResetCanvasNode_001 + * @tc.desc: Test ResetCanvasNode + * @tc.type: Function + * @tc.require: + */ +HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ResetCanvasNode_001, TestSize.Level1) +{ + CALL_TEST_DEBUG; + TouchDrawingHandler touchDrawingHandler; + auto canvasNode = Rosen::RSCanvasDrawingNode::Create(); + touchDrawingHandler.ResetCanvasNode(canvasNode); +} +} // namespace MMI +} // namespace OHOS \ No newline at end of file diff --git a/service/window_manager/test/touch_drawing_manager_ai_test.cpp b/service/window_manager/test/touch_drawing_manager_ai_test.cpp deleted file mode 100644 index a465edeabf..0000000000 --- a/service/window_manager/test/touch_drawing_manager_ai_test.cpp +++ /dev/null @@ -1,681 +0,0 @@ -/* - * Copyright (c) 2024 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 -#include - -#include "mmi_log.h" -#include "pointer_event.h" -#ifndef USE_ROSEN_DRAWING -#define USE_ROSEN_DRAWING -#endif -#include "touch_drawing_manager.h" -#include "window_info.h" - -#undef MMI_LOG_TAG -#define MMI_LOG_TAG "TouchDrawingManagerTest" - -namespace OHOS { -namespace MMI { -namespace { -using namespace testing::ext; -} // namespace -class TouchDrawingManagerTest : public testing::Test { -public: - static void SetUpTestCase(void) {}; - static void TearDownTestCase(void) {}; - void SetUp(void) {}; -}; - -/** - * @tc.name: TouchDrawingManagerTest_RecordLabelsInfo - * @tc.desc: Test RecordLabelsInfo - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_RecordLabelsInfo, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawMgr; - touchDrawMgr.pointerEvent_ = PointerEvent::Create(); - ASSERT_NE(touchDrawMgr.pointerEvent_, nullptr); - PointerEvent::PointerItem item; - item.SetPointerId(0); - item.SetPressed(true); - item.SetDisplayX(100); - item.SetDisplayY(100); - touchDrawMgr.pointerEvent_->AddPointerItem(item); - touchDrawMgr.pointerEvent_->SetPointerId(0); - touchDrawMgr.currentPointerId_ = 1; - EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); - - touchDrawMgr.currentPointerId_ = 0; - touchDrawMgr.isFirstDownAction_ = true; - touchDrawMgr.lastPointerItem_.push_back(item); - touchDrawMgr.pointerEvent_->SetActionTime(150); - touchDrawMgr.lastActionTime_ = 300; - EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); - - touchDrawMgr.pointerEvent_->SetActionTime(50); - touchDrawMgr.lastActionTime_ = 50; - EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); - - item.SetPressed(false); - touchDrawMgr.isFirstDownAction_ = false; - touchDrawMgr.pointerEvent_->SetPointerId(10); - touchDrawMgr.pointerEvent_->UpdatePointerItem(0, item); - EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); -} - -/** - * @tc.name: TouchDrawingManagerTest_TouchDrawHandler - * @tc.desc: Test TouchDrawHandler - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_TouchDrawHandler, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawMgr; - std::shared_ptr pointerEvent = PointerEvent::Create(); - ASSERT_NE(pointerEvent, nullptr); - PointerEvent::PointerItem item; - touchDrawMgr.bubbleMode_.isShow = true; - touchDrawMgr.stopRecord_ = false; - touchDrawMgr.pointerMode_.isShow = true; - pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); - pointerEvent->AddPointerItem(item); - EXPECT_NO_FATAL_FAILURE(touchDrawMgr.TouchDrawHandler(pointerEvent)); - - touchDrawMgr.bubbleMode_.isShow = false; - touchDrawMgr.pointerMode_.isShow = false; - pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); - EXPECT_NO_FATAL_FAILURE(touchDrawMgr.TouchDrawHandler(pointerEvent)); -} - -/** - * @tc.name: TouchDrawingManagerTest_UpdateDisplayInfo - * @tc.desc: Test UpdateDisplayInfo - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdateDisplayInfo, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawMgr; - DisplayInfo displayInfo; - displayInfo.direction = Direction::DIRECTION0; - touchDrawMgr.displayInfo_.direction = Direction::DIRECTION0; - displayInfo.width = 700; - displayInfo.height = 500; - EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo)); - - displayInfo.direction = Direction::DIRECTION180; - touchDrawMgr.displayInfo_.direction = Direction::DIRECTION180; - EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo)); - - displayInfo.direction = Direction::DIRECTION270; - touchDrawMgr.displayInfo_.direction = Direction::DIRECTION270; - EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo)); -} - -/** - * @tc.name: TouchDrawingManagerTest_GetOriginalTouchScreenCoordinates - * @tc.desc: Test GetOriginalTouchScreenCoordinates - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_GetOriginalTouchScreenCoordinates, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - int32_t width = 720; - int32_t height = 1800; - int32_t physicalX = 300; - int32_t physicalY = 600; - Direction direction = DIRECTION0; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height, - physicalX, physicalY)); - direction = DIRECTION90; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height, - physicalX, physicalY)); - direction = DIRECTION180; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height, - physicalX, physicalY)); - direction = DIRECTION270; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height, - physicalX, physicalY)); - direction = static_cast(10); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height, - physicalX, physicalY)); -} - -/** - * @tc.name: TouchDrawingManagerTest_UpdateBubbleData - * @tc.desc: Test UpdateBubbleData - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdateBubbleData, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - Rosen::RSSurfaceNodeConfig surfaceNodeConfig; - surfaceNodeConfig.SurfaceNodeName = "touch window"; - Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; - touchDrawingMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); - ASSERT_NE(touchDrawingMgr.surfaceNode_, nullptr); - touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.bubbleCanvasNode_, nullptr); - touchDrawingMgr.bubbleMode_.isShow = false; - EXPECT_EQ(touchDrawingMgr.UpdateBubbleData(), RET_OK); - - touchDrawingMgr.bubbleMode_.isShow = true; - EXPECT_EQ(touchDrawingMgr.UpdateBubbleData(), RET_OK); -} - -/** - * @tc.name: TouchDrawingManagerTest_RotationScreen - * @tc.desc: Test RotationScreen - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_RotationScreen, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.isChangedRotation_ = false; - touchDrawingMgr.isChangedMode_ = false; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen()); - - touchDrawingMgr.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.trackerCanvasNode_, nullptr); - touchDrawingMgr.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.crosshairCanvasNode_, nullptr); - touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.bubbleCanvasNode_, nullptr); - touchDrawingMgr.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.labelsCanvasNode_, nullptr); - touchDrawingMgr.isChangedRotation_ = true; - touchDrawingMgr.isChangedMode_ = true; - touchDrawingMgr.pointerMode_.isShow = true; - touchDrawingMgr.bubbleMode_.isShow = true; - PointerEvent::PointerItem item; - touchDrawingMgr.lastPointerItem_.push_back(item); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen()); - - touchDrawingMgr.lastPointerItem_.clear(); - touchDrawingMgr.stopRecord_ = true; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen()); - - touchDrawingMgr.bubbleMode_.isShow = false; - touchDrawingMgr.stopRecord_ = false; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen()); - - touchDrawingMgr.pointerMode_.isShow = false; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen()); -} - -/** - * @tc.name: TouchDrawingManagerTest_CreateObserver - * @tc.desc: Test CreateObserver - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateObserver, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.hasBubbleObserver_ = false; - touchDrawingMgr.hasPointerObserver_ = false; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateObserver()); -} - -/** - * @tc.name: TouchDrawingManagerTest_CreateObserver_001 - * @tc.desc: Test CreateObserver - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateObserver_001, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.hasBubbleObserver_ = true; - touchDrawingMgr.hasPointerObserver_ = true; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateObserver()); -} - -/** - * @tc.name: TouchDrawingManagerTest_AddCanvasNode - * @tc.desc: Test AddCanvasNode - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_AddCanvasNode, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - Rosen::RSSurfaceNodeConfig surfaceNodeConfig; - surfaceNodeConfig.SurfaceNodeName = "touch window"; - Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; - touchDrawingMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); - std::shared_ptr canvasNode = Rosen::RSCanvasNode::Create(); - ASSERT_NE(canvasNode, nullptr); - bool isTrackerNode = true; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.AddCanvasNode(canvasNode, isTrackerNode)); - - canvasNode = nullptr; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.AddCanvasNode(canvasNode, isTrackerNode)); -} - -/** - * @tc.name: TouchDrawingManagerTest_RotationCanvasNode - * @tc.desc: Test RotationCanvasNode - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_RotationCanvasNode, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - std::shared_ptr canvasNode = Rosen::RSCanvasNode::Create(); - ASSERT_NE(canvasNode, nullptr); - touchDrawingMgr.displayInfo_.width = 720; - touchDrawingMgr.displayInfo_.height = 1800; - touchDrawingMgr.displayInfo_.direction = Direction::DIRECTION90; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvasNode(canvasNode)); - touchDrawingMgr.displayInfo_.direction = Direction::DIRECTION270; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvasNode(canvasNode)); - touchDrawingMgr.displayInfo_.direction = Direction::DIRECTION180; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvasNode(canvasNode)); - touchDrawingMgr.displayInfo_.direction = Direction::DIRECTION0; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvasNode(canvasNode)); -} - -/** - * @tc.name: TouchDrawingManagerTest_RotationCanvas - * @tc.desc: Test RotationCanvas - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_RotationCanvas, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - int32_t width = 720; - int32_t height = 1800; - touchDrawingMgr.displayInfo_.width = 300; - touchDrawingMgr.displayInfo_.height = 100; - Direction direction = Direction::DIRECTION90; - touchDrawingMgr.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); - auto canvas = static_cast - (touchDrawingMgr.labelsCanvasNode_->BeginRecording(width, height)); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvas(canvas, direction)); - direction = Direction::DIRECTION180; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvas(canvas, direction)); - direction = Direction::DIRECTION270; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvas(canvas, direction)); - direction = Direction::DIRECTION0; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvas(canvas, direction)); -} - -/** - * @tc.name: TouchDrawingManagerTest_CreateTouchWindow - * @tc.desc: Test CreateTouchWindow - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateTouchWindow, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - Rosen::RSSurfaceNodeConfig surfaceNodeConfig; - surfaceNodeConfig.SurfaceNodeName = "touch window"; - Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; - touchDrawingMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); - ASSERT_NE(touchDrawingMgr.surfaceNode_, nullptr); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow()); - touchDrawingMgr.surfaceNode_ = nullptr; - touchDrawingMgr.scaleW_ = 0; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow()); - touchDrawingMgr.scaleW_ = 100; - touchDrawingMgr.scaleH_ = 0; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow()); - touchDrawingMgr.scaleH_ = 500; - touchDrawingMgr.displayInfo_.id = 1000; - touchDrawingMgr.displayInfo_.displayMode = DisplayMode::MAIN; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow()); -} - -/** - * @tc.name: TouchDrawingManagerTest_CreateTouchWindow_001 - * @tc.desc: Test CreateTouchWindow - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateTouchWindow_001, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.surfaceNode_ = nullptr; - touchDrawingMgr.scaleW_ = 100; - touchDrawingMgr.scaleH_ = 500; - touchDrawingMgr.displayInfo_.id = 1000; - touchDrawingMgr.displayInfo_.displayMode = DisplayMode::FULL; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow()); -} - -/** - * @tc.name: TouchDrawingManagerTest_CreateTouchWindow_002 - * @tc.desc: Test CreateTouchWindow - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateTouchWindow_002, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.surfaceNode_ = nullptr; - touchDrawingMgr.scaleW_ = 100; - touchDrawingMgr.scaleH_ = 500; - touchDrawingMgr.displayInfo_.id = 1000; - touchDrawingMgr.displayInfo_.displayMode = DisplayMode::UNKNOWN; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow()); -} - -/** - * @tc.name: TouchDrawingManagerTest_DrawBubbleHandler - * @tc.desc: Test DrawBubbleHandler - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawBubbleHandler, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.pointerEvent_ = PointerEvent::Create(); - ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr); - touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.bubbleCanvasNode_, nullptr); - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubbleHandler()); - - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubbleHandler()); -} - -/** - * @tc.name: TouchDrawingManagerTest_DrawBubble - * @tc.desc: Test DrawBubble - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawBubble, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); - touchDrawingMgr.pointerEvent_ = PointerEvent::Create(); - ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr); - PointerEvent::PointerItem item; - item.SetPointerId(1); - touchDrawingMgr.pointerEvent_->SetPointerId(1); - touchDrawingMgr.pointerEvent_->AddPointerItem(item); - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubble()); - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubble()); - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubble()); -} - -/** - * @tc.name: TouchDrawingManagerTest_DrawBubble_001 - * @tc.desc: Test DrawBubble - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawBubble_001, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); - touchDrawingMgr.pointerEvent_ = PointerEvent::Create(); - ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr); - PointerEvent::PointerItem item; - item.SetPointerId(1); - touchDrawingMgr.pointerEvent_->AddPointerItem(item); - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); - item.SetPointerId(2); - touchDrawingMgr.pointerEvent_->SetPointerId(2); - touchDrawingMgr.pointerEvent_->AddPointerItem(item); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubble()); -} - -/** - * @tc.name: TouchDrawingManagerTest_DrawPointerPositionHandler - * @tc.desc: Test DrawPointerPositionHandler - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawPointerPositionHandler, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); - touchDrawingMgr.pointerEvent_ = PointerEvent::Create(); - ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr); - touchDrawingMgr.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.trackerCanvasNode_, nullptr); - touchDrawingMgr.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.crosshairCanvasNode_, nullptr); - touchDrawingMgr.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.labelsCanvasNode_, nullptr); - PointerEvent::PointerItem item; - item.SetDisplayX(300); - item.SetDisplayY(500); - item.SetPointerId(100); - touchDrawingMgr.scaleW_ = 720; - touchDrawingMgr.scaleH_ = 1800; - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); - touchDrawingMgr.pointerEvent_->SetPointerId(100); - touchDrawingMgr.pointerEvent_->AddPointerItem(item); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawPointerPositionHandler()); - - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawPointerPositionHandler()); -} - -/** - * @tc.name: TouchDrawingManagerTest_DrawTracker - * @tc.desc: Test DrawTracker - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawTracker, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - int32_t x = 100; - int32_t y = 300; - int32_t pointerId = 10; - PointerEvent::PointerItem item; - item.SetPointerId(10); - item.SetDisplayX(100); - item.SetDisplayY(300); - touchDrawingMgr.isDownAction_ = true; - touchDrawingMgr.xVelocity_ = 200; - touchDrawingMgr.yVelocity_ = 400; - touchDrawingMgr.lastPointerItem_.push_back(item); - touchDrawingMgr.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.trackerCanvasNode_, nullptr); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawTracker(x, y, pointerId)); - - pointerId = 20; - touchDrawingMgr.isDownAction_ = false; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawTracker(x, y, pointerId)); -} - -/** - * @tc.name: TouchDrawingManagerTest_DrawLabels - * @tc.desc: Test DrawLabels - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawLabels, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.labelsCanvasNode_, nullptr); - PointerEvent::PointerItem item; - touchDrawingMgr.currentPointerCount_ = 10; - touchDrawingMgr.maxPointerCount_ = 20; - touchDrawingMgr.scaleW_ = 30; - touchDrawingMgr.scaleH_ = 50; - touchDrawingMgr.xVelocity_ = 30; - touchDrawingMgr.yVelocity_ = 50; - touchDrawingMgr.pressure_ = 10; - touchDrawingMgr.rectTopPosition_ = 100; - touchDrawingMgr.itemRectW_ = 100.0; - touchDrawingMgr.isDownAction_ = true; - touchDrawingMgr.lastPointerItem_.push_back(item); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawLabels()); - touchDrawingMgr.isDownAction_ = false; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawLabels()); - touchDrawingMgr.lastPointerItem_.clear(); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawLabels()); -} - -/** - * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition - * @tc.desc: Test UpdatePointerPosition - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdatePointerPosition, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.pointerEvent_ = PointerEvent::Create(); - ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr); - PointerEvent::PointerItem item; - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); - touchDrawingMgr.pointerEvent_->SetPointerId(10); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition()); - touchDrawingMgr.lastPointerItem_.push_back(item); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition()); -} - -/** - * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_001 - * @tc.desc: Test UpdatePointerPosition - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdatePointerPosition_001, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.pointerEvent_ = PointerEvent::Create(); - ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr); - PointerEvent::PointerItem item; - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); - touchDrawingMgr.pointerEvent_->SetPointerId(10); - item.SetPointerId(20); - touchDrawingMgr.lastPointerItem_.push_back(item); - item.SetPointerId(10); - touchDrawingMgr.lastPointerItem_.push_back(item); - touchDrawingMgr.currentPointerId_ = 10; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition()); - touchDrawingMgr.lastPointerItem_.clear(); - touchDrawingMgr.currentPointerId_ = 50; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition()); - touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition()); -} - -/** - * @tc.name: TouchDrawingManagerTest_UpdateLastPointerItem - * @tc.desc: Test UpdateLastPointerItem - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdateLastPointerItem, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - PointerEvent::PointerItem item; - item.SetPressed(false); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdateLastPointerItem(item)); - item.SetPressed(true); - item.SetPointerId(10); - touchDrawingMgr.lastPointerItem_.push_back(item); - item.SetPointerId(20); - touchDrawingMgr.lastPointerItem_.push_back(item); - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdateLastPointerItem(item)); -} - -/** - * @tc.name: TouchDrawingManagerTest_ClearTracker - * @tc.desc: Test ClearTracker - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_ClearTracker, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - touchDrawingMgr.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); - ASSERT_NE(touchDrawingMgr.trackerCanvasNode_, nullptr); - touchDrawingMgr.scaleW_ = 300; - touchDrawingMgr.scaleH_ = 500; - touchDrawingMgr.isDownAction_ = true; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.ClearTracker()); - touchDrawingMgr.isDownAction_ = false; - EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.ClearTracker()); -} - -/** - * @tc.name: TouchDrawingManagerTest_IsValidAction - * @tc.desc: Test IsValidAction - * @tc.type: Function - * @tc.require: - */ -HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_IsValidAction, TestSize.Level1) -{ - CALL_TEST_DEBUG; - TouchDrawingManager touchDrawingMgr; - int32_t action = PointerEvent::POINTER_ACTION_DOWN; - EXPECT_TRUE(touchDrawingMgr.IsValidAction(action)); - action = PointerEvent::POINTER_ACTION_PULL_DOWN; - EXPECT_TRUE(touchDrawingMgr.IsValidAction(action)); - action = PointerEvent::POINTER_ACTION_MOVE; - EXPECT_TRUE(touchDrawingMgr.IsValidAction(action)); - action = PointerEvent::POINTER_ACTION_PULL_MOVE; - EXPECT_TRUE(touchDrawingMgr.IsValidAction(action)); - action = PointerEvent::POINTER_ACTION_UP; - EXPECT_TRUE(touchDrawingMgr.IsValidAction(action)); - action = PointerEvent::POINTER_ACTION_PULL_UP; - EXPECT_TRUE(touchDrawingMgr.IsValidAction(action)); - action = PointerEvent::POINTER_ACTION_CANCEL; - EXPECT_TRUE(touchDrawingMgr.IsValidAction(action)); - action = PointerEvent::POINTER_ACTION_UNKNOWN; - EXPECT_FALSE(touchDrawingMgr.IsValidAction(action)); -} -} // namespace MMI -} // namespace OHOS \ No newline at end of file -- Gitee