1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <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 } // namespace 34 class KnuckleDrawingManagerTest : public testing::Test { 35 public: SetUpTestCase(void)36 static void SetUpTestCase(void) {}; TearDownTestCase(void)37 static void TearDownTestCase(void) {}; SetUp(void)38 void SetUp(void) 39 { 40 DisplayInfo info; 41 info.id = 1; 42 info.x =1; 43 info.y = 1; 44 info.width = 1; 45 info.height = 1; 46 int32_t displayDpi = 240; 47 info.dpi = displayDpi; 48 info.name = "display"; 49 info.uniq = "xx"; 50 if (knuckleDrawMgr_ == nullptr) { 51 knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>(); 52 } 53 knuckleDrawMgr_->UpdateDisplayInfo(info); 54 } 55 private: 56 std::shared_ptr<KnuckleDrawingManager> knuckleDrawMgr_ { nullptr }; 57 }; 58 59 /** 60 * @tc.name: KnuckleDrawingManagerTest_StartTouchDraw 61 * @tc.desc: Test Overrides StartTouchDraw function branches 62 * @tc.type: Function 63 * @tc.require: 64 */ 65 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_StartTouchDraw, TestSize.Level1) 66 { 67 CALL_TEST_DEBUG; 68 KnuckleDrawingManager kceDrawMgr; 69 auto pointerEvent = PointerEvent::Create(); 70 ASSERT_NE(pointerEvent, nullptr); 71 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 72 kceDrawMgr.trackCanvasNode_ = nullptr; 73 kceDrawMgr.StartTouchDraw(pointerEvent); 74 EXPECT_EQ(kceDrawMgr.trackCanvasNode_, nullptr); 75 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 76 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 77 #else 78 kceDrawMgr.canvasNode_ = nullptr; 79 kceDrawMgr.StartTouchDraw(pointerEvent); 80 EXPECT_EQ(kceDrawMgr.canvasNode_, nullptr); 81 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 82 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 83 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 84 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 85 kceDrawMgr.isActionUp_ = true; 86 kceDrawMgr.displayInfo_.width = 200; 87 kceDrawMgr.displayInfo_.height = 200; 88 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 89 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 90 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 91 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 92 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 93 kceDrawMgr.StartTouchDraw(pointerEvent); 94 } 95 96 /** 97 * @tc.name: KnuckleDrawingManagerTest_CreateTouchWindow 98 * @tc.desc: Test Overrides CreateTouchWindow function branches 99 * @tc.type: Function 100 * @tc.require: 101 */ 102 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_CreateTouchWindow, TestSize.Level1) 103 { 104 CALL_TEST_DEBUG; 105 KnuckleDrawingManager kceDrawMgr; 106 int32_t displayId = 10; 107 kceDrawMgr.surfaceNode_ = nullptr; 108 kceDrawMgr.displayInfo_.width = 200; 109 kceDrawMgr.displayInfo_.height = 200; 110 kceDrawMgr.CreateTouchWindow(displayId); 111 112 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 113 surfaceNodeConfig.SurfaceNodeName = "touch window"; 114 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 115 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 116 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 117 kceDrawMgr.CreateTouchWindow(displayId); 118 } 119 120 /** 121 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_001 122 * @tc.desc: Test KnuckleDrawHandler 123 * @tc.type: Function 124 * @tc.require: 125 */ 126 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_001, TestSize.Level1) 127 { 128 CALL_TEST_DEBUG; 129 auto pointerEvent = PointerEvent::Create(); 130 EXPECT_NE(pointerEvent, nullptr); 131 132 PointerEvent::PointerItem item; 133 item.SetPointerId(0); 134 int32_t displayX = 100; 135 int32_t displayY = 100; 136 item.SetDisplayX(displayX); 137 item.SetDisplayY(displayY); 138 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER); 139 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 140 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 141 pointerEvent->SetTargetDisplayId(0); 142 pointerEvent->SetPointerId(0); 143 pointerEvent->AddPointerItem(item); 144 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 145 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 146 } 147 148 /** 149 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_002 150 * @tc.desc: Test KnuckleDrawHandler 151 * @tc.type: Function 152 * @tc.require: 153 */ 154 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_002, TestSize.Level1) 155 { 156 CALL_TEST_DEBUG; 157 auto pointerEvent = PointerEvent::Create(); 158 EXPECT_NE(pointerEvent, nullptr); 159 160 PointerEvent::PointerItem item; 161 item.SetPointerId(0); 162 int32_t displayX = 200; 163 int32_t displayY = 200; 164 item.SetDisplayX(displayX); 165 item.SetDisplayY(displayY); 166 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 167 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 168 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 169 pointerEvent->SetTargetDisplayId(0); 170 pointerEvent->SetPointerId(0); 171 pointerEvent->AddPointerItem(item); 172 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 173 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 174 } 175 176 /** 177 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_003 178 * @tc.desc: Test KnuckleDrawHandler 179 * @tc.type: Function 180 * @tc.require: 181 */ 182 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_003, TestSize.Level1) 183 { 184 CALL_TEST_DEBUG; 185 auto pointerEvent = PointerEvent::Create(); 186 EXPECT_NE(pointerEvent, nullptr); 187 188 PointerEvent::PointerItem item1; 189 item1.SetPointerId(0); 190 int32_t displayX = 100; 191 int32_t displayY = 200; 192 item1.SetDisplayX(displayX); 193 item1.SetDisplayY(displayY); 194 item1.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 195 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE); 196 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 197 pointerEvent->SetTargetDisplayId(0); 198 pointerEvent->SetPointerId(0); 199 pointerEvent->AddPointerItem(item1); 200 201 PointerEvent::PointerItem item2; 202 item2.SetPointerId(1); 203 displayX = 200; 204 displayY = 200; 205 item2.SetDisplayX(displayX); 206 item2.SetDisplayY(displayY); 207 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 208 pointerEvent->AddPointerItem(item2); 209 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 210 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 211 } 212 213 /** 214 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_004 215 * @tc.desc: Test KnuckleDrawHandler 216 * @tc.type: Function 217 * @tc.require: 218 */ 219 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_004, TestSize.Level1) 220 { 221 CALL_TEST_DEBUG; 222 auto pointerEvent = PointerEvent::Create(); 223 EXPECT_NE(pointerEvent, nullptr); 224 225 PointerEvent::PointerItem item; 226 item.SetPointerId(0); 227 int32_t displayX = 200; 228 int32_t displayY = 200; 229 item.SetDisplayX(displayX); 230 item.SetDisplayY(displayY); 231 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 232 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 233 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 234 pointerEvent->SetTargetDisplayId(0); 235 pointerEvent->SetPointerId(0); 236 pointerEvent->AddPointerItem(item); 237 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 238 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 239 } 240 241 /** 242 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_006 243 * @tc.desc: Test KnuckleDrawHandler 244 * @tc.type: Function 245 * @tc.require: 246 */ 247 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_006, TestSize.Level1) 248 { 249 CALL_TEST_DEBUG; 250 auto pointerEvent = PointerEvent::Create(); 251 EXPECT_NE(pointerEvent, nullptr); 252 253 PointerEvent::PointerItem item; 254 item.SetPointerId(0); 255 int32_t displayX = 200; 256 int32_t displayY = 200; 257 item.SetDisplayX(displayX); 258 item.SetDisplayY(displayY); 259 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 260 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL); 261 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN); 262 pointerEvent->SetTargetDisplayId(0); 263 pointerEvent->SetPointerId(0); 264 pointerEvent->AddPointerItem(item); 265 knuckleDrawMgr_->KnuckleDrawHandler(pointerEvent); 266 EXPECT_FALSE(knuckleDrawMgr_->isRotate_); 267 } 268 269 /** 270 * @tc.name: KnuckleDrawingManagerTest_IsValidAction 271 * @tc.desc: Test Overrides IsValidAction function branches 272 * @tc.type: Function 273 * @tc.require: 274 */ 275 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsValidAction, TestSize.Level1) 276 { 277 CALL_TEST_DEBUG; 278 KnuckleDrawingManager kceDrawMgr; 279 int32_t action = PointerEvent::POINTER_ACTION_DOWN; 280 ASSERT_TRUE(kceDrawMgr.IsValidAction(action)); 281 action = PointerEvent::POINTER_ACTION_UP; 282 ASSERT_TRUE(kceDrawMgr.IsValidAction(action)); 283 284 action = PointerEvent::POINTER_ACTION_MOVE; 285 PointerInfo pointerInfo; 286 pointerInfo.x = 100; 287 pointerInfo.y = 100; 288 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 289 ASSERT_TRUE(kceDrawMgr.IsValidAction(action)); 290 291 action = PointerEvent::POINTER_ACTION_UNKNOWN; 292 kceDrawMgr.pointerInfos_.clear(); 293 ASSERT_FALSE(kceDrawMgr.IsValidAction(action)); 294 } 295 296 /** 297 * @tc.name: KnuckleDrawingManagerTest_IsSingleKnuckle 298 * @tc.desc: Test Overrides IsSingleKnuckle function branches 299 * @tc.type: Function 300 * @tc.require: 301 */ 302 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsSingleKnuckle, TestSize.Level1) 303 { 304 CALL_TEST_DEBUG; 305 KnuckleDrawingManager kceDrawMgr; 306 auto pointerEvent = PointerEvent::Create(); 307 EXPECT_NE(pointerEvent, nullptr); 308 309 PointerEvent::PointerItem item; 310 item.SetPointerId(0); 311 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 312 pointerEvent->SetPointerId(0); 313 pointerEvent->AddPointerItem(item); 314 ASSERT_TRUE(kceDrawMgr.IsSingleKnuckle(pointerEvent)); 315 316 item.SetPointerId(1); 317 item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD); 318 pointerEvent->SetPointerId(0); 319 pointerEvent->AddPointerItem(item); 320 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 321 kceDrawMgr.trackCanvasNode_ = nullptr; 322 ASSERT_FALSE(kceDrawMgr.IsSingleKnuckle(pointerEvent)); 323 324 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 325 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 326 #else 327 kceDrawMgr.canvasNode_ = nullptr; 328 ASSERT_FALSE(kceDrawMgr.IsSingleKnuckle(pointerEvent)); 329 330 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 331 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 332 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 333 ASSERT_FALSE(kceDrawMgr.IsSingleKnuckle(pointerEvent)); 334 } 335 336 /** 337 * @tc.name: KnuckleDrawingManagerTest_GetPointerPos 338 * @tc.desc: Test Overrides GetPointerPos function branches 339 * @tc.type: Function 340 * @tc.require: 341 */ 342 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_GetPointerPos, TestSize.Level1) 343 { 344 CALL_TEST_DEBUG; 345 KnuckleDrawingManager kceDrawMgr; 346 auto pointerEvent = PointerEvent::Create(); 347 ASSERT_NE(pointerEvent, nullptr); 348 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 349 ASSERT_EQ(kceDrawMgr.GetPointerPos(pointerEvent), RET_OK); 350 351 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 352 PointerEvent::PointerItem item; 353 item.SetPointerId(0); 354 item.SetDisplayX(200); 355 item.SetDisplayY(200); 356 pointerEvent->SetPointerId(1); 357 pointerEvent->AddPointerItem(item); 358 ASSERT_EQ(kceDrawMgr.GetPointerPos(pointerEvent), RET_ERR); 359 360 pointerEvent->SetPointerId(0); 361 ASSERT_EQ(kceDrawMgr.GetPointerPos(pointerEvent), RET_ERR); 362 363 PointerInfo pointerInfo; 364 pointerInfo.x = 100; 365 pointerInfo.y = 100; 366 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 367 pointerInfo.x = 150; 368 pointerInfo.y = 150; 369 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 370 pointerInfo.x = 300; 371 pointerInfo.y = 300; 372 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 373 ASSERT_EQ(kceDrawMgr.GetPointerPos(pointerEvent), RET_OK); 374 } 375 376 /** 377 * @tc.name: KnuckleDrawingManagerTest_DrawGraphic 378 * @tc.desc: Test Overrides DrawGraphic function branches 379 * @tc.type: Function 380 * @tc.require: 381 */ 382 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 383 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawGraphic, TestSize.Level1) 384 { 385 CALL_TEST_DEBUG; 386 KnuckleDrawingManager kceDrawMgr; 387 auto pointerEvent = PointerEvent::Create(); 388 ASSERT_NE(pointerEvent, nullptr); 389 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 390 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 391 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 392 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 393 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 394 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 395 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 396 kceDrawMgr.brushCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 397 ASSERT_NE(kceDrawMgr.brushCanvasNode_, nullptr); 398 PointerEvent::PointerItem item; 399 item.SetPointerId(0); 400 item.SetDisplayX(500); 401 item.SetDisplayY(500); 402 pointerEvent->AddPointerItem(item); 403 pointerEvent->SetPointerId(1); 404 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 405 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_ERR); 406 407 kceDrawMgr.displayInfo_.width = 200; 408 kceDrawMgr.displayInfo_.height = 200; 409 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 410 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_OK); 411 412 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 413 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 414 PointerInfo pointerInfo; 415 pointerInfo.x = 100; 416 pointerInfo.y = 100; 417 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 418 pointerEvent->SetPointerId(0); 419 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 420 pointerInfo.x = 150; 421 pointerInfo.y = 150; 422 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 423 pointerInfo.x = 200; 424 pointerInfo.y = 200; 425 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 426 pointerInfo.x = 300; 427 pointerInfo.y = 300; 428 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 429 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_ERR); 430 } 431 #else 432 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DrawGraphic, TestSize.Level1) 433 { 434 CALL_TEST_DEBUG; 435 KnuckleDrawingManager kceDrawMgr; 436 auto pointerEvent = PointerEvent::Create(); 437 ASSERT_NE(pointerEvent, nullptr); 438 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 439 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 440 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 441 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 442 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 443 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 444 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 445 PointerEvent::PointerItem item; 446 item.SetPointerId(0); 447 item.SetDisplayX(500); 448 item.SetDisplayY(500); 449 pointerEvent->AddPointerItem(item); 450 pointerEvent->SetPointerId(1); 451 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 452 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_ERR); 453 454 kceDrawMgr.displayInfo_.width = 200; 455 kceDrawMgr.displayInfo_.height = 200; 456 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 457 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_OK); 458 459 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 460 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 461 PointerInfo pointerInfo; 462 pointerInfo.x = 100; 463 pointerInfo.y = 100; 464 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 465 pointerEvent->SetPointerId(0); 466 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 467 pointerInfo.x = 150; 468 pointerInfo.y = 150; 469 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 470 pointerInfo.x = 200; 471 pointerInfo.y = 200; 472 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 473 pointerInfo.x = 300; 474 pointerInfo.y = 300; 475 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 476 ASSERT_EQ(kceDrawMgr.DrawGraphic(pointerEvent), RET_ERR); 477 } 478 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 479 480 /** 481 * @tc.name: KnuckleDrawingManagerTest_DestoryWindow_001 482 * @tc.desc: Test Overrides DestoryWindow function branches 483 * @tc.type: Function 484 * @tc.require: 485 */ 486 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DestoryWindow_001, TestSize.Level1) 487 { 488 CALL_TEST_DEBUG; 489 KnuckleDrawingManager kceDrawMgr; 490 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 491 kceDrawMgr.trackCanvasNode_ = nullptr; 492 #else 493 kceDrawMgr.canvasNode_ = nullptr; 494 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 495 ASSERT_EQ(kceDrawMgr.DestoryWindow(), RET_ERR); 496 } 497 498 /** 499 * @tc.name: KnuckleDrawingManagerTest_DestoryWindow_002 500 * @tc.desc: Test Overrides DestoryWindow function branches 501 * @tc.type: Function 502 * @tc.require: 503 */ 504 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 505 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DestoryWindow_002, TestSize.Level1) 506 { 507 CALL_TEST_DEBUG; 508 KnuckleDrawingManager kceDrawMgr; 509 kceDrawMgr.trackCanvasNode_ = nullptr; 510 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 511 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 512 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 513 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 514 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 515 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 516 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 517 ASSERT_EQ(kceDrawMgr.DestoryWindow(), RET_OK); 518 } 519 #else 520 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_DestoryWindow_002, TestSize.Level1) 521 { 522 CALL_TEST_DEBUG; 523 KnuckleDrawingManager kceDrawMgr; 524 kceDrawMgr.canvasNode_ = nullptr; 525 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 526 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 527 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 528 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 529 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 530 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 531 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 532 ASSERT_EQ(kceDrawMgr.DestoryWindow(), RET_OK); 533 } 534 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 535 536 /** 537 * @tc.name: KnuckleDrawingManagerTest_KnuckleDrawHandler_007 538 * @tc.desc: Test Overrides KnuckleDrawHandler function branches 539 * @tc.type: Function 540 * @tc.require: 541 */ 542 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_KnuckleDrawHandler_007, TestSize.Level1) 543 { 544 CALL_TEST_DEBUG; 545 KnuckleDrawingManager kceDrawMgr; 546 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create(); 547 ASSERT_NE(touchEvent, nullptr); 548 touchEvent->SetPointerId(1); 549 PointerEvent::PointerItem item; 550 item.SetPointerId(1); 551 item.SetDisplayX(150); 552 item.SetDisplayY(150); 553 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 554 touchEvent->AddPointerItem(item); 555 kceDrawMgr.isRotate_ = false; 556 kceDrawMgr.lastUpTime_ = 1000; 557 kceDrawMgr.lastDownPointer_.x = 50; 558 kceDrawMgr.lastDownPointer_.y = 50; 559 touchEvent->SetTargetDisplayId(10); 560 touchEvent->SetActionTime(100); 561 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 562 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.KnuckleDrawHandler(touchEvent)); 563 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN); 564 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.KnuckleDrawHandler(touchEvent)); 565 } 566 567 /** 568 * @tc.name: KnuckleDrawingManagerTest_IsSingleKnuckleDoubleClick 569 * @tc.desc: Test Overrides IsSingleKnuckleDoubleClick function branches 570 * @tc.type: Function 571 * @tc.require: 572 */ 573 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsSingleKnuckleDoubleClick, TestSize.Level1) 574 { 575 CALL_TEST_DEBUG; 576 KnuckleDrawingManager kceDrawMgr; 577 kceDrawMgr.lastUpTime_ = 100; 578 std::shared_ptr<PointerEvent> touchEvent = PointerEvent::Create(); 579 ASSERT_NE(touchEvent, nullptr); 580 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN); 581 touchEvent->SetActionTime(200); 582 touchEvent->SetPointerId(1); 583 PointerEvent::PointerItem item; 584 item.SetPointerId(1); 585 item.SetDisplayX(50); 586 item.SetDisplayY(50); 587 kceDrawMgr.lastDownPointer_.x = 60; 588 kceDrawMgr.lastDownPointer_.y = 60; 589 EXPECT_FALSE(kceDrawMgr.IsSingleKnuckleDoubleClick(touchEvent)); 590 kceDrawMgr.lastUpTime_ = 500; 591 EXPECT_TRUE(kceDrawMgr.IsSingleKnuckleDoubleClick(touchEvent)); 592 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP); 593 EXPECT_TRUE(kceDrawMgr.IsSingleKnuckleDoubleClick(touchEvent)); 594 touchEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE); 595 EXPECT_TRUE(kceDrawMgr.IsSingleKnuckleDoubleClick(touchEvent)); 596 } 597 598 /** 599 * @tc.name: KnuckleDrawingManagerTest_IsValidAction_001 600 * @tc.desc: Test Overrides IsValidAction function branches 601 * @tc.type: Function 602 * @tc.require: 603 */ 604 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsValidAction_001, TestSize.Level1) 605 { 606 CALL_TEST_DEBUG; 607 KnuckleDrawingManager kceDrawMgr; 608 int32_t action = PointerEvent::POINTER_ACTION_DOWN; 609 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 610 action = PointerEvent::POINTER_ACTION_PULL_DOWN; 611 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 612 action = PointerEvent::POINTER_ACTION_MOVE; 613 PointerInfo pointerInfo; 614 pointerInfo.x = 100; 615 pointerInfo.y = 100; 616 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 617 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 618 action = PointerEvent::POINTER_ACTION_PULL_MOVE; 619 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 620 action = PointerEvent::POINTER_ACTION_UP; 621 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 622 action = PointerEvent::POINTER_ACTION_PULL_UP; 623 EXPECT_TRUE(kceDrawMgr.IsValidAction(action)); 624 action = PointerEvent::POINTER_ACTION_UNKNOWN; 625 EXPECT_FALSE(kceDrawMgr.IsValidAction(action)); 626 } 627 628 /** 629 * @tc.name: KnuckleDrawingManagerTest_CreateTouchWindow_001 630 * @tc.desc: Test Overrides CreateTouchWindow function branches 631 * @tc.type: Function 632 * @tc.require: 633 */ 634 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_CreateTouchWindow_001, TestSize.Level1) 635 { 636 CALL_TEST_DEBUG; 637 KnuckleDrawingManager kceDrawMgr; 638 int32_t displayId = 10; 639 kceDrawMgr.surfaceNode_ = nullptr; 640 kceDrawMgr.displayInfo_.displayMode = DisplayMode::MAIN; 641 EXPECT_NO_FATAL_FAILURE(kceDrawMgr.CreateTouchWindow(displayId)); 642 } 643 644 /** 645 * @tc.name: KnuckleDrawingManagerTest_IsSingleKnuckle_001 646 * @tc.desc: Test Overrides IsSingleKnuckle function branches 647 * @tc.type: Function 648 * @tc.require: 649 */ 650 HWTEST_F(KnuckleDrawingManagerTest, KnuckleDrawingManagerTest_IsSingleKnuckle_001, TestSize.Level1) 651 { 652 CALL_TEST_DEBUG; 653 KnuckleDrawingManager kceDrawMgr; 654 auto touchEvent = PointerEvent::Create(); 655 ASSERT_NE(touchEvent, nullptr); 656 touchEvent->SetPointerId(1); 657 PointerEvent::PointerItem item; 658 item.SetPointerId(1); 659 item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD); 660 touchEvent->AddPointerItem(item); 661 kceDrawMgr.isRotate_ = true; 662 EXPECT_FALSE(kceDrawMgr.IsSingleKnuckle(touchEvent)); 663 664 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 665 touchEvent->UpdatePointerItem(1, item); 666 kceDrawMgr.isRotate_ = true; 667 EXPECT_TRUE(kceDrawMgr.IsSingleKnuckle(touchEvent)); 668 669 touchEvent->SetPointerId(2); 670 item.SetPointerId(2); 671 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE); 672 kceDrawMgr.isRotate_ = false; 673 PointerInfo pointerInfo; 674 kceDrawMgr.pointerInfos_.push_back(pointerInfo); 675 #ifdef OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 676 kceDrawMgr.trackCanvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 677 ASSERT_NE(kceDrawMgr.trackCanvasNode_, nullptr); 678 #else 679 kceDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create(); 680 ASSERT_NE(kceDrawMgr.canvasNode_, nullptr); 681 #endif // OHOS_BUILD_ENABLE_NEW_KNUCKLE_DYNAMIC 682 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 683 surfaceNodeConfig.SurfaceNodeName = "knuckle window"; 684 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 685 kceDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 686 ASSERT_NE(kceDrawMgr.surfaceNode_, nullptr); 687 EXPECT_FALSE(kceDrawMgr.IsSingleKnuckle(touchEvent)); 688 } 689 } // namespace MMI 690 } // namespace OHOS