1 /* 2 * Copyright (c) 2024-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 19 #include <gtest/gtest.h> 20 21 #include "knuckle_drawing_manager.h" 22 #include "mmi_log.h" 23 #include "pointer_event.h" 24 #include "window_info.h" 25 26 #undef MMI_LOG_TAG 27 #define MMI_LOG_TAG "KnuckleDrawingManagerTest" 28 29 namespace OHOS { 30 namespace MMI { 31 namespace { 32 using namespace testing::ext; 33 constexpr uint32_t TRACK_COLOR_BLUE {0xFF1ED0EE}; 34 constexpr uint32_t TRACK_COLOR_PINK {0xFFFF42D2}; 35 constexpr uint32_t TRACK_COLOR_ORANGE_RED {0xFFFF7B47}; 36 constexpr uint32_t TRACK_COLOR_YELLOW {0xFFFFC628}; 37 constexpr int32_t TRACK_PATH_LENGTH_400 {400}; 38 constexpr int32_t TRACK_PATH_LENGTH_500 {500}; 39 constexpr int32_t TRACK_PATH_LENGTH_1000 {1000}; 40 constexpr int32_t TRACK_PATH_LENGTH_1500 {1500}; 41 constexpr int32_t TRACK_PATH_LENGTH_2000 {2000}; 42 constexpr std::string_view SCREEN_READ_ENABLE { "1" }; 43 constexpr int32_t POINTER_NUMBER_TO_DRAW { 10 }; 44 } // namespace 45 class KnuckleDrawingManagerTest : public testing::Test { 46 public: SetUpTestCase(void)47 static void SetUpTestCase(void) {}; TearDownTestCase(void)48 static void TearDownTestCase(void) {}; SetUp(void)49 void SetUp(void) 50 { 51 OLD::DisplayInfo info; 52 info.id = 1; 53 info.x = 1; 54 info.y = 1; 55 info.width = 1; 56 info.height = 1; 57 int32_t displayDpi = 240; 58 info.dpi = displayDpi; 59 info.name = "display"; 60 if (knuckleDrawMgr_ == nullptr) { 61 knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>(); 62 } 63 knuckleDrawMgr_->UpdateDisplayInfo(info); 64 pointerEvent_ = PointerEvent::Create(); 65 } 66 TearDown(void)67 void TearDown(void) 68 { 69 pointerEvent_ = nullptr; 70 } 71 72 private: 73 std::shared_ptr<KnuckleDrawingManager> knuckleDrawMgr_ {nullptr}; 74 std::shared_ptr<PointerEvent> pointerEvent_ {nullptr}; 75 }; 76 77 /** 78 * @tc.name: KnuckleDrawingManagerTest_StartTouchDraw 79 * @tc.desc: Test Overrides StartTouchDraw function branches 80 * @tc.type: Function 81 * @tc.require: 82 */ 83 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_StartTouchDraw, TestSize.Level1) 84 { 85 CALL_TEST_DEBUG; 86 KnuckleDrawingManager kceDrawMgr; 87 auto pointerEvent = PointerEvent::Create(); 88 ASSERT_NE(pointerEvent, nullptr); 89 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 90 kceDrawMgr.trackCanvasNode_ = nullptr; 91 kceDrawMgr.StartTouchDraw(pointerEvent); 92 EXPECT_EQ(kceDrawMgr.trackCanvasNode_, nullptr); 93 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 94 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 95 #else 96 kceDrawMgr.canvasNode_ = nullptr; 97 kceDrawMgr.StartTouchDraw(pointerEvent); 98 EXPECT_EQ(kceDrawMgr.canvasNode_, nullptr); 99 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 100 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 101 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 102 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 103 kceDrawMgr.isActionUp_ = true; 104 kceDrawMgr.displayInfo_.width = 200; 105 kceDrawMgr.displayInfo_.height = 200; 106 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 107 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 108 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 109 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 110 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 111 kceDrawMgr.StartTouchDraw(pointerEvent); 112 } 113 114 /** 115 * @tc.name: KnuckleDrawingManagerTest_CreateTouchWindow 116 * @tc.desc: Test Overrides CreateTouchWindow function branches 117 * @tc.type: Function 118 * @tc.require: 119 */ 120 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_CreateTouchWindow, TestSize.Level1) 121 { 122 CALL_TEST_DEBUG; 123 KnuckleDrawingManager kceDrawMgr; 124 int32_t displayId = 10; 125 kceDrawMgr.surfaceNode_ = nullptr; 126 kceDrawMgr.displayInfo_.width = 200; 127 kceDrawMgr.displayInfo_.height = 200; 128 kceDrawMgr.CreateTouchWindow(displayId); 129 130 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 131 surfaceNodeConfig.SurfaceNodeName = "touch window"; 132 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 133 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 134 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 135 kceDrawMgr.CreateTouchWindow(displayId); 136 } 137 138 /** 139 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_001 140 * @tc.desc: Test KnuckleDrawHandler 141 * @tc.type: Function 142 * @tc.require: 143 */ 144 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_001, TestSize.Level1) 145 { 146 CALL_TEST_DEBUG; 147 auto pointerEvent = PointerEvent::Create(); 148 EXPECT_NE(pointerEvent, nullptr); 149 150 PointerEvent::PointerItem item; 151 item.SetPointerId(0); 152 int32_t displayX = 100; 153 int32_t displayY = 100; 154 item.SetDisplayX(displayX); 155 item.SetDisplayY(displayY); 156 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER); 157 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 158 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 159 pointerEvent->SetTargetDisplayId(0); 160 pointerEvent->SetPointerId(0); 161 pointerEvent->AddPointerItem(item); 162 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 163 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 164 } 165 166 /** 167 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_002 168 * @tc.desc: Test KnuckleDrawHandler 169 * @tc.type: Function 170 * @tc.require: 171 */ 172 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_002, TestSize.Level1) 173 { 174 CALL_TEST_DEBUG; 175 auto pointerEvent = PointerEvent::Create(); 176 EXPECT_NE(pointerEvent, nullptr); 177 178 PointerEvent::PointerItem item; 179 item.SetPointerId(0); 180 int32_t displayX = 200; 181 int32_t displayY = 200; 182 item.SetDisplayX(displayX); 183 item.SetDisplayY(displayY); 184 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 185 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 186 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 187 pointerEvent->SetTargetDisplayId(0); 188 pointerEvent->SetPointerId(0); 189 pointerEvent->AddPointerItem(item); 190 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 191 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 192 } 193 194 /** 195 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_003 196 * @tc.desc: Test KnuckleDrawHandler 197 * @tc.type: Function 198 * @tc.require: 199 */ 200 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_003, TestSize.Level1) 201 { 202 CALL_TEST_DEBUG; 203 auto pointerEvent = PointerEvent::Create(); 204 EXPECT_NE(pointerEvent, nullptr); 205 206 PointerEvent::PointerItem item1; 207 item1.SetPointerId(0); 208 int32_t displayX = 100; 209 int32_t displayY = 200; 210 item1.SetDisplayX(displayX); 211 item1.SetDisplayY(displayY); 212 item1.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 213 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE); 214 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 215 pointerEvent->SetTargetDisplayId(0); 216 pointerEvent->SetPointerId(0); 217 pointerEvent->AddPointerItem(item1); 218 219 PointerEvent::PointerItem item2; 220 item2.SetPointerId(1); 221 displayX = 200; 222 displayY = 200; 223 item2.SetDisplayX(displayX); 224 item2.SetDisplayY(displayY); 225 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 226 pointerEvent->AddPointerItem(item2); 227 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 228 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 229 } 230 231 /** 232 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_004 233 * @tc.desc: Test KnuckleDrawHandler 234 * @tc.type: Function 235 * @tc.require: 236 */ 237 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_004, TestSize.Level1) 238 { 239 CALL_TEST_DEBUG; 240 auto pointerEvent = PointerEvent::Create(); 241 EXPECT_NE(pointerEvent, nullptr); 242 243 PointerEvent::PointerItem item; 244 item.SetPointerId(0); 245 int32_t displayX = 200; 246 int32_t displayY = 200; 247 item.SetDisplayX(displayX); 248 item.SetDisplayY(displayY); 249 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 250 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 251 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 252 pointerEvent->SetTargetDisplayId(0); 253 pointerEvent->SetPointerId(0); 254 pointerEvent->AddPointerItem(item); 255 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 256 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 257 } 258 259 /** 260 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_005 261 * @tc.desc: Test Overrides KnuckleDrawHandler function branches 262 * @tc.type: Function 263 * @tc.require: 264 */ 265 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_005, TestSize.Level1) 266 { 267 CALL_TEST_DEBUG; 268 KnuckleDrawingManager kceDrawMgr; 269 ASSERT_NE(pointerEvent_, nullptr); 270 pointerEvent_->SetPointerId(1); 271 PointerEvent::PointerItem item; 272 item.SetPointerId(1); 273 item.SetDisplayX(150); 274 item.SetDisplayY(150); 275 item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD); 276 pointerEvent_->AddPointerItem(item); 277 item.SetPointerId(2); 278 pointerEvent_->AddPointerItem(item); 279 kceDrawMgr.isRotate_ = true; 280 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.KnuckleDrawHandler(pointerEvent_)); 281 } 282 283 /** 284 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_006 285 * @tc.desc: Test KnuckleDrawHandler 286 * @tc.type: Function 287 * @tc.require: 288 */ 289 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_006, TestSize.Level1) 290 { 291 CALL_TEST_DEBUG; 292 auto pointerEvent = PointerEvent::Create(); 293 EXPECT_NE(pointerEvent, nullptr); 294 295 PointerEvent::PointerItem item; 296 item.SetPointerId(0); 297 int32_t displayX = 200; 298 int32_t displayY = 200; 299 item.SetDisplayX(displayX); 300 item.SetDisplayY(displayY); 301 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 302 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL); 303 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 304 pointerEvent->SetTargetDisplayId(0); 305 pointerEvent->SetPointerId(0); 306 pointerEvent->AddPointerItem(item); 307 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 308 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 309 } 310 311 /** 312 * @tc.name: KnuckleDrawingManagerTest_IsValidAction 313 * @tc.desc: Test Overrides IsValidAction function branches 314 * @tc.type: Function 315 * @tc.require: 316 */ 317 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsValidAction, TestSize.Level1) 318 { 319 CALL_TEST_DEBUG; 320 KnuckleDrawingManager kceDrawMgr; 321 int32_t action = PointerEvent::POINTER_ACTION_DOWN; 322 ASSERT_TRUE(kceDrawMgr.IsValidAction(action)); 323 action = PointerEvent::POINTER_ACTION_UP; 324 ASSERT_TRUE(kceDrawMgr.IsValidAction(action)); 325 326 action = PointerEvent::POINTER_ACTION_MOVE; 327 PointerInfo pointerInfo; 328 pointerInfo.x = 100; 329 pointerInfo.y = 100; 330 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 331 ASSERT_TRUE(kceDrawMgr.IsValidAction(action)); 332 333 action = PointerEvent::POINTER_ACTION_UNKNOWN; 334 kceDrawMgr.pointerInfos_.clear(); 335 ASSERT_FALSE(kceDrawMgr.IsValidAction(action)); 336 } 337 338 /** 339 * @tc.name: KnuckleDrawingManagerTest_IsSingleKnuckle 340 * @tc.desc: Test Overrides IsSingleKnuckle function branches 341 * @tc.type: Function 342 * @tc.require: 343 */ 344 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsSingleKnuckle, TestSize.Level1) 345 { 346 CALL_TEST_DEBUG; 347 KnuckleDrawingManager kceDrawMgr; 348 auto pointerEvent = PointerEvent::Create(); 349 EXPECT_NE(pointerEvent, nullptr); 350 351 PointerEvent::PointerItem item; 352 item.SetPointerId(0); 353 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 354 pointerEvent->SetPointerId(0); 355 pointerEvent->AddPointerItem(item); 356 ASSERT_TRUE(kceDrawMgr.IsSingleKnuckle(pointerEvent)); 357 358 item.SetPointerId(1); 359 item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD); 360 pointerEvent->SetPointerId(0); 361 pointerEvent->AddPointerItem(item); 362 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 363 kceDrawMgr.trackCanvasNode_ = nullptr; 364 ASSERT_FALSE(kceDrawMgr.IsSingleKnuckle(pointerEvent)); 365 366 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 367 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 368 #else 369 kceDrawMgr.canvasNode_ = nullptr; 370 ASSERT_FALSE(kceDrawMgr.IsSingleKnuckle(pointerEvent)); 371 372 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 373 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 374 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 375 ASSERT_FALSE(kceDrawMgr.IsSingleKnuckle(pointerEvent)); 376 } 377 378 /** 379 * @tc.name: KnuckleDrawingManagerTest_GetPointerPos 380 * @tc.desc: Test Overrides GetPointerPos function branches 381 * @tc.type: Function 382 * @tc.require: 383 */ 384 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_GetPointerPos, TestSize.Level1) 385 { 386 CALL_TEST_DEBUG; 387 KnuckleDrawingManager kceDrawMgr; 388 auto pointerEvent = PointerEvent::Create(); 389 ASSERT_NE(pointerEvent, nullptr); 390 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 391 ASSERT_EQ(kceDrawMgr.GetPointerPos(pointerEvent), RET_OK); 392 393 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 394 PointerEvent::PointerItem item; 395 item.SetPointerId(0); 396 item.SetDisplayX(200); 397 item.SetDisplayY(200); 398 pointerEvent->SetPointerId(1); 399 pointerEvent->AddPointerItem(item); 400 ASSERT_EQ(kceDrawMgr.GetPointerPos(pointerEvent), RET_ERR); 401 402 pointerEvent->SetPointerId(0); 403 ASSERT_EQ(kceDrawMgr.GetPointerPos(pointerEvent), RET_ERR); 404 405 PointerInfo pointerInfo; 406 pointerInfo.x = 100; 407 pointerInfo.y = 100; 408 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 409 pointerInfo.x = 150; 410 pointerInfo.y = 150; 411 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 412 pointerInfo.x = 300; 413 pointerInfo.y = 300; 414 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 415 ASSERT_EQ(kceDrawMgr.GetPointerPos(pointerEvent), RET_OK); 416 } 417 418 /** 419 * @tc.name: KnuckleDrawingManagerTest_DrawGraphic 420 * @tc.desc: Test Overrides DrawGraphic function branches 421 * @tc.type: Function 422 * @tc.require: 423 */ 424 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 425 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawGraphic, TestSize.Level1) 426 { 427 CALL_TEST_DEBUG; 428 KnuckleDrawingManager kceDrawMgr; 429 auto pointerEvent = PointerEvent::Create(); 430 ASSERT_NE(pointerEvent, nullptr); 431 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 432 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 433 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 434 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 435 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 436 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 437 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 438 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 439 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 440 PointerEvent::PointerItem item; 441 item.SetPointerId(0); 442 item.SetDisplayX(500); 443 item.SetDisplayY(500); 444 pointerEvent->AddPointerItem(item); 445 pointerEvent->SetPointerId(1); 446 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 447 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_ERR); 448 449 kceDrawMgr.displayInfo_.width = 200; 450 kceDrawMgr.displayInfo_.height = 200; 451 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 452 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_OK); 453 454 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 455 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 456 PointerInfo pointerInfo; 457 pointerInfo.x = 100; 458 pointerInfo.y = 100; 459 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 460 pointerEvent->SetPointerId(0); 461 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 462 pointerInfo.x = 150; 463 pointerInfo.y = 150; 464 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 465 pointerInfo.x = 200; 466 pointerInfo.y = 200; 467 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 468 pointerInfo.x = 300; 469 pointerInfo.y = 300; 470 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 471 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_ERR); 472 } 473 474 /** 475 * @tc.name: KnuckleDrawingManagerTest_DrawGraphic_002 476 * @tc.desc: Test Overrides DrawGraphic function branches 477 * @tc.type: Function 478 * @tc.require: 479 */ 480 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawGraphic_002, TestSize.Level1) 481 { 482 CALL_TEST_DEBUG; 483 KnuckleDrawingManager kceDrawMgr; 484 PointerInfo pointerInfo; 485 pointerInfo.x = 100; 486 pointerInfo.y = 100; 487 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 488 pointerInfo.x = 150; 489 pointerInfo.y = 150; 490 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 491 pointerInfo.x = 200; 492 pointerInfo.y = 200; 493 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 494 pointerInfo.x = 300; 495 pointerInfo.y = 300; 496 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 497 498 auto pointerEvent = PointerEvent::Create(); 499 ASSERT_NE(pointerEvent, nullptr); 500 pointerEvent->SetPointerId(1); 501 PointerEvent::PointerItem item; 502 item.SetPointerId(1); 503 item.SetDisplayX(500); 504 item.SetDisplayY(500); 505 pointerEvent->AddPointerItem(item); 506 507 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 508 kceDrawMgr.isActionUp_ = false; 509 pointerEvent->SetActionTime(200001); 510 kceDrawMgr.firstDownTime_ = 200000; 511 kceDrawMgr.pointerNum_ = POINTER_NUMBER_TO_DRAW; 512 auto ret = kceDrawMgr.DrawGraphic(pointerEvent); 513 EXPECT_FALSE(kceDrawMgr.isActionUp_); 514 EXPECT_EQ(ret, RET_OK); 515 } 516 517 /** 518 * @tc.name: KnuckleDrawingManagerTest_DrawGraphic_003 519 * @tc.desc: Test Overrides DrawGraphic function branches 520 * @tc.type: Function 521 * @tc.require: 522 */ 523 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawGraphic_003, TestSize.Level1) 524 { 525 CALL_TEST_DEBUG; 526 KnuckleDrawingManager kceDrawMgr; 527 kceDrawMgr.pointerInfos_.clear(); 528 PointerInfo pointerInfo; 529 pointerInfo.x = 100; 530 pointerInfo.y = 100; 531 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 532 pointerInfo.x = 150; 533 pointerInfo.y = 150; 534 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 535 pointerInfo.x = 200; 536 pointerInfo.y = 200; 537 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 538 pointerInfo.x = 300; 539 pointerInfo.y = 300; 540 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 541 542 auto pointerEvent = PointerEvent::Create(); 543 ASSERT_NE(pointerEvent, nullptr); 544 pointerEvent->SetPointerId(1); 545 PointerEvent::PointerItem item; 546 item.SetPointerId(1); 547 item.SetDisplayX(500); 548 item.SetDisplayY(500); 549 pointerEvent->AddPointerItem(item); 550 551 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 552 kceDrawMgr.isActionUp_ = false; 553 pointerEvent->SetActionTime(200001); 554 kceDrawMgr.firstDownTime_ = 100000; 555 kceDrawMgr.isNeedInitParticleEmitter_ = false; 556 auto ret = kceDrawMgr.DrawGraphic(pointerEvent); 557 EXPECT_EQ(ret, RET_ERR); 558 } 559 #else 560 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawGraphic, TestSize.Level1) 561 { 562 CALL_TEST_DEBUG; 563 KnuckleDrawingManager kceDrawMgr; 564 auto pointerEvent = PointerEvent::Create(); 565 ASSERT_NE(pointerEvent, nullptr); 566 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 567 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 568 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 569 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 570 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 571 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 572 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 573 PointerEvent::PointerItem item; 574 item.SetPointerId(0); 575 item.SetDisplayX(500); 576 item.SetDisplayY(500); 577 pointerEvent->AddPointerItem(item); 578 pointerEvent->SetPointerId(1); 579 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 580 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_ERR); 581 582 kceDrawMgr.displayInfo_.width = 200; 583 kceDrawMgr.displayInfo_.height = 200; 584 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 585 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_OK); 586 587 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 588 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 589 PointerInfo pointerInfo; 590 pointerInfo.x = 100; 591 pointerInfo.y = 100; 592 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 593 pointerEvent->SetPointerId(0); 594 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 595 pointerInfo.x = 150; 596 pointerInfo.y = 150; 597 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 598 pointerInfo.x = 200; 599 pointerInfo.y = 200; 600 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 601 pointerInfo.x = 300; 602 pointerInfo.y = 300; 603 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 604 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_ERR); 605 } 606 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 607 608 /** 609 * @tc.name: KnuckleDrawingManagerTest_DestoryWindow_001 610 * @tc.desc: Test Overrides DestoryWindow function branches 611 * @tc.type: Function 612 * @tc.require: 613 */ 614 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DestoryWindow_001, TestSize.Level1) 615 { 616 CALL_TEST_DEBUG; 617 KnuckleDrawingManager kceDrawMgr; 618 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 619 kceDrawMgr.trackCanvasNode_ = nullptr; 620 #else 621 kceDrawMgr.canvasNode_ = nullptr; 622 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 623 ASSERT_EQ(kceDrawMgr.DestoryWindow(), RET_ERR); 624 } 625 626 /** 627 * @tc.name: KnuckleDrawingManagerTest_DestoryWindow_002 628 * @tc.desc: Test Overrides DestoryWindow function branches 629 * @tc.type: Function 630 * @tc.require: 631 */ 632 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 633 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DestoryWindow_002, TestSize.Level1) 634 { 635 CALL_TEST_DEBUG; 636 KnuckleDrawingManager kceDrawMgr; 637 kceDrawMgr.trackCanvasNode_ = nullptr; 638 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 639 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 640 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 641 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 642 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 643 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 644 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 645 ASSERT_EQ(kceDrawMgr.DestoryWindow(), RET_OK); 646 } 647 #else 648 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DestoryWindow_002, TestSize.Level1) 649 { 650 CALL_TEST_DEBUG; 651 KnuckleDrawingManager kceDrawMgr; 652 kceDrawMgr.canvasNode_ = nullptr; 653 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 654 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 655 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 656 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 657 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 658 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 659 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 660 ASSERT_EQ(kceDrawMgr.DestoryWindow(), RET_OK); 661 } 662 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 663 664 /** 665 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_007 666 * @tc.desc: Test Overrides KnuckleDrawHandler function branches 667 * @tc.type: Function 668 * @tc.require: 669 */ 670 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_007, TestSize.Level1) 671 { 672 CALL_TEST_DEBUG; 673 KnuckleDrawingManager kceDrawMgr; 674 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create(); 675 ASSERT_NE(touchEvent, nullptr); 676 touchEvent->SetPointerId(1); 677 PointerEvent::PointerItem item; 678 item.SetPointerId(1); 679 item.SetDisplayX(150); 680 item.SetDisplayY(150); 681 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 682 touchEvent->AddPointerItem(item); 683 kceDrawMgr.isRotate_ = false; 684 kceDrawMgr.lastUpTime_ = 1000; 685 kceDrawMgr.lastDownPointer_.x = 50; 686 kceDrawMgr.lastDownPointer_.y = 50; 687 touchEvent->SetTargetDisplayId(10); 688 touchEvent->SetActionTime(100); 689 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 690 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.KnuckleDrawHandler(touchEvent)); 691 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN); 692 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.KnuckleDrawHandler(touchEvent)); 693 } 694 695 /** 696 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_008 697 * @tc.desc: Test Overrides KnuckleDrawHandler function branches 698 * @tc.type: Function 699 * @tc.require: 700 */ 701 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_008, TestSize.Level1) 702 { 703 CALL_TEST_DEBUG; 704 KnuckleDrawingManager kceDrawMgr; 705 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create(); 706 ASSERT_NE(touchEvent, nullptr); 707 touchEvent->SetPointerId(1); 708 touchEvent->SetActionTime(10); 709 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 710 PointerEvent::PointerItem item; 711 item.SetPointerId(1); 712 item.SetDisplayX(150); 713 item.SetDisplayY(150); 714 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 715 touchEvent->AddPointerItem(item); 716 item.SetPointerId(2); 717 touchEvent->AddPointerItem(item); 718 kceDrawMgr.isRotate_ = true; 719 constexpr int32_t rsId = 1; 720 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.KnuckleDrawHandler(touchEvent, rsId)); 721 } 722 723 /** 724 * @tc.name: KnuckleDrawingManagerTest_IsSingleKnuckleDoubleClick 725 * @tc.desc: Test Overrides IsSingleKnuckleDoubleClick function branches 726 * @tc.type: Function 727 * @tc.require: 728 */ 729 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsSingleKnuckleDoubleClick, TestSize.Level1) 730 { 731 CALL_TEST_DEBUG; 732 KnuckleDrawingManager kceDrawMgr; 733 kceDrawMgr.lastUpTime_ = 100; 734 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create(); 735 ASSERT_NE(touchEvent, nullptr); 736 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 737 touchEvent->SetActionTime(200); 738 touchEvent->SetPointerId(1); 739 PointerEvent::PointerItem item; 740 item.SetPointerId(1); 741 item.SetDisplayX(50); 742 item.SetDisplayY(50); 743 kceDrawMgr.lastDownPointer_.x = 60; 744 kceDrawMgr.lastDownPointer_.y = 60; 745 EXPECT_FALSE(kceDrawMgr.IsSingleKnuckleDoubleClick(touchEvent)); 746 kceDrawMgr.lastUpTime_ = 500; 747 EXPECT_TRUE(kceDrawMgr.IsSingleKnuckleDoubleClick(touchEvent)); 748 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 749 EXPECT_TRUE(kceDrawMgr.IsSingleKnuckleDoubleClick(touchEvent)); 750 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE); 751 EXPECT_TRUE(kceDrawMgr.IsSingleKnuckleDoubleClick(touchEvent)); 752 } 753 754 /** 755 * @tc.name: KnuckleDrawingManagerTest_IsValidAction_001 756 * @tc.desc: Test Overrides IsValidAction function branches 757 * @tc.type: Function 758 * @tc.require: 759 */ 760 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsValidAction_001, TestSize.Level1) 761 { 762 CALL_TEST_DEBUG; 763 KnuckleDrawingManager kceDrawMgr; 764 int32_t action = PointerEvent::POINTER_ACTION_DOWN; 765 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 766 action = PointerEvent::POINTER_ACTION_PULL_DOWN; 767 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 768 action = PointerEvent::POINTER_ACTION_MOVE; 769 PointerInfo pointerInfo; 770 pointerInfo.x = 100; 771 pointerInfo.y = 100; 772 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 773 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 774 action = PointerEvent::POINTER_ACTION_PULL_MOVE; 775 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 776 action = PointerEvent::POINTER_ACTION_UP; 777 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 778 action = PointerEvent::POINTER_ACTION_PULL_UP; 779 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 780 action = PointerEvent::POINTER_ACTION_UNKNOWN; 781 EXPECT_FALSE(kceDrawMgr.IsValidAction(action)); 782 } 783 784 /** 785 * @tc.name: KnuckleDrawingManagerTest_IsValidAction_003 786 * @tc.desc: Test Overrides IsValidAction function branches 787 * @tc.type: Function 788 * @tc.require: 789 */ 790 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsValidAction_003, TestSize.Level1) 791 { 792 CALL_TEST_DEBUG; 793 KnuckleDrawingManager kceDrawMgr; 794 int32_t action = PointerEvent::POINTER_ACTION_DOWN; 795 kceDrawMgr.screenReadState_.state = SCREEN_READ_ENABLE; 796 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 797 } 798 799 /** 800 * @tc.name: KnuckleDrawingManagerTest_CreateTouchWindow_001 801 * @tc.desc: Test Overrides CreateTouchWindow function branches 802 * @tc.type: Function 803 * @tc.require: 804 */ 805 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_CreateTouchWindow_001, TestSize.Level1) 806 { 807 CALL_TEST_DEBUG; 808 int32_t displayId = 10; 809 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 810 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 811 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 812 knuckleDrawMgr_->surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 813 knuckleDrawMgr_->displayInfo_.displayMode = DisplayMode::MAIN; 814 EXPECT_NO_FATAL_FAILURE(knuckleDrawMgr_->CreateTouchWindow(displayId)); 815 } 816 817 /** 818 * @tc.name: KnuckleDrawingManagerTest_CreateTouchWindow_002 819 * @tc.desc: Test Overrides CreateTouchWindow function branches 820 * @tc.type: Function 821 * @tc.require: 822 */ 823 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_CreateTouchWindow_002, TestSize.Level1) 824 { 825 CALL_TEST_DEBUG; 826 int32_t displayId = 10; 827 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 828 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 829 knuckleDrawMgr_->surfaceNode_ = nullptr; 830 knuckleDrawMgr_->displayInfo_.displayMode = DisplayMode::MAIN; 831 knuckleDrawMgr_->SetMultiWindowScreenId(10, 0); 832 knuckleDrawMgr_->CreateTouchWindow(displayId); 833 EXPECT_EQ(knuckleDrawMgr_->screenId_, 0); 834 } 835 836 /** 837 * @tc.name: KnuckleDrawingManagerTest_IsSingleKnuckle_001 838 * @tc.desc: Test Overrides IsSingleKnuckle function branches 839 * @tc.type: Function 840 * @tc.require: 841 */ 842 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsSingleKnuckle_001, TestSize.Level1) 843 { 844 CALL_TEST_DEBUG; 845 KnuckleDrawingManager kceDrawMgr; 846 auto touchEvent = PointerEvent::Create(); 847 ASSERT_NE(touchEvent, nullptr); 848 touchEvent->SetPointerId(1); 849 PointerEvent::PointerItem item; 850 item.SetPointerId(1); 851 item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD); 852 touchEvent->AddPointerItem(item); 853 kceDrawMgr.isRotate_ = true; 854 EXPECT_FALSE(kceDrawMgr.IsSingleKnuckle(touchEvent)); 855 856 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 857 touchEvent->UpdatePointerItem(1, item); 858 kceDrawMgr.isRotate_ = true; 859 EXPECT_TRUE(kceDrawMgr.IsSingleKnuckle(touchEvent)); 860 861 touchEvent->SetPointerId(2); 862 item.SetPointerId(2); 863 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 864 kceDrawMgr.isRotate_ = false; 865 PointerInfo pointerInfo; 866 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 867 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 868 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 869 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 870 #else 871 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 872 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 873 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 874 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 875 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 876 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 877 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 878 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 879 EXPECT_FALSE(kceDrawMgr.IsSingleKnuckle(touchEvent)); 880 } 881 882 /** 883 * @tc.name: KnuckleDrawingManagerTest_RotationCanvasNode_001 884 * @tc.desc: Test Overrides RotationCanvasNode function branches 885 * @tc.type: Function 886 * @tc.require: 887 */ 888 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_RotationCanvasNode_001, TestSize.Level1) 889 { 890 CALL_TEST_DEBUG; 891 KnuckleDrawingManager kceDrawMgr; 892 OLD::DisplayInfo displayInfo; 893 displayInfo.direction = Direction::DIRECTION90; 894 displayInfo.displayDirection = Direction::DIRECTION0; 895 auto canvasNode = Rosen::RSCanvasNode::Create(); 896 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.RotationCanvasNode(canvasNode, displayInfo)); 897 898 displayInfo.direction = Direction::DIRECTION270; 899 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.RotationCanvasNode(canvasNode, displayInfo)); 900 901 displayInfo.direction = Direction::DIRECTION180; 902 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.RotationCanvasNode(canvasNode, displayInfo)); 903 904 displayInfo.direction = Direction::DIRECTION0; 905 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.RotationCanvasNode(canvasNode, displayInfo)); 906 } 907 908 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 909 /** 910 * @tc.name: KnuckleDrawingManagerTest_GetDeltaColor_001 911 * @tc.desc: Test Overrides GetDeltaColor function branches 912 * @tc.type: Function 913 * @tc.require: 914 */ 915 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_GetDeltaColor_001, TestSize.Level1) 916 { 917 CALL_TEST_DEBUG; 918 uint32_t deltaSource = 1; 919 uint32_t deltaTarget = 2; 920 KnuckleDrawingManager kceDrawMgr; 921 auto ret = kceDrawMgr.GetDeltaColor(deltaSource, deltaTarget); 922 EXPECT_EQ(ret, 0); 923 924 deltaTarget = 0; 925 ret = kceDrawMgr.GetDeltaColor(deltaSource, deltaTarget); 926 EXPECT_EQ(ret, (deltaSource - deltaTarget)); 927 } 928 929 /** 930 * @tc.name: KnuckleDrawingManagerTest_DrawTrackColorBlue_001 931 * @tc.desc: Test Overrides DrawTrackColorBlue function branches 932 * @tc.type: Function 933 * @tc.require: 934 */ 935 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawTrackColorBlue_001, TestSize.Level1) 936 { 937 CALL_TEST_DEBUG; 938 int32_t pathValue = 0; 939 KnuckleDrawingManager kceDrawMgr; 940 kceDrawMgr.pathLength_ = TRACK_PATH_LENGTH_2000; 941 auto ret = kceDrawMgr.DrawTrackColorBlue(pathValue); 942 EXPECT_NE(ret, TRACK_COLOR_BLUE); 943 944 pathValue = TRACK_PATH_LENGTH_2000; 945 ret = kceDrawMgr.DrawTrackColorBlue(pathValue); 946 EXPECT_EQ(ret, TRACK_COLOR_BLUE); 947 948 kceDrawMgr.pathLength_ = TRACK_PATH_LENGTH_400; 949 ret = kceDrawMgr.DrawTrackColorBlue(pathValue); 950 EXPECT_EQ(ret, TRACK_COLOR_BLUE); 951 } 952 953 /** 954 * @tc.name: KnuckleDrawingManagerTest_DrawTrackColorPink_001 955 * @tc.desc: Test Overrides DrawTrackColorPink function branches 956 * @tc.type: Function 957 * @tc.require: 958 */ 959 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawTrackColorPink_001, TestSize.Level1) 960 { 961 CALL_TEST_DEBUG; 962 int32_t pathValue = 0; 963 KnuckleDrawingManager kceDrawMgr; 964 auto ret = kceDrawMgr.DrawTrackColorPink(pathValue); 965 EXPECT_NE(ret, TRACK_COLOR_PINK); 966 967 pathValue = TRACK_PATH_LENGTH_2000; 968 ret = kceDrawMgr.DrawTrackColorPink(pathValue); 969 EXPECT_EQ(ret, TRACK_COLOR_PINK); 970 } 971 972 /** 973 * @tc.name: KnuckleDrawingManagerTest_DrawTrackColorYellow_001 974 * @tc.desc: Test Overrides DrawTrackColorYellow function branches 975 * @tc.type: Function 976 * @tc.require: 977 */ 978 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawTrackColorYellow_001, TestSize.Level1) 979 { 980 CALL_TEST_DEBUG; 981 int32_t pathValue = 0; 982 KnuckleDrawingManager kceDrawMgr; 983 auto ret = kceDrawMgr.DrawTrackColorYellow(pathValue); 984 EXPECT_NE(ret, TRACK_COLOR_YELLOW); 985 986 pathValue = TRACK_PATH_LENGTH_2000; 987 ret = kceDrawMgr.DrawTrackColorYellow(pathValue); 988 EXPECT_EQ(ret, TRACK_COLOR_YELLOW); 989 } 990 991 /** 992 * @tc.name: KnuckleDrawingManagerTest_DrawTrackColorOrangeRed_001 993 * @tc.desc: Test Overrides DrawTrackColorOrangeRed function branches 994 * @tc.type: Function 995 * @tc.require: 996 */ 997 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawTrackColorOrangeRed_001, TestSize.Level1) 998 { 999 CALL_TEST_DEBUG; 1000 int32_t pathValue = 0; 1001 KnuckleDrawingManager kceDrawMgr; 1002 auto ret = kceDrawMgr.DrawTrackColorOrangeRed(pathValue); 1003 EXPECT_NE(ret, TRACK_COLOR_ORANGE_RED); 1004 1005 pathValue = TRACK_PATH_LENGTH_2000; 1006 ret = kceDrawMgr.DrawTrackColorOrangeRed(pathValue); 1007 EXPECT_EQ(ret, TRACK_COLOR_ORANGE_RED); 1008 } 1009 1010 /** 1011 * @tc.name: KnuckleDrawingManagerTest_DrawTrackCanvas_001 1012 * @tc.desc: Test Overrides DrawTrackCanvas function branches 1013 * @tc.type: Function 1014 * @tc.require: 1015 */ 1016 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawTrackCanvas_001, TestSize.Level1) 1017 { 1018 CALL_TEST_DEBUG; 1019 KnuckleDrawingManager kceDrawMgr; 1020 kceDrawMgr.CreateTrackCanvasNode(); 1021 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 1022 1023 kceDrawMgr.pathLength_ = TRACK_PATH_LENGTH_500; 1024 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.DrawTrackCanvas()); 1025 1026 kceDrawMgr.pathLength_ = TRACK_PATH_LENGTH_1000; 1027 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.DrawTrackCanvas()); 1028 1029 kceDrawMgr.pathLength_ = TRACK_PATH_LENGTH_1500; 1030 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.DrawTrackCanvas()); 1031 } 1032 1033 /** 1034 * @tc.name: KnuckleDrawingManagerTest_ProcessUpEvent_001 1035 * @tc.desc: Test Overrides ProcessUpEvent function branches when isNeedUpAnimation is false 1036 * @tc.type: Function 1037 * @tc.require: 1038 */ 1039 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_ProcessUpEvent_001, TestSize.Level1) 1040 { 1041 CALL_TEST_DEBUG; 1042 KnuckleDrawingManager kceDrawMgr; 1043 bool isNeedUpAnimation = false; 1044 auto ret = kceDrawMgr.ProcessUpEvent(isNeedUpAnimation); 1045 EXPECT_EQ(ret, RET_OK); 1046 } 1047 1048 /** 1049 * @tc.name: KnuckleDrawingManagerTest_ProcessUpEvent_002 1050 * @tc.desc: Test Overrides ProcessUpEvent function branches when isNeedUpAnimation is true and 1051 * destroyTimerId_ greater than 0 1052 * @tc.type: Function 1053 * @tc.require: 1054 */ 1055 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_ProcessUpEvent_002, TestSize.Level1) 1056 { 1057 CALL_TEST_DEBUG; 1058 KnuckleDrawingManager kceDrawMgr; 1059 bool isNeedUpAnimation = true; 1060 kceDrawMgr.destroyTimerId_ = 1; 1061 auto ret = kceDrawMgr.ProcessUpEvent(isNeedUpAnimation); 1062 kceDrawMgr.destroyTimerId_ = -1; 1063 EXPECT_EQ(ret, RET_OK); 1064 } 1065 1066 /** 1067 * @tc.name: KnuckleDrawingManagerTest_ProcessUpEvent_003 1068 * @tc.desc: Test Overrides ProcessUpEvent function branches when isNeedUpAnimation is true, 1069 * destroyTimerId_ small than 0 and addTimerFunc_ is invalid 1070 * @tc.type: Function 1071 * @tc.require: 1072 */ 1073 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_ProcessUpEvent_003, TestSize.Level1) 1074 { 1075 CALL_TEST_DEBUG; 1076 KnuckleDrawingManager kceDrawMgr; 1077 bool isNeedUpAnimation = true; 1078 kceDrawMgr.destroyTimerId_ = -1; 1079 auto ret = kceDrawMgr.ProcessUpEvent(isNeedUpAnimation); 1080 EXPECT_EQ(ret, RET_OK); 1081 } 1082 1083 /** 1084 * @tc.name: KnuckleDrawingManagerTest_ProcessUpEvent_004 1085 * @tc.desc: Test Overrides ProcessUpEvent function branches when isNeedUpAnimation is true, 1086 * destroyTimerId_ small than 0, addTimerFunc_ is valid and addTimerFunc_ calling fail 1087 * @tc.type: Function 1088 * @tc.require: 1089 */ 1090 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_ProcessUpEvent_004, TestSize.Level1) 1091 { 1092 CALL_TEST_DEBUG; 1093 KnuckleDrawingManager kceDrawMgr; 1094 bool isNeedUpAnimation = true; 1095 kceDrawMgr.destroyTimerId_ = -1; 1096 1097 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1098 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1099 1100 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1101 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 1102 1103 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1104 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 1105 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1106 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1107 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 1108 1109 kceDrawMgr.addTimerFunc_ = [] (int32_t intervalMs, int32_t repeatCount, std::function<void()> callback, __anon451932d90202(int32_t intervalMs, int32_t repeatCount, std::function<void()> callback, const std::string &name) 1110 const std::string &name) -> int32_t { 1111 (void)intervalMs; 1112 (void)repeatCount; 1113 (void)callback; 1114 (void)name; 1115 return -1; 1116 }; 1117 auto ret = kceDrawMgr.ProcessUpEvent(isNeedUpAnimation); 1118 EXPECT_EQ(ret, RET_OK); 1119 EXPECT_EQ(kceDrawMgr.destroyTimerId_, -1); 1120 ASSERT_EQ(kceDrawMgr.brushCanvasNode_, nullptr); 1121 ASSERT_EQ(kceDrawMgr.trackCanvasNode_, nullptr); 1122 ASSERT_EQ(kceDrawMgr.surfaceNode_, nullptr); 1123 } 1124 1125 /** 1126 * @tc.name: KnuckleDrawingManagerTest_ProcessUpEvent_005 1127 * @tc.desc: Test Overrides ProcessUpEvent function branches when isNeedUpAnimation is true, 1128 * destroyTimerId_ small than 0, addTimerFunc_ is valid and addTimerFunc_ call success 1129 * @tc.type: Function 1130 * @tc.require: 1131 */ 1132 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_ProcessUpEvent_005, TestSize.Level1) 1133 { 1134 CALL_TEST_DEBUG; 1135 KnuckleDrawingManager kceDrawMgr; 1136 bool isNeedUpAnimation = true; 1137 kceDrawMgr.destroyTimerId_ = -1; 1138 1139 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1140 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1141 1142 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1143 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 1144 1145 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1146 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 1147 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1148 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1149 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 1150 1151 kceDrawMgr.addTimerFunc_ = [] (int32_t intervalMs, int32_t repeatCount, std::function<void()> callback, __anon451932d90302(int32_t intervalMs, int32_t repeatCount, std::function<void()> callback, const std::string &name) 1152 const std::string &name) -> int32_t { 1153 (void)intervalMs; 1154 (void)repeatCount; 1155 (void)callback; 1156 (void)name; 1157 return 1; 1158 }; 1159 auto ret = kceDrawMgr.ProcessUpEvent(isNeedUpAnimation); 1160 EXPECT_EQ(ret, RET_OK); 1161 EXPECT_EQ(kceDrawMgr.destroyTimerId_, 1); 1162 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1163 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 1164 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 1165 } 1166 1167 /** 1168 * @tc.name: KnuckleDrawingManagerTest_UpdateEmitter_001 1169 * @tc.desc: Test Overrides UpdateEmitter function branches 1170 * @tc.type: Function 1171 * @tc.require: 1172 */ 1173 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_UpdateEmitter_001, TestSize.Level1) 1174 { 1175 CALL_TEST_DEBUG; 1176 KnuckleDrawingManager kceDrawMgr; 1177 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.UpdateEmitter()); 1178 } 1179 1180 /** 1181 * @tc.name: KnuckleDrawingManagerTest_UpdateEmitter_002 1182 * @tc.desc: Test Overrides UpdateEmitter function branches 1183 * @tc.type: Function 1184 * @tc.require: 1185 */ 1186 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_UpdateEmitter_002, TestSize.Level1) 1187 { 1188 CALL_TEST_DEBUG; 1189 KnuckleDrawingManager kceDrawMgr; 1190 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1191 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1192 1193 PointerInfo pointerInfo; 1194 pointerInfo.x = 100; 1195 pointerInfo.y = 100; 1196 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 1197 pointerInfo.x = 150; 1198 pointerInfo.y = 150; 1199 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 1200 pointerInfo.x = 200; 1201 pointerInfo.y = 200; 1202 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 1203 pointerInfo.x = 300; 1204 pointerInfo.y = 300; 1205 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 1206 1207 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.UpdateEmitter()); 1208 } 1209 1210 /** 1211 * @tc.name: KnuckleDrawingManagerTest_DrawBrushCanvas_001 1212 * @tc.desc: Test Overrides DrawBrushCanvas function branches 1213 * @tc.type: Function 1214 * @tc.require: 1215 */ 1216 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawBrushCanvas_001, TestSize.Level1) 1217 { 1218 CALL_TEST_DEBUG; 1219 KnuckleDrawingManager kceDrawMgr; 1220 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.DrawBrushCanvas()); 1221 } 1222 1223 /** 1224 * @tc.name: KnuckleDrawingManagerTest_DrawBrushCanvas_002 1225 * @tc.desc: Test Overrides DrawBrushCanvas function branches 1226 * @tc.type: Function 1227 * @tc.require: 1228 */ 1229 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawBrushCanvas_002, TestSize.Level1) 1230 { 1231 CALL_TEST_DEBUG; 1232 KnuckleDrawingManager kceDrawMgr; 1233 kceDrawMgr.DrawBrushCanvas(); 1234 kceDrawMgr.DrawBrushCanvas(); 1235 kceDrawMgr.DrawBrushCanvas(); 1236 kceDrawMgr.DrawBrushCanvas(); 1237 kceDrawMgr.DrawBrushCanvas(); 1238 kceDrawMgr.DrawBrushCanvas(); 1239 kceDrawMgr.DrawBrushCanvas(); 1240 kceDrawMgr.DrawBrushCanvas(); 1241 EXPECT_EQ(kceDrawMgr.pathInfos_.size(), 8); 1242 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1243 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1244 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.DrawBrushCanvas()); 1245 } 1246 1247 /** 1248 * @tc.name: KnuckleDrawingManagerTest_SetMultiWindowScreenId_001 1249 * @tc.desc: Test Overrides SetMultiWindowScreenId function branches 1250 * @tc.type: Function 1251 * @tc.require: 1252 */ 1253 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_SetMultiWindowScreenId_001, TestSize.Level1) 1254 { 1255 CALL_TEST_DEBUG; 1256 KnuckleDrawingManager kceDrawMgr; 1257 uint64_t screenId = 1; 1258 uint64_t displayNodeScreenId = 2; 1259 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.SetMultiWindowScreenId(screenId, displayNodeScreenId)); 1260 } 1261 1262 /** 1263 * @tc.name: KnuckleDrawingManagerTest_InitParticleEmitter_001 1264 * @tc.desc: Test Overrides InitParticleEmitter function branches 1265 * @tc.type: Function 1266 * @tc.require: 1267 */ 1268 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_InitParticleEmitter_001, TestSize.Level1) 1269 { 1270 CALL_TEST_DEBUG; 1271 KnuckleDrawingManager kceDrawMgr; 1272 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.InitParticleEmitter()); 1273 } 1274 1275 /** 1276 * @tc.name: KnuckleDrawingManagerTest_InitParticleEmitter_002 1277 * @tc.desc: Test Overrides InitParticleEmitter function branches 1278 * @tc.type: Function 1279 * @tc.require: 1280 */ 1281 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_InitParticleEmitter_002, TestSize.Level1) 1282 { 1283 CALL_TEST_DEBUG; 1284 KnuckleDrawingManager kceDrawMgr; 1285 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1286 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1287 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.InitParticleEmitter()); 1288 EXPECT_FALSE(kceDrawMgr.isNeedInitParticleEmitter_); 1289 } 1290 1291 /** 1292 * @tc.name: KnuckleDrawingManagerTest_DrawBrushCanvas_003 1293 * @tc.desc: Test Overrides DrawBrushCanvas function branches 1294 * @tc.type: Function 1295 * @tc.require: 1296 */ 1297 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawBrushCanvas_003, TestSize.Level1) 1298 { 1299 CALL_TEST_DEBUG; 1300 KnuckleDrawingManager kceDrawMgr; 1301 auto pointerEvent = PointerEvent::Create(); 1302 ASSERT_NE(pointerEvent, nullptr); 1303 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1304 surfaceNodeConfig.SurfaceNodeName = "The test knuckle window"; 1305 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1306 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1307 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 1308 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1309 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 1310 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1311 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1312 PointerEvent::PointerItem item; 1313 item.SetPointerId(0); 1314 item.SetDisplayX(500); 1315 item.SetDisplayY(500); 1316 pointerEvent->AddPointerItem(item); 1317 pointerEvent->SetPointerId(1); 1318 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1319 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.DrawBrushCanvas()); 1320 1321 auto pathSize = 8; 1322 for (size_t i = 0; (i < pathSize); i++) { 1323 Rosen::Drawing::Path path; 1324 kceDrawMgr.pathInfos_.emplace_back(path); 1325 } 1326 EXPECT_GT(kceDrawMgr.pathInfos_.size(), pathSize); 1327 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.DrawBrushCanvas()); 1328 } 1329 #endif 1330 1331 /** 1332 * @tc.name: KnuckleDrawingManagerTest_UpdateDisplayInfo_002 1333 * @tc.desc: Test UpdateDisplayInfo 1334 * @tc.type: Function 1335 * @tc.require: 1336 */ 1337 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_UpdateDisplayInfo_002, TestSize.Level1) 1338 { 1339 CALL_TEST_DEBUG; 1340 KnuckleDrawingManager kceDrawMgr; 1341 OLD::DisplayInfo displayInfo; 1342 kceDrawMgr.isRotate_ = false; 1343 displayInfo.direction = Direction::DIRECTION90; 1344 kceDrawMgr.displayInfo_.direction = Direction::DIRECTION90; 1345 kceDrawMgr.UpdateDisplayInfo(displayInfo); 1346 EXPECT_FALSE(kceDrawMgr.isRotate_); 1347 1348 displayInfo.direction = Direction::DIRECTION90; 1349 kceDrawMgr.displayInfo_.direction = Direction::DIRECTION0; 1350 kceDrawMgr.UpdateDisplayInfo(displayInfo); 1351 EXPECT_TRUE(kceDrawMgr.isRotate_); 1352 } 1353 1354 /** 1355 * @tc.name: KnuckleDrawingManagerTest_RegisterAddTimer_001 1356 * @tc.desc: Test Overrides RegisterAddTimer function branches 1357 * @tc.type: Function 1358 * @tc.require: 1359 */ 1360 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_RegisterAddTimer_001, TestSize.Level1) 1361 { 1362 knuckleDrawMgr_->RegisterAddTimer([] (int32_t intervalMs, int32_t repeatCount, std::function<void()> callback, __anon451932d90402(int32_t intervalMs, int32_t repeatCount, std::function<void()> callback, const std::string &name) 1363 const std::string &name) -> int32_t { 1364 (void)intervalMs; 1365 (void)repeatCount; 1366 (void)callback; 1367 (void)name; 1368 return 1; 1369 }); 1370 ASSERT_TRUE(knuckleDrawMgr_->addTimerFunc_); 1371 } 1372 1373 /** 1374 * @tc.name: KnuckleDrawingManagerTest_IsValidAction_002 1375 * @tc.desc: Test IsValidAction 1376 * @tc.type: Function 1377 * @tc.require: 1378 */ 1379 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsValidAction_002, TestSize.Level1) 1380 { 1381 CALL_TEST_DEBUG; 1382 KnuckleDrawingManager kceDrawMgr; 1383 ASSERT_NE(knuckleDrawMgr_, nullptr); 1384 ASSERT_NE(pointerEvent_, nullptr); 1385 kceDrawMgr.screenReadState_.state = "1"; 1386 int32_t action = PointerEvent::POINTER_ACTION_DOWN; 1387 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.IsValidAction(action)); 1388 } 1389 1390 /** 1391 * @tc.name: KnuckleDrawingManagerTest_UpdateDisplayInfo_001 1392 * @tc.desc: Test UpdateDisplayInfo 1393 * @tc.type: Function 1394 * @tc.require: 1395 */ 1396 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_UpdateDisplayInfo_001, TestSize.Level1) 1397 { 1398 CALL_TEST_DEBUG; 1399 ASSERT_NE(knuckleDrawMgr_, nullptr); 1400 ASSERT_NE(pointerEvent_, nullptr); 1401 OLD::DisplayInfo info; 1402 info.id = 10; 1403 info.x = 10; 1404 info.y = 5; 1405 info.width = 5; 1406 info.height = 5; 1407 int32_t displayDpi = 220; 1408 info.dpi = displayDpi; 1409 info.name = "display"; 1410 info.direction = Direction::DIRECTION90; 1411 if (knuckleDrawMgr_ == nullptr) 1412 { 1413 knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>(); 1414 } 1415 EXPECT_NO_FATAL_FAILURE(knuckleDrawMgr_->UpdateDisplayInfo(info)); 1416 } 1417 1418 /** 1419 * @tc.name: KnuckleDrawingManagerTest_UpdateEmitter001 1420 * @tc.desc: Test Overrides UpdateEmitter function branches 1421 * @tc.type: Function 1422 * @tc.require: 1423 */ 1424 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_UpdateEmitter001, TestSize.Level1) 1425 { 1426 CALL_TEST_DEBUG; 1427 KnuckleDrawingManager kceDrawMgr; 1428 ASSERT_NE(pointerEvent_, nullptr); 1429 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1430 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 1431 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1432 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1433 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 1434 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1435 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 1436 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1437 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1438 EXPECT_NO_FATAL_FAILURE(knuckleDrawMgr_->UpdateEmitter()); 1439 } 1440 1441 /** 1442 * @tc.name: KnuckleDrawingManagerTest_DrawGraphic002 1443 * @tc.desc: Test Overrides DrawGraphic function branches 1444 * @tc.type: Function 1445 * @tc.require: 1446 */ 1447 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawGraphic002, TestSize.Level1) 1448 { 1449 CALL_TEST_DEBUG; 1450 KnuckleDrawingManager kceDrawMgr; 1451 ASSERT_NE(pointerEvent_, nullptr); 1452 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1453 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 1454 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1455 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1456 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 1457 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1458 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 1459 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1460 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1461 PointerEvent::PointerItem item; 1462 item.SetPointerId(10); 1463 item.SetDisplayX(50); 1464 item.SetDisplayY(50); 1465 pointerEvent_->AddPointerItem(item); 1466 pointerEvent_->SetPointerId(1); 1467 pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1468 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent_), RET_ERR); 1469 1470 kceDrawMgr.displayInfo_.width = 20; 1471 kceDrawMgr.displayInfo_.height = 20; 1472 pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 1473 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent_), RET_OK); 1474 1475 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1476 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 1477 PointerInfo pointerInfo; 1478 pointerInfo.x = 10; 1479 pointerInfo.y = 10; 1480 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 1481 pointerEvent_->SetPointerId(0); 1482 pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 1483 pointerInfo.x = 50; 1484 pointerInfo.y = 50; 1485 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 1486 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent_), RET_ERR); 1487 kceDrawMgr.isActionUp_ = false; 1488 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.DrawGraphic(pointerEvent_)); 1489 } 1490 1491 /** 1492 * @tc.name: KnuckleDrawingManagerTest_ProcessUpEvent_006 1493 * @tc.desc: Test Overrides ProcessUpEvent function branches 1494 * @tc.type: Function 1495 * @tc.require: 1496 */ 1497 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_ProcessUpEvent_006, TestSize.Level1) 1498 { 1499 CALL_TEST_DEBUG; 1500 KnuckleDrawingManager kceDrawMgr; 1501 bool isNeedUpAnimation = true; 1502 auto ret = kceDrawMgr.ProcessUpEvent(isNeedUpAnimation); 1503 EXPECT_EQ(ret, RET_OK); 1504 1505 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1506 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1507 1508 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1509 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 1510 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1511 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1512 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 1513 ret = kceDrawMgr.ProcessUpEvent(isNeedUpAnimation); 1514 EXPECT_EQ(ret, RET_OK); 1515 1516 isNeedUpAnimation = false; 1517 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 1518 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 1519 1520 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1521 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 1522 ret = kceDrawMgr.ProcessUpEvent(isNeedUpAnimation); 1523 EXPECT_EQ(ret, RET_OK); 1524 } 1525 } // namespace MMI 1526 } // namespace OHOS