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 19 #include <gtest/gtest.h> 20 21 #include "event_log_helper.h" 22 #include "image_source.h" 23 #include "input_device_manager.h" 24 #include "input_windows_manager.h" 25 #include "input_windows_manager_mock.h" 26 #include "i_preference_manager.h" 27 #include "knuckle_drawing_manager.h" 28 #include "libinput_mock.h" 29 #include "mmi_log.h" 30 #include "parameters.h" 31 #include "pixel_map.h" 32 #include "pointer_drawing_manager.h" 33 #include "pointer_event.h" 34 #include "pointer_style.h" 35 36 #undef MMI_LOG_TAG 37 #define MMI_LOG_TAG "PointerDrawingManagerSupTest" 38 39 namespace OHOS { 40 namespace MMI { 41 namespace { 42 using namespace testing; 43 using namespace testing::ext; 44 constexpr int32_t MAX_POINTER_COLOR { 0x00ffffff }; 45 constexpr int32_t AECH_DEVELOPER_DEFINED_STYLE { 47 }; 46 constexpr int32_t AECH_DEVELOPER_DEFINED { 4 }; 47 } // namespace 48 49 class PointerDrawingManagerSupTest : public testing::Test { 50 public: SetUpTestCase(void)51 static void SetUpTestCase(void) {}; TearDownTestCase(void)52 static void TearDownTestCase(void) {}; SetUp(void)53 void SetUp(void) {} TearDown(void)54 void TearDown(void) {} 55 }; 56 57 /** 58 * @tc.name: PointerDrawingManagerSupTest_PostMoveRetryTask_001 59 * @tc.desc: Test PostMoveRetryTask 60 * @tc.type: FUNC 61 * @tc.require: 62 */ 63 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_PostMoveRetryTask_001, TestSize.Level1) 64 { 65 CALL_TEST_DEBUG; 66 std::function<void()> task; 67 PointerDrawingManager pointerDrawingManager; 68 EXPECT_NO_FATAL_FAILURE(pointerDrawingManager.PostMoveRetryTask(task)); 69 70 pointerDrawingManager.InitPointerCallback(); 71 EXPECT_NO_FATAL_FAILURE(pointerDrawingManager.PostMoveRetryTask(task)); 72 } 73 74 /** 75 * @tc.name: PointerDrawingManagerSupTest_DrawDynamicHardwareCursor_001 76 * @tc.desc: Test DrawDynamicHardwareCursor 77 * @tc.type: FUNC 78 * @tc.require: 79 */ 80 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_DrawDynamicHardwareCursor_001, TestSize.Level1) 81 { 82 CALL_TEST_DEBUG; 83 hwcmgr_ptr_t hwcmgr = std::make_shared<HardwareCursorPointerManager>(); 84 ASSERT_NE(hwcmgr, nullptr); 85 handler_ptr_t handler = nullptr; 86 sptr<OHOS::Rosen::ScreenInfo> screenInfo = new OHOS::Rosen::ScreenInfo(); 87 auto screenpointer = std::make_shared<ScreenPointer>(hwcmgr, handler, screenInfo); 88 ASSERT_NE(screenpointer, nullptr); 89 RenderConfig cfg; 90 PointerDrawingManager pointerDrawingManager; 91 auto rlt = pointerDrawingManager.DrawDynamicHardwareCursor(screenpointer, cfg); 92 EXPECT_EQ(rlt, RET_ERR); 93 94 PointerRenderer renderer; 95 ASSERT_TRUE(screenpointer->Init(renderer)); 96 screenpointer->bufferId_ = 5; 97 cfg.style_ = TRANSPARENT_ICON; 98 rlt = pointerDrawingManager.DrawDynamicHardwareCursor(screenpointer, cfg); 99 EXPECT_EQ(rlt, RET_OK); 100 } 101 102 /** 103 * @tc.name: PointerDrawingManagerSupTest_HardwareCursorDynamicRender_001 104 * @tc.desc: Test HardwareCursorDynamicRender 105 * @tc.type: FUNC 106 * @tc.require: 107 */ 108 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_HardwareCursorDynamicRender_001, TestSize.Level1) 109 { 110 CALL_TEST_DEBUG; 111 hwcmgr_ptr_t hwcmgr = std::make_shared<HardwareCursorPointerManager>(); 112 ASSERT_NE(hwcmgr, nullptr); 113 handler_ptr_t handler = nullptr; 114 sptr<OHOS::Rosen::ScreenInfo> screenInfo = new OHOS::Rosen::ScreenInfo(); 115 auto screenpointer = std::make_shared<ScreenPointer>(hwcmgr, handler, screenInfo); 116 ASSERT_NE(screenpointer, nullptr); 117 PointerDrawingManager pointerDrawingManager; 118 119 pointerDrawingManager.screenPointers_[0] = screenpointer; 120 121 MOUSE_ICON mouseStyle = MOUSE_ICON::LOADING; 122 EXPECT_NO_FATAL_FAILURE(pointerDrawingManager.HardwareCursorDynamicRender(mouseStyle)); 123 124 mouseStyle = MOUSE_ICON::RUNNING_RIGHT; 125 EXPECT_NO_FATAL_FAILURE(pointerDrawingManager.HardwareCursorDynamicRender(mouseStyle)); 126 } 127 128 /** 129 * @tc.name: PointerDrawingManagerSupTest_DrawDynamicSoftCursor_001 130 * @tc.desc: Test DrawDynamicSoftCursor 131 * @tc.type: FUNC 132 * @tc.require: 133 */ 134 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_DrawDynamicSoftCursor_001, TestSize.Level1) 135 { 136 CALL_TEST_DEBUG; 137 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 138 surfaceNodeConfig.SurfaceNodeName = "touch window"; 139 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 140 auto sn = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 141 ASSERT_NE(sn, nullptr); 142 143 RenderConfig cfg; 144 PointerDrawingManager pointerDrawingManager; 145 auto rlt = pointerDrawingManager.DrawDynamicSoftCursor(sn, cfg); 146 EXPECT_EQ(rlt, RET_OK); 147 } 148 149 /** 150 * @tc.name: PointerDrawingManagerSupTest_SoftwareCursorDynamicRender_001 151 * @tc.desc: Test SoftwareCursorDynamicRender 152 * @tc.type: FUNC 153 * @tc.require: 154 */ 155 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SoftwareCursorDynamicRender_001, TestSize.Level1) 156 { 157 CALL_TEST_DEBUG; 158 hwcmgr_ptr_t hwcmgr = std::make_shared<HardwareCursorPointerManager>(); 159 ASSERT_NE(hwcmgr, nullptr); 160 handler_ptr_t handler = nullptr; 161 sptr<OHOS::Rosen::ScreenInfo> screenInfo = new OHOS::Rosen::ScreenInfo(); 162 auto screenpointer = std::make_shared<ScreenPointer>(hwcmgr, handler, screenInfo); 163 ASSERT_NE(screenpointer, nullptr); 164 PointerDrawingManager pointerDrawingManager; 165 166 pointerDrawingManager.screenPointers_[0] = screenpointer; 167 168 MOUSE_ICON mouseStyle = MOUSE_ICON::LOADING; 169 EXPECT_NO_FATAL_FAILURE(pointerDrawingManager.SoftwareCursorDynamicRender(mouseStyle)); 170 171 mouseStyle = MOUSE_ICON::RUNNING_RIGHT; 172 EXPECT_NO_FATAL_FAILURE(pointerDrawingManager.SoftwareCursorDynamicRender(mouseStyle)); 173 } 174 175 /** 176 * @tc.name: PointerDrawingManagerSupTest_RequestNextVSync_001 177 * @tc.desc: Test RequestNextVSync 178 * @tc.type: FUNC 179 * @tc.require: 180 */ 181 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_RequestNextVSync_001, TestSize.Level1) 182 { 183 CALL_TEST_DEBUG; 184 PointerDrawingManager pointerDrawingManager; 185 EXPECT_EQ(pointerDrawingManager.isRenderRuning_, false); 186 auto rlt = pointerDrawingManager.RequestNextVSync(); 187 EXPECT_EQ(rlt, RET_ERR); 188 } 189 190 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR 191 /** 192 * @tc.name: PointerDrawingManagerSupTest_SetCursorLocation_002 193 * @tc.desc: Test SetCursorLocation 194 * @tc.type: FUNC 195 * @tc.require: 196 */ 197 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetCursorLocation_002, TestSize.Level1) 198 { 199 CALL_TEST_DEBUG; 200 PointerDrawingManager pointerDrawingManager; 201 auto align = pointerDrawingManager.MouseIcon2IconType(MOUSE_ICON(2)); 202 int32_t physicalX = 100; 203 int32_t physicalY = 100; 204 pointerDrawingManager.lastMouseStyle_.id = 2; 205 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 206 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 207 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 208 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 209 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetCursorLocation(physicalX, physicalY, align)); 210 } 211 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR 212 213 /** 214 * @tc.name: PointerDrawingManagerSupTest_SetCursorLocation_003 215 * @tc.desc: Test SetCursorLocation 216 * @tc.type: FUNC 217 * @tc.require: 218 */ 219 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetCursorLocation_003, TestSize.Level1) 220 { 221 CALL_TEST_DEBUG; 222 PointerDrawingManager pointerDrawingManager; 223 auto align = pointerDrawingManager.MouseIcon2IconType(MOUSE_ICON(2)); 224 int32_t physicalX = 100; 225 int32_t physicalY = 100; 226 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 227 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 228 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 229 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 230 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetCursorLocation(physicalX, physicalY, align)); 231 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 232 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 233 pointerDrawingManager.lastMouseStyle_.id = 2; 234 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetCursorLocation(physicalX, physicalY, align)); 235 pointerDrawingManager.lastMouseStyle_.id = 42; 236 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetCursorLocation(physicalX, physicalY, align)); 237 pointerDrawingManager.lastMouseStyle_.id = 43; 238 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetCursorLocation(physicalX, physicalY, align)); 239 } 240 241 /** 242 * @tc.name: PointerDrawingManagerSupTest_UpdateMouseStyle_001 243 * @tc.desc: Test UpdateMouseStyle 244 * @tc.type: Function 245 * @tc.require: 246 */ 247 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_UpdateMouseStyle_001, TestSize.Level1) 248 { 249 CALL_TEST_DEBUG; 250 PointerDrawingManager pointerDrawingManager; 251 PointerStyle pointerStyle; 252 pointerStyle.id = AECH_DEVELOPER_DEFINED; 253 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdateMouseStyle()); 254 pointerStyle.id = AECH_DEVELOPER_DEFINED_STYLE; 255 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdateMouseStyle()); 256 257 pointerStyle.id = -2; 258 pointerStyle.color = 0; 259 pointerStyle.size = 2; 260 pointerDrawingManager.pid_ = 1; 261 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdateMouseStyle()); 262 } 263 264 /** 265 * @tc.name: PointerDrawingManagerSupTest_UpdateStyleOptions_001 266 * @tc.desc: Test UpdateStyleOptions 267 * @tc.type: FUNC 268 * @tc.require: 269 */ 270 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_UpdateStyleOptions_001, TestSize.Level1) 271 { 272 CALL_TEST_DEBUG; 273 PointerDrawingManager pointerDrawingManager; 274 PointerStyle pointerStyle; 275 pointerStyle.id = -2; 276 pointerStyle.color = 0; 277 pointerStyle.size = 2; 278 pointerDrawingManager.pid_ = 1; 279 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdateStyleOptions()); 280 } 281 282 /** 283 * @tc.name: PointerDrawingManagerSupTest_InitVsync_001 284 * @tc.desc: Test InitVsync 285 * @tc.type: FUNC 286 * @tc.require: 287 */ 288 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_InitVsync_001, TestSize.Level1) 289 { 290 CALL_TEST_DEBUG; 291 PointerDrawingManager pointerDrawingManager; 292 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 293 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 294 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 295 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 296 pointerDrawingManager.currentMouseStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 297 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.InitVsync(MOUSE_ICON(MOUSE_ICON::DEVELOPER_DEFINED_ICON))); 298 } 299 300 /** 301 * @tc.name: PointerDrawingManagerSupTest_RetryGetSurfaceBuffer_001 302 * @tc.desc: Test RetryGetSurfaceBuffer 303 * @tc.type: FUNC 304 * @tc.require: 305 */ 306 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_RetryGetSurfaceBuffer_001, TestSize.Level1) 307 { 308 CALL_TEST_DEBUG; 309 PointerDrawingManager pointerDrawingManager; 310 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 311 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 312 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 313 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 314 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 315 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 316 auto layer = pointerDrawingManager.surfaceNode_->GetSurface(); 317 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.RetryGetSurfaceBuffer(layer)); 318 } 319 320 /** 321 * @tc.name: PointerDrawingManagerSupTest_PostTask_001 322 * @tc.desc: Test PostTask 323 * @tc.type: FUNC 324 * @tc.require: 325 */ 326 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_PostTask_001, TestSize.Level1) 327 { 328 CALL_TEST_DEBUG; 329 PointerDrawingManager pointerDrawingManager; 330 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 331 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; __anonbf4482640202() 332 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.PostTask([this]() {})); 333 pointerDrawingManager.handler_ = nullptr; __anonbf4482640302() 334 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.PostTask([this]() {})); 335 } 336 337 /** 338 * @tc.name: PointerDrawingManagerSupTest_PostTask_002 339 * @tc.desc: Test PostTask 340 * @tc.type: FUNC 341 * @tc.require: 342 */ 343 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_PostTask_002, TestSize.Level1) 344 { 345 CALL_TEST_DEBUG; 346 PointerDrawingManager pointerDrawingManager; 347 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 348 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 349 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 350 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 351 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 352 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 353 int32_t rsId = 10; 354 int32_t physicalX = 100; 355 int32_t physicalY = 100; 356 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION90); 357 pointerDrawingManager.runner_ = AppExecFwk::EventRunner::Create(false); 358 pointerDrawingManager.handler_ = std::make_shared<AppExecFwk::EventHandler>(pointerDrawingManager.runner_); __anonbf4482640402() 359 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.PostTask([this]() {})); 360 } 361 362 /** 363 * @tc.name: PointerDrawingManagerSupTest_PostSoftCursorTask_001 364 * @tc.desc: Test PostSoftCursorTask 365 * @tc.type: FUNC 366 * @tc.require: 367 */ 368 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_PostSoftCursorTask_001, TestSize.Level1) 369 { 370 CALL_TEST_DEBUG; 371 PointerDrawingManager pointerDrawingManager; 372 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 373 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 374 pointerDrawingManager.softCursorHander_ = nullptr; __anonbf4482640502() 375 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.PostSoftCursorTask([this]() {})); 376 } 377 378 /** 379 * @tc.name: PointerDrawingManagerSupTest_PostSoftCursorTask_002 380 * @tc.desc: Test PostSoftCursorTask 381 * @tc.type: FUNC 382 * @tc.require: 383 */ 384 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_PostSoftCursorTask_002, TestSize.Level1) 385 { 386 CALL_TEST_DEBUG; 387 PointerDrawingManager pointerDrawingManager; 388 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 389 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 390 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 391 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 392 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 393 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 394 int32_t rsId = 10; 395 int32_t physicalX = 100; 396 int32_t physicalY = 100; 397 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION90); 398 pointerDrawingManager.softCursorRunner_ = AppExecFwk::EventRunner::Create(false); 399 auto softCursorHander = std::make_shared<AppExecFwk::EventHandler>(pointerDrawingManager.softCursorRunner_); 400 pointerDrawingManager.softCursorHander_ = softCursorHander; __anonbf4482640602() 401 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.PostSoftCursorTask([this]() {})); 402 } 403 404 /** 405 * @tc.name: PointerDrawingManagerSupTest_PostMoveRetryTask_002 406 * @tc.desc: Test PostMoveRetryTask 407 * @tc.type: FUNC 408 * @tc.require: 409 */ 410 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_PostMoveRetryTask_002, TestSize.Level1) 411 { 412 CALL_TEST_DEBUG; 413 PointerDrawingManager pointerDrawingManager; 414 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 415 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 416 pointerDrawingManager.moveRetryHander_ = nullptr; __anonbf4482640702() 417 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.PostMoveRetryTask([this]() {})); 418 } 419 420 /** 421 * @tc.name: PointerDrawingManagerSupTest_OnVsync_001 422 * @tc.desc: Test OnVsync 423 * @tc.type: FUNC 424 * @tc.require: 425 */ 426 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_OnVsync_001, TestSize.Level1) 427 { 428 CALL_TEST_DEBUG; 429 PointerDrawingManager pointerDrawingManager; 430 pointerDrawingManager.currentMouseStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 431 uint64_t timestamp = 1; 432 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnVsync(timestamp)); 433 } 434 435 /** 436 * @tc.name: PointerDrawingManagerSupTest_OnVsync_002 437 * @tc.desc: Test OnVsync 438 * @tc.type: FUNC 439 * @tc.require: 440 */ 441 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_OnVsync_002, TestSize.Level1) 442 { 443 CALL_TEST_DEBUG; 444 PointerDrawingManager pointerDrawingManager; 445 pointerDrawingManager.currentMouseStyle_.id = MOUSE_ICON::RUNNING; 446 uint64_t timestamp = 1; 447 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnVsync(timestamp)); 448 pointerDrawingManager.currentMouseStyle_.id = MOUSE_ICON::LOADING; 449 pointerDrawingManager.mouseDisplayState_ = false; 450 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnVsync(timestamp)); 451 } 452 453 /** 454 * @tc.name: PointerDrawingManagerSupTest_OnVsync_003 455 * @tc.desc: Test OnVsync 456 * @tc.type: FUNC 457 * @tc.require: 458 */ 459 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_OnVsync_003, TestSize.Level1) 460 { 461 CALL_TEST_DEBUG; 462 PointerDrawingManager pointerDrawingManager; 463 pointerDrawingManager.currentMouseStyle_.id = MOUSE_ICON::RUNNING; 464 uint64_t timestamp = 1; 465 pointerDrawingManager.mouseDisplayState_ = true; 466 pointerDrawingManager.currentMouseStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 467 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnVsync(timestamp)); 468 pointerDrawingManager.currentMouseStyle_.id = MOUSE_ICON::LOADING; 469 pointerDrawingManager.lastPhysicalX_ = 1; 470 pointerDrawingManager.lastPhysicalY_ = 1; 471 pointerDrawingManager.currentFrame_ = 0; 472 pointerDrawingManager.frameCount_ = 0; 473 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnVsync(timestamp)); 474 pointerDrawingManager.frameCount_ = 1; 475 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnVsync(timestamp)); 476 } 477 478 /** 479 * @tc.name: PointerDrawingManagerSupTest_GetDisplayDirection_001 480 * @tc.desc: Test GetDisplayDirection 481 * @tc.type: FUNC 482 * @tc.require: 483 */ 484 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_GetDisplayDirection_001, TestSize.Level1) 485 { 486 CALL_TEST_DEBUG; 487 PointerDrawingManager pointerDrawingManager; 488 OLD::DisplayInfo displayInfo; 489 displayInfo.id = 10; 490 displayInfo.width = 600; 491 displayInfo.height = 600; 492 displayInfo.direction = DIRECTION0; 493 displayInfo.displayDirection = DIRECTION90; 494 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 495 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 496 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.GetDisplayDirection(&displayInfo)); 497 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = false; 498 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.GetDisplayDirection(&displayInfo)); 499 } 500 501 /** 502 * @tc.name: PointerDrawingManagerSupTest_CreatePointerWindow_001 503 * @tc.desc: Test CreatePointerWindow 504 * @tc.type: FUNC 505 * @tc.require: 506 */ 507 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_CreatePointerWindow_001, TestSize.Level0) 508 { 509 CALL_TEST_DEBUG; 510 PointerDrawingManager pointerDrawingManager; 511 int32_t rsId = 10; 512 int32_t physicalX = 100; 513 int32_t physicalY = 100; 514 pointerDrawingManager.surfaceNode_ = nullptr; 515 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 516 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = false; 517 ASSERT_NO_FATAL_FAILURE( 518 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION90)); 519 ASSERT_NO_FATAL_FAILURE( 520 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION180)); 521 ASSERT_NO_FATAL_FAILURE( 522 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION270)); 523 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 524 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 525 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 526 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 527 ASSERT_NO_FATAL_FAILURE( 528 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION90)); 529 ASSERT_NO_FATAL_FAILURE( 530 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION180)); 531 ASSERT_NO_FATAL_FAILURE( 532 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION270)); 533 } 534 535 /** 536 * @tc.name: PointerDrawingManagerSupTest_CreatePointerWindow_002 537 * @tc.desc: Test CreatePointerWindow 538 * @tc.type: FUNC 539 * @tc.require: 540 */ 541 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_CreatePointerWindow_002, TestSize.Level0) 542 { 543 CALL_TEST_DEBUG; 544 PointerDrawingManager pointerDrawingManager; 545 int32_t rsId = 10; 546 int32_t physicalX = 100; 547 int32_t physicalY = 100; 548 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 549 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 550 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 551 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 552 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 553 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 554 OLD::DisplayInfo displaysInfo; 555 displaysInfo.rsId = 102; 556 displaysInfo.direction = DIRECTION0; 557 displaysInfo.displayDirection = DIRECTION0; 558 displaysInfo.width = 400; 559 displaysInfo.height = 300; 560 pointerDrawingManager.displayInfo_.rsId = 100; 561 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 562 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 563 pointerDrawingManager.displayInfo_.width = 600; 564 pointerDrawingManager.displayInfo_.height = 400; 565 auto screenPointer = std::make_shared<ScreenPointer>( 566 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 567 pointerDrawingManager.screenPointers_[rsId] = screenPointer; 568 ASSERT_NO_FATAL_FAILURE( 569 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION90)); 570 ASSERT_NO_FATAL_FAILURE( 571 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION180)); 572 ASSERT_NO_FATAL_FAILURE( 573 pointerDrawingManager.CreatePointerWindow(rsId, physicalX, physicalY, Direction::DIRECTION270)); 574 } 575 576 /** 577 * @tc.name: PointerDrawingManagerSupTest_SetCustomCursor_001 578 * @tc.desc: Test SetCustomCursor 579 * @tc.type: FUNC 580 * @tc.require: 581 */ 582 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetCustomCursor_001, TestSize.Level1) 583 { 584 CALL_TEST_DEBUG; 585 PointerDrawingManager pointerDrawingManager; 586 int32_t pid = -1; 587 int32_t windowId = 1; 588 int32_t focusX = 2; 589 int32_t focusY = 3; 590 CursorPixelMap curPixelMap; 591 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetCustomCursor(curPixelMap, pid, windowId, focusX, focusY)); 592 } 593 594 /** 595 * @tc.name: PointerDrawingManagerSupTest_SetCustomCursor_002 596 * @tc.desc: Test SetCustomCursor 597 * @tc.type: FUNC 598 * @tc.require: 599 */ 600 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetCustomCursor_002, TestSize.Level1) 601 { 602 CALL_TEST_DEBUG; 603 PointerDrawingManager pointerDrawingManager; 604 int32_t pid = 1; 605 int32_t windowId = -1; 606 int32_t focusX = 2; 607 int32_t focusY = 3; 608 CursorPixelMap curPixelMap; 609 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetCustomCursor(curPixelMap, pid, windowId, focusX, focusY)); 610 } 611 612 /** 613 * @tc.name: PointerDrawingManagerSupTest_SetCustomCursor_003 614 * @tc.desc: Test SetCustomCursor 615 * @tc.type: FUNC 616 * @tc.require: 617 */ 618 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetCustomCursor_003, TestSize.Level1) 619 { 620 CALL_TEST_DEBUG; 621 PointerDrawingManager pointerDrawingManager; 622 int32_t pid = 1; 623 int32_t windowId = 2; 624 int32_t focusX = 2; 625 int32_t focusY = 3; 626 CursorPixelMap curPixelMap; 627 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetCustomCursor(curPixelMap, pid, windowId, focusX, focusY)); 628 } 629 630 /** 631 * @tc.name: PointerDrawingManagerSupTest_SetCustomCursor_004 632 * @tc.desc: Test SetCustomCursor 633 * @tc.type: FUNC 634 * @tc.require: 635 */ 636 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetCustomCursor_004, TestSize.Level1) 637 { 638 CALL_TEST_DEBUG; 639 PointerDrawingManager pointerDrawingManager; 640 int32_t pid = 1; 641 int32_t windowId = 1; 642 int32_t focusX = 2; 643 int32_t focusY = 3; 644 CursorPixelMap curPixelMap; 645 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetCustomCursor(curPixelMap, pid, windowId, focusX, focusY)); 646 } 647 648 /** 649 * @tc.name: PointerDrawingManagerSupTest_SetMouseHotSpot_001 650 * @tc.desc: Test SetMouseHotSpot 651 * @tc.type: FUNC 652 * @tc.require: 653 */ 654 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetMouseHotSpot_001, TestSize.Level1) 655 { 656 CALL_TEST_DEBUG; 657 PointerDrawingManager pointerDrawingManager; 658 int32_t pid = 2; 659 int32_t windowId = 2; 660 int32_t hotSpotX = 3; 661 int32_t hotSpotY = 4; 662 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>(); 663 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>(); 664 inputWindowsManager->globalStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 665 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY)); 666 } 667 668 /** 669 * @tc.name: PointerDrawingManagerSupTest_SetMouseHotSpot_002 670 * @tc.desc: Test SetMouseHotSpot 671 * @tc.type: FUNC 672 * @tc.require: 673 */ 674 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetMouseHotSpot_002, TestSize.Level1) 675 { 676 CALL_TEST_DEBUG; 677 PointerDrawingManager pointerDrawingManager; 678 int32_t pid = 2; 679 int32_t windowId = 2; 680 int32_t hotSpotX = 3; 681 int32_t hotSpotY = 4; 682 std::shared_ptr<InputWindowsManager> inputWindowsManager = std::make_shared<InputWindowsManager>(); 683 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>(); 684 inputWindowsManager->globalStyle_.id = MOUSE_ICON::DEFAULT; 685 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY)); 686 } 687 688 /** 689 * @tc.name: PointerDrawingManagerSupTest_LoadCursorSvgWithColor_001 690 * @tc.desc: Test LoadCursorSvgWithColor 691 * @tc.type: FUNC 692 * @tc.require: 693 */ 694 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_LoadCursorSvgWithColor_001, TestSize.Level1) 695 { 696 CALL_TEST_DEBUG; 697 PointerDrawingManager pointerDrawingManager; 698 PointerStyle pointerStyle; 699 IconStyle iconStyle; 700 pointerStyle.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 701 iconStyle.alignmentWay = 0; 702 iconStyle.iconPath = "testpath"; 703 pointerDrawingManager.mouseIcons_.insert(std::make_pair(static_cast<MOUSE_ICON>(pointerStyle.id), iconStyle)); 704 pointerDrawingManager.tempPointerColor_ = -1; 705 int32_t color = 1; 706 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.LoadCursorSvgWithColor(MOUSE_ICON::DEVELOPER_DEFINED_ICON, color)); 707 } 708 709 /** 710 * @tc.name: PointerDrawingManagerSupTest_LoadCursorSvgWithColor_002 711 * @tc.desc: Test LoadCursorSvgWithColor 712 * @tc.type: FUNC 713 * @tc.require: 714 */ 715 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_LoadCursorSvgWithColor_002, TestSize.Level1) 716 { 717 CALL_TEST_DEBUG; 718 PointerDrawingManager pointerDrawingManager; 719 PointerStyle pointerStyle; 720 IconStyle iconStyle; 721 pointerStyle.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 722 iconStyle.alignmentWay = 0; 723 iconStyle.iconPath = "testpath"; 724 pointerDrawingManager.mouseIcons_.insert(std::make_pair(static_cast<MOUSE_ICON>(pointerStyle.id), iconStyle)); 725 pointerDrawingManager.tempPointerColor_ = 1; 726 int32_t color = 0; 727 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.LoadCursorSvgWithColor(MOUSE_ICON::DEVELOPER_DEFINED_ICON, color)); 728 } 729 730 /** 731 * @tc.name: PointerDrawingManagerSupTest_LoadCursorSvgWithColor_003 732 * @tc.desc: Test LoadCursorSvgWithColor 733 * @tc.type: FUNC 734 * @tc.require: 735 */ 736 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_LoadCursorSvgWithColor_003, TestSize.Level1) 737 { 738 CALL_TEST_DEBUG; 739 PointerDrawingManager pointerDrawingManager; 740 PointerStyle pointerStyle; 741 IconStyle iconStyle; 742 pointerStyle.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 743 iconStyle.alignmentWay = 0; 744 iconStyle.iconPath = "testpath"; 745 pointerDrawingManager.mouseIcons_.insert(std::make_pair(static_cast<MOUSE_ICON>(pointerStyle.id), iconStyle)); 746 pointerDrawingManager.tempPointerColor_ = -1; 747 int32_t color = MAX_POINTER_COLOR; 748 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.LoadCursorSvgWithColor(MOUSE_ICON::DEVELOPER_DEFINED_ICON, color)); 749 } 750 751 /** 752 * @tc.name: PointerDrawingManagerSupTest_DecodeImageToPixelMap_001 753 * @tc.desc: Test DecodeImageToPixelMap 754 * @tc.type: FUNC 755 * @tc.require: 756 */ 757 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_DecodeImageToPixelMap_001, TestSize.Level1) 758 { 759 CALL_TEST_DEBUG; 760 PointerDrawingManager pointerDrawingManager; 761 PointerStyle pointerStyle; 762 pointerDrawingManager.InitPixelMaps(); 763 pointerDrawingManager.imageWidth_ = 2; 764 pointerDrawingManager.imageHeight_ = 2; 765 pointerDrawingManager.tempPointerColor_ = 2; 766 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DecodeImageToPixelMap(MOUSE_ICON::LOADING)); 767 } 768 769 /** 770 * @tc.name: PointerDrawingManagerSupTest_DecodeImageToPixelMap_002 771 * @tc.desc: Test DecodeImageToPixelMap 772 * @tc.type: FUNC 773 * @tc.require: 774 */ 775 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_DecodeImageToPixelMap_002, TestSize.Level1) 776 { 777 CALL_TEST_DEBUG; 778 PointerDrawingManager pointerDrawingManager; 779 PointerStyle pointerStyle; 780 pointerDrawingManager.InitPixelMaps(); 781 pointerDrawingManager.imageWidth_ = 2; 782 pointerDrawingManager.imageHeight_ = 2; 783 pointerDrawingManager.tempPointerColor_ = 2; 784 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DecodeImageToPixelMap(MOUSE_ICON::RUNNING)); 785 } 786 787 /** 788 * @tc.name: PointerDrawingManagerSupTest_UpdateDisplayInfo_001 789 * @tc.desc: Test UpdateDisplayInfo 790 * @tc.type: FUNC 791 * @tc.require: 792 */ 793 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_UpdateDisplayInfo_001, TestSize.Level1) 794 { 795 CALL_TEST_DEBUG; 796 PointerDrawingManager pointerDrawingManager; 797 int32_t rsId = 10; 798 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 799 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 800 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 801 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 802 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 803 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 804 805 OLD::DisplayInfo displaysInfo; 806 displaysInfo.rsId = 102; 807 displaysInfo.direction = DIRECTION0; 808 displaysInfo.displayDirection = DIRECTION0; 809 displaysInfo.width = 400; 810 displaysInfo.height = 300; 811 pointerDrawingManager.displayInfo_.rsId = 100; 812 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 813 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 814 pointerDrawingManager.displayInfo_.width = 600; 815 pointerDrawingManager.displayInfo_.height = 400; 816 817 auto screenPointer = std::make_shared<ScreenPointer>( 818 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 819 pointerDrawingManager.screenPointers_[rsId] = nullptr; 820 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdateDisplayInfo(displaysInfo)); 821 pointerDrawingManager.screenPointers_[rsId] = screenPointer; 822 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdateDisplayInfo(displaysInfo)); 823 } 824 825 /** 826 * @tc.name: PointerDrawingManagerSupTest_SetPointerSize_001 827 * @tc.desc: Test SetPointerSize 828 * @tc.type: FUNC 829 * @tc.require: 830 */ 831 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetPointerSize_001, TestSize.Level1) 832 { 833 CALL_TEST_DEBUG; 834 PointerDrawingManager pointerDrawingManager; 835 int32_t size = 10; 836 pointerDrawingManager.lastMouseStyle_.id = MOUSE_ICON::CURSOR_CIRCLE; 837 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 838 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 839 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetPointerSize(size)); 840 } 841 842 /** 843 * @tc.name: PointerDrawingManagerSupTest_SetPointerSize_002 844 * @tc.desc: Test SetPointerSize 845 * @tc.type: FUNC 846 * @tc.require: 847 */ 848 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SetPointerSize_002, TestSize.Level1) 849 { 850 CALL_TEST_DEBUG; 851 PointerDrawingManager pointerDrawingManager; 852 int32_t size = 10; 853 pointerDrawingManager.lastMouseStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 854 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetPointerSize(size)); 855 } 856 857 /** 858 * @tc.name: PointerDrawingManagerSupTest_AttachAllSurfaceNode_001 859 * @tc.desc: Test AttachAllSurfaceNode 860 * @tc.type: FUNC 861 * @tc.require: 862 */ 863 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_AttachAllSurfaceNode_001, TestSize.Level1) 864 { 865 CALL_TEST_DEBUG; 866 PointerDrawingManager pointerDrawingManager; 867 int32_t rsId = 10; 868 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 869 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 870 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 871 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 872 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 873 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 874 875 OLD::DisplayInfo displaysInfo; 876 displaysInfo.rsId = 102; 877 displaysInfo.direction = DIRECTION0; 878 displaysInfo.displayDirection = DIRECTION0; 879 displaysInfo.width = 400; 880 displaysInfo.height = 300; 881 pointerDrawingManager.displayInfo_.rsId = 100; 882 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 883 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 884 pointerDrawingManager.displayInfo_.width = 600; 885 pointerDrawingManager.displayInfo_.height = 400; 886 887 auto screenPointer = std::make_shared<ScreenPointer>( 888 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 889 pointerDrawingManager.screenPointers_[rsId] = screenPointer; 890 pointerDrawingManager.screenId_ = 100; 891 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.AttachAllSurfaceNode()); 892 } 893 894 /** 895 * @tc.name: PointerDrawingManagerSupTest_AttachAllSurfaceNode_002 896 * @tc.desc: Test AttachAllSurfaceNode 897 * @tc.type: FUNC 898 * @tc.require: 899 */ 900 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_AttachAllSurfaceNode_002, TestSize.Level1) 901 { 902 CALL_TEST_DEBUG; 903 PointerDrawingManager pointerDrawingManager; 904 int32_t rsId = 10; 905 pointerDrawingManager.surfaceNode_ = nullptr; 906 pointerDrawingManager.screenPointers_[rsId] = nullptr; 907 pointerDrawingManager.screenId_ = 100; 908 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.AttachAllSurfaceNode()); 909 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 910 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 911 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 912 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 913 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.AttachAllSurfaceNode()); 914 } 915 916 /** 917 * @tc.name: PointerDrawingManagerSupTest_DetachAllSurfaceNode_001 918 * @tc.desc: Test DetachAllSurfaceNode 919 * @tc.type: FUNC 920 * @tc.require: 921 */ 922 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_DetachAllSurfaceNode_001, TestSize.Level1) 923 { 924 CALL_TEST_DEBUG; 925 PointerDrawingManager pointerDrawingManager; 926 int32_t rsId = 10; 927 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 928 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 929 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 930 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 931 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 932 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 933 934 OLD::DisplayInfo displaysInfo; 935 displaysInfo.rsId = 102; 936 displaysInfo.direction = DIRECTION0; 937 displaysInfo.displayDirection = DIRECTION0; 938 displaysInfo.width = 400; 939 displaysInfo.height = 300; 940 pointerDrawingManager.displayInfo_.rsId = 100; 941 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 942 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 943 pointerDrawingManager.displayInfo_.width = 600; 944 pointerDrawingManager.displayInfo_.height = 400; 945 946 auto screenPointer = std::make_shared<ScreenPointer>( 947 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 948 pointerDrawingManager.screenPointers_[rsId] = screenPointer; 949 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DetachAllSurfaceNode()); 950 pointerDrawingManager.surfaceNode_ = nullptr; 951 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DetachAllSurfaceNode()); 952 } 953 954 /** 955 * @tc.name: PointerDrawingManagerSupTest_DetachAllSurfaceNode_002 956 * @tc.desc: Test DetachAllSurfaceNode 957 * @tc.type: FUNC 958 * @tc.require: 959 */ 960 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_DetachAllSurfaceNode_002, TestSize.Level1) 961 { 962 CALL_TEST_DEBUG; 963 PointerDrawingManager pointerDrawingManager; 964 int32_t rsId = 0; 965 pointerDrawingManager.surfaceNode_ = nullptr; 966 pointerDrawingManager.screenPointers_[rsId] = nullptr; 967 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DetachAllSurfaceNode()); 968 } 969 970 /** 971 * @tc.name: PointerDrawingManagerSupTest_DeletePointerVisible_001 972 * @tc.desc: Test DeletePointerVisible 973 * @tc.type: FUNC 974 * @tc.require: 975 */ 976 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_DeletePointerVisible_001, TestSize.Level1) 977 { 978 CALL_TEST_DEBUG; 979 PointerDrawingManager pointerDrawingManager; 980 int32_t pid = 1; 981 pointerDrawingManager.InitPointerCallback(); 982 pointerDrawingManager.surfaceNode_ = nullptr; 983 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DeletePointerVisible(pid)); 984 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 985 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 986 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 987 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 988 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DeletePointerVisible(pid)); 989 } 990 991 /** 992 * @tc.name: PointerDrawingManagerSupTest_OnSessionLost_001 993 * @tc.desc: Test OnSessionLost 994 * @tc.type: FUNC 995 * @tc.require: 996 */ 997 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_OnSessionLost_001, TestSize.Level1) 998 { 999 CALL_TEST_DEBUG; 1000 PointerDrawingManager pointerDrawingManager; 1001 pointerDrawingManager.pidInfos_.clear(); 1002 int32_t pid = 1; 1003 PointerDrawingManager::PidInfo pidInfo; 1004 for (int32_t i = 1; i < 3; i++) { 1005 pidInfo.pid = 3 - i; 1006 pidInfo.visible = false; 1007 pointerDrawingManager.hapPidInfos_.push_back(pidInfo); 1008 } 1009 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnSessionLost(pid)); 1010 } 1011 1012 /** 1013 * @tc.name: PointerDrawingManagerSupTest_OnSessionLost_002 1014 * @tc.desc: Test OnSessionLost 1015 * @tc.type: FUNC 1016 * @tc.require: 1017 */ 1018 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_OnSessionLost_002, TestSize.Level1) 1019 { 1020 CALL_TEST_DEBUG; 1021 PointerDrawingManager pointerDrawingManager; 1022 pointerDrawingManager.pidInfos_.clear(); 1023 int32_t pid = 10; 1024 PointerDrawingManager::PidInfo pidInfo; 1025 for (int32_t i = 1; i < 3; i++) { 1026 pidInfo.pid = 3 - i; 1027 pidInfo.visible = false; 1028 pointerDrawingManager.hapPidInfos_.push_back(pidInfo); 1029 } 1030 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnSessionLost(pid)); 1031 } 1032 1033 /** 1034 * @tc.name: PointerDrawingManagerSupTest_SubscribeScreenModeChange_001 1035 * @tc.desc: Test SubscribeScreenModeChange 1036 * @tc.type: FUNC 1037 * @tc.require: 1038 */ 1039 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SubscribeScreenModeChange_001, TestSize.Level1) 1040 { 1041 CALL_TEST_DEBUG; 1042 PointerDrawingManager pointerDrawingManager; 1043 pointerDrawingManager.hardwareCursorPointerManager_ = nullptr; 1044 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SubscribeScreenModeChange()); 1045 pointerDrawingManager.hardwareCursorPointerManager_ = std::make_shared<HardwareCursorPointerManager>(); 1046 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 1047 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 1048 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SubscribeScreenModeChange()); 1049 } 1050 1051 /** 1052 * @tc.name: PointerDrawingManagerSupTest_RegisterDisplayStatusReceiver_001 1053 * @tc.desc: Test RegisterDisplayStatusReceiver 1054 * @tc.type: FUNC 1055 * @tc.require: 1056 */ 1057 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_RegisterDisplayStatusReceiver_001, TestSize.Level1) 1058 { 1059 CALL_TEST_DEBUG; 1060 PointerDrawingManager pointerDrawingManager; 1061 pointerDrawingManager.hardwareCursorPointerManager_ = nullptr; 1062 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.RegisterDisplayStatusReceiver()); 1063 pointerDrawingManager.hardwareCursorPointerManager_ = std::make_shared<HardwareCursorPointerManager>(); 1064 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 1065 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 1066 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.RegisterDisplayStatusReceiver()); 1067 } 1068 1069 /** 1070 * @tc.name: PointerDrawingManagerSupTest_RegisterDisplayStatusReceiver_002 1071 * @tc.desc: Test RegisterDisplayStatusReceiver 1072 * @tc.type: FUNC 1073 * @tc.require: 1074 */ 1075 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_RegisterDisplayStatusReceiver_002, TestSize.Level1) 1076 { 1077 CALL_TEST_DEBUG; 1078 PointerDrawingManager pointerDrawingManager; 1079 pointerDrawingManager.hardwareCursorPointerManager_ = std::make_shared<HardwareCursorPointerManager>(); 1080 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 1081 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 1082 pointerDrawingManager.initDisplayStatusReceiverFlag_ = true; 1083 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.RegisterDisplayStatusReceiver()); 1084 pointerDrawingManager.initDisplayStatusReceiverFlag_ = false; 1085 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.RegisterDisplayStatusReceiver()); 1086 } 1087 1088 /** 1089 * @tc.name: PointerDrawingManagerSupTest_UpdateBindDisplayId_001 1090 * @tc.desc: Test UpdateBindDisplayId 1091 * @tc.type: FUNC 1092 * @tc.require: 1093 */ 1094 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_UpdateBindDisplayId_001, TestSize.Level1) 1095 { 1096 CALL_TEST_DEBUG; 1097 PointerDrawingManager pointerDrawingManager; 1098 pointerDrawingManager.lastDisplayId_ = 0; 1099 uint64_t rsId = 1; 1100 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1101 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 1102 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1103 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1104 pointerDrawingManager.hardwareCursorPointerManager_ = std::make_shared<HardwareCursorPointerManager>(); 1105 pointerDrawingManager.hardwareCursorPointerManager_->SetHdiServiceState(true); 1106 pointerDrawingManager.hardwareCursorPointerManager_->isEnableState_ = true; 1107 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdateBindDisplayId(rsId)); 1108 } 1109 1110 /** 1111 * @tc.name: PointerDrawingManagerSupTest_OnScreenModeChange_001 1112 * @tc.desc: Test OnScreenModeChange 1113 * @tc.type: FUNC 1114 * @tc.require: 1115 */ 1116 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_OnScreenModeChange_001, TestSize.Level1) 1117 { 1118 CALL_TEST_DEBUG; 1119 PointerDrawingManager pointerDrawingManager; 1120 std::vector<sptr<OHOS::Rosen::ScreenInfo>> screenInfos; 1121 OLD::DisplayInfo displaysInfo; 1122 displaysInfo.rsId = 102; 1123 displaysInfo.direction = DIRECTION0; 1124 displaysInfo.displayDirection = DIRECTION0; 1125 displaysInfo.width = 400; 1126 displaysInfo.height = 300; 1127 pointerDrawingManager.displayInfo_.rsId = 100; 1128 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 1129 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 1130 pointerDrawingManager.displayInfo_.width = 600; 1131 pointerDrawingManager.displayInfo_.height = 400; 1132 auto spMirror = std::make_shared<ScreenPointer>( 1133 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 1134 spMirror->mode_ = mode_t::SCREEN_MIRROR; 1135 spMirror->displayDirection_ = DIRECTION0; 1136 pointerDrawingManager.screenPointers_[displaysInfo.rsId] = spMirror; 1137 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnScreenModeChange(screenInfos)); 1138 } 1139 1140 /** 1141 * @tc.name: PointerDrawingManagerSupTest_CreateRenderConfig_001 1142 * @tc.desc: Test CreateRenderConfig 1143 * @tc.type: FUNC 1144 * @tc.require: 1145 */ 1146 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_CreateRenderConfig_001, TestSize.Level1) 1147 { 1148 CALL_TEST_DEBUG; 1149 PointerDrawingManager pointerDrawingManager; 1150 RenderConfig cfg; 1151 OLD::DisplayInfo displayInfo; 1152 std::shared_ptr<ScreenPointer> screenpointer = std::make_shared<ScreenPointer>(nullptr, nullptr, displayInfo); 1153 MOUSE_ICON mouseStyle = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 1154 bool isHard = true; 1155 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.CreateRenderConfig(cfg, screenpointer, mouseStyle, isHard)); 1156 } 1157 1158 /** 1159 * @tc.name: PointerDrawingManagerSupTest_CreateRenderConfig_002 1160 * @tc.desc: Test CreateRenderConfig 1161 * @tc.type: FUNC 1162 * @tc.require: 1163 */ 1164 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_CreateRenderConfig_002, TestSize.Level1) 1165 { 1166 CALL_TEST_DEBUG; 1167 PointerDrawingManager pointerDrawingManager; 1168 RenderConfig cfg; 1169 OLD::DisplayInfo displayInfo; 1170 std::shared_ptr<ScreenPointer> screenpointer = std::make_shared<ScreenPointer>(nullptr, nullptr, displayInfo); 1171 MOUSE_ICON mouseStyle = MOUSE_ICON::DEFAULT; 1172 bool isHard = false; 1173 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.CreateRenderConfig(cfg, screenpointer, mouseStyle, isHard)); 1174 } 1175 1176 /** 1177 * @tc.name: PointerDrawingManagerSupTest_SoftwareCursorRender_001 1178 * @tc.desc: Test SoftwareCursorRender 1179 * @tc.type: FUNC 1180 * @tc.require: 1181 */ 1182 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_SoftwareCursorRender_001, TestSize.Level1) 1183 { 1184 CALL_TEST_DEBUG; 1185 PointerDrawingManager pointerDrawingManager; 1186 OLD::DisplayInfo displaysInfo; 1187 displaysInfo.rsId = 102; 1188 displaysInfo.direction = DIRECTION0; 1189 displaysInfo.displayDirection = DIRECTION0; 1190 displaysInfo.width = 400; 1191 displaysInfo.height = 300; 1192 pointerDrawingManager.displayInfo_.rsId = 100; 1193 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 1194 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 1195 pointerDrawingManager.displayInfo_.width = 600; 1196 pointerDrawingManager.displayInfo_.height = 400; 1197 auto spMirror = std::make_shared<ScreenPointer>( 1198 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 1199 spMirror->mode_ = mode_t::SCREEN_MIRROR; 1200 spMirror->displayDirection_ = DIRECTION0; 1201 pointerDrawingManager.screenPointers_[displaysInfo.rsId] = spMirror; 1202 pointerDrawingManager.screenId_ = 100; 1203 MOUSE_ICON mouseStyle = MOUSE_ICON::DEVELOPER_DEFINED_ICON; 1204 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SoftwareCursorRender(mouseStyle)); 1205 pointerDrawingManager.screenId_ = 102; 1206 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SoftwareCursorRender(mouseStyle)); 1207 } 1208 1209 /** 1210 * @tc.name: PointerDrawingManagerSupTest_DrawSoftCursor_001 1211 * @tc.desc: Test DrawSoftCursor 1212 * @tc.type: FUNC 1213 * @tc.require: 1214 */ 1215 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_DrawSoftCursor_001, TestSize.Level1) 1216 { 1217 CALL_TEST_DEBUG; 1218 PointerDrawingManager pointerDrawingManager; 1219 RenderConfig cfg; 1220 Rosen::RSSurfaceNodeConfig surfaceNodeConfig; 1221 surfaceNodeConfig.SurfaceNodeName = "pointer window"; 1222 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE; 1223 auto surfaceNode = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType); 1224 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawSoftCursor(surfaceNode, cfg)); 1225 } 1226 1227 /** 1228 * @tc.name: PointerDrawingManagerSupTest_DrawHardCursor_001 1229 * @tc.desc: Test DrawHardCursor 1230 * @tc.type: FUNC 1231 * @tc.require: 1232 */ 1233 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_DrawHardCursor_001, TestSize.Level1) 1234 { 1235 CALL_TEST_DEBUG; 1236 PointerDrawingManager pointerDrawingManager; 1237 RenderConfig cfg; 1238 OLD::DisplayInfo displaysInfo; 1239 cfg.style_ = TRANSPARENT_ICON; 1240 displaysInfo.rsId = 102; 1241 displaysInfo.direction = DIRECTION0; 1242 displaysInfo.displayDirection = DIRECTION0; 1243 displaysInfo.width = 400; 1244 displaysInfo.height = 300; 1245 pointerDrawingManager.displayInfo_.rsId = 100; 1246 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 1247 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 1248 pointerDrawingManager.displayInfo_.width = 600; 1249 pointerDrawingManager.displayInfo_.height = 400; 1250 auto sp = std::make_shared<ScreenPointer>( 1251 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 1252 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawHardCursor(sp, cfg)); 1253 } 1254 1255 /** 1256 * @tc.name: PointerDrawingManagerSupTest_GetMirrorScreenPointers_001 1257 * @tc.desc: Test GetMirrorScreenPointers 1258 * @tc.type: FUNC 1259 * @tc.require: 1260 */ 1261 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_GetMirrorScreenPointers_001, TestSize.Level1) 1262 { 1263 CALL_TEST_DEBUG; 1264 PointerDrawingManager pointerDrawingManager; 1265 OLD::DisplayInfo displaysInfo; 1266 1267 displaysInfo.rsId = 102; 1268 displaysInfo.direction = DIRECTION0; 1269 displaysInfo.displayDirection = DIRECTION0; 1270 displaysInfo.width = 400; 1271 displaysInfo.height = 300; 1272 pointerDrawingManager.displayInfo_.rsId = 100; 1273 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 1274 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 1275 pointerDrawingManager.displayInfo_.width = 600; 1276 pointerDrawingManager.displayInfo_.height = 400; 1277 1278 auto spMirror = std::make_shared<ScreenPointer>( 1279 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 1280 spMirror->mode_ = mode_t::SCREEN_MIRROR; 1281 spMirror->displayDirection_ = DIRECTION0; 1282 pointerDrawingManager.screenPointers_[displaysInfo.rsId] = spMirror; 1283 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.GetMirrorScreenPointers()); 1284 spMirror->mode_ = mode_t::SCREEN_MAIN; 1285 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.GetMirrorScreenPointers()); 1286 } 1287 1288 /** 1289 * @tc.name: PointerDrawingManagerSupTest_HardwareCursorMove_001 1290 * @tc.desc: Test HardwareCursorMove 1291 * @tc.type: FUNC 1292 * @tc.require: 1293 */ 1294 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_HardwareCursorMove_001, TestSize.Level1) 1295 { 1296 CALL_TEST_DEBUG; 1297 PointerDrawingManager pointerDrawingManager; 1298 OLD::DisplayInfo displaysInfo; 1299 int32_t x = 1; 1300 int32_t y = 1; 1301 ICON_TYPE align = ANGLE_E; 1302 1303 displaysInfo.rsId = 100; 1304 displaysInfo.direction = DIRECTION0; 1305 displaysInfo.displayDirection = DIRECTION0; 1306 displaysInfo.width = 400; 1307 displaysInfo.height = 300; 1308 pointerDrawingManager.displayInfo_.rsId = 101; 1309 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 1310 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 1311 pointerDrawingManager.displayInfo_.width = 600; 1312 pointerDrawingManager.displayInfo_.height = 400; 1313 1314 auto spMirror = std::make_shared<ScreenPointer>( 1315 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 1316 spMirror->mode_ = mode_t::SCREEN_MIRROR; 1317 spMirror->displayDirection_ = DIRECTION0; 1318 pointerDrawingManager.screenPointers_[displaysInfo.rsId] = spMirror; 1319 pointerDrawingManager.displayId_ = 100; 1320 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.HardwareCursorMove(x, y, align)); 1321 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SoftwareCursorMove(x, y, align)); 1322 spMirror->mode_ = mode_t::SCREEN_EXTEND; 1323 pointerDrawingManager.displayId_ = 200; 1324 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.HardwareCursorMove(x, y, align)); 1325 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SoftwareCursorMoveAsync(x, y, align)); 1326 } 1327 1328 /** 1329 * @tc.name: PointerDrawingManagerSupTest_CheckHwcReady_001 1330 * @tc.desc: Test CheckHwcReady 1331 * @tc.type: FUNC 1332 * @tc.require: 1333 */ 1334 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_CheckHwcReady_001, TestSize.Level1) 1335 { 1336 CALL_TEST_DEBUG; 1337 PointerDrawingManager pointerDrawingManager; 1338 OLD::DisplayInfo displaysInfo; 1339 1340 displaysInfo.rsId = 100; 1341 displaysInfo.direction = DIRECTION0; 1342 displaysInfo.displayDirection = DIRECTION0; 1343 displaysInfo.width = 400; 1344 displaysInfo.height = 300; 1345 pointerDrawingManager.displayInfo_.rsId = 101; 1346 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 1347 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 1348 pointerDrawingManager.displayInfo_.width = 600; 1349 pointerDrawingManager.displayInfo_.height = 400; 1350 1351 auto spMirror = std::make_shared<ScreenPointer>( 1352 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 1353 spMirror->mode_ = mode_t::SCREEN_MIRROR; 1354 spMirror->displayDirection_ = DIRECTION0; 1355 pointerDrawingManager.screenPointers_[displaysInfo.rsId] = spMirror; 1356 pointerDrawingManager.displayId_ = 100; 1357 pointerDrawingManager.lastPhysicalX_ = 1; 1358 pointerDrawingManager.lastPhysicalY_ = 1; 1359 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.CheckHwcReady()); 1360 } 1361 1362 /** 1363 * @tc.name: PointerDrawingManagerSupTest_ResetMoveRetryTimer_001 1364 * @tc.desc: Test ResetMoveRetryTimer 1365 * @tc.type: FUNC 1366 * @tc.require: 1367 */ 1368 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_ResetMoveRetryTimer_001, TestSize.Level1) 1369 { 1370 CALL_TEST_DEBUG; 1371 PointerDrawingManager pointerDrawingManager; 1372 pointerDrawingManager.moveRetryTimerId_ = -1; 1373 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.ResetMoveRetryTimer()); 1374 pointerDrawingManager.moveRetryTimerId_ = 2; 1375 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.ResetMoveRetryTimer()); 1376 } 1377 1378 /** 1379 * @tc.name: PointerDrawingManagerSupTest_HideHardwareCursors_001 1380 * @tc.desc: Test HideHardwareCursors 1381 * @tc.type: FUNC 1382 * @tc.require: 1383 */ 1384 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_HideHardwareCursors_001, TestSize.Level1) 1385 { 1386 CALL_TEST_DEBUG; 1387 PointerDrawingManager pointerDrawingManager; 1388 OLD::DisplayInfo displaysInfo; 1389 1390 displaysInfo.rsId = 100; 1391 displaysInfo.direction = DIRECTION0; 1392 displaysInfo.displayDirection = DIRECTION0; 1393 displaysInfo.width = 400; 1394 displaysInfo.height = 300; 1395 pointerDrawingManager.displayInfo_.rsId = 101; 1396 pointerDrawingManager.displayInfo_.direction = DIRECTION0; 1397 pointerDrawingManager.displayInfo_.displayDirection = DIRECTION0; 1398 pointerDrawingManager.displayInfo_.width = 600; 1399 pointerDrawingManager.displayInfo_.height = 400; 1400 1401 auto spMirror = std::make_shared<ScreenPointer>( 1402 pointerDrawingManager.hardwareCursorPointerManager_, pointerDrawingManager.handler_, displaysInfo); 1403 spMirror->mode_ = mode_t::SCREEN_MIRROR; 1404 spMirror->displayDirection_ = DIRECTION0; 1405 pointerDrawingManager.screenPointers_[displaysInfo.rsId] = spMirror; 1406 pointerDrawingManager.screenId_ = 100; 1407 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.HideHardwareCursors()); 1408 } 1409 1410 /** 1411 * @tc.name: PointerDrawingManagerSupTest_GetUserIconCopy_001 1412 * @tc.desc: Test GetUserIconCopy 1413 * @tc.type: FUNC 1414 * @tc.require: 1415 */ 1416 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_GetUserIconCopy_001, TestSize.Level1) 1417 { 1418 CALL_TEST_DEBUG; 1419 PointerDrawingManager pointerDrawingManager; 1420 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>(); 1421 pointerDrawingManager.followSystem_ = true; 1422 pointerDrawingManager.cursorWidth_ = 300; 1423 pointerDrawingManager.cursorHeight_ = 300; 1424 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.GetUserIconCopy()); 1425 pointerDrawingManager.cursorWidth_ = 200; 1426 pointerDrawingManager.cursorHeight_ = 200; 1427 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.GetUserIconCopy()); 1428 } 1429 1430 /** 1431 * @tc.name: PointerDrawingManagerSupTest_GetUserIconCopy_002 1432 * @tc.desc: Test GetUserIconCopy 1433 * @tc.type: FUNC 1434 * @tc.require: 1435 */ 1436 HWTEST_F(PointerDrawingManagerSupTest, PointerDrawingManagerSupTest_GetUserIconCopy_002, TestSize.Level1) 1437 { 1438 CALL_TEST_DEBUG; 1439 PointerDrawingManager pointerDrawingManager; 1440 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>(); 1441 pointerDrawingManager.followSystem_ = false; 1442 pointerDrawingManager.cursorWidth_ = 300; 1443 pointerDrawingManager.cursorHeight_ = 300; 1444 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.GetUserIconCopy()); 1445 } 1446 } // namespace MMI 1447 } // namespace OHOS