1 /* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <cstdio> 17 #include <fstream> 18 #include <gtest/gtest.h> 19 20 #include "mmi_log.h" 21 #include "pointer_event.h" 22 #ifndef USE_ROSEN_DRAWING 23 #define USE_ROSEN_DRAWING 24 #endif 25 #include "touch_drawing_handler.h" 26 #include "window_info.h" 27 28 #undef MMI_LOG_TAG 29 #define MMI_LOG_TAG "TouchDrawingHandlerTest" 30 31 namespace OHOS { 32 namespace MMI { 33 namespace { 34 using namespace testing::ext; 35 } // namespace 36 37 #ifdef USE_ROSEN_DRAWING 38 using RosenRecordingCanvas = Rosen::Drawing::RecordingCanvas; 39 #else 40 using RosenRecordingCanvas = Rosen::RSRecordingCanvas; 41 #endif // USE_ROSEN_DRAWING 42 43 class TouchDrawingHandlerTest : public testing::Test { 44 public: SetUpTestCase(void)45 static void SetUpTestCase(void) {}; TearDownTestCase(void)46 static void TearDownTestCase(void) {}; SetUp(void)47 void SetUp(void) {}; 48 }; 49 50 /** 51 * @tc.name: TouchDrawingHandlerTest_RecordLabelsInfo 52 * @tc.desc: Test RecordLabelsInfo 53 * @tc.type: Function 54 * @tc.require: 55 */ 56 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_RecordLabelsInfo, TestSize.Level1) 57 { 58 CALL_TEST_DEBUG; 59 TouchDrawingHandler touchDrawMgr; 60 touchDrawMgr.pointerEvent_ = PointerEvent::Create(); 61 ASSERT_NE(touchDrawMgr.pointerEvent_, nullptr); 62 PointerEvent::PointerItem item; 63 item.SetPointerId(0); 64 item.SetPressed(true); 65 item.SetDisplayX(100); 66 item.SetDisplayY(100); 67 touchDrawMgr.pointerEvent_->AddPointerItem(item); 68 touchDrawMgr.pointerEvent_->SetPointerId(0); 69 touchDrawMgr.currentPointerId_ = 1; 70 EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); 71 72 touchDrawMgr.currentPointerId_ = 0; 73 touchDrawMgr.isFirstDownAction_ = true; 74 touchDrawMgr.lastPointerItem_.push_back(item); 75 touchDrawMgr.pointerEvent_->SetActionTime(150); 76 touchDrawMgr.lastActionTime_ = 300; 77 EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); 78 79 touchDrawMgr.pointerEvent_->SetActionTime(50); 80 touchDrawMgr.lastActionTime_ = 50; 81 EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); 82 83 item.SetPressed(false); 84 touchDrawMgr.isFirstDownAction_ = false; 85 touchDrawMgr.pointerEvent_->SetPointerId(10); 86 touchDrawMgr.pointerEvent_->UpdatePointerItem(0, item); 87 EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo()); 88 } 89 90 /** 91 * @tc.name: TouchDrawingHandlerTest_TouchDrawHandler 92 * @tc.desc: Test TouchDrawHandler 93 * @tc.type: Function 94 * @tc.require: 95 */ 96 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_TouchDrawHandler, TestSize.Level1) 97 { 98 CALL_TEST_DEBUG; 99 TouchDrawingHandler touchDrawMgr; 100 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create(); 101 ASSERT_NE(pointerEvent, nullptr); 102 PointerEvent::PointerItem item; 103 touchDrawMgr.bubbleMode_.isShow = true; 104 touchDrawMgr.stopRecord_ = false; 105 touchDrawMgr.pointerMode_.isShow = true; 106 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 107 pointerEvent->AddPointerItem(item); 108 EXPECT_NO_FATAL_FAILURE(touchDrawMgr.TouchDrawHandler(pointerEvent)); 109 110 touchDrawMgr.bubbleMode_.isShow = false; 111 touchDrawMgr.pointerMode_.isShow = false; 112 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 113 EXPECT_NO_FATAL_FAILURE(touchDrawMgr.TouchDrawHandler(pointerEvent)); 114 } 115 116 /** 117 * @tc.name: TouchDrawingHandlerTest_UpdateDisplayInfo_001 118 * @tc.desc: Test UpdateDisplayInfo 119 * @tc.type: Function 120 * @tc.require: 121 */ 122 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_UpdateDisplayInfo_001, TestSize.Level1) 123 { 124 CALL_TEST_DEBUG; 125 TouchDrawingHandler touchDrawMgr; 126 OLD::DisplayInfo displayInfo; 127 displayInfo.direction = Direction::DIRECTION0; 128 touchDrawMgr.displayInfo_.direction = Direction::DIRECTION0; 129 displayInfo.width = 700; 130 displayInfo.height = 500; 131 EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo)); 132 133 displayInfo.direction = Direction::DIRECTION180; 134 touchDrawMgr.displayInfo_.direction = Direction::DIRECTION180; 135 EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo)); 136 137 displayInfo.direction = Direction::DIRECTION270; 138 touchDrawMgr.displayInfo_.direction = Direction::DIRECTION270; 139 EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo)); 140 } 141 142 /** 143 * @tc.name: TouchDrawingHandlerTest_UpdateDisplayInfo_002 144 * @tc.desc: Test UpdateDisplayInfo 145 * @tc.type: Function 146 * @tc.require: 147 */ 148 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_UpdateDisplayInfo_002, TestSize.Level1) 149 { 150 CALL_TEST_DEBUG; 151 TouchDrawingHandler touchDrawingHandler; 152 OLD::DisplayInfo displayInfo; 153 displayInfo.direction = Direction::DIRECTION0; 154 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION0; 155 displayInfo.width = 700; 156 displayInfo.height = 500; 157 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); 158 displayInfo.direction = Direction::DIRECTION180; 159 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION180; 160 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); 161 displayInfo.direction = Direction::DIRECTION270; 162 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION270; 163 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); 164 displayInfo.displaySourceMode = DisplaySourceMode::SCREEN_MAIN; 165 touchDrawingHandler.displayInfo_.displaySourceMode = DisplaySourceMode::SCREEN_MAIN; 166 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); 167 displayInfo.rsId = 1; 168 touchDrawingHandler.displayInfo_.rsId = 2; 169 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); 170 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 171 surfaceNodeConfig.SurfaceNodeName = "touch window"; 172 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 173 touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 174 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); 175 touchDrawingHandler.isChangedMode_ = true; 176 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); 177 touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 178 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 179 touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); 180 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 181 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateDisplayInfo(displayInfo)); 182 } 183 184 /** 185 * @tc.name: TouchDrawingManagerTest_UpdateBubbleData_001 186 * @tc.desc: Test UpdateBubbleData 187 * @tc.type: Function 188 * @tc.require: 189 */ 190 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateBubbleData_001, TestSize.Level1) 191 { 192 CALL_TEST_DEBUG; 193 TouchDrawingHandler touchDrawingHandler; 194 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateBubbleData(true)); 195 } 196 197 /** 198 * @tc.name: TouchDrawingManagerTest_UpdateBubbleData_002 199 * @tc.desc: Test UpdateBubbleData 200 * @tc.type: Function 201 * @tc.require: 202 */ 203 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateBubbleData_002, TestSize.Level1) 204 { 205 CALL_TEST_DEBUG; 206 TouchDrawingHandler touchDrawingHandler; 207 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateBubbleData(false)); 208 } 209 210 /** 211 * @tc.name: TouchDrawingManagerTest_UpdateBubbleData_003 212 * @tc.desc: Test UpdateBubbleData 213 * @tc.type: Function 214 * @tc.require: 215 */ 216 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateBubbleData_003, TestSize.Level1) 217 { 218 CALL_TEST_DEBUG; 219 TouchDrawingHandler touchDrawingHandler; 220 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 221 surfaceNodeConfig.SurfaceNodeName = "touch window"; 222 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 223 touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 224 ASSERT_NE(touchDrawingHandler.surfaceNode_, nullptr); 225 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 226 ASSERT_NE(touchDrawingHandler.bubbleCanvasNode_, nullptr); 227 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateBubbleData(false)); 228 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateBubbleData(true)); 229 } 230 231 /** 232 * @tc.name: TouchDrawingManagerTest_RotationScreen_001 233 * @tc.desc: Test RotationScreen 234 * @tc.type: Function 235 * @tc.require: 236 */ 237 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_001, TestSize.Level1) 238 { 239 CALL_TEST_DEBUG; 240 TouchDrawingHandler touchDrawingHandler; 241 touchDrawingHandler.isChangedRotation_ = true; 242 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 243 touchDrawingHandler.pointerMode_.isShow = true; 244 touchDrawingHandler.bubbleMode_.isShow = true; 245 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 246 } 247 248 /** 249 * @tc.name: TouchDrawingManagerTest_RotationScreen_002 250 * @tc.desc: Test RotationScreen 251 * @tc.type: Function 252 * @tc.require: 253 */ 254 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_002, TestSize.Level1) 255 { 256 CALL_TEST_DEBUG; 257 TouchDrawingHandler touchDrawingHandler; 258 touchDrawingHandler.isChangedRotation_ = false; 259 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 260 touchDrawingHandler.pointerMode_.isShow = true; 261 touchDrawingHandler.bubbleMode_.isShow = true; 262 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 263 } 264 265 /** 266 * @tc.name: TouchDrawingManagerTest_RotationScreen_003 267 * @tc.desc: Test RotationScreen 268 * @tc.type: Function 269 * @tc.require: 270 */ 271 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_003, TestSize.Level1) 272 { 273 CALL_TEST_DEBUG; 274 TouchDrawingHandler touchDrawingHandler; 275 touchDrawingHandler.isChangedRotation_ = true; 276 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION90; 277 touchDrawingHandler.pointerMode_.isShow = true; 278 touchDrawingHandler.bubbleMode_.isShow = true; 279 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 280 } 281 282 /** 283 * @tc.name: TouchDrawingManagerTest_RotationScreen_004 284 * @tc.desc: Test RotationScreen 285 * @tc.type: Function 286 * @tc.require: 287 */ 288 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_004, TestSize.Level1) 289 { 290 CALL_TEST_DEBUG; 291 TouchDrawingHandler touchDrawingHandler; 292 touchDrawingHandler.isChangedRotation_ = true; 293 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 294 touchDrawingHandler.pointerMode_.isShow = false; 295 touchDrawingHandler.bubbleMode_.isShow = true; 296 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 297 } 298 299 /** 300 * @tc.name: TouchDrawingManagerTest_RotationScreen_005 301 * @tc.desc: Test RotationScreen 302 * @tc.type: Function 303 * @tc.require: 304 */ 305 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_005, TestSize.Level1) 306 { 307 CALL_TEST_DEBUG; 308 TouchDrawingHandler touchDrawingHandler; 309 touchDrawingHandler.isChangedRotation_ = true; 310 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 311 touchDrawingHandler.pointerMode_.isShow = true; 312 touchDrawingHandler.bubbleMode_.isShow = false; 313 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 314 } 315 316 /** 317 * @tc.name: TouchDrawingManagerTest_RotationScreen_006 318 * @tc.desc: Test RotationScreen 319 * @tc.type: Function 320 * @tc.require: 321 */ 322 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_006, TestSize.Level1) 323 { 324 CALL_TEST_DEBUG; 325 TouchDrawingHandler touchDrawingHandler; 326 touchDrawingHandler.isChangedRotation_ = false; 327 touchDrawingHandler.isChangedMode_ = true; 328 touchDrawingHandler.pointerMode_.isShow = true; 329 touchDrawingHandler.bubbleMode_.isShow = true; 330 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 331 } 332 333 /** 334 * @tc.name: TouchDrawingManagerTest_RotationScreen_007 335 * @tc.desc: Test RotationScreen 336 * @tc.type: Function 337 * @tc.require: 338 */ 339 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_007, TestSize.Level1) 340 { 341 CALL_TEST_DEBUG; 342 TouchDrawingHandler touchDrawingHandler; 343 touchDrawingHandler.isChangedRotation_ = false; 344 touchDrawingHandler.isChangedMode_ = true; 345 touchDrawingHandler.pointerMode_.isShow = false; 346 touchDrawingHandler.bubbleMode_.isShow = false; 347 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 348 } 349 350 /** 351 * @tc.name: TouchDrawingManagerTest_RotationScreen_008 352 * @tc.desc: Test RotationScreen 353 * @tc.type: Function 354 * @tc.require: 355 */ 356 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_008, TestSize.Level1) 357 { 358 CALL_TEST_DEBUG; 359 TouchDrawingHandler touchDrawingHandler; 360 touchDrawingHandler.isChangedRotation_ = false; 361 touchDrawingHandler.isChangedMode_ = false; 362 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 363 } 364 365 /** 366 * @tc.name: TouchDrawingManagerTest_RotationScreen_009 367 * @tc.desc: Test RotationScreen 368 * @tc.type: Function 369 * @tc.require: 370 */ 371 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_009, TestSize.Level1) 372 { 373 CALL_TEST_DEBUG; 374 TouchDrawingHandler touchDrawingHandler; 375 touchDrawingHandler.isChangedRotation_ = false; 376 touchDrawingHandler.isChangedMode_ = false; 377 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 378 379 touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); 380 ASSERT_NE(touchDrawingHandler.trackerCanvasNode_, nullptr); 381 touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); 382 ASSERT_NE(touchDrawingHandler.crosshairCanvasNode_, nullptr); 383 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 384 ASSERT_NE(touchDrawingHandler.bubbleCanvasNode_, nullptr); 385 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); 386 ASSERT_NE(touchDrawingHandler.labelsCanvasNode_, nullptr); 387 touchDrawingHandler.isChangedRotation_ = true; 388 touchDrawingHandler.isChangedMode_ = true; 389 touchDrawingHandler.pointerMode_.isShow = true; 390 touchDrawingHandler.bubbleMode_.isShow = true; 391 PointerEvent::PointerItem item; 392 touchDrawingHandler.lastPointerItem_.push_back(item); 393 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 394 395 touchDrawingHandler.lastPointerItem_.clear(); 396 touchDrawingHandler.stopRecord_ = true; 397 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 398 399 touchDrawingHandler.bubbleMode_.isShow = false; 400 touchDrawingHandler.stopRecord_ = false; 401 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 402 403 touchDrawingHandler.pointerMode_.isShow = false; 404 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 405 } 406 407 /** 408 * @tc.name: TouchDrawingManagerTest_RotationScreen_010 409 * @tc.desc: Test RotationScreen 410 * @tc.type: Function 411 * @tc.require: 412 */ 413 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationScreen_010, TestSize.Level1) 414 { 415 CALL_TEST_DEBUG; 416 TouchDrawingHandler touchDrawingHandler; 417 touchDrawingHandler.isChangedRotation_ = true; 418 touchDrawingHandler.isChangedMode_ = false; 419 touchDrawingHandler.pointerMode_.isShow = true; 420 touchDrawingHandler.bubbleMode_.isShow = true; 421 touchDrawingHandler.stopRecord_ = true; 422 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 423 touchDrawingHandler.stopRecord_ = false; 424 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 425 PointerEvent::PointerItem item; 426 item.SetPointerId(1); 427 item.SetPressed(true); 428 touchDrawingHandler.lastPointerItem_.emplace_back(item); 429 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 430 touchDrawingHandler.stopRecord_ = true; 431 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 432 touchDrawingHandler.stopRecord_ = false; 433 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationScreen()); 434 } 435 436 /** 437 * @tc.name: TouchDrawingManagerTest_AddCanvasNode_001 438 * @tc.desc: Test AddCanvasNode 439 * @tc.type: Function 440 * @tc.require: 441 */ 442 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_AddCanvasNode_001, TestSize.Level1) 443 { 444 CALL_TEST_DEBUG; 445 TouchDrawingHandler touchDrawingHandler; 446 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 447 surfaceNodeConfig.SurfaceNodeName = "touch window"; 448 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 449 touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 450 451 std::shared_ptr<Rosen::RSCanvasNode> canvasNode = nullptr; 452 bool isTrackerNode = true; 453 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.AddCanvasNode(canvasNode, isTrackerNode)); 454 } 455 456 /** 457 * @tc.name: TouchDrawingManagerTest_AddCanvasNode_002 458 * @tc.desc: Test AddCanvasNode 459 * @tc.type: Function 460 * @tc.require: 461 */ 462 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_AddCanvasNode_002, TestSize.Level1) 463 { 464 CALL_TEST_DEBUG; 465 TouchDrawingHandler touchDrawingHandler; 466 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 467 surfaceNodeConfig.SurfaceNodeName = "touch window"; 468 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 469 touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 470 471 std::shared_ptr<Rosen::RSCanvasNode> canvasNode = nullptr; 472 bool isTrackerNode = false; 473 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.AddCanvasNode(canvasNode, isTrackerNode)); 474 } 475 476 /** 477 * @tc.name: TouchDrawingManagerTest_AddCanvasNode_003 478 * @tc.desc: Test AddCanvasNode 479 * @tc.type: Function 480 * @tc.require: 481 */ 482 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_AddCanvasNode_003, TestSize.Level1) 483 { 484 CALL_TEST_DEBUG; 485 TouchDrawingHandler touchDrawingHandler; 486 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 487 surfaceNodeConfig.SurfaceNodeName = "touch window"; 488 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 489 touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 490 std::shared_ptr<Rosen::RSCanvasNode> canvasNode = Rosen::RSCanvasNode::Create(); 491 ASSERT_NE(canvasNode, nullptr); 492 bool isTrackerNode = true; 493 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.AddCanvasNode(canvasNode, isTrackerNode)); 494 495 canvasNode = nullptr; 496 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.AddCanvasNode(canvasNode, isTrackerNode)); 497 } 498 499 /** 500 * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_001 501 * @tc.desc: Test RotationCanvasNode 502 * @tc.type: Function 503 * @tc.require: 504 */ 505 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_001, TestSize.Level1) 506 { 507 CALL_TEST_DEBUG; 508 TouchDrawingHandler touchDrawingHandler; 509 std::shared_ptr<Rosen::RSCanvasNode> canvasNode = Rosen::RSCanvasNode::Create(); 510 ASSERT_NE(canvasNode, nullptr); 511 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION90; 512 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); 513 } 514 515 /** 516 * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_002 517 * @tc.desc: Test RotationCanvasNode 518 * @tc.type: Function 519 * @tc.require: 520 */ 521 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_002, TestSize.Level1) 522 { 523 CALL_TEST_DEBUG; 524 TouchDrawingHandler touchDrawingHandler; 525 std::shared_ptr<Rosen::RSCanvasNode> canvasNode = Rosen::RSCanvasNode::Create(); 526 ASSERT_NE(canvasNode, nullptr); 527 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION270; 528 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); 529 } 530 531 /** 532 * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_003 533 * @tc.desc: Test RotationCanvasNode 534 * @tc.type: Function 535 * @tc.require: 536 */ 537 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_003, TestSize.Level1) 538 { 539 CALL_TEST_DEBUG; 540 TouchDrawingHandler touchDrawingHandler; 541 std::shared_ptr<Rosen::RSCanvasNode> canvasNode = Rosen::RSCanvasNode::Create(); 542 ASSERT_NE(canvasNode, nullptr); 543 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION180; 544 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); 545 } 546 547 /** 548 * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_004 549 * @tc.desc: Test RotationCanvasNode 550 * @tc.type: Function 551 * @tc.require: 552 */ 553 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_004, TestSize.Level1) 554 { 555 CALL_TEST_DEBUG; 556 TouchDrawingHandler touchDrawingHandler; 557 std::shared_ptr<Rosen::RSCanvasNode> canvasNode = Rosen::RSCanvasNode::Create(); 558 ASSERT_NE(canvasNode, nullptr); 559 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION0; 560 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); 561 } 562 563 /** 564 * @tc.name: TouchDrawingManagerTest_RotationCanvasNode_005 565 * @tc.desc: Test RotationCanvasNode 566 * @tc.type: Function 567 * @tc.require: 568 */ 569 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RotationCanvasNode_005, TestSize.Level1) 570 { 571 CALL_TEST_DEBUG; 572 TouchDrawingHandler touchDrawingHandler; 573 std::shared_ptr<Rosen::RSCanvasNode> canvasNode = Rosen::RSCanvasNode::Create(); 574 ASSERT_NE(canvasNode, nullptr); 575 touchDrawingHandler.displayInfo_.width = 720; 576 touchDrawingHandler.displayInfo_.height = 1800; 577 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION90; 578 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); 579 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION270; 580 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); 581 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION180; 582 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); 583 touchDrawingHandler.displayInfo_.direction = Direction::DIRECTION0; 584 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvasNode(canvasNode)); 585 } 586 587 /** 588 * @tc.name: TouchDrawingHandlerTest_RotationCanvas_001 589 * @tc.desc: Test RotationCanvas 590 * @tc.type: Function 591 * @tc.require: 592 */ 593 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_RotationCanvas_001, TestSize.Level1) 594 { 595 CALL_TEST_DEBUG; 596 TouchDrawingHandler touchDrawingHandler; 597 int32_t width = 720; 598 int32_t height = 1800; 599 touchDrawingHandler.displayInfo_.width = 300; 600 touchDrawingHandler.displayInfo_.height = 100; 601 Direction direction = Direction::DIRECTION90; 602 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 603 auto canvas = static_cast<RosenRecordingCanvas *>( 604 touchDrawingHandler.labelsCanvasNode_->BeginRecording(width, height)); 605 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); 606 direction = Direction::DIRECTION180; 607 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); 608 direction = Direction::DIRECTION270; 609 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); 610 direction = Direction::DIRECTION0; 611 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); 612 } 613 614 /** 615 * @tc.name: TouchDrawingHandlerTest_RotationCanvas_002 616 * @tc.desc: Test RotationCanvas 617 * @tc.type: Function 618 * @tc.require: 619 */ 620 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_RotationCanvas_002, TestSize.Level1) 621 { 622 CALL_TEST_DEBUG; 623 TouchDrawingHandler touchDrawingHandler; 624 int32_t width = 300; 625 int32_t height = 100; 626 Direction direction = Direction::DIRECTION90; 627 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 628 auto canvas = static_cast<RosenRecordingCanvas *>( 629 touchDrawingHandler.labelsCanvasNode_->BeginRecording(width, height)); 630 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); 631 direction = Direction::DIRECTION180; 632 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); 633 direction = Direction::DIRECTION270; 634 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); 635 direction = Direction::DIRECTION0; 636 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RotationCanvas(canvas, direction)); 637 } 638 639 /** 640 * @tc.name: TouchDrawingManagerTest_CreateTouchWindow_001 641 * @tc.desc: Test CreateTouchWindow 642 * @tc.type: Function 643 * @tc.require: 644 */ 645 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_CreateTouchWindow_001, TestSize.Level1) 646 { 647 CALL_TEST_DEBUG; 648 TouchDrawingHandler touchDrawingHandler; 649 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 650 surfaceNodeConfig.SurfaceNodeName = "touch window"; 651 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 652 touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 653 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); 654 } 655 656 /** 657 * @tc.name: TouchDrawingHandlerTest_CreateTouchWindow_002 658 * @tc.desc: Test CreateTouchWindow 659 * @tc.type: Function 660 * @tc.require: 661 */ 662 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_CreateTouchWindow_002, TestSize.Level1) 663 { 664 CALL_TEST_DEBUG; 665 TouchDrawingHandler touchDrawingHandler; 666 touchDrawingHandler.surfaceNode_ = nullptr; 667 touchDrawingHandler.scaleW_ = 100; 668 touchDrawingHandler.scaleH_ = 500; 669 touchDrawingHandler.displayInfo_.id = 1000; 670 touchDrawingHandler.displayInfo_.displayMode = DisplayMode::FULL; 671 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); 672 } 673 674 /** 675 * @tc.name: TouchDrawingHandlerTest_CreateTouchWindow_003 676 * @tc.desc: Test CreateTouchWindow 677 * @tc.type: Function 678 * @tc.require: 679 */ 680 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_CreateTouchWindow_003, TestSize.Level1) 681 { 682 CALL_TEST_DEBUG; 683 TouchDrawingHandler touchDrawingHandler; 684 touchDrawingHandler.surfaceNode_ = nullptr; 685 touchDrawingHandler.scaleW_ = 100; 686 touchDrawingHandler.scaleH_ = 500; 687 touchDrawingHandler.displayInfo_.id = 1000; 688 touchDrawingHandler.displayInfo_.displayMode = DisplayMode::UNKNOWN; 689 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); 690 } 691 692 /** 693 * @tc.name: TouchDrawingHandlerTest_CreateTouchWindow_004 694 * @tc.desc: Test CreateTouchWindow 695 * @tc.type: Function 696 * @tc.require: 697 */ 698 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_CreateTouchWindow_004, TestSize.Level1) 699 { 700 CALL_TEST_DEBUG; 701 TouchDrawingHandler touchDrawingHandler; 702 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 703 surfaceNodeConfig.SurfaceNodeName = "touch window"; 704 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 705 touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 706 ASSERT_NE(touchDrawingHandler.surfaceNode_, nullptr); 707 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); 708 touchDrawingHandler.surfaceNode_ = nullptr; 709 touchDrawingHandler.scaleW_ = 0; 710 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); 711 touchDrawingHandler.scaleW_ = 100; 712 touchDrawingHandler.scaleH_ = 0; 713 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); 714 touchDrawingHandler.scaleH_ = 500; 715 touchDrawingHandler.displayInfo_.id = 1000; 716 touchDrawingHandler.displayInfo_.displayMode = DisplayMode::MAIN; 717 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CreateTouchWindow()); 718 } 719 720 /** 721 * @tc.name: TouchDrawingManagerTest_DestoryTouchWindow_001 722 * @tc.desc: Test DestoryTouchWindow 723 * @tc.type: Function 724 * @tc.require: 725 */ 726 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DestoryTouchWindow_001, TestSize.Level1) 727 { 728 CALL_TEST_DEBUG; 729 TouchDrawingHandler touchDrawingHandler; 730 touchDrawingHandler.bubbleMode_.isShow = true; 731 touchDrawingHandler.pointerMode_.isShow = true; 732 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DestoryTouchWindow()); 733 } 734 735 /** 736 * @tc.name: TouchDrawingManagerTest_DestoryTouchWindow_002 737 * @tc.desc: Test DestoryTouchWindow 738 * @tc.type: Function 739 * @tc.require: 740 */ 741 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DestoryTouchWindow_002, TestSize.Level1) 742 { 743 CALL_TEST_DEBUG; 744 TouchDrawingHandler touchDrawingHandler; 745 touchDrawingHandler.bubbleMode_.isShow = false; 746 touchDrawingHandler.pointerMode_.isShow = false; 747 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DestoryTouchWindow()); 748 } 749 750 /** 751 * @tc.name: TouchDrawingManagerTest_DestoryTouchWindow_003 752 * @tc.desc: Test DestoryTouchWindow 753 * @tc.type: Function 754 * @tc.require: 755 */ 756 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DestoryTouchWindow_003, TestSize.Level1) 757 { 758 CALL_TEST_DEBUG; 759 TouchDrawingHandler touchDrawingHandler; 760 touchDrawingHandler.bubbleMode_.isShow = false; 761 touchDrawingHandler.pointerMode_.isShow = false; 762 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 763 surfaceNodeConfig.SurfaceNodeName = "touch window"; 764 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 765 touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 766 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DestoryTouchWindow()); 767 } 768 769 /** 770 * @tc.name: TouchDrawingHandlerTest_DrawBubbleHandler 771 * @tc.desc: Test DrawBubbleHandler 772 * @tc.type: Function 773 * @tc.require: 774 */ 775 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_DrawBubbleHandler, TestSize.Level1) 776 { 777 CALL_TEST_DEBUG; 778 TouchDrawingHandler touchDrawingHandler; 779 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 780 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 781 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 782 ASSERT_NE(touchDrawingHandler.bubbleCanvasNode_, nullptr); 783 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 784 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); 785 786 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN); 787 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); 788 } 789 790 /** 791 * @tc.name: TouchDrawingManagerTest_DrawBubbleHandler_001 792 * @tc.desc: Test DrawBubbleHandler 793 * @tc.type: Function 794 * @tc.require: 795 */ 796 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubbleHandler_001, TestSize.Level1) 797 { 798 CALL_TEST_DEBUG; 799 auto pointerEvent = PointerEvent::Create(); 800 ASSERT_NE(pointerEvent, nullptr); 801 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_AXIS_BEGIN); 802 TouchDrawingHandler touchDrawingHandler; 803 touchDrawingHandler.pointerEvent_ = pointerEvent; 804 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); 805 } 806 807 /** 808 * @tc.name: TouchDrawingManagerTest_DrawBubbleHandler_002 809 * @tc.desc: Test DrawBubbleHandler 810 * @tc.type: Function 811 * @tc.require: 812 */ 813 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubbleHandler_002, TestSize.Level1) 814 { 815 CALL_TEST_DEBUG; 816 auto pointerEvent = PointerEvent::Create(); 817 ASSERT_NE(pointerEvent, nullptr); 818 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP); 819 TouchDrawingHandler touchDrawingHandler; 820 touchDrawingHandler.pointerEvent_ = pointerEvent; 821 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); 822 } 823 824 /** 825 * @tc.name: TouchDrawingManagerTest_DrawBubbleHandler_003 826 * @tc.desc: Test DrawBubbleHandler 827 * @tc.type: Function 828 * @tc.require: 829 */ 830 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubbleHandler_003, TestSize.Level1) 831 { 832 CALL_TEST_DEBUG; 833 auto pointerEvent = PointerEvent::Create(); 834 ASSERT_NE(pointerEvent, nullptr); 835 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 836 TouchDrawingHandler touchDrawingHandler; 837 touchDrawingHandler.pointerEvent_ = pointerEvent; 838 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubbleHandler()); 839 } 840 841 /** 842 * @tc.name: TouchDrawingManagerTest_DrawBubble_001 843 * @tc.desc: Test DrawBubble 844 * @tc.type: Function 845 * @tc.require: 846 */ 847 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubble_001, TestSize.Level1) 848 { 849 CALL_TEST_DEBUG; 850 TouchDrawingHandler touchDrawingHandler; 851 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); 852 } 853 854 /** 855 * @tc.name: TouchDrawingManagerTest_DrawBubble_002 856 * @tc.desc: Test DrawBubble 857 * @tc.type: Function 858 * @tc.require: 859 */ 860 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubble_002, TestSize.Level1) 861 { 862 CALL_TEST_DEBUG; 863 auto pointerEvent = PointerEvent::Create(); 864 ASSERT_NE(pointerEvent, nullptr); 865 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 866 867 TouchDrawingHandler touchDrawingHandler; 868 touchDrawingHandler.pointerEvent_ = pointerEvent; 869 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); 870 } 871 872 /** 873 * @tc.name: TouchDrawingHandlerTest_DrawBubble_001 874 * @tc.desc: Test DrawBubble 875 * @tc.type: Function 876 * @tc.require: 877 */ 878 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_DrawBubble_001, TestSize.Level1) 879 { 880 CALL_TEST_DEBUG; 881 TouchDrawingHandler touchDrawingHandler; 882 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 883 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 884 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 885 886 int32_t pointerId { 1 }; 887 PointerEvent::PointerItem item {}; 888 item.SetPointerId(pointerId); 889 touchDrawingHandler.pointerEvent_->SetPointerId(pointerId); 890 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 891 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 892 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); 893 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP); 894 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); 895 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL); 896 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); 897 } 898 899 /** 900 * @tc.name: TouchDrawingHandlerTest_DrawBubble_002 901 * @tc.desc: Test DrawBubble 902 * @tc.type: Function 903 * @tc.require: 904 */ 905 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_DrawBubble_002, TestSize.Level1) 906 { 907 CALL_TEST_DEBUG; 908 TouchDrawingHandler touchDrawingHandler; 909 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 910 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 911 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 912 913 PointerEvent::PointerItem item; 914 item.SetPointerId(1); 915 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 916 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 917 item.SetPointerId(2); 918 touchDrawingHandler.pointerEvent_->SetPointerId(2); 919 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 920 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); 921 } 922 923 /** 924 * @tc.name: TouchDrawingManagerTest_DrawBubble_003 925 * @tc.desc: Test DrawBubble 926 * @tc.type: Function 927 * @tc.require: 928 */ 929 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawBubble_003, TestSize.Level1) 930 { 931 CALL_TEST_DEBUG; 932 TouchDrawingHandler touchDrawingHandler; 933 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 934 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 935 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 936 PointerEvent::PointerItem item; 937 item.SetPointerId(1); 938 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 939 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 940 item.SetPointerId(2); 941 touchDrawingHandler.pointerEvent_->SetPointerId(2); 942 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 943 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawBubble()); 944 } 945 946 /** 947 * @tc.name: TouchDrawingManagerTest_DrawPointerPositionHandler_001 948 * @tc.desc: Test DrawPointerPositionHandler 949 * @tc.type: Function 950 * @tc.require: 951 */ 952 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawPointerPositionHandler_001, TestSize.Level1) 953 { 954 CALL_TEST_DEBUG; 955 TouchDrawingHandler touchDrawingHandler; 956 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawPointerPositionHandler()); 957 } 958 959 /** 960 * @tc.name: TouchDrawingManagerTest_DrawPointerPositionHandler_002 961 * @tc.desc: Test DrawPointerPositionHandler 962 * @tc.type: Function 963 * @tc.require: 964 */ 965 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawPointerPositionHandler_002, TestSize.Level1) 966 { 967 CALL_TEST_DEBUG; 968 auto pointerEvent = PointerEvent::Create(); 969 ASSERT_NE(pointerEvent, nullptr); 970 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 971 972 TouchDrawingHandler touchDrawingHandler; 973 touchDrawingHandler.pointerEvent_ = pointerEvent; 974 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawPointerPositionHandler()); 975 } 976 977 /** 978 * @tc.name: TouchDrawingManagerTest_DrawPointerPositionHandler_003 979 * @tc.desc: Test DrawPointerPositionHandler 980 * @tc.type: Function 981 * @tc.require: 982 */ 983 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawPointerPositionHandler_003, TestSize.Level1) 984 { 985 CALL_TEST_DEBUG; 986 TouchDrawingHandler touchDrawingHandler; 987 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 988 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 989 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 990 touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); 991 ASSERT_NE(touchDrawingHandler.trackerCanvasNode_, nullptr); 992 touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); 993 ASSERT_NE(touchDrawingHandler.crosshairCanvasNode_, nullptr); 994 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); 995 ASSERT_NE(touchDrawingHandler.labelsCanvasNode_, nullptr); 996 PointerEvent::PointerItem item; 997 item.SetDisplayX(300); 998 item.SetDisplayY(500); 999 item.SetPointerId(100); 1000 touchDrawingHandler.scaleW_ = 720; 1001 touchDrawingHandler.scaleH_ = 1800; 1002 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 1003 touchDrawingHandler.pointerEvent_->SetPointerId(100); 1004 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 1005 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawPointerPositionHandler()); 1006 1007 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1008 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawPointerPositionHandler()); 1009 } 1010 1011 /** 1012 * @tc.name: TouchDrawingManagerTest_DrawTracker_001 1013 * @tc.desc: Test DrawTracker 1014 * @tc.type: Function 1015 * @tc.require: 1016 */ 1017 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawTracker_001, TestSize.Level1) 1018 { 1019 CALL_TEST_DEBUG; 1020 int32_t x = 10; 1021 int32_t y = 10; 1022 int32_t pointerId = 0; 1023 TouchDrawingHandler touchDrawingHandler; 1024 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawTracker(x, y, pointerId)); 1025 } 1026 1027 /** 1028 * @tc.name: TouchDrawingManagerTest_DrawTracker_002 1029 * @tc.desc: Test DrawTracker 1030 * @tc.type: Function 1031 * @tc.require: 1032 */ 1033 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawTracker_002, TestSize.Level1) 1034 { 1035 CALL_TEST_DEBUG; 1036 int32_t x = 11; 1037 int32_t y = 11; 1038 int32_t pointerId = 5; 1039 TouchDrawingHandler touchDrawingHandler; 1040 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawTracker(x, y, pointerId)); 1041 } 1042 1043 /** 1044 * @tc.name: TouchDrawingManagerTest_DrawTracker_003 1045 * @tc.desc: Test DrawTracker 1046 * @tc.type: Function 1047 * @tc.require: 1048 */ 1049 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawTracker_003, TestSize.Level1) 1050 { 1051 CALL_TEST_DEBUG; 1052 TouchDrawingHandler touchDrawingHandler; 1053 int32_t x = 100; 1054 int32_t y = 300; 1055 int32_t pointerId = 10; 1056 PointerEvent::PointerItem item; 1057 item.SetPointerId(10); 1058 item.SetDisplayX(100); 1059 item.SetDisplayY(300); 1060 touchDrawingHandler.isDownAction_ = true; 1061 touchDrawingHandler.xVelocity_ = 200; 1062 touchDrawingHandler.yVelocity_ = 400; 1063 touchDrawingHandler.lastPointerItem_.push_back(item); 1064 touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); 1065 ASSERT_NE(touchDrawingHandler.trackerCanvasNode_, nullptr); 1066 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawTracker(x, y, pointerId)); 1067 1068 pointerId = 20; 1069 touchDrawingHandler.isDownAction_ = false; 1070 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawTracker(x, y, pointerId)); 1071 } 1072 1073 1074 /** 1075 * @tc.name: TouchDrawingManagerTest_DrawCrosshairs_001 1076 * @tc.desc: Test DrawCrosshairs 1077 * @tc.type: Function 1078 * @tc.require: 1079 */ 1080 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawCrosshairs_001, TestSize.Level1) 1081 { 1082 CALL_TEST_DEBUG; 1083 int32_t x = 11; 1084 int32_t y = 11; 1085 TouchDrawingHandler touchDrawingHandler; 1086 if (touchDrawingHandler.crosshairCanvasNode_ == nullptr) { 1087 touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); 1088 } 1089 ASSERT_NE(touchDrawingHandler.crosshairCanvasNode_, nullptr); 1090 auto canvas = static_cast<RosenRecordingCanvas *>( 1091 touchDrawingHandler.crosshairCanvasNode_->BeginRecording(touchDrawingHandler.displayInfo_.width, 1092 touchDrawingHandler.displayInfo_.height)); 1093 ASSERT_NE(canvas, nullptr); 1094 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawCrosshairs(canvas, x, y)); 1095 } 1096 1097 /** 1098 * @tc.name: TouchDrawingManagerTest_DrawCrosshairs_002 1099 * @tc.desc: Test DrawCrosshairs 1100 * @tc.type: Function 1101 * @tc.require: 1102 */ 1103 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawCrosshairs_002, TestSize.Level1) 1104 { 1105 CALL_TEST_DEBUG; 1106 int32_t x = 11; 1107 int32_t y = 11; 1108 TouchDrawingHandler touchDrawingHandler; 1109 if (touchDrawingHandler.crosshairCanvasNode_ == nullptr) { 1110 touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); 1111 } 1112 auto canvas = static_cast<RosenRecordingCanvas *>( 1113 touchDrawingHandler.crosshairCanvasNode_->BeginRecording(touchDrawingHandler.displayInfo_.width, 1114 touchDrawingHandler.displayInfo_.height)); 1115 ASSERT_NE(canvas, nullptr); 1116 touchDrawingHandler.displayInfo_.direction = DIRECTION90; 1117 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawCrosshairs(canvas, x, y)); 1118 } 1119 1120 /** 1121 * @tc.name: TouchDrawingManagerTest_DrawCrosshairs_003 1122 * @tc.desc: Test DrawCrosshairs 1123 * @tc.type: Function 1124 * @tc.require: 1125 */ 1126 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawCrosshairs_003, TestSize.Level1) 1127 { 1128 CALL_TEST_DEBUG; 1129 int32_t x = 11; 1130 int32_t y = 11; 1131 TouchDrawingHandler touchDrawingHandler; 1132 if (touchDrawingHandler.crosshairCanvasNode_ == nullptr) { 1133 touchDrawingHandler.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create(); 1134 } 1135 auto canvas = static_cast<RosenRecordingCanvas *>( 1136 touchDrawingHandler.crosshairCanvasNode_->BeginRecording(touchDrawingHandler.displayInfo_.width, 1137 touchDrawingHandler.displayInfo_.height)); 1138 ASSERT_NE(canvas, nullptr); 1139 touchDrawingHandler.displayInfo_.direction = DIRECTION270; 1140 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawCrosshairs(canvas, x, y)); 1141 } 1142 1143 /** 1144 * @tc.name: TouchDrawingManagerTest_DrawLabels_001 1145 * @tc.desc: Test DrawLabels 1146 * @tc.type: Function 1147 * @tc.require: 1148 */ 1149 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_001, TestSize.Level1) 1150 { 1151 CALL_TEST_DEBUG; 1152 TouchDrawingHandler touchDrawingHandler; 1153 touchDrawingHandler.isDownAction_ = true; 1154 touchDrawingHandler.displayInfo_.direction = DIRECTION90; 1155 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); 1156 } 1157 1158 /** 1159 * @tc.name: TouchDrawingManagerTest_DrawLabels_002 1160 * @tc.desc: Test DrawLabels 1161 * @tc.type: Function 1162 * @tc.require: 1163 */ 1164 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_002, TestSize.Level1) 1165 { 1166 CALL_TEST_DEBUG; 1167 TouchDrawingHandler touchDrawingHandler; 1168 if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { 1169 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1170 } 1171 touchDrawingHandler.isDownAction_ = true; 1172 touchDrawingHandler.displayInfo_.direction = DIRECTION180; 1173 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 1174 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); 1175 } 1176 1177 /** 1178 * @tc.name: TouchDrawingManagerTest_DrawLabels_003 1179 * @tc.desc: Test DrawLabels 1180 * @tc.type: Function 1181 * @tc.require: 1182 */ 1183 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_003, TestSize.Level1) 1184 { 1185 CALL_TEST_DEBUG; 1186 TouchDrawingHandler touchDrawingHandler; 1187 if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { 1188 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1189 } 1190 touchDrawingHandler.isDownAction_ = true; 1191 touchDrawingHandler.displayInfo_.direction = DIRECTION270; 1192 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 1193 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); 1194 } 1195 1196 /** 1197 * @tc.name: TouchDrawingManagerTest_DrawLabels_004 1198 * @tc.desc: Test DrawLabels 1199 * @tc.type: Function 1200 * @tc.require: 1201 */ 1202 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_004, TestSize.Level1) 1203 { 1204 CALL_TEST_DEBUG; 1205 TouchDrawingHandler touchDrawingHandler; 1206 if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { 1207 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1208 } 1209 touchDrawingHandler.isDownAction_ = true; 1210 touchDrawingHandler.displayInfo_.direction = DIRECTION270; 1211 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 1212 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); 1213 } 1214 1215 /** 1216 * @tc.name: TouchDrawingManagerTest_DrawLabels_005 1217 * @tc.desc: Test DrawLabels 1218 * @tc.type: Function 1219 * @tc.require: 1220 */ 1221 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawLabels_005, TestSize.Level1) 1222 { 1223 CALL_TEST_DEBUG; 1224 TouchDrawingHandler touchDrawingHandler; 1225 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); 1226 ASSERT_NE(touchDrawingHandler.labelsCanvasNode_, nullptr); 1227 PointerEvent::PointerItem item; 1228 touchDrawingHandler.currentPointerCount_ = 10; 1229 touchDrawingHandler.maxPointerCount_ = 20; 1230 touchDrawingHandler.scaleW_ = 30; 1231 touchDrawingHandler.scaleH_ = 50; 1232 touchDrawingHandler.xVelocity_ = 30; 1233 touchDrawingHandler.yVelocity_ = 50; 1234 touchDrawingHandler.pressure_ = 10; 1235 touchDrawingHandler.rectTopPosition_ = 100; 1236 touchDrawingHandler.itemRectW_ = 100.0; 1237 touchDrawingHandler.isDownAction_ = true; 1238 touchDrawingHandler.lastPointerItem_.push_back(item); 1239 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); 1240 touchDrawingHandler.isDownAction_ = false; 1241 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); 1242 touchDrawingHandler.lastPointerItem_.clear(); 1243 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawLabels()); 1244 } 1245 1246 /** 1247 * @tc.name: TouchDrawingHandlerTest_UpdatePointerPosition_001 1248 * @tc.desc: Test UpdatePointerPosition 1249 * @tc.type: Function 1250 * @tc.require: 1251 */ 1252 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_UpdatePointerPosition_001, TestSize.Level1) 1253 { 1254 CALL_TEST_DEBUG; 1255 TouchDrawingHandler touchDrawingHandler; 1256 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 1257 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 1258 PointerEvent::PointerItem item; 1259 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1260 touchDrawingHandler.pointerEvent_->SetPointerId(10); 1261 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); 1262 touchDrawingHandler.lastPointerItem_.push_back(item); 1263 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); 1264 } 1265 1266 /** 1267 * @tc.name: TouchDrawingHandlerTest_UpdatePointerPosition_002 1268 * @tc.desc: Test UpdatePointerPosition 1269 * @tc.type: Function 1270 * @tc.require: 1271 */ 1272 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_UpdatePointerPosition_002, TestSize.Level1) 1273 { 1274 CALL_TEST_DEBUG; 1275 TouchDrawingHandler touchDrawingHandler; 1276 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 1277 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 1278 PointerEvent::PointerItem item; 1279 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 1280 touchDrawingHandler.pointerEvent_->SetPointerId(10); 1281 item.SetPointerId(20); 1282 touchDrawingHandler.lastPointerItem_.push_back(item); 1283 item.SetPointerId(10); 1284 touchDrawingHandler.lastPointerItem_.push_back(item); 1285 touchDrawingHandler.currentPointerId_ = 10; 1286 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); 1287 touchDrawingHandler.lastPointerItem_.clear(); 1288 touchDrawingHandler.currentPointerId_ = 50; 1289 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); 1290 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN); 1291 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); 1292 } 1293 1294 /** 1295 * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_003 1296 * @tc.desc: Test UpdatePointerPosition 1297 * @tc.type: Function 1298 * @tc.require: 1299 */ 1300 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdatePointerPosition_003, TestSize.Level1) 1301 { 1302 CALL_TEST_DEBUG; 1303 auto pointerEvent = PointerEvent::Create(); 1304 ASSERT_NE(pointerEvent, nullptr); 1305 pointerEvent->SetPointerId(5); 1306 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 1307 1308 TouchDrawingHandler touchDrawingHandler; 1309 touchDrawingHandler.pointerEvent_ = pointerEvent; 1310 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); 1311 } 1312 1313 /** 1314 * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_004 1315 * @tc.desc: Test UpdatePointerPosition 1316 * @tc.type: Function 1317 * @tc.require: 1318 */ 1319 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdatePointerPosition_004, TestSize.Level1) 1320 { 1321 CALL_TEST_DEBUG; 1322 auto pointerEvent = PointerEvent::Create(); 1323 ASSERT_NE(pointerEvent, nullptr); 1324 pointerEvent->SetPointerId(5); 1325 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 1326 1327 TouchDrawingHandler touchDrawingHandler; 1328 touchDrawingHandler.pointerEvent_ = pointerEvent; 1329 touchDrawingHandler.currentPointerId_ = 5; 1330 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); 1331 } 1332 1333 /** 1334 * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_005 1335 * @tc.desc: Test UpdatePointerPosition 1336 * @tc.type: Function 1337 * @tc.require: 1338 */ 1339 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdatePointerPosition_005, TestSize.Level1) 1340 { 1341 CALL_TEST_DEBUG; 1342 auto pointerEvent = PointerEvent::Create(); 1343 ASSERT_NE(pointerEvent, nullptr); 1344 pointerEvent->SetPointerId(0); 1345 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1346 1347 TouchDrawingHandler touchDrawingHandler; 1348 touchDrawingHandler.pointerEvent_ = pointerEvent; 1349 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); 1350 } 1351 1352 /** 1353 * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_006 1354 * @tc.desc: Test UpdatePointerPosition 1355 * @tc.type: Function 1356 * @tc.require: 1357 */ 1358 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdatePointerPosition_006, TestSize.Level1) 1359 { 1360 CALL_TEST_DEBUG; 1361 auto pointerEvent = PointerEvent::Create(); 1362 ASSERT_NE(pointerEvent, nullptr); 1363 pointerEvent->SetPointerId(0); 1364 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1365 1366 PointerEvent::PointerItem item; 1367 item.SetPointerId(0); 1368 item.SetPressed(true); 1369 1370 TouchDrawingHandler touchDrawingHandler; 1371 touchDrawingHandler.pointerEvent_ = pointerEvent; 1372 touchDrawingHandler.lastPointerItem_.emplace_back(item); 1373 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdatePointerPosition()); 1374 } 1375 1376 /** 1377 * @tc.name: TouchDrawingManagerTest_UpdateLastPointerItem_001 1378 * @tc.desc: Test UpdateLastPointerItem 1379 * @tc.type: Function 1380 * @tc.require: 1381 */ 1382 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateLastPointerItem_001, TestSize.Level1) 1383 { 1384 CALL_TEST_DEBUG; 1385 TouchDrawingHandler touchDrawingHandler; 1386 PointerEvent::PointerItem item; 1387 item.SetPressed(false); 1388 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLastPointerItem(item)); 1389 } 1390 1391 /** 1392 * @tc.name: TouchDrawingManagerTest_UpdateLastPointerItem_002 1393 * @tc.desc: Test UpdateLastPointerItem 1394 * @tc.type: Function 1395 * @tc.require: 1396 */ 1397 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateLastPointerItem_002, TestSize.Level1) 1398 { 1399 CALL_TEST_DEBUG; 1400 TouchDrawingHandler touchDrawingHandler; 1401 PointerEvent::PointerItem item; 1402 item.SetPressed(true); 1403 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLastPointerItem(item)); 1404 } 1405 1406 /** 1407 * @tc.name: TouchDrawingManagerTest_UpdateLastPointerItem_003 1408 * @tc.desc: Test UpdateLastPointerItem 1409 * @tc.type: Function 1410 * @tc.require: 1411 */ 1412 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateLastPointerItem_003, TestSize.Level1) 1413 { 1414 CALL_TEST_DEBUG; 1415 TouchDrawingHandler touchDrawingHandler; 1416 PointerEvent::PointerItem item; 1417 item.SetPressed(false); 1418 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLastPointerItem(item)); 1419 item.SetPressed(true); 1420 item.SetPointerId(10); 1421 touchDrawingHandler.lastPointerItem_.push_back(item); 1422 item.SetPointerId(20); 1423 touchDrawingHandler.lastPointerItem_.push_back(item); 1424 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLastPointerItem(item)); 1425 } 1426 1427 /** 1428 * @tc.name: TouchDrawingManagerTest_RemovePointerPosition_001 1429 * @tc.desc: Test RemovePointerPosition 1430 * @tc.type: Function 1431 * @tc.require: 1432 */ 1433 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_RemovePointerPosition_001, TestSize.Level1) 1434 { 1435 CALL_TEST_DEBUG; 1436 TouchDrawingHandler touchDrawingHandler; 1437 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1438 surfaceNodeConfig.SurfaceNodeName = "touch window"; 1439 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1440 touchDrawingHandler.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1441 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.RemovePointerPosition()); 1442 } 1443 1444 /** 1445 * @tc.name: TouchDrawingManagerTest_ClearTracker_001 1446 * @tc.desc: Test ClearTracker 1447 * @tc.type: Function 1448 * @tc.require: 1449 */ 1450 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ClearTracker_001, TestSize.Level1) 1451 { 1452 CALL_TEST_DEBUG; 1453 TouchDrawingHandler touchDrawingHandler; 1454 if (touchDrawingHandler.trackerCanvasNode_ == nullptr) { 1455 touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1456 } 1457 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); 1458 } 1459 1460 /** 1461 * @tc.name: TouchDrawingManagerTest_ClearTracker_002 1462 * @tc.desc: Test ClearTracker 1463 * @tc.type: Function 1464 * @tc.require: 1465 */ 1466 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ClearTracker_002, TestSize.Level1) 1467 { 1468 CALL_TEST_DEBUG; 1469 TouchDrawingHandler touchDrawingHandler; 1470 if (touchDrawingHandler.trackerCanvasNode_ == nullptr) { 1471 touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1472 } 1473 touchDrawingHandler.lastPointerItem_.clear(); 1474 touchDrawingHandler.isDownAction_ = false; 1475 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); 1476 } 1477 1478 /** 1479 * @tc.name: TouchDrawingManagerTest_ClearTracker_003 1480 * @tc.desc: Test ClearTracker 1481 * @tc.type: Function 1482 * @tc.require: 1483 */ 1484 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ClearTracker_003, TestSize.Level1) 1485 { 1486 CALL_TEST_DEBUG; 1487 TouchDrawingHandler touchDrawingHandler; 1488 if (touchDrawingHandler.trackerCanvasNode_ == nullptr) { 1489 touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1490 } 1491 PointerEvent::PointerItem item; 1492 item.SetPointerId(0); 1493 item.SetDisplayY(200); 1494 touchDrawingHandler.lastPointerItem_.emplace_back(item); 1495 touchDrawingHandler.isDownAction_ = true; 1496 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); 1497 } 1498 1499 /** 1500 * @tc.name: TouchDrawingManagerTest_ClearTracker_004 1501 * @tc.desc: Test ClearTracker 1502 * @tc.type: Function 1503 * @tc.require: 1504 */ 1505 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ClearTracker_004, TestSize.Level1) 1506 { 1507 CALL_TEST_DEBUG; 1508 TouchDrawingHandler touchDrawingHandler; 1509 touchDrawingHandler.trackerCanvasNode_ = Rosen::RSCanvasNode::Create(); 1510 ASSERT_NE(touchDrawingHandler.trackerCanvasNode_, nullptr); 1511 touchDrawingHandler.scaleW_ = 300; 1512 touchDrawingHandler.scaleH_ = 500; 1513 touchDrawingHandler.isDownAction_ = true; 1514 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); 1515 touchDrawingHandler.isDownAction_ = false; 1516 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ClearTracker()); 1517 } 1518 1519 /** 1520 * @tc.name: TouchDrawingManagerTest_UpdateLabels_001 1521 * @tc.desc: Test UpdateLabels 1522 * @tc.type: Function 1523 * @tc.require: 1524 */ 1525 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_UpdateLabels_001, TestSize.Level1) 1526 { 1527 CALL_TEST_DEBUG; 1528 TouchDrawingHandler touchDrawingHandler; 1529 if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { 1530 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1531 } 1532 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.UpdateLabels(true)); 1533 } 1534 1535 /** 1536 * @tc.name: TouchDrawingHandlerTest_IsValidAction 1537 * @tc.desc: Test IsValidAction 1538 * @tc.type: Function 1539 * @tc.require: 1540 */ 1541 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_IsValidAction, TestSize.Level1) 1542 { 1543 CALL_TEST_DEBUG; 1544 TouchDrawingHandler touchDrawingHandler; 1545 int32_t action = PointerEvent::POINTER_ACTION_DOWN; 1546 EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); 1547 action = PointerEvent::POINTER_ACTION_PULL_DOWN; 1548 EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); 1549 action = PointerEvent::POINTER_ACTION_MOVE; 1550 EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); 1551 action = PointerEvent::POINTER_ACTION_PULL_MOVE; 1552 EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); 1553 action = PointerEvent::POINTER_ACTION_UP; 1554 EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); 1555 action = PointerEvent::POINTER_ACTION_PULL_UP; 1556 EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); 1557 action = PointerEvent::POINTER_ACTION_CANCEL; 1558 EXPECT_TRUE(touchDrawingHandler.IsValidAction(action)); 1559 action = PointerEvent::POINTER_ACTION_UNKNOWN; 1560 EXPECT_FALSE(touchDrawingHandler.IsValidAction(action)); 1561 int32_t unknownAction { 100 }; 1562 EXPECT_FALSE(touchDrawingHandler.IsValidAction(unknownAction)); 1563 } 1564 1565 /** 1566 * @tc.name: TouchDrawingManagerTest_DrawRectItem_001 1567 * @tc.desc: Test DrawRectItem 1568 * @tc.type: Function 1569 * @tc.require: 1570 */ 1571 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawRectItem_001, TestSize.Level1) 1572 { 1573 CALL_TEST_DEBUG; 1574 TouchDrawingHandler touchDrawingHandler; 1575 RosenRecordingCanvas *canvas = nullptr; 1576 std::string text; 1577 Rosen::Drawing::Rect rect {}; 1578 Rosen::Drawing::Color color {}; 1579 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawRectItem(canvas, text, rect, color)); 1580 } 1581 1582 /** 1583 * @tc.name: TouchDrawingManagerTest_DrawRectItem_002 1584 * @tc.desc: Test DrawRectItem 1585 * @tc.type: Function 1586 * @tc.require: 1587 */ 1588 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_DrawRectItem_002, TestSize.Level1) 1589 { 1590 CALL_TEST_DEBUG; 1591 TouchDrawingHandler touchDrawingHandler; 1592 if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { 1593 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasNode::Create(); 1594 } 1595 auto canvas = static_cast<RosenRecordingCanvas *>( 1596 touchDrawingHandler.labelsCanvasNode_->BeginRecording(touchDrawingHandler.displayInfo_.width, 1597 touchDrawingHandler.displayInfo_.height)); 1598 ASSERT_NE(canvas, nullptr); 1599 std::string text = "test"; 1600 Rosen::Drawing::Rect rect { 1, 1, 10, 10 }; 1601 Rosen::Drawing::Color color = Rosen::Drawing::Color::ColorQuadSetARGB(192, 255, 255, 255); 1602 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.DrawRectItem(canvas, text, rect, color)); 1603 touchDrawingHandler.labelsCanvasNode_->FinishRecording(); 1604 Rosen::RSTransaction::FlushImplicitTransaction(); 1605 } 1606 1607 /** 1608 * @tc.name: TouchDrawingManagerTest_Snapshot_001 1609 * @tc.desc: Test Snapshot 1610 * @tc.type: Function 1611 * @tc.require: 1612 */ 1613 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_Snapshot_001, TestSize.Level1) 1614 { 1615 CALL_TEST_DEBUG; 1616 TouchDrawingHandler touchDrawingHandler; 1617 if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { 1618 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1619 } 1620 touchDrawingHandler.isChangedRotation_ = true; 1621 touchDrawingHandler.displayInfo_.direction = DIRECTION90; 1622 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 1623 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.Snapshot()); 1624 } 1625 1626 /** 1627 * @tc.name: TouchDrawingManagerTest_Snapshot_002 1628 * @tc.desc: Test Snapshot 1629 * @tc.type: Function 1630 * @tc.require: 1631 */ 1632 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_Snapshot_002, TestSize.Level1) 1633 { 1634 CALL_TEST_DEBUG; 1635 TouchDrawingHandler touchDrawingHandler; 1636 if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { 1637 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1638 } 1639 touchDrawingHandler.isChangedRotation_ = true; 1640 touchDrawingHandler.displayInfo_.direction = DIRECTION180; 1641 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 1642 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.Snapshot()); 1643 } 1644 1645 /** 1646 * @tc.name: TouchDrawingManagerTest_Snapshot_003 1647 * @tc.desc: Test Snapshot 1648 * @tc.type: Function 1649 * @tc.require: 1650 */ 1651 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_Snapshot_003, TestSize.Level1) 1652 { 1653 CALL_TEST_DEBUG; 1654 TouchDrawingHandler touchDrawingHandler; 1655 if (touchDrawingHandler.labelsCanvasNode_ == nullptr) { 1656 touchDrawingHandler.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1657 } 1658 touchDrawingHandler.isChangedRotation_ = true; 1659 touchDrawingHandler.displayInfo_.direction = DIRECTION270; 1660 touchDrawingHandler.displayInfo_.displayDirection = DIRECTION0; 1661 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.Snapshot()); 1662 } 1663 1664 /** 1665 * @tc.name: TouchDrawingManagerTest_ResetCanvasNode_001 1666 * @tc.desc: Test ResetCanvasNode 1667 * @tc.type: Function 1668 * @tc.require: 1669 */ 1670 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_ResetCanvasNode_001, TestSize.Level1) 1671 { 1672 CALL_TEST_DEBUG; 1673 TouchDrawingHandler touchDrawingHandler; 1674 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ResetCanvasNode(nullptr)); 1675 1676 auto canvasNode = Rosen::RSCanvasDrawingNode::Create(); 1677 ASSERT_NE(canvasNode, nullptr); 1678 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.ResetCanvasNode(canvasNode)); 1679 } 1680 1681 /** 1682 * @tc.name: TouchDrawingManagerTest_SetMultiWindowScreenId 1683 * @tc.desc: Test SetMultiWindowScreenId 1684 * @tc.type: Function 1685 * @tc.require: 1686 */ 1687 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_SetMultiWindowScreenId, TestSize.Level1) 1688 { 1689 CALL_TEST_DEBUG; 1690 TouchDrawingHandler touchDrawingHandler; 1691 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 1692 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 1693 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 1694 PointerEvent::PointerItem item; 1695 item.SetPointerId(1); 1696 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 1697 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1698 uint64_t screenId = 1; 1699 uint64_t displayNodeScreenId = 1000; 1700 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.SetMultiWindowScreenId(screenId, displayNodeScreenId)); 1701 } 1702 1703 /** 1704 * @tc.name: TouchDrawingManagerTest_Dump 1705 * @tc.desc: Test Dump 1706 * @tc.type: Function 1707 * @tc.require: 1708 */ 1709 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_Dump, TestSize.Level1) 1710 { 1711 CALL_TEST_DEBUG; 1712 TouchDrawingHandler touchDrawingHandler; 1713 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 1714 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 1715 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 1716 PointerEvent::PointerItem item; 1717 item.SetPointerId(1); 1718 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 1719 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1720 int32_t fd = 1; 1721 std::vector<std::string> args; 1722 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.Dump(fd, args)); 1723 } 1724 1725 /** 1726 * @tc.name: TouchDrawingManagerTest_CalcDrawCoordinate 1727 * @tc.desc: Test CalcDrawCoordinate 1728 * @tc.type: Function 1729 * @tc.require: 1730 */ 1731 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_CalcDrawCoordinate, TestSize.Level1) 1732 { 1733 CALL_TEST_DEBUG; 1734 TouchDrawingHandler touchDrawingHandler; 1735 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 1736 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 1737 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 1738 OLD::DisplayInfo displayInfo; 1739 displayInfo.id = 0; 1740 displayInfo.width = 1920; 1741 displayInfo.height = 1080; 1742 displayInfo.name = "Main Display"; 1743 PointerEvent::PointerItem item; 1744 item.SetPointerId(1); 1745 item.rawDisplayX_ = 0; 1746 item.rawDisplayY_ = 0; 1747 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 1748 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 1749 EXPECT_TRUE(displayInfo.transform.empty()); 1750 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CalcDrawCoordinate(displayInfo, item)); 1751 1752 std::vector<float> transform = {1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0}; 1753 displayInfo.transform = transform; 1754 EXPECT_FALSE(displayInfo.transform.empty()); 1755 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.CalcDrawCoordinate(displayInfo, item)); 1756 } 1757 1758 /** 1759 * @tc.name: TouchDrawingManagerTest_TransformDisplayXY 1760 * @tc.desc: Test TransformDisplayXY 1761 * @tc.type: Function 1762 * @tc.require: 1763 */ 1764 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_TransformDisplayXY, TestSize.Level1) 1765 { 1766 CALL_TEST_DEBUG; 1767 TouchDrawingHandler touchDrawingHandler; 1768 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 1769 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 1770 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 1771 OLD::DisplayInfo displayInfo; 1772 displayInfo.id = 0; 1773 displayInfo.width = 10; 1774 displayInfo.height = 20; 1775 displayInfo.validWidth = displayInfo.width; 1776 displayInfo.validHeight = displayInfo.height; 1777 displayInfo.direction = DIRECTION90; 1778 displayInfo.name = "Main Display"; 1779 1780 double logicX = 1280.00; 1781 double logicY = 960.00; 1782 auto transformSize = 9; 1783 EXPECT_NE(displayInfo.transform.size(), transformSize); 1784 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.TransformDisplayXY(displayInfo, logicX, logicY)); 1785 } 1786 1787 /** 1788 * @tc.name: TouchDrawingManagerTest_TransformDisplayXY_001 1789 * @tc.desc: Test TransformDisplayXY 1790 * @tc.type: Function 1791 * @tc.require: 1792 */ 1793 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_TransformDisplayXY_001, TestSize.Level1) 1794 { 1795 CALL_TEST_DEBUG; 1796 TouchDrawingHandler touchDrawingHandler; 1797 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 1798 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 1799 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 1800 OLD::DisplayInfo displayInfo; 1801 displayInfo.id = 0; 1802 displayInfo.width = 10; 1803 displayInfo.height = 20; 1804 displayInfo.validWidth = displayInfo.width; 1805 displayInfo.validHeight = displayInfo.height; 1806 displayInfo.direction = DIRECTION90; 1807 displayInfo.name = "Main Display"; 1808 double logicX = 1280.00; 1809 double logicY = 960.00; 1810 std::vector<float> transform = {1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0}; 1811 displayInfo.transform = transform; 1812 EXPECT_FALSE(displayInfo.transform.empty()); 1813 auto transformSize = 9; 1814 EXPECT_EQ(displayInfo.transform.size(), transformSize); 1815 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.TransformDisplayXY(displayInfo, logicX, logicY)); 1816 } 1817 1818 /** 1819 * @tc.name: TouchDrawingManagerTest_StartTrace 1820 * @tc.desc: Test StartTrace 1821 * @tc.type: Function 1822 * @tc.require: 1823 */ 1824 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingManagerTest_StartTrace, TestSize.Level1) 1825 { 1826 CALL_TEST_DEBUG; 1827 TouchDrawingHandler touchDrawingHandler; 1828 touchDrawingHandler.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create(); 1829 touchDrawingHandler.pointerEvent_ = PointerEvent::Create(); 1830 ASSERT_NE(touchDrawingHandler.pointerEvent_, nullptr); 1831 PointerEvent::PointerItem item; 1832 item.SetPointerId(1); 1833 touchDrawingHandler.pointerEvent_->AddPointerItem(item); 1834 touchDrawingHandler.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1835 int32_t pointerId = 1; 1836 EXPECT_NO_FATAL_FAILURE(touchDrawingHandler.StartTrace(pointerId)); 1837 } 1838 1839 /** 1840 * @tc.name: TouchDrawingManagerTest_IsValidScaleInfo_001 1841 * @tc.desc: Test ResetCanvasNode 1842 * @tc.type: Function 1843 * @tc.require: 1844 */ 1845 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_IsValidScaleInfo_001, TestSize.Level1) 1846 { 1847 CALL_TEST_DEBUG; 1848 TouchDrawingHandler handler; 1849 handler.scaleW_ = 10; 1850 handler.scaleH_ = 20; 1851 bool result = handler.IsValidScaleInfo(); 1852 EXPECT_TRUE(result); 1853 } 1854 1855 /** 1856 * @tc.name: TouchDrawingManagerTest_IsValidScaleInfo_002 1857 * @tc.desc: Test ResetCanvasNode 1858 * @tc.type: Function 1859 * @tc.require: 1860 */ 1861 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_IsValidScaleInfo_002, TestSize.Level1) 1862 { 1863 CALL_TEST_DEBUG; 1864 TouchDrawingHandler handler; 1865 handler.scaleW_ = 0; 1866 handler.scaleH_ = 0; 1867 bool result = handler.IsValidScaleInfo(); 1868 EXPECT_FALSE(result); 1869 } 1870 1871 /** 1872 * @tc.name: TouchDrawingManagerTest_IsValidScaleInfo_002 1873 * @tc.desc: Test ResetCanvasNode 1874 * @tc.type: Function 1875 * @tc.require: 1876 */ 1877 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_IsValidScaleInfo_003, TestSize.Level1) 1878 { 1879 CALL_TEST_DEBUG; 1880 TouchDrawingHandler handler; 1881 handler.scaleW_ = 0; 1882 handler.scaleH_ = 2700; 1883 bool result = handler.IsValidScaleInfo(); 1884 EXPECT_FALSE(result); 1885 } 1886 1887 /** 1888 * @tc.name: TouchDrawingManagerTest_IsValidScaleInfo_002 1889 * @tc.desc: Test ResetCanvasNode 1890 * @tc.type: Function 1891 * @tc.require: 1892 */ 1893 HWTEST_F(TouchDrawingHandlerTest, TouchDrawingHandlerTest_IsValidScaleInfo_004, TestSize.Level1) 1894 { 1895 CALL_TEST_DEBUG; 1896 TouchDrawingHandler handler; 1897 handler.scaleW_ = 2700; 1898 handler.scaleH_ = 0; 1899 bool result = handler.IsValidScaleInfo(); 1900 EXPECT_FALSE(result); 1901 } 1902 } // namespace MMI 1903 } // namespace OHOS