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 "image_source.h"
22 #include "input_windows_manager_mock.h"
23 #include "i_preference_manager.h"
24 #include "knuckle_drawing_manager.h"
25 #include "libinput_mock.h"
26 #include "mmi_log.h"
27 #include "parameters.h"
28 #include "pixel_map.h"
29 #include "pointer_drawing_manager.h"
30 #include "pointer_event.h"
31
32 #undef MMI_LOG_TAG
33 #define MMI_LOG_TAG "PointerDrawingManagerTest"
34
35 namespace OHOS {
36 namespace MMI {
37 namespace {
38 using namespace testing::ext;
39 constexpr int32_t MOUSE_ICON_SIZE = 64;
40 constexpr uint32_t DEFAULT_ICON_COLOR { 0xFF };
41 constexpr int32_t MIDDLE_PIXEL_MAP_WIDTH { 400 };
42 constexpr int32_t MIDDLE_PIXEL_MAP_HEIGHT { 400 };
43 constexpr int32_t MAX_PIXEL_MAP_WIDTH { 600 };
44 constexpr int32_t MAX_PIXEL_MAP_HEIGHT { 600 };
45 constexpr int32_t INT32_BYTE { 4 };
46 constexpr int32_t WINDOW_ROTATE { 0 };
47 constexpr int32_t FOLDABLE_DEVICE { 2 };
48 const std::string MOUSE_FILE_NAME { "mouse_settings.xml" };
49 const int32_t ROTATE_POLICY = system::GetIntParameter("const.window.device.rotate_policy", 0);
50 } // namespace
51
52 class PointerDrawingManagerTest : public testing::Test {
53 public:
SetUpTestCase(void)54 static void SetUpTestCase(void) {};
TearDownTestCase(void)55 static void TearDownTestCase(void) {};
56 static std::shared_ptr<Media::PixelMap> CreatePixelMap(int32_t width, int32_t height);
SetUp(void)57 void SetUp(void)
58 {}
TearDown(void)59 void TearDown(void)
60 {}
61
62 std::unique_ptr<OHOS::Media::PixelMap> SetMouseIconTest(const std::string iconPath);
63 private:
64 };
65
SetMouseIconTest(const std::string iconPath)66 std::unique_ptr<OHOS::Media::PixelMap> PointerDrawingManagerTest::SetMouseIconTest(const std::string iconPath)
67 {
68 CALL_DEBUG_ENTER;
69 OHOS::Media::SourceOptions opts;
70 opts.formatHint = "image/svg+xml";
71 uint32_t ret = 0;
72 auto imageSource = OHOS::Media::ImageSource::CreateImageSource(iconPath, opts, ret);
73 CHKPP(imageSource);
74 std::set<std::string> formats;
75 ret = imageSource->GetSupportedFormats(formats);
76 MMI_HILOGD("Get supported format ret:%{public}u", ret);
77
78 OHOS::Media::DecodeOptions decodeOpts;
79 decodeOpts.desiredSize = {.width = MOUSE_ICON_SIZE, .height = MOUSE_ICON_SIZE};
80
81 std::unique_ptr<OHOS::Media::PixelMap> pixelMap = imageSource->CreatePixelMap(decodeOpts, ret);
82 CHKPL(pixelMap);
83 return pixelMap;
84 }
85
CreatePixelMap(int32_t width,int32_t height)86 std::shared_ptr<Media::PixelMap> PointerDrawingManagerTest::CreatePixelMap(int32_t width, int32_t height)
87 {
88 CALL_DEBUG_ENTER;
89 if (width <= 0 || width > MAX_PIXEL_MAP_WIDTH || height <= 0 || height > MAX_PIXEL_MAP_HEIGHT) {
90 return nullptr;
91 }
92 Media::InitializationOptions opts;
93 opts.size.height = height;
94 opts.size.width = width;
95 opts.pixelFormat = Media::PixelFormat::BGRA_8888;
96 opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
97 opts.scaleMode = Media::ScaleMode::FIT_TARGET_SIZE;
98
99 int32_t colorLen = width * height;
100 uint32_t *pixelColors = new (std::nothrow) uint32_t[colorLen];
101 CHKPP(pixelColors);
102 int32_t colorByteCount = colorLen * INT32_BYTE;
103 errno_t ret = memset_s(pixelColors, colorByteCount, DEFAULT_ICON_COLOR, colorByteCount);
104 if (ret != EOK) {
105 delete[] pixelColors;
106 return nullptr;
107 }
108 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(pixelColors, colorLen, opts);
109 if (pixelMap == nullptr) {
110 delete[] pixelColors;
111 return nullptr;
112 }
113 delete[] pixelColors;
114 return pixelMap;
115 }
116
117 /**
118 * @tc.name: InputWindowsManagerTest_DrawPointerStyle_01
119 * @tc.desc: Test DrawPointerStyle
120 * @tc.type: FUNC
121 * @tc.require:
122 */
123 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPointerStyle_01, TestSize.Level1)
124 {
125 CALL_TEST_DEBUG;
126 PointerDrawingManager pointerDrawingManager;
127 pointerDrawingManager.hasDisplay_ = true;
128 pointerDrawingManager.hasPointerDevice_ = true;
129 pointerDrawingManager.surfaceNode_ = nullptr;
130
131 PointerStyle pointerStyle;
132 pointerStyle.id = 1;
133 pointerStyle.color = 1;
134 pointerStyle.size = 2;
135
136 int32_t ROTATE_POLICY;
137 ROTATE_POLICY = WINDOW_ROTATE;
138 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
139 }
140
141 /**
142 * @tc.name: InputWindowsManagerTest_DrawPointerStyle_02
143 * @tc.desc: Test DrawManager
144 * @tc.type: FUNC
145 * @tc.require:
146 */
147 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPointerStyle_02, TestSize.Level1)
148 {
149 CALL_TEST_DEBUG;
150 PointerDrawingManager pointerDrawingManager;
151 pointerDrawingManager.hasDisplay_ = true;
152 pointerDrawingManager.hasPointerDevice_ = true;
153 pointerDrawingManager.surfaceNode_ = nullptr;
154
155 PointerStyle pointerStyle;
156 pointerStyle.id = 1;
157 pointerStyle.color = 1;
158 pointerStyle.size = 2;
159
160 int32_t ROTATE_POLICY;
161 ROTATE_POLICY = FOLDABLE_DEVICE;
162 pointerDrawingManager.lastPhysicalX_ = -1;
163 pointerDrawingManager.lastPhysicalY_ = -1;
164 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
165 }
166
167 /**
168 * @tc.name: InputWindowsManagerTest_DrawPointerStyle_03
169 * @tc.desc: Test DrawManager
170 * @tc.type: FUNC
171 * @tc.require:
172 */
173 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPointerStyle_03, TestSize.Level1)
174 {
175 CALL_TEST_DEBUG;
176 PointerDrawingManager pointerDrawingManager;
177 pointerDrawingManager.hasDisplay_ = true;
178 pointerDrawingManager.hasPointerDevice_ = true;
179 pointerDrawingManager.surfaceNode_ = nullptr;
180
181 PointerStyle pointerStyle;
182 pointerStyle.id = 1;
183 pointerStyle.color = 1;
184 pointerStyle.size = 2;
185
186 int32_t ROTATE_POLICY;
187 ROTATE_POLICY = FOLDABLE_DEVICE;
188 pointerDrawingManager.lastPhysicalX_ = 1;
189 pointerDrawingManager.lastPhysicalY_ = -1;
190 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
191 }
192
193 /**
194 * @tc.name: InputWindowsManagerTest_DrawPointerStyle_04
195 * @tc.desc: Test DrawManager
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPointerStyle_04, TestSize.Level1)
200 {
201 CALL_TEST_DEBUG;
202 PointerDrawingManager pointerDrawingManager;
203 pointerDrawingManager.hasDisplay_ = true;
204 pointerDrawingManager.hasPointerDevice_ = true;
205 pointerDrawingManager.surfaceNode_ = nullptr;
206
207 PointerStyle pointerStyle;
208 pointerStyle.id = 1;
209 pointerStyle.color = 1;
210 pointerStyle.size = 2;
211
212 int32_t ROTATE_POLICY;
213 ROTATE_POLICY = FOLDABLE_DEVICE;
214 pointerDrawingManager.lastPhysicalX_ = 2;
215 pointerDrawingManager.lastPhysicalY_ = 2;
216 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
217 }
218
219 /**
220 * @tc.name: InputWindowsManagerTest_SetPointerStyle_01
221 * @tc.desc: Test SetPointerStyle
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerStyle_01, TestSize.Level1)
226 {
227 CALL_TEST_DEBUG;
228 PointerDrawingManager pointerDrawingManager;
229 bool isUiExtension = false;
230
231 PointerStyle pointerStyle;
232 pointerStyle.id = 1;
233 pointerStyle.color = 0;
234 pointerStyle.size = 2;
235
236 int32_t pid = 1;
237 int32_t windowId = -2;
238 bool ret = pointerDrawingManager.CheckPointerStyleParam(windowId, pointerStyle);
239 EXPECT_FALSE(ret);
240
241 int32_t ret2 = pointerDrawingManager.SetPointerStyle(pid, windowId, pointerStyle, isUiExtension);
242 EXPECT_EQ(ret2, RET_ERR);
243 }
244
245 /**
246 * @tc.name: InputWindowsManagerTest_SetPointerStyle_02
247 * @tc.desc: Test SetPointerStyle
248 * @tc.type: FUNC
249 * @tc.require:
250 */
251 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerStyle_02, TestSize.Level1)
252 {
253 CALL_TEST_DEBUG;
254 PointerDrawingManager pointerDrawingManager;
255 bool isUiExtension = true;
256
257 PointerStyle pointerStyle;
258 pointerStyle.id = 1;
259 pointerStyle.color = 0;
260 pointerStyle.size = 2;
261
262 int32_t pid = 1;
263 int32_t windowId = GLOBAL_WINDOW_ID;
264 bool ret = pointerDrawingManager.CheckPointerStyleParam(windowId, pointerStyle);
265 EXPECT_TRUE(ret);
266
267 int32_t ret2 = pointerDrawingManager.SetPointerStyle(pid, windowId, pointerStyle, isUiExtension);
268 EXPECT_EQ(ret2, RET_OK);
269 }
270
271 /**
272 * @tc.name: InputWindowsManagerTest_SetPointerStylePreference_01
273 * @tc.desc: Test SetPointerStylePreference
274 * @tc.type: FUNC
275 * @tc.require:
276 */
277 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerStylePreference_01, TestSize.Level1)
278 {
279 CALL_TEST_DEBUG;
280 PointerDrawingManager pointerDrawingManager;
281 PointerStyle pointerStyle;
282 pointerStyle.id = 1;
283 pointerStyle.color = 1;
284 pointerStyle.size = 2;
285
286 std::string name = "pointerStyle";
287 int32_t ret = PREFERENCES_MGR->SetIntValue(name, MOUSE_FILE_NAME, pointerStyle.id);
288 EXPECT_EQ(ret, RET_OK);
289
290 int32_t ret2 = pointerDrawingManager.SetPointerStylePreference(pointerStyle);
291 EXPECT_EQ(ret2, RET_OK);
292 }
293
294 /**
295 * @tc.name: InputWindowsManagerTest_SetMouseHotSpot_01
296 * @tc.desc: Test SetMouseHotSpot
297 * @tc.type: FUNC
298 * @tc.require:
299 */
300 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseHotSpot_01, TestSize.Level1)
301 {
302 CALL_TEST_DEBUG;
303 PointerDrawingManager pointerDrawingManager;
304 int32_t pid = -1;
305 int32_t windowId = 2;
306 int32_t hotSpotX = 3;
307 int32_t hotSpotY = 4;
308 int32_t ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
309 ASSERT_EQ(ret, RET_ERR);
310 }
311
312 /**
313 * @tc.name: InputWindowsManagerTest_SetMouseHotSpot_02
314 * @tc.desc: Test SetMouseHotSpot
315 * @tc.type: FUNC
316 * @tc.require:
317 */
318 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseHotSpot_02, TestSize.Level1)
319 {
320 CALL_TEST_DEBUG;
321 PointerDrawingManager pointerDrawingManager;
322 int32_t pid = 1;
323 int32_t windowId = -2;
324 int32_t hotSpotX = 3;
325 int32_t hotSpotY = 4;
326 int32_t ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
327 ASSERT_EQ(ret, RET_ERR);
328 }
329
330 /**
331 * @tc.name: InputWindowsManagerTest_SetMouseHotSpot_03
332 * @tc.desc: Test SetMouseHotSpot
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseHotSpot_03, TestSize.Level1)
337 {
338 CALL_TEST_DEBUG;
339 PointerDrawingManager pointerDrawingManager;
340 int32_t pid = 1;
341 int32_t windowId = 2;
342 EXPECT_CALL(*WIN_MGR_MOCK, CheckWindowIdPermissionByPid).WillRepeatedly(testing::Return(RET_ERR));
343 int32_t hotSpotX = 3;
344 int32_t hotSpotY = 4;
345 int32_t ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
346 ASSERT_EQ(ret, RET_ERR);
347 }
348
349 /**
350 * @tc.name: InputWindowsManagerTest_SetMouseHotSpot_04
351 * @tc.desc: Test SetMouseHotSpot
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseHotSpot_04, TestSize.Level1)
356 {
357 CALL_TEST_DEBUG;
358 PointerDrawingManager pointerDrawingManager;
359 int32_t pid = 1;
360 int32_t windowId = 2;
361 EXPECT_CALL(*WIN_MGR_MOCK, CheckWindowIdPermissionByPid).WillRepeatedly(testing::Return(RET_OK));
362 int32_t hotSpotX = -3;
363 int32_t hotSpotY = -4;
364 pointerDrawingManager.userIcon_ = nullptr;
365 int32_t ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
366 ASSERT_EQ(ret, RET_ERR);
367 }
368
369 /**
370 * @tc.name: InputWindowsManagerTest_SetMouseIcon_01
371 * @tc.desc: Test SetMouseIcon
372 * @tc.type: FUNC
373 * @tc.require:
374 */
375 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseIcon_01, TestSize.Level1)
376 {
377 CALL_TEST_DEBUG;
378 PointerDrawingManager pointerDrawingManager;
379 int32_t pid = -1;
380 int32_t windowId = -2;
381 void* pixelMap = nullptr;
382 int32_t ret = pointerDrawingManager.SetMouseIcon(pid, windowId, pixelMap);
383 ASSERT_EQ(ret, RET_ERR);
384 }
385
386 /**
387 * @tc.name: InputWindowsManagerTest_SetMouseIcon_02
388 * @tc.desc: Test SetMouseIcon
389 * @tc.type: FUNC
390 * @tc.require:
391 */
392 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseIcon_02, TestSize.Level1)
393 {
394 CALL_TEST_DEBUG;
395 PointerDrawingManager pointerDrawingManager;
396 int32_t pid = 1;
397 int32_t windowId = -2;
398 void* pixelMap = nullptr;
399 int32_t ret = pointerDrawingManager.SetMouseIcon(pid, windowId, pixelMap);
400 ASSERT_EQ(ret, RET_ERR);
401 }
402
403 /**
404 * @tc.name: InputWindowsManagerTest_SetMouseIcon_03
405 * @tc.desc: Test SetMouseIcon
406 * @tc.type: FUNC
407 * @tc.require:
408 */
409 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseIcon_03, TestSize.Level1)
410 {
411 CALL_TEST_DEBUG;
412 PointerDrawingManager pointerDrawingManager;
413 int32_t pid = 1;
414 int32_t windowId = 2;
415 PointerStyle style;
416 int32_t ret1 = pointerDrawingManager.SetPointerStyle(pid, windowId, style);
417 EXPECT_EQ(ret1, RET_ERR);
418
419 void* pixelMap = nullptr;
420 int32_t ret = pointerDrawingManager.SetMouseIcon(pid, windowId, pixelMap);
421 ASSERT_EQ(ret, RET_ERR);
422 }
423
424 /**
425 * @tc.name: InputWindowsManagerTest_AdjustMouseFocusByDirection270_01
426 * @tc.desc: Test AdjustMouseFocusByDirection270
427 * @tc.type: FUNC
428 * @tc.require:
429 */
430 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_AdjustMouseFocusByDirection270_01, TestSize.Level1)
431 {
432 CALL_TEST_DEBUG;
433 PointerDrawingManager pointerDrawingManager;
434 ICON_TYPE iconType = ANGLE_SW;
435 int32_t physicalX = 150;
436 int32_t physicalY = 200;
437 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.AdjustMouseFocusByDirection270(iconType, physicalX, physicalY));
438 }
439
440 /**
441 * @tc.name: InputWindowsManagerTest_AdjustMouseFocusByDirection270_02
442 * @tc.desc: Test AdjustMouseFocusByDirection270
443 * @tc.type: FUNC
444 * @tc.require:
445 */
446 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_AdjustMouseFocusByDirection270_02, TestSize.Level1)
447 {
448 CALL_TEST_DEBUG;
449 PointerDrawingManager pointerDrawingManager;
450 ICON_TYPE iconType = ANGLE_CENTER;
451 int32_t physicalX = 100;
452 int32_t physicalY = 150;
453 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.AdjustMouseFocusByDirection270(iconType, physicalX, physicalY));
454 }
455
456 /**
457 * @tc.name: InputWindowsManagerTest_AdjustMouseFocusByDirection270_03
458 * @tc.desc: Test AdjustMouseFocusByDirection270
459 * @tc.type: FUNC
460 * @tc.require:
461 */
462 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_AdjustMouseFocusByDirection270_03, TestSize.Level1)
463 {
464 CALL_TEST_DEBUG;
465 PointerDrawingManager pointerDrawingManager;
466 ICON_TYPE iconType = ANGLE_NW_RIGHT;
467 int32_t physicalX = 50;
468 int32_t physicalY = 150;
469 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.AdjustMouseFocusByDirection270(iconType, physicalX, physicalY));
470 }
471
472 /**
473 * @tc.name: InputWindowsManagerTest_AdjustMouseFocusByDirection270_04
474 * @tc.desc: Test AdjustMouseFocusByDirection270
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_AdjustMouseFocusByDirection270_04, TestSize.Level1)
479 {
480 CALL_TEST_DEBUG;
481 PointerDrawingManager pointerDrawingManager;
482 ICON_TYPE iconType = ANGLE_NW;
483 int32_t physicalX = 100;
484 int32_t physicalY = 50;
485 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.AdjustMouseFocusByDirection270(iconType, physicalX, physicalY));
486 }
487
488 /**
489 * @tc.name: InputWindowsManagerTest_DrawMovePointer_001
490 * @tc.desc: Test the funcation DrawMovePointer
491 * @tc.type: FUNC
492 * @tc.require:
493 */
494 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawMovePointer_001, TestSize.Level1)
495 {
496 CALL_TEST_DEBUG;
497 PointerDrawingManager manager;
498 int32_t displayId = 1;
499 int32_t physicalX = 2;
500 int32_t physicalY = 3;
501 PointerStyle pointerStyle;
502 Direction direction = DIRECTION0;
503 manager.surfaceNode_ = nullptr;
504 int32_t ret = manager.DrawMovePointer(displayId, physicalX, physicalY, pointerStyle, direction);
505 EXPECT_EQ(ret, RET_ERR);
506 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
507 surfaceNodeConfig.SurfaceNodeName = "pointer window";
508 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
509 manager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
510 ASSERT_TRUE(manager.surfaceNode_ != nullptr);
511 ret = manager.DrawMovePointer(displayId, physicalX, physicalY, pointerStyle, direction);
512 EXPECT_EQ(ret, RET_OK);
513 }
514
515 /**
516 * @tc.name: InputWindowsManagerTest_DrawCursor_002
517 * @tc.desc: Test the funcation DrawCursor
518 * @tc.type: FUNC
519 * @tc.require:
520 */
521 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawCursor_002, TestSize.Level1)
522 {
523 CALL_TEST_DEBUG;
524 PointerDrawingManager manager;
525 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
526 surfaceNodeConfig.SurfaceNodeName = "pointer window";
527 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
528 manager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
529 ASSERT_TRUE(manager.surfaceNode_ != nullptr);
530 MOUSE_ICON mouseStyle = EAST;
531 int32_t ret = manager.DrawCursor(mouseStyle);
532 EXPECT_EQ(ret, RET_OK);
533 }
534
535 /**
536 * @tc.name: InputWindowsManagerTest_SetMouseHotSpot_003
537 * @tc.desc: Test SetMouseHotSpot
538 * @tc.type: FUNC
539 * @tc.require:
540 */
541 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseHotSpot_003, TestSize.Level1)
542 {
543 CALL_TEST_DEBUG;
544 PointerDrawingManager pointerDrawingManager;
545 auto winmgrmock = std::make_shared<InputWindowsManagerMock>();
546 int32_t pid = 1;
547 int32_t windowId = -2;
548 EXPECT_CALL(*winmgrmock, CheckWindowIdPermissionByPid).WillRepeatedly(testing::Return(RET_OK));
549 int32_t hotSpotX = -1;
550 int32_t hotSpotY = 2;
551 pointerDrawingManager.userIcon_ = nullptr;
552 int32_t ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
553 ASSERT_EQ(ret, RET_ERR);
554 hotSpotX = 1;
555 hotSpotY = -2;
556 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
557 ASSERT_EQ(ret, RET_ERR);
558 hotSpotX = 1;
559 hotSpotY = 2;
560 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
561 ASSERT_EQ(ret, RET_ERR);
562 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
563 ASSERT_NE(pointerDrawingManager.userIcon_, nullptr);
564 hotSpotX = -1;
565 hotSpotY = 2;
566 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
567 ASSERT_EQ(ret, RET_ERR);
568 hotSpotX = -1;
569 hotSpotY = -2;
570 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
571 ASSERT_EQ(ret, RET_ERR);
572 hotSpotX = 1;
573 hotSpotY = -2;
574 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
575 ASSERT_EQ(ret, RET_ERR);
576 hotSpotX = 3;
577 hotSpotY = 4;
578 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
579 ASSERT_NE(pointerDrawingManager.userIcon_, nullptr);
580 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
581 ASSERT_EQ(ret, RET_ERR);
582 testing::Mock::AllowLeak(winmgrmock.get());
583 }
584
585 /**
586 * @tc.name: InputWindowsManagerTest_SetPointerColor_002
587 * @tc.desc: Test SetPointerColor
588 * @tc.type: FUNC
589 * @tc.require:
590 */
591 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerColor_002, TestSize.Level1)
592 {
593 CALL_TEST_DEBUG;
594 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
595 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
596 surfaceNodeConfig.SurfaceNodeName = "pointer window";
597 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
598 pointerDrawingManager->surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
599 ASSERT_TRUE(pointerDrawingManager->surfaceNode_ != nullptr);
600 pointerDrawingManager->SetPointerColor(16777216);
601 int32_t color = pointerDrawingManager->GetPointerColor();
602 EXPECT_EQ(color, RET_OK);
603 }
604
605 /**
606 * @tc.name: InputWindowsManagerTest_UpdatePointerDevice_002
607 * @tc.desc: Test UpdatePointerDevice
608 * @tc.type: FUNC
609 * @tc.require:
610 */
611 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_UpdatePointerDevice_002, TestSize.Level1)
612 {
613 CALL_TEST_DEBUG;
614 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
615 EXPECT_EQ(pointerDrawingManager->pidInfos_.size(), 0);
616 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager->UpdatePointerDevice(true, false, true));
617 EXPECT_EQ(pointerDrawingManager->pidInfos_.size(), 1);
618 pointerDrawingManager->surfaceNode_ = nullptr;
619 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager->UpdatePointerDevice(false, false, true));
620 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
621 surfaceNodeConfig.SurfaceNodeName = "pointer window";
622 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
623 pointerDrawingManager->surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
624 ASSERT_TRUE(pointerDrawingManager->surfaceNode_ != nullptr);
625 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager->UpdatePointerDevice(false, false, true));
626 }
627
628 /**
629 * @tc.name: InputWindowsManagerTest_DrawManager_005
630 * @tc.desc: Test DrawManager
631 * @tc.type: FUNC
632 * @tc.require:
633 */
634 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawManager_005, TestSize.Level1)
635 {
636 CALL_TEST_DEBUG;
637 PointerDrawingManager pointerDrawingManager;
638 auto winmgrmock = std::make_shared<InputWindowsManagerMock>();
639 pointerDrawingManager.hasDisplay_ = true;
640 pointerDrawingManager.hasPointerDevice_ = true;
641 pointerDrawingManager.surfaceNode_ = nullptr;
642 EXPECT_CALL(*winmgrmock, CheckWindowIdPermissionByPid).WillRepeatedly(testing::Return(RET_ERR));
643 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
644 EXPECT_CALL(*winmgrmock, CheckWindowIdPermissionByPid).WillRepeatedly(testing::Return(RET_OK));
645 pointerDrawingManager.lastPhysicalX_ = -1;
646 pointerDrawingManager.lastPhysicalY_ = 1;
647 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
648 pointerDrawingManager.lastPhysicalX_ = 1;
649 pointerDrawingManager.lastPhysicalY_ = -1;
650 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
651 pointerDrawingManager.lastPhysicalX_ = -1;
652 pointerDrawingManager.lastPhysicalY_ = -1;
653 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
654 EXPECT_CALL(*winmgrmock, CheckWindowIdPermissionByPid).WillRepeatedly(testing::Return(RET_OK));
655 pointerDrawingManager.lastPhysicalX_ = 1;
656 pointerDrawingManager.lastPhysicalY_ = 1;
657 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
658 testing::Mock::AllowLeak(winmgrmock.get());
659 }
660
661 /**
662 * @tc.name: InputWindowsManagerTest_SetPointerVisible_002
663 * @tc.desc: Test SetPointerVisible
664 * @tc.type: FUNC
665 * @tc.require:
666 */
667 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerVisible_002, TestSize.Level1)
668 {
669 CALL_TEST_DEBUG;
670 auto winmgrmock = std::make_shared<InputWindowsManagerMock>();
671 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
672 EXPECT_CALL(*winmgrmock, GetExtraData).WillRepeatedly(testing::Return(ExtraData{true}));
673 int32_t pid = 1;
674 bool visible = true;
675 int32_t priority = 0;
676 int32_t ret = pointerDrawingManager->SetPointerVisible(pid, visible, priority, false);
677 ASSERT_EQ(ret, RET_OK);
678 visible = false;
679 priority = 0;
680 ret = pointerDrawingManager->SetPointerVisible(pid, visible, priority, false);
681 ASSERT_EQ(ret, RET_OK);
682 visible = true;
683 priority = 1;
684 ret = pointerDrawingManager->SetPointerVisible(pid, visible, priority, false);
685 ASSERT_EQ(ret, RET_OK);
686 visible = false;
687 priority = 1;
688 ret = pointerDrawingManager->SetPointerVisible(pid, visible, priority, false);
689 ASSERT_EQ(ret, RET_OK);
690 EXPECT_CALL(*winmgrmock, GetExtraData).WillRepeatedly(testing::Return(ExtraData{false}));
691 visible = false;
692 priority = 0;
693 ret = pointerDrawingManager->SetPointerVisible(pid, visible, priority, false);
694 ASSERT_EQ(ret, RET_OK);
695 visible = true;
696 priority = 1;
697 ret = pointerDrawingManager->SetPointerVisible(pid, visible, priority, false);
698 ASSERT_EQ(ret, RET_OK);
699 visible = false;
700 priority = 1;
701 ret = pointerDrawingManager->SetPointerVisible(pid, visible, priority, false);
702 ASSERT_EQ(ret, RET_OK);
703 testing::Mock::AllowLeak(winmgrmock.get());
704 }
705
706 /**
707 * @tc.name: InputWindowsManagerTest_SetPointerLocation_002
708 * @tc.desc: Test SetPointerLocation
709 * @tc.type: FUNC
710 * @tc.require:
711 */
712 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerLocation_002, TestSize.Level1)
713 {
714 CALL_TEST_DEBUG;
715 PointerDrawingManager pointerDrawingManager;
716 int32_t x = 100;
717 int32_t y = 100;
718 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
719 surfaceNodeConfig.SurfaceNodeName = "pointer window";
720 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
721 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
722 ASSERT_TRUE(pointerDrawingManager.surfaceNode_ != nullptr);
723 int32_t displayId = 0;
724 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetPointerLocation(x, y, displayId));
725 }
726
727 /**
728 * @tc.name: InputWindowsManagerTest_UpdateDefaultPointerStyle_002
729 * @tc.desc: Test UpdateDefaultPointerStyle
730 * @tc.type: FUNC
731 * @tc.require:
732 */
733 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_UpdateDefaultPointerStyle_002, TestSize.Level1)
734 {
735 CALL_TEST_DEBUG;
736 auto winmgrmock = std::make_shared<InputWindowsManagerMock>();
737 PointerDrawingManager pointerDrawingManager;
738 int32_t pid = 1;
739 int32_t windowId = -1;
740 PointerStyle pointerStyle;
741 pointerStyle.id = 0;
742 pointerStyle.color = 0;
743 pointerStyle.size = 2;
744 EXPECT_CALL(*winmgrmock, GetPointerStyle).WillRepeatedly(testing::Return(RET_ERR));
745 int32_t ret = pointerDrawingManager.UpdateDefaultPointerStyle(pid, windowId, pointerStyle);
746 EXPECT_EQ(ret, RET_OK);
747 testing::Mock::AllowLeak(winmgrmock.get());
748 }
749
750 /**
751 * @tc.name: InputWindowsManagerTest_GetPointerStyle_001
752 * @tc.desc: Test GetPointerStyle
753 * @tc.type: FUNC
754 * @tc.require:
755 */
756 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_GetPointerStyle_001, TestSize.Level1)
757 {
758 CALL_TEST_DEBUG;
759 auto winmgrmock = std::make_shared<InputWindowsManagerMock>();
760 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
761 int32_t pid = 1;
762 int32_t windowId = 2;
763 bool isUiExtension = true;
764 PointerStyle pointerStyle;
765 EXPECT_CALL(*winmgrmock, GetPointerStyle).WillRepeatedly(testing::Return(RET_ERR));
766 int32_t ret = pointerDrawingManager->GetPointerStyle(pid, windowId, pointerStyle, isUiExtension);
767 EXPECT_EQ(ret, RET_OK);
768 testing::Mock::AllowLeak(winmgrmock.get());
769 }
770
771 /**
772 * @tc.name: InputWindowsManagerTest_DrawPointerStyle_002
773 * @tc.desc: Test DrawPointerStyle
774 * @tc.type: FUNC
775 * @tc.require:
776 */
777 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPointerStyle_002, TestSize.Level1)
778 {
779 CALL_TEST_DEBUG;
780 PointerDrawingManager pointerDrawingManager;
781 PointerStyle pointerStyle;
782 pointerStyle.id = 0;
783 pointerStyle.color = 0;
784 pointerStyle.size = 2;
785 pointerDrawingManager.hasDisplay_ = false;
786 pointerDrawingManager.hasPointerDevice_ = true;
787 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
788 pointerDrawingManager.hasDisplay_ = true;
789 pointerDrawingManager.hasPointerDevice_ = false;
790 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
791 pointerDrawingManager.hasDisplay_ = false;
792 pointerDrawingManager.hasPointerDevice_ = false;
793 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
794 pointerDrawingManager.hasDisplay_ = true;
795 pointerDrawingManager.hasPointerDevice_ = true;
796 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
797 surfaceNodeConfig.SurfaceNodeName = "pointer window";
798 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
799 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
800 ASSERT_TRUE(pointerDrawingManager.surfaceNode_ != nullptr);
801 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
802 pointerDrawingManager.hasDisplay_ = true;
803 pointerDrawingManager.hasPointerDevice_ = true;
804 pointerDrawingManager.surfaceNode_ = nullptr;
805 pointerDrawingManager.lastPhysicalX_ = -1;
806 pointerDrawingManager.lastPhysicalY_ = 1;
807 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
808 pointerDrawingManager.lastPhysicalX_ = 1;
809 pointerDrawingManager.lastPhysicalY_ = -1;
810 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
811 pointerDrawingManager.lastPhysicalX_ = -1;
812 pointerDrawingManager.lastPhysicalY_ = -1;
813 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
814 pointerDrawingManager.lastPhysicalX_ = 1;
815 pointerDrawingManager.lastPhysicalY_ = 1;
816 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
817 }
818
819 /**
820 * @tc.name: InputWindowsManagerTest_Init_001
821 * @tc.desc: Test Init
822 * @tc.type: FUNC
823 * @tc.require:
824 */
825 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_Init_001, TestSize.Level1)
826 {
827 CALL_TEST_DEBUG;
828 bool isSucess = IPointerDrawingManager::GetInstance()->Init();
829 EXPECT_EQ(isSucess, true);
830 IconStyle iconStyle = IPointerDrawingManager::GetInstance()->GetIconStyle(MOUSE_ICON(MOUSE_ICON::DEFAULT));
831 EXPECT_EQ(iconStyle.alignmentWay, 7);
832 }
833
834 /**
835 * @tc.name: InputWindowsManagerTest_SetMouseDisplayState_001
836 * @tc.desc: Test SetMouseDisplayState
837 * @tc.type: FUNC
838 * @tc.require:
839 */
840 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseDisplayState_001, TestSize.Level1)
841 {
842 CALL_TEST_DEBUG;
843 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
844 pointerDrawingManager->SetMouseDisplayState(true);
845 bool mouseDisplayState = pointerDrawingManager->GetMouseDisplayState();
846 EXPECT_EQ(mouseDisplayState, true);
847 }
848
849 /**
850 * @tc.name: InputWindowsManagerTest_UpdatePointerDevice_001
851 * @tc.desc: Test UpdatePointerDevice
852 * @tc.type: FUNC
853 * @tc.require:
854 */
855 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_UpdatePointerDevice_001, TestSize.Level1)
856 {
857 CALL_TEST_DEBUG;
858 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
859 EXPECT_EQ(pointerDrawingManager->pidInfos_.size(), 0);
860 pointerDrawingManager->UpdatePointerDevice(true, true, true);
861 EXPECT_EQ(pointerDrawingManager->pidInfos_.size(), 1);
862 pointerDrawingManager->UpdatePointerDevice(false, true, true);
863 EXPECT_EQ(pointerDrawingManager->pidInfos_.size(), 0);
864 }
865
866 /**
867 * @tc.name: InputWindowsManagerTest_AdjustMouseFocusByDirection0_001
868 * @tc.desc: Test AdjustMouseFocusByDirection0
869 * @tc.type: FUNC
870 * @tc.require:
871 */
872 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_AdjustMouseFocusByDirection0_001, TestSize.Level1)
873 {
874 CALL_TEST_DEBUG;
875 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
876 pointerDrawingManager->imageWidth_ = 50;
877 pointerDrawingManager->imageHeight_ = 50;
878 pointerDrawingManager->userIconHotSpotX_ = 5;
879 pointerDrawingManager->userIconHotSpotY_ = 5;
880 int32_t physicalX = 100;
881 int32_t physicalY = 100;
882 pointerDrawingManager->AdjustMouseFocusByDirection0(ANGLE_SW, physicalX, physicalY);
883 EXPECT_EQ(physicalX, 100);
884 EXPECT_EQ(physicalY, 50);
885 physicalX = 100;
886 physicalY = 100;
887 pointerDrawingManager->AdjustMouseFocusByDirection0(ANGLE_CENTER, physicalX, physicalY);
888 EXPECT_EQ(physicalX, 75);
889 EXPECT_EQ(physicalY, 75);
890 physicalX = 100;
891 physicalY = 100;
892 pointerDrawingManager->AdjustMouseFocusByDirection0(ANGLE_NW_RIGHT, physicalX, physicalY);
893 EXPECT_EQ(physicalX, 92);
894 EXPECT_EQ(physicalY, 100);
895 physicalX = 100;
896 physicalY = 100;
897 pointerDrawingManager->userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
898 pointerDrawingManager->currentMouseStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
899 pointerDrawingManager->AdjustMouseFocusByDirection0(ANGLE_NW, physicalX, physicalY);
900 EXPECT_EQ(physicalX, 100);
901 EXPECT_EQ(physicalY, 100);
902 physicalX = 100;
903 physicalY = 100;
904 pointerDrawingManager->AdjustMouseFocusByDirection0(ANGLE_E, physicalX, physicalY);
905 EXPECT_EQ(physicalX, 100);
906 EXPECT_EQ(physicalY, 100);
907 }
908
909 /**
910 * @tc.name: InputWindowsManagerTest_AdjustMouseFocusByDirection90_001
911 * @tc.desc: Test AdjustMouseFocusByDirection90
912 * @tc.type: FUNC
913 * @tc.require:
914 */
915 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_AdjustMouseFocusByDirection90_001, TestSize.Level1)
916 {
917 CALL_TEST_DEBUG;
918 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
919 pointerDrawingManager->imageWidth_ = 50;
920 pointerDrawingManager->imageHeight_ = 50;
921 pointerDrawingManager->userIconHotSpotX_ = 5;
922 pointerDrawingManager->userIconHotSpotY_ = 5;
923 int32_t physicalX = 100;
924 int32_t physicalY = 100;
925 pointerDrawingManager->AdjustMouseFocusByDirection90(ANGLE_SW, physicalX, physicalY);
926 EXPECT_EQ(physicalX, 100);
927 EXPECT_EQ(physicalY, 150);
928 physicalX = 100;
929 physicalY = 100;
930 pointerDrawingManager->AdjustMouseFocusByDirection90(ANGLE_CENTER, physicalX, physicalY);
931 EXPECT_EQ(physicalX, 75);
932 EXPECT_EQ(physicalY, 125);
933 physicalX = 100;
934 physicalY = 100;
935 pointerDrawingManager->AdjustMouseFocusByDirection90(ANGLE_NW_RIGHT, physicalX, physicalY);
936 EXPECT_EQ(physicalX, 92);
937 EXPECT_EQ(physicalY, 100);
938 physicalX = 100;
939 physicalY = 100;
940 pointerDrawingManager->userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
941 pointerDrawingManager->currentMouseStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
942 pointerDrawingManager->AdjustMouseFocusByDirection90(ANGLE_NW, physicalX, physicalY);
943 EXPECT_EQ(physicalX, 100);
944 EXPECT_EQ(physicalY, 100);
945 physicalX = 100;
946 physicalY = 100;
947 pointerDrawingManager->AdjustMouseFocusByDirection90(ANGLE_E, physicalX, physicalY);
948 EXPECT_EQ(physicalX, 100);
949 EXPECT_EQ(physicalY, 100);
950 }
951
952 /**
953 * @tc.name: InputWindowsManagerTest_AdjustMouseFocusByDirection180_001
954 * @tc.desc: Test AdjustMouseFocusByDirection180
955 * @tc.type: FUNC
956 * @tc.require:
957 */
958 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_AdjustMouseFocusByDirection180_001, TestSize.Level1)
959 {
960 CALL_TEST_DEBUG;
961 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
962 pointerDrawingManager->imageWidth_ = 50;
963 pointerDrawingManager->imageHeight_ = 50;
964 pointerDrawingManager->userIconHotSpotX_ = 5;
965 pointerDrawingManager->userIconHotSpotY_ = 5;
966 int32_t physicalX = 100;
967 int32_t physicalY = 100;
968 pointerDrawingManager->AdjustMouseFocusByDirection180(ANGLE_SW, physicalX, physicalY);
969 EXPECT_EQ(physicalX, 100);
970 EXPECT_EQ(physicalY, 150);
971 physicalX = 100;
972 physicalY = 100;
973 pointerDrawingManager->AdjustMouseFocusByDirection180(ANGLE_CENTER, physicalX, physicalY);
974 EXPECT_EQ(physicalX, 125);
975 EXPECT_EQ(physicalY, 125);
976 physicalX = 100;
977 physicalY = 100;
978 pointerDrawingManager->AdjustMouseFocusByDirection180(ANGLE_NW_RIGHT, physicalX, physicalY);
979 EXPECT_EQ(physicalX, 107);
980 EXPECT_EQ(physicalY, 100);
981 physicalX = 100;
982 physicalY = 100;
983 pointerDrawingManager->userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
984 pointerDrawingManager->currentMouseStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
985 pointerDrawingManager->AdjustMouseFocusByDirection180(ANGLE_NW, physicalX, physicalY);
986 EXPECT_EQ(physicalX, 100);
987 EXPECT_EQ(physicalY, 100);
988 physicalX = 100;
989 physicalY = 100;
990 pointerDrawingManager->AdjustMouseFocusByDirection180(ANGLE_E, physicalX, physicalY);
991 EXPECT_EQ(physicalX, 100);
992 EXPECT_EQ(physicalY, 100);
993 }
994
995 /**
996 * @tc.name: InputWindowsManagerTest_AdjustMouseFocusByDirection270_001
997 * @tc.desc: Test AdjustMouseFocusByDirection270
998 * @tc.type: FUNC
999 * @tc.require:
1000 */
1001 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_AdjustMouseFocusByDirection270_001, TestSize.Level1)
1002 {
1003 CALL_TEST_DEBUG;
1004 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1005 pointerDrawingManager->imageWidth_ = 50;
1006 pointerDrawingManager->imageHeight_ = 50;
1007 pointerDrawingManager->userIconHotSpotX_ = 5;
1008 pointerDrawingManager->userIconHotSpotY_ = 5;
1009 int32_t physicalX = 100;
1010 int32_t physicalY = 100;
1011 pointerDrawingManager->AdjustMouseFocusByDirection270(ANGLE_SW, physicalX, physicalY);
1012 EXPECT_EQ(physicalX, 100);
1013 EXPECT_EQ(physicalY, 50);
1014 physicalX = 100;
1015 physicalY = 100;
1016 pointerDrawingManager->AdjustMouseFocusByDirection270(ANGLE_CENTER, physicalX, physicalY);
1017 EXPECT_EQ(physicalX, 125);
1018 EXPECT_EQ(physicalY, 75);
1019 physicalX = 100;
1020 physicalY = 100;
1021 pointerDrawingManager->AdjustMouseFocusByDirection270(ANGLE_NW_RIGHT, physicalX, physicalY);
1022 EXPECT_EQ(physicalX, 107);
1023 EXPECT_EQ(physicalY, 100);
1024 physicalX = 100;
1025 physicalY = 100;
1026 pointerDrawingManager->userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
1027 pointerDrawingManager->currentMouseStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
1028 pointerDrawingManager->AdjustMouseFocusByDirection270(ANGLE_NW, physicalX, physicalY);
1029 EXPECT_EQ(physicalX, 100);
1030 EXPECT_EQ(physicalY, 100);
1031 physicalX = 100;
1032 physicalY = 100;
1033 pointerDrawingManager->AdjustMouseFocusByDirection270(ANGLE_E, physicalX, physicalY);
1034 EXPECT_EQ(physicalX, 100);
1035 EXPECT_EQ(physicalY, 100);
1036 }
1037
1038 /**
1039 * @tc.name: InputWindowsManagerTest_AdjustMouseFocus_001
1040 * @tc.desc: Test AdjustMouseFocus
1041 * @tc.type: FUNC
1042 * @tc.require:
1043 */
1044 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_AdjustMouseFocus_001, TestSize.Level1)
1045 {
1046 CALL_TEST_DEBUG;
1047 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1048 pointerDrawingManager->imageWidth_ = 50;
1049 pointerDrawingManager->imageHeight_ = 50;
1050 int32_t physicalX = 100;
1051 int32_t physicalY = 100;
1052 pointerDrawingManager->RotateDegree(DIRECTION0);
1053 pointerDrawingManager->AdjustMouseFocus(DIRECTION0, ANGLE_SW, physicalX, physicalY);
1054 EXPECT_EQ(physicalX, 100);
1055 EXPECT_EQ(physicalY, 50);
1056 physicalX = 100;
1057 physicalY = 100;
1058 pointerDrawingManager->RotateDegree(DIRECTION90);
1059 pointerDrawingManager->AdjustMouseFocus(DIRECTION90, ANGLE_SW, physicalX, physicalY);
1060 EXPECT_EQ(physicalX, 100);
1061 EXPECT_EQ(physicalY, 150);
1062 physicalX = 100;
1063 physicalY = 100;
1064 pointerDrawingManager->RotateDegree(DIRECTION180);
1065 pointerDrawingManager->AdjustMouseFocus(DIRECTION180, ANGLE_SW, physicalX, physicalY);
1066 EXPECT_EQ(physicalX, 100);
1067 EXPECT_EQ(physicalY, 150);
1068 physicalX = 100;
1069 physicalY = 100;
1070 pointerDrawingManager->RotateDegree(DIRECTION270);
1071 pointerDrawingManager->AdjustMouseFocus(DIRECTION270, ANGLE_SW, physicalX, physicalY);
1072 EXPECT_EQ(physicalX, 100);
1073 EXPECT_EQ(physicalY, 50);
1074 physicalX = 100;
1075 physicalY = 100;
1076 pointerDrawingManager->RotateDegree(static_cast<Direction>(4));
1077 pointerDrawingManager->AdjustMouseFocus(static_cast<Direction>(4), ANGLE_SW, physicalX, physicalY);
1078 EXPECT_EQ(physicalX, 100);
1079 EXPECT_EQ(physicalY, 100);
1080 }
1081
1082 /**
1083 * @tc.name: InputWindowsManagerTest_SetPointerColor_001
1084 * @tc.desc: Test SetPointerColor
1085 * @tc.type: FUNC
1086 * @tc.require:
1087 */
1088 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerColor_001, TestSize.Level1)
1089 {
1090 CALL_TEST_DEBUG;
1091 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1092 pointerDrawingManager->SetPointerColor(-1);
1093 int32_t color = pointerDrawingManager->GetPointerColor();
1094 EXPECT_NE(color, 0);
1095 pointerDrawingManager->SetPointerColor(16777216);
1096 color = pointerDrawingManager->GetPointerColor();
1097 EXPECT_EQ(color, 0);
1098 }
1099
1100 /**
1101 * @tc.name: InputWindowsManagerTest_SetPointerVisible_001
1102 * @tc.desc: Test SetPointerVisible
1103 * @tc.type: FUNC
1104 * @tc.require:
1105 */
1106 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerVisible_001, TestSize.Level1)
1107 {
1108 CALL_TEST_DEBUG;
1109 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1110 for (int32_t i = 1; i < 102; i++) {
1111 pointerDrawingManager->SetPointerVisible(i, false, 0, false);
1112 }
1113 bool visible = pointerDrawingManager->GetPointerVisible(1);
1114 EXPECT_EQ(visible, true);
1115 pointerDrawingManager->SetPointerVisible(11, true, 0, false);
1116 visible = pointerDrawingManager->GetPointerVisible(11);
1117 EXPECT_EQ(visible, true);
1118 }
1119
1120 /**
1121 * @tc.name: InputWindowsManagerTest_SetPointerStyle_001
1122 * @tc.desc: Test SetPointerStyle
1123 * @tc.type: FUNC
1124 * @tc.require:
1125 */
1126 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerStyle_001, TestSize.Level1)
1127 {
1128 CALL_TEST_DEBUG;
1129 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1130 PointerStyle pointerStyle;
1131 pointerStyle.id = 0;
1132 pointerDrawingManager->SetPointerStyle(1, -1, pointerStyle);
1133 PointerStyle pointerStyleTmp;
1134 pointerDrawingManager->GetPointerStyle(1, -1, pointerStyleTmp);
1135 EXPECT_EQ(pointerStyleTmp.id, pointerStyle.id);
1136 }
1137
1138 /**
1139 * @tc.name: InputWindowsManagerTest_SetPointerSize_001
1140 * @tc.desc: Test SetPointerSize
1141 * @tc.type: FUNC
1142 * @tc.require:
1143 */
1144 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerSize_001, TestSize.Level1)
1145 {
1146 CALL_TEST_DEBUG;
1147 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1148 pointerDrawingManager->SetPointerSize(0);
1149 int32_t pointerSize = pointerDrawingManager->GetPointerSize();
1150 EXPECT_NE(pointerSize, 0);
1151 pointerDrawingManager->SetPointerSize(8);
1152 pointerSize = pointerDrawingManager->GetPointerSize();
1153 EXPECT_NE(pointerSize, 0);
1154 }
1155
1156 /**
1157 * @tc.name: InputWindowsManagerTest_FixCursorPosition_001
1158 * @tc.desc: Test FixCursorPosition
1159 * @tc.type: FUNC
1160 * @tc.require:
1161 */
1162 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_FixCursorPosition_001, TestSize.Level1)
1163 {
1164 CALL_TEST_DEBUG;
1165 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1166 pointerDrawingManager->displayInfo_.displayDirection = DIRECTION0;
1167 pointerDrawingManager->displayInfo_.direction = DIRECTION0;
1168 pointerDrawingManager->displayInfo_.width = 500;
1169 pointerDrawingManager->displayInfo_.height = 1100;
1170 pointerDrawingManager->imageWidth_ = 48;
1171 pointerDrawingManager->imageHeight_ = 48;
1172 int32_t physicalX = 500;
1173 int32_t physicalY = 1100;
1174 pointerDrawingManager->FixCursorPosition(physicalX, physicalY);
1175 EXPECT_EQ(physicalX, -3);
1176 EXPECT_EQ(physicalY, -3);
1177 pointerDrawingManager->displayInfo_.direction = DIRECTION90;
1178 physicalX = 1100;
1179 physicalY = 500;
1180 pointerDrawingManager->FixCursorPosition(physicalX, physicalY);
1181 EXPECT_EQ(physicalX, -3);
1182 EXPECT_EQ(physicalY, 500);
1183 pointerDrawingManager->displayInfo_.displayDirection = DIRECTION90;
1184 pointerDrawingManager->displayInfo_.direction = DIRECTION0;
1185 physicalX = 500;
1186 physicalY = 1100;
1187 pointerDrawingManager->FixCursorPosition(physicalX, physicalY);
1188 EXPECT_EQ(physicalX, -3);
1189 EXPECT_EQ(physicalY, -3);
1190 }
1191
1192 /**
1193 * @tc.name: InputWindowsManagerTest_CreatePointerSwitchObserver_001
1194 * @tc.desc: Test CreatePointerSwitchObserver
1195 * @tc.type: FUNC
1196 * @tc.require:
1197 */
1198 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_CreatePointerSwitchObserver_001, TestSize.Level1)
1199 {
1200 CALL_TEST_DEBUG;
1201 PointerDrawingManager pointerDrawingManager;
1202 isMagicCursor item;
1203 item.isShow = true;
1204 item.name = "test";
1205 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.CreatePointerSwitchObserver(item));
1206 }
1207
1208 /**
1209 * @tc.name: InputWindowsManagerTest_DrawCursor_001
1210 * @tc.desc: Test DrawCursor
1211 * @tc.type: FUNC
1212 * @tc.require:
1213 */
1214 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawCursor_001, TestSize.Level1)
1215 {
1216 CALL_TEST_DEBUG;
1217 PointerDrawingManager pointerDrawingManager;
1218 MOUSE_ICON mouseStyle = EAST;
1219 int32_t ret = pointerDrawingManager.DrawCursor(mouseStyle);
1220 EXPECT_EQ(ret, RET_ERR);
1221 pointerDrawingManager.surfaceNode_ = nullptr;
1222 ret = pointerDrawingManager.DrawCursor(mouseStyle);
1223 EXPECT_EQ(ret, RET_ERR);
1224 }
1225
1226 /**
1227 * @tc.name: InputWindowsManagerTest_DrawLoadingPointerStyle_001
1228 * @tc.desc: Test DrawLoadingPointerStyle
1229 * @tc.type: FUNC
1230 * @tc.require:
1231 */
1232 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawLoadingPointerStyle_001, TestSize.Level1)
1233 {
1234 CALL_TEST_DEBUG;
1235 PointerDrawingManager pointerDrawingManager;
1236 MOUSE_ICON mouseStyle = EAST;
1237 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawLoadingPointerStyle(mouseStyle));
1238 }
1239
1240 /**
1241 * @tc.name: InputWindowsManagerTest_DrawRunningPointerAnimate_001
1242 * @tc.desc: Test DrawRunningPointerAnimate
1243 * @tc.type: FUNC
1244 * @tc.require:
1245 */
1246 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawRunningPointerAnimate_001, TestSize.Level1)
1247 {
1248 CALL_TEST_DEBUG;
1249 PointerDrawingManager pointerDrawingManager;
1250 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
1251 surfaceNodeConfig.SurfaceNodeName = "pointer window";
1252 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
1253 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
1254 pointerDrawingManager.surfaceNode_->SetFrameGravity(Rosen::Gravity::RESIZE_ASPECT_FILL);
1255 pointerDrawingManager.surfaceNode_->SetPositionZ(Rosen::RSSurfaceNode::POINTER_WINDOW_POSITION_Z);
1256 MOUSE_ICON mouseStyle = EAST;
1257 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawRunningPointerAnimate(mouseStyle));
1258 }
1259
1260 /**
1261 * @tc.name: InputWindowsManagerTest_GetLayer_001
1262 * @tc.desc: Test GetLayer
1263 * @tc.type: FUNC
1264 * @tc.require:
1265 */
1266 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_GetLayer_001, TestSize.Level1)
1267 {
1268 CALL_TEST_DEBUG;
1269 PointerDrawingManager pointerDrawingManager;
1270 pointerDrawingManager.surfaceNode_ = nullptr;
1271 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.GetLayer());
1272 }
1273
1274 /**
1275 * @tc.name: InputWindowsManagerTest_SetMouseIcon_001
1276 * @tc.desc: Test SetMouseIcon
1277 * @tc.type: FUNC
1278 * @tc.require:
1279 */
1280 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseIcon_001, TestSize.Level1)
1281 {
1282 CALL_TEST_DEBUG;
1283 PointerDrawingManager pointerDrawingManager;
1284 int32_t pid = -1;
1285 int32_t windowId = 1;
1286 void* pixelMap = nullptr;
1287 int32_t ret = pointerDrawingManager.SetMouseIcon(pid, windowId, pixelMap);
1288 EXPECT_EQ(ret, RET_ERR);
1289 pid = 1;
1290 ret = pointerDrawingManager.SetMouseIcon(pid, windowId, pixelMap);
1291 EXPECT_EQ(ret, RET_ERR);
1292 }
1293
1294 /**
1295 * @tc.name: InputWindowsManagerTest_SetMouseHotSpot_001
1296 * @tc.desc: Test SetMouseHotSpot
1297 * @tc.type: FUNC
1298 * @tc.require:
1299 */
1300 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseHotSpot_001, TestSize.Level1)
1301 {
1302 CALL_TEST_DEBUG;
1303 PointerDrawingManager pointerDrawingManager;
1304 int32_t pid = -1;
1305 int32_t windowId = 1;
1306 int32_t hotSpotX = 100;
1307 int32_t hotSpotY = 100;
1308 int32_t ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
1309 EXPECT_EQ(ret, RET_ERR);
1310 pid = 1;
1311 windowId = -1;
1312 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
1313 EXPECT_EQ(ret, RET_ERR);
1314 pid = 1;
1315 windowId = 1;
1316 hotSpotX = -1;
1317 hotSpotY = -1;
1318 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
1319 EXPECT_EQ(ret, RET_ERR);
1320 pid = 1;
1321 windowId = 1;
1322 hotSpotX = 100;
1323 hotSpotY = 100;
1324 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
1325 EXPECT_EQ(ret, RET_ERR);
1326 }
1327
1328 /**
1329 * @tc.name: InputWindowsManagerTest_DecodeImageToPixelMap_001
1330 * @tc.desc: Test DecodeImageToPixelMap
1331 * @tc.type: FUNC
1332 * @tc.require:
1333 */
1334 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DecodeImageToPixelMap_001, TestSize.Level1)
1335 {
1336 CALL_TEST_DEBUG;
1337 PointerDrawingManager pointerDrawingManager;
1338 std::string iconPath = ("/system/etc/multimodalinput/mouse_icon/Loading_Left.svg");
1339 pointerDrawingManager.tempPointerColor_ = 1;
1340 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DecodeImageToPixelMap(MOUSE_ICON::RUNNING));
1341 }
1342
1343 /**
1344 * @tc.name: InputWindowsManagerTest_UpdatePointerVisible_001
1345 * @tc.desc: Test UpdatePointerVisible
1346 * @tc.type: FUNC
1347 * @tc.require:
1348 */
1349 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_UpdatePointerVisible_001, TestSize.Level1)
1350 {
1351 CALL_TEST_DEBUG;
1352 PointerDrawingManager pointerDrawingManager;
1353 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
1354 surfaceNodeConfig.SurfaceNodeName = "pointer window";
1355 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
1356 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
1357 pointerDrawingManager.mouseDisplayState_ = true;
1358 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdatePointerVisible());
1359 pointerDrawingManager.mouseDisplayState_ = false;
1360 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdatePointerVisible());
1361 }
1362
1363 /**
1364 * @tc.name: InputWindowsManagerTest_IsPointerVisible_001
1365 * @tc.desc: Test IsPointerVisible
1366 * @tc.type: FUNC
1367 * @tc.require:
1368 */
1369 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_IsPointerVisible_001, TestSize.Level1)
1370 {
1371 CALL_TEST_DEBUG;
1372 PointerDrawingManager pointerDrawingManager;
1373 bool ret = pointerDrawingManager.IsPointerVisible();
1374 EXPECT_TRUE(ret);
1375 }
1376
1377 /**
1378 * @tc.name: InputWindowsManagerTest_DeletePointerVisible_001
1379 * @tc.desc: Test DeletePointerVisible
1380 * @tc.type: FUNC
1381 * @tc.require:
1382 */
1383 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DeletePointerVisible_001, TestSize.Level1)
1384 {
1385 CALL_TEST_DEBUG;
1386 PointerDrawingManager pointerDrawingManager;
1387 int32_t pid = 1;
1388 PointerDrawingManager::PidInfo info = { .pid = 1, .visible = true };
1389 pointerDrawingManager.pidInfos_.push_back(info);
1390 info = { .pid = 2, .visible = true };
1391 pointerDrawingManager.pidInfos_.push_back(info);
1392 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DeletePointerVisible(pid));
1393 }
1394
1395 /**
1396 * @tc.name: InputWindowsManagerTest_SetPointerLocation_001
1397 * @tc.desc: Test SetPointerLocation
1398 * @tc.type: FUNC
1399 * @tc.require:
1400 */
1401 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerLocation_001, TestSize.Level1)
1402 {
1403 CALL_TEST_DEBUG;
1404 PointerDrawingManager pointerDrawingManager;
1405 int32_t x = 100;
1406 int32_t y = 100;
1407 int32_t displayId = 0;
1408 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetPointerLocation(x, y, displayId));
1409 }
1410
1411 /**
1412 * @tc.name: InputWindowsManagerTest_UpdateDefaultPointerStyle_001
1413 * @tc.desc: Test UpdateDefaultPointerStyle
1414 * @tc.type: FUNC
1415 * @tc.require:
1416 */
1417 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_UpdateDefaultPointerStyle_001, TestSize.Level1)
1418 {
1419 CALL_TEST_DEBUG;
1420 PointerDrawingManager pointerDrawingManager;
1421 int32_t pid = 1;
1422 int32_t windowId = 1;
1423 PointerStyle pointerStyle;
1424 pointerStyle.id = 0;
1425 pointerStyle.color = 0;
1426 pointerStyle.size = 2;
1427 int32_t ret = pointerDrawingManager.UpdateDefaultPointerStyle(pid, windowId, pointerStyle);
1428 EXPECT_EQ(ret, RET_OK);
1429 windowId = -1;
1430 ret = pointerDrawingManager.UpdateDefaultPointerStyle(pid, windowId, pointerStyle);
1431 EXPECT_EQ(ret, RET_OK);
1432 }
1433
1434 /**
1435 * @tc.name: InputWindowsManagerTest_UpdateIconPath_001
1436 * @tc.desc: Test UpdateIconPath
1437 * @tc.type: FUNC
1438 * @tc.require:
1439 */
1440 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_UpdateIconPath_001, TestSize.Level1)
1441 {
1442 CALL_TEST_DEBUG;
1443 PointerDrawingManager pointerDrawingManager;
1444 MOUSE_ICON mouseStyle = EAST;
1445 std::string iconPath = "test";
1446 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.UpdateIconPath(mouseStyle, iconPath));
1447 }
1448
1449 /**
1450 * @tc.name: InputWindowsManagerTest_SetPointerStylePreference_001
1451 * @tc.desc: Test SetPointerStylePreference
1452 * @tc.type: FUNC
1453 * @tc.require:
1454 */
1455 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerStylePreference_001, TestSize.Level1)
1456 {
1457 CALL_TEST_DEBUG;
1458 PointerDrawingManager pointerDrawingManager;
1459 PointerStyle pointerStyle;
1460 pointerStyle.id = 0;
1461 pointerStyle.color = 0;
1462 pointerStyle.size = 2;
1463 int32_t ret = pointerDrawingManager.SetPointerStylePreference(pointerStyle);
1464 EXPECT_EQ(ret, RET_OK);
1465 }
1466
1467 /**
1468 * @tc.name: InputWindowsManagerTest_CheckPointerStyleParam_001
1469 * @tc.desc: Test CheckPointerStyleParam
1470 * @tc.type: FUNC
1471 * @tc.require:
1472 */
1473 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_CheckPointerStyleParam_001, TestSize.Level1)
1474 {
1475 CALL_TEST_DEBUG;
1476 PointerDrawingManager pointerDrawingManager;
1477 PointerStyle pointerStyle;
1478 pointerStyle.id = EAST;
1479 pointerStyle.color = 0;
1480 pointerStyle.size = 2;
1481 int32_t windowId = -2;
1482 bool ret = pointerDrawingManager.CheckPointerStyleParam(windowId, pointerStyle);
1483 EXPECT_FALSE(ret);
1484 windowId = 1;
1485 ret = pointerDrawingManager.CheckPointerStyleParam(windowId, pointerStyle);
1486 EXPECT_TRUE(ret);
1487 }
1488
1489 /**
1490 * @tc.name: InputWindowsManagerTest_CheckMouseIconPath_001
1491 * @tc.desc: Test CheckMouseIconPath
1492 * @tc.type: FUNC
1493 * @tc.require:
1494 */
1495 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_CheckMouseIconPath_001, TestSize.Level1)
1496 {
1497 CALL_TEST_DEBUG;
1498 PointerDrawingManager pointerDrawingManager;
1499 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.CheckMouseIconPath());
1500 }
1501
1502 /**
1503 * @tc.name: InputWindowsManagerTest_DrawPixelmap_001
1504 * @tc.desc: Test DrawPixelmap
1505 * @tc.type: FUNC
1506 * @tc.require:
1507 */
1508 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPixelmap_001, TestSize.Level1)
1509 {
1510 CALL_TEST_DEBUG;
1511 PointerDrawingManager pointerDrawingManager;
1512 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
1513 OHOS::Rosen::Drawing::Canvas canvas;
1514 MOUSE_ICON mouseStyle = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
1515 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPixelmap(canvas, mouseStyle));
1516 }
1517
1518 /**
1519 * @tc.name: InputWindowsManagerTest_DrawPixelmap_002
1520 * @tc.desc: Test DrawPixelmap
1521 * @tc.type: FUNC
1522 * @tc.require:
1523 */
1524 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPixelmap_002, TestSize.Level1)
1525 {
1526 CALL_TEST_DEBUG;
1527 PointerDrawingManager pointerDrawingManager;
1528 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
1529 OHOS::Rosen::Drawing::Canvas canvas;
1530 MOUSE_ICON mouseStyle = MOUSE_ICON::RUNNING;
1531 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPixelmap(canvas, mouseStyle));
1532 }
1533
1534 /**
1535 * @tc.name: InputWindowsManagerTest_DrawPixelmap_003
1536 * @tc.desc: Test DrawPixelmap
1537 * @tc.type: FUNC
1538 * @tc.require:
1539 */
1540 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPixelmap_003, TestSize.Level1)
1541 {
1542 CALL_TEST_DEBUG;
1543 PointerDrawingManager pointerDrawingManager;
1544 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
1545 OHOS::Rosen::Drawing::Canvas canvas;
1546 MOUSE_ICON mouseStyle = MOUSE_ICON::WEST_EAST;
1547 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPixelmap(canvas, mouseStyle));
1548 }
1549
1550 /**
1551 * @tc.name: InputWindowsManagerTest_SetCustomCursor_001
1552 * @tc.desc: Test SetCustomCursor
1553 * @tc.type: FUNC
1554 * @tc.require:
1555 */
1556 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetCustomCursor_001, TestSize.Level1)
1557 {
1558 CALL_TEST_DEBUG;
1559 PointerDrawingManager pointerDrawingManager;
1560 const std::string iconPath = "/system/etc/multimodalinput/mouse_icon/North_South.svg";
1561 std::unique_ptr<OHOS::Media::PixelMap> pixelMap = SetMouseIconTest(iconPath);
1562 ASSERT_NE(pixelMap, nullptr);
1563 int32_t pid = -1;
1564 int32_t windowId = 1;
1565 int32_t focusX = 2;
1566 int32_t focusY = 3;
1567 int32_t ret = pointerDrawingManager.SetCustomCursor((void *)pixelMap.get(), pid, windowId, focusX, focusY);
1568 ASSERT_EQ(ret, RET_ERR);
1569 }
1570
1571 /**
1572 * @tc.name: InputWindowsManagerTest_SetCustomCursor_002
1573 * @tc.desc: Test SetCustomCursor
1574 * @tc.type: FUNC
1575 * @tc.require:
1576 */
1577 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetCustomCursor_002, TestSize.Level1)
1578 {
1579 CALL_TEST_DEBUG;
1580 PointerDrawingManager pointerDrawingManager;
1581 const std::string iconPath = "/system/etc/multimodalinput/mouse_icon/North_South.svg";
1582 std::unique_ptr<OHOS::Media::PixelMap> pixelMap = SetMouseIconTest(iconPath);
1583 ASSERT_NE(pixelMap, nullptr);
1584 int32_t pid = 1;
1585 int32_t windowId = 1;
1586 int32_t focusX = 2;
1587 int32_t focusY = 3;
1588 int32_t ret = pointerDrawingManager.SetCustomCursor((void *)pixelMap.get(), pid, windowId, focusX, focusY);
1589 ASSERT_EQ(ret, RET_ERR);
1590 }
1591
1592 /**
1593 * @tc.name: InputWindowsManagerTest_SetMouseIcon_002
1594 * @tc.desc: Test SetMouseIcon
1595 * @tc.type: FUNC
1596 * @tc.require:
1597 */
1598 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseIcon_002, TestSize.Level1)
1599 {
1600 CALL_TEST_DEBUG;
1601 PointerDrawingManager pointerDrawingManager;
1602 const std::string iconPath = "/system/etc/multimodalinput/mouse_icon/North_South.svg";
1603 std::unique_ptr<OHOS::Media::PixelMap> pixelMap = SetMouseIconTest(iconPath);
1604 ASSERT_NE(pixelMap, nullptr);
1605 int32_t pid = -1;
1606 int32_t windowId = 2;
1607 int32_t ret = pointerDrawingManager.SetMouseIcon(pid, windowId, (void *)pixelMap.get());
1608 ASSERT_EQ(ret, RET_ERR);
1609 }
1610
1611 /**
1612 * @tc.name: InputWindowsManagerTest_SetMouseIcon_003
1613 * @tc.desc: Test SetMouseIcon
1614 * @tc.type: FUNC
1615 * @tc.require:
1616 */
1617 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseIcon_003, TestSize.Level1)
1618 {
1619 CALL_TEST_DEBUG;
1620 PointerDrawingManager pointerDrawingManager;
1621 const std::string iconPath = "/system/etc/multimodalinput/mouse_icon/North_South.svg";
1622 std::unique_ptr<OHOS::Media::PixelMap> pixelMap = SetMouseIconTest(iconPath);
1623 ASSERT_NE(pixelMap, nullptr);
1624 int32_t pid = 1;
1625 int32_t windowId = -2;
1626 int32_t ret = pointerDrawingManager.SetMouseIcon(pid, windowId, (void *)pixelMap.get());
1627 ASSERT_EQ(ret, RET_ERR);
1628 }
1629
1630 /**
1631 * @tc.name: InputWindowsManagerTest_SetMouseHotSpot_002
1632 * @tc.desc: Test SetMouseHotSpot
1633 * @tc.type: FUNC
1634 * @tc.require:
1635 */
1636 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetMouseHotSpot_002, TestSize.Level1)
1637 {
1638 CALL_TEST_DEBUG;
1639 PointerDrawingManager pointerDrawingManager;
1640 int32_t pid = -1;
1641 int32_t windowId = 2;
1642 int32_t hotSpotX = 3;
1643 int32_t hotSpotY = 4;
1644 int32_t ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
1645 ASSERT_EQ(ret, RET_ERR);
1646 pid = 1;
1647 windowId = -2;
1648 hotSpotX = 3;
1649 hotSpotY = 4;
1650 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
1651 ASSERT_EQ(ret, RET_ERR);
1652 pid = 1;
1653 windowId = 2;
1654 hotSpotX = 3;
1655 hotSpotY = 4;
1656 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
1657 ASSERT_EQ(ret, RET_ERR);
1658 pid = 2;
1659 windowId = 2;
1660 hotSpotX = -3;
1661 hotSpotY = -4;
1662 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
1663 ASSERT_EQ(ret, RET_ERR);
1664 pid = 2;
1665 windowId = 2;
1666 hotSpotX = 3;
1667 hotSpotY = 4;
1668 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
1669 ASSERT_EQ(ret, RET_ERR);
1670 }
1671
1672 /**
1673 * @tc.name: InputWindowsManagerTest_OnDisplayInfo_001
1674 * @tc.desc: Test OnDisplayInfo
1675 * @tc.type: FUNC
1676 * @tc.require:
1677 */
1678 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_OnDisplayInfo_001, TestSize.Level1)
1679 {
1680 CALL_TEST_DEBUG;
1681 PointerDrawingManager pointerDrawingManager;
1682 DisplayInfo displaysInfo;
1683 DisplayGroupInfo displayGroupInfo;
1684 displayGroupInfo.displaysInfo.push_back(displaysInfo);
1685 displayGroupInfo.focusWindowId = 0;
1686 displayGroupInfo.width = 0;
1687 displayGroupInfo.height = 0;
1688 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
1689 surfaceNodeConfig.SurfaceNodeName = "pointer window";
1690 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
1691 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
1692 pointerDrawingManager.surfaceNode_->SetFrameGravity(Rosen::Gravity::RESIZE_ASPECT_FILL);
1693 pointerDrawingManager.surfaceNode_->SetPositionZ(Rosen::RSSurfaceNode::POINTER_WINDOW_POSITION_Z);
1694 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnDisplayInfo(displayGroupInfo));
1695 }
1696
1697 /**
1698 * @tc.name: InputWindowsManagerTest_OnDisplayInfo_002
1699 * @tc.desc: Test OnDisplayInfo
1700 * @tc.type: FUNC
1701 * @tc.require:
1702 */
1703 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_OnDisplayInfo_002, TestSize.Level1)
1704 {
1705 CALL_TEST_DEBUG;
1706 PointerDrawingManager pointerDrawingManager;
1707 DisplayInfo displaysInfo;
1708 DisplayGroupInfo displayGroupInfo;
1709 displayGroupInfo.displaysInfo.push_back(displaysInfo);
1710 displayGroupInfo.focusWindowId = 0;
1711 displayGroupInfo.width = 0;
1712 displayGroupInfo.height = 0;
1713 pointerDrawingManager.surfaceNode_ = nullptr;
1714 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.OnDisplayInfo(displayGroupInfo));
1715 }
1716
1717 /**
1718 * @tc.name: InputWindowsManagerTest_DrawManager_004
1719 * @tc.desc: Test DrawManager
1720 * @tc.type: FUNC
1721 * @tc.require:
1722 */
1723 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawManager_004, TestSize.Level1)
1724 {
1725 CALL_TEST_DEBUG;
1726 PointerDrawingManager pointerDrawingManager;
1727 pointerDrawingManager.hasDisplay_ = false;
1728 pointerDrawingManager.hasPointerDevice_ = true;
1729 pointerDrawingManager.surfaceNode_ = nullptr;
1730 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
1731 }
1732
1733 /**
1734 * @tc.name: InputWindowsManagerTest_DrawPointerStyle_005
1735 * @tc.desc: Test DrawPointerStyle
1736 * @tc.type: FUNC
1737 * @tc.require:
1738 */
1739 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPointerStyle_005, TestSize.Level1)
1740 {
1741 CALL_TEST_DEBUG;
1742 PointerDrawingManager pointerDrawingManager;
1743 PointerStyle pointerStyle;
1744 pointerStyle.id = 0;
1745 pointerStyle.color = 0;
1746 pointerStyle.size = 2;
1747 pointerDrawingManager.hasDisplay_ = false;
1748 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
1749 }
1750
1751 /**
1752 * @tc.name: PointerDrawingManagerTest_ConvertToColorSpace
1753 * @tc.desc: Test ConvertToColorSpace
1754 * @tc.type: FUNC
1755 * @tc.require:
1756 */
1757 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_ConvertToColorSpace, TestSize.Level1)
1758 {
1759 CALL_TEST_DEBUG;
1760 PointerDrawingManager pointerDrawingManager;
1761 Media::ColorSpace colorSpace = Media::ColorSpace::DISPLAY_P3;
1762 EXPECT_NE(pointerDrawingManager.ConvertToColorSpace(colorSpace), nullptr);
1763 colorSpace = Media::ColorSpace::LINEAR_SRGB;
1764 EXPECT_NE(pointerDrawingManager.ConvertToColorSpace(colorSpace), nullptr);
1765 colorSpace = Media::ColorSpace::SRGB;
1766 EXPECT_NE(pointerDrawingManager.ConvertToColorSpace(colorSpace), nullptr);
1767 colorSpace = static_cast<Media::ColorSpace>(5);
1768 EXPECT_NE(pointerDrawingManager.ConvertToColorSpace(colorSpace), nullptr);
1769 }
1770
1771 /**
1772 * @tc.name: PointerDrawingManagerTest_PixelFormatToColorType
1773 * @tc.desc: Test PixelFormatToColorType
1774 * @tc.type: FUNC
1775 * @tc.require:
1776 */
1777 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_PixelFormatToColorType, TestSize.Level1)
1778 {
1779 CALL_TEST_DEBUG;
1780 PointerDrawingManager pointerDrawingManager;
1781 Media::PixelFormat pixelFmt = Media::PixelFormat::RGB_565;
1782 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1783 Rosen::Drawing::ColorType::COLORTYPE_RGB_565);
1784 pixelFmt = Media::PixelFormat::RGBA_8888;
1785 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1786 Rosen::Drawing::ColorType::COLORTYPE_RGBA_8888);
1787 pixelFmt = Media::PixelFormat::BGRA_8888;
1788 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1789 Rosen::Drawing::ColorType::COLORTYPE_BGRA_8888);
1790 pixelFmt = Media::PixelFormat::ALPHA_8;
1791 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1792 Rosen::Drawing::ColorType::COLORTYPE_ALPHA_8);
1793 pixelFmt = Media::PixelFormat::RGBA_F16;
1794 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1795 Rosen::Drawing::ColorType::COLORTYPE_RGBA_F16);
1796 pixelFmt = Media::PixelFormat::UNKNOWN;
1797 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1798 Rosen::Drawing::ColorType::COLORTYPE_UNKNOWN);
1799 pixelFmt = Media::PixelFormat::ARGB_8888;
1800 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1801 Rosen::Drawing::ColorType::COLORTYPE_UNKNOWN);
1802 pixelFmt = Media::PixelFormat::RGB_888;
1803 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1804 Rosen::Drawing::ColorType::COLORTYPE_UNKNOWN);
1805 pixelFmt = Media::PixelFormat::NV21;
1806 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1807 Rosen::Drawing::ColorType::COLORTYPE_UNKNOWN);
1808 pixelFmt = Media::PixelFormat::NV12;
1809 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1810 Rosen::Drawing::ColorType::COLORTYPE_UNKNOWN);
1811 pixelFmt = Media::PixelFormat::CMYK;
1812 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1813 Rosen::Drawing::ColorType::COLORTYPE_UNKNOWN);
1814 pixelFmt = static_cast<Media::PixelFormat>(100);
1815 EXPECT_EQ(pointerDrawingManager.PixelFormatToColorType(pixelFmt),
1816 Rosen::Drawing::ColorType::COLORTYPE_UNKNOWN);
1817 }
1818
1819 /**
1820 * @tc.name: PointerDrawingManagerTest__AlphaTypeToAlphaType
1821 * @tc.desc: Test AlphaTypeToAlphaType
1822 * @tc.type: Function
1823 * @tc.require:
1824 */
1825 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_AlphaTypeToAlphaType, TestSize.Level1)
1826 {
1827 CALL_TEST_DEBUG;
1828 PointerDrawingManager pointerDrawingManager;
1829 Media::AlphaType alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_UNKNOWN;
1830 EXPECT_EQ(pointerDrawingManager.AlphaTypeToAlphaType(alphaType),
1831 Rosen::Drawing::AlphaType::ALPHATYPE_UNKNOWN);
1832 alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1833 EXPECT_EQ(pointerDrawingManager.AlphaTypeToAlphaType(alphaType),
1834 Rosen::Drawing::AlphaType::ALPHATYPE_OPAQUE);
1835 alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
1836 EXPECT_EQ(pointerDrawingManager.AlphaTypeToAlphaType(alphaType),
1837 Rosen::Drawing::AlphaType::ALPHATYPE_PREMUL);
1838 alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_UNPREMUL;
1839 EXPECT_EQ(pointerDrawingManager.AlphaTypeToAlphaType(alphaType),
1840 Rosen::Drawing::AlphaType::ALPHATYPE_UNPREMUL);
1841 alphaType = static_cast<Media::AlphaType>(5);
1842 EXPECT_EQ(pointerDrawingManager.AlphaTypeToAlphaType(alphaType),
1843 Rosen::Drawing::AlphaType::ALPHATYPE_UNKNOWN);
1844 }
1845
1846 /**
1847 * @tc.name: PointerDrawingManagerTest_ExtractDrawingImage_003
1848 * @tc.desc: Test ExtractDrawingImage
1849 * @tc.type: FUNC
1850 * @tc.require:
1851 */
1852 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_ExtractDrawingImage_003, TestSize.Level1)
1853 {
1854 CALL_TEST_DEBUG;
1855 OHOS::Rosen::Drawing::Bitmap bitmap;
1856 OHOS::Rosen::Drawing::BitmapFormat format { OHOS::Rosen::Drawing::COLORTYPE_RGBA_8888,
1857 OHOS::Rosen::Drawing::ALPHATYPE_OPAQUE };
1858 PointerDrawingManager pointerDrawingManager;
1859 bitmap.Build(64, 64, format);
1860 OHOS::Rosen::Drawing::Canvas canvas(256, 256);
1861 canvas.Bind(bitmap);
1862 canvas.Clear(OHOS::Rosen::Drawing::Color::COLOR_TRANSPARENT);
1863 MOUSE_ICON mouseStyle = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
1864 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawImage(canvas, mouseStyle));
1865 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.SetPointerLocation(200, 200, 0));
1866 }
1867
1868 /**
1869 * @tc.name: InputWindowsManagerTest_DrawPointer_001
1870 * @tc.desc: Test DrawPointer
1871 * @tc.type: FUNC
1872 * @tc.require:
1873 */
1874 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPointer_001, TestSize.Level1)
1875 {
1876 CALL_TEST_DEBUG;
1877 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1878 PointerStyle pointerStyle;
1879 pointerStyle.id = 0;
1880 pointerDrawingManager->DrawPointer(1, 100, 100, pointerStyle, DIRECTION180);
1881 EXPECT_EQ(pointerDrawingManager->lastDirection_, DIRECTION180);
1882 pointerDrawingManager->DrawPointer(1, 200, 200, pointerStyle, DIRECTION270);
1883 EXPECT_EQ(pointerDrawingManager->lastDirection_, DIRECTION270);
1884 }
1885
1886 /**
1887 * @tc.name: InputWindowsManagerTest_DrawPointerStyle_001
1888 * @tc.desc: Test DrawPointerStyle
1889 * @tc.type: FUNC
1890 * @tc.require:
1891 */
1892 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawPointerStyle_001, TestSize.Level1)
1893 {
1894 CALL_TEST_DEBUG;
1895 PointerDrawingManager pointerDrawingManager;
1896 PointerStyle pointerStyle;
1897 pointerStyle.id = EAST;
1898 pointerStyle.color = 0;
1899 pointerStyle.size = 2;
1900 pointerDrawingManager.hasDisplay_ = true;
1901 pointerDrawingManager.hasPointerDevice_ = true;
1902 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
1903 pointerDrawingManager.lastPhysicalX_ = -1;
1904 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawPointerStyle(pointerStyle));
1905 }
1906 /**
1907 * @tc.name: InputWindowsManagerTest_InitPointerCallback_001
1908 * @tc.desc: Test InitPointerCallback
1909 * @tc.type: FUNC
1910 * @tc.require:
1911 */
1912 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_InitPointerCallback_001, TestSize.Level1)
1913 {
1914 CALL_TEST_DEBUG;
1915 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1916 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager->InitPointerCallback());
1917 }
1918
1919 /**
1920 * @tc.name: InputWindowsManagerTest_InitPointerObserver_001
1921 * @tc.desc: Test InitPointerObserver
1922 * @tc.type: FUNC
1923 * @tc.require:
1924 */
1925 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_InitPointerObserver_001, TestSize.Level1)
1926 {
1927 CALL_TEST_DEBUG;
1928 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
1929 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager->InitPointerObserver());
1930 }
1931
1932 #ifdef OHOS_BUILD_ENABLE_MAGICCURSOR
1933 /**
1934 * @tc.name: InputWindowsManagerTest_SetPixelMap
1935 * @tc.desc: Test SetPixelMap
1936 * @tc.type: FUNC
1937 * @tc.require:
1938 */
1939 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPixelMap, TestSize.Level1)
1940 {
1941 CALL_TEST_DEBUG;
1942 PointerDrawingManager manager;
1943 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = CreatePixelMap(MIDDLE_PIXEL_MAP_WIDTH, MIDDLE_PIXEL_MAP_HEIGHT);
1944 ASSERT_NO_FATAL_FAILURE(manager.SetPixelMap(pixelMap));
1945 }
1946 #endif // OHOS_BUILD_ENABLE_MAGICCURSOR
1947
1948 /**
1949 * @tc.name: PointerDrawingManagerTest_SwitchPointerStyle
1950 * @tc.desc: Test SwitchPointerStyle
1951 * @tc.type: FUNC
1952 * @tc.require:
1953 */
1954 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_SwitchPointerStyle, TestSize.Level1)
1955 {
1956 CALL_TEST_DEBUG;
1957 PointerDrawingManager pointerDrawMgr;
1958 pointerDrawMgr.lastMouseStyle_.id = 2;
1959 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.SwitchPointerStyle());
1960 }
1961
1962 /**
1963 * @tc.name: PointerDrawingManagerTest_CreateMagicCursorChangeObserver
1964 * @tc.desc: Test CreateMagicCursorChangeObserver
1965 * @tc.type: FUNC
1966 * @tc.require:
1967 */
1968 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_CreateMagicCursorChangeObserver, TestSize.Level1)
1969 {
1970 CALL_TEST_DEBUG;
1971 PointerDrawingManager pointerDrawMgr;
1972 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.CreateMagicCursorChangeObserver());
1973 }
1974
1975 /**
1976 * @tc.name: PointerDrawingManagerTest_UpdateStyleOptions
1977 * @tc.desc: Test UpdateStyleOptions
1978 * @tc.type: FUNC
1979 * @tc.require:
1980 */
1981 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_UpdateStyleOptions, TestSize.Level1)
1982 {
1983 CALL_TEST_DEBUG;
1984 PointerDrawingManager pointerDrawMgr;
1985 pointerDrawMgr.pid_ = 100;
1986 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.UpdateStyleOptions());
1987 }
1988
1989 /**
1990 * @tc.name: PointerDrawingManagerTest_InitPointerObserver
1991 * @tc.desc: Test InitPointerObserver
1992 * @tc.type: FUNC
1993 * @tc.require:
1994 */
1995 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_InitPointerObserver, TestSize.Level1)
1996 {
1997 CALL_TEST_DEBUG;
1998 PointerDrawingManager pointerDrawMgr;
1999 pointerDrawMgr.hasInitObserver_ = true;
2000 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.InitPointerObserver());
2001
2002 pointerDrawMgr.hasInitObserver_ = false;
2003 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.InitPointerObserver());
2004 }
2005
2006 /**
2007 * @tc.name: PointerDrawingManagerTest_AdjustMouseFocusByDirection90
2008 * @tc.desc: Test AdjustMouseFocusByDirection90
2009 * @tc.type: FUNC
2010 * @tc.require:
2011 */
2012 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_AdjustMouseFocusByDirection90, TestSize.Level1)
2013 {
2014 CALL_TEST_DEBUG;
2015 PointerDrawingManager pointerDrawMgr;
2016 ICON_TYPE iconType = ANGLE_SW;
2017 int32_t physicalX = 500;
2018 int32_t physicalY = 500;
2019 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.AdjustMouseFocusByDirection90(iconType, physicalX, physicalY));
2020 iconType = ANGLE_CENTER;
2021 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.AdjustMouseFocusByDirection90(iconType, physicalX, physicalY));
2022 iconType = ANGLE_NW_RIGHT;
2023 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.AdjustMouseFocusByDirection90(iconType, physicalX, physicalY));
2024 iconType = ANGLE_NW;
2025 pointerDrawMgr.userIcon_ = CreatePixelMap(MIDDLE_PIXEL_MAP_WIDTH, MIDDLE_PIXEL_MAP_HEIGHT);
2026 ASSERT_NE(pointerDrawMgr.userIcon_, nullptr);
2027 pointerDrawMgr.currentMouseStyle_.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
2028 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.AdjustMouseFocusByDirection90(iconType, physicalX, physicalY));
2029 pointerDrawMgr.userIcon_ = nullptr;
2030 ASSERT_NO_FATAL_FAILURE(pointerDrawMgr.AdjustMouseFocusByDirection90(iconType, physicalX, physicalY));
2031 }
2032
2033 /**
2034 * @tc.name: InputWindowsManagerTest_UpdatePointerDevice_003
2035 * @tc.desc: Test UpdatePointerDevice
2036 * @tc.type: FUNC
2037 * @tc.require:
2038 */
2039 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_UpdatePointerDevice_003, TestSize.Level1)
2040 {
2041 CALL_TEST_DEBUG;
2042 auto* pointerDrawingManager = static_cast<PointerDrawingManager*>(IPointerDrawingManager::GetInstance());
2043 EXPECT_EQ(pointerDrawingManager->pidInfos_.size(), 100);
2044 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager->UpdatePointerDevice(true, false, true));
2045 pointerDrawingManager->UpdatePointerDevice(true, true, true);
2046 EXPECT_EQ(pointerDrawingManager->pidInfos_.size(), 100);
2047 pointerDrawingManager->surfaceNode_ = nullptr;
2048 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager->UpdatePointerDevice(false, false, true));
2049 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
2050 surfaceNodeConfig.SurfaceNodeName = "pointer window";
2051 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
2052 pointerDrawingManager->surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
2053 ASSERT_TRUE(pointerDrawingManager->surfaceNode_ != nullptr);
2054 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager->UpdatePointerDevice(false, false, true));
2055 }
2056
2057 /**
2058 * @tc.name: InputWindowsManagerTest_DrawManager_001
2059 * @tc.desc: Test DrawManager
2060 * @tc.type: FUNC
2061 * @tc.require:
2062 */
2063 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawManager_001, TestSize.Level1)
2064 {
2065 CALL_TEST_DEBUG;
2066 PointerDrawingManager pointerDrawingManager;
2067 pointerDrawingManager.hasDisplay_ = false;
2068 pointerDrawingManager.hasPointerDevice_ = true;
2069 pointerDrawingManager.surfaceNode_ = nullptr;
2070 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2071 pointerDrawingManager.hasDisplay_ = true;
2072 pointerDrawingManager.hasPointerDevice_ = false;
2073 pointerDrawingManager.surfaceNode_ = nullptr;
2074 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2075 pointerDrawingManager.hasDisplay_ = false;
2076 pointerDrawingManager.hasPointerDevice_ = false;
2077 pointerDrawingManager.surfaceNode_ = nullptr;
2078 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2079 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
2080 surfaceNodeConfig.SurfaceNodeName = "pointer window";
2081 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
2082 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
2083 ASSERT_TRUE(pointerDrawingManager.surfaceNode_ != nullptr);
2084 pointerDrawingManager.hasDisplay_ = true;
2085 pointerDrawingManager.hasPointerDevice_ = true;
2086 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2087 pointerDrawingManager.hasDisplay_ = false;
2088 pointerDrawingManager.hasPointerDevice_ = true;
2089 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2090 pointerDrawingManager.hasDisplay_ = true;
2091 pointerDrawingManager.hasPointerDevice_ = false;
2092 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2093 pointerDrawingManager.hasDisplay_ = false;
2094 pointerDrawingManager.hasPointerDevice_ = false;
2095 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2096 pointerDrawingManager.hasDisplay_ = true;
2097 pointerDrawingManager.hasPointerDevice_ = true;
2098 pointerDrawingManager.surfaceNode_ = nullptr;
2099 pointerDrawingManager.lastPhysicalX_ = -1;
2100 pointerDrawingManager.lastPhysicalY_ = 1;
2101 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2102 pointerDrawingManager.lastPhysicalX_ = 1;
2103 pointerDrawingManager.lastPhysicalY_ = -1;
2104 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2105 pointerDrawingManager.lastPhysicalX_ = -1;
2106 pointerDrawingManager.lastPhysicalY_ = -1;
2107 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2108 pointerDrawingManager.lastPhysicalX_ = 1;
2109 pointerDrawingManager.lastPhysicalY_ = 1;
2110 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawManager());
2111 }
2112
2113 /**
2114 * @tc.name: InputWindowsManagerTest_DeletePointerVisible_002
2115 * @tc.desc: Test DeletePointerVisible
2116 * @tc.type: FUNC
2117 * @tc.require:
2118 */
2119 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DeletePointerVisible_002, TestSize.Level1)
2120 {
2121 CALL_TEST_DEBUG;
2122 PointerDrawingManager pointerDrawingManager;
2123 int32_t pid = 1;
2124 pointerDrawingManager.surfaceNode_ = nullptr;
2125 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DeletePointerVisible(pid));
2126 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
2127 surfaceNodeConfig.SurfaceNodeName = "pointer window";
2128 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
2129 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
2130 ASSERT_TRUE(pointerDrawingManager.surfaceNode_ != nullptr);
2131 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DeletePointerVisible(pid));
2132 }
2133
2134 /**
2135 * @tc.name: InputWindowsManagerTest_DeletePointerVisible_003
2136 * @tc.desc: Test DeletePointerVisible
2137 * @tc.type: FUNC
2138 * @tc.require:
2139 */
2140 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DeletePointerVisible_003, TestSize.Level1)
2141 {
2142 CALL_TEST_DEBUG;
2143 PointerDrawingManager pointerDrawingManager;
2144 int32_t pid = 1;
2145 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DeletePointerVisible(pid));
2146 PointerDrawingManager::PidInfo info = { .pid = 1, .visible = true };
2147 pointerDrawingManager.pidInfos_.push_back(info);
2148 info = { .pid = 2, .visible = true };
2149 pointerDrawingManager.pidInfos_.push_back(info);
2150 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DeletePointerVisible(pid));
2151 pid = 5;
2152 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DeletePointerVisible(pid));
2153 }
2154
2155 /**
2156 * @tc.name: InputWindowsManagerTest_UpdateDefaultPointerStyle_003
2157 * @tc.desc: Test UpdateDefaultPointerStyle
2158 * @tc.type: FUNC
2159 * @tc.require:
2160 */
2161 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_UpdateDefaultPointerStyle_003, TestSize.Level1)
2162 {
2163 CALL_TEST_DEBUG;
2164 PointerDrawingManager pointerDrawingManager;
2165 int32_t pid = 1;
2166 int32_t windowId = 2;
2167 PointerStyle pointerStyle;
2168 pointerStyle.id = 0;
2169 pointerStyle.color = 0;
2170 pointerStyle.size = 2;
2171 bool isUiExtension = true;
2172 int32_t ret = pointerDrawingManager.UpdateDefaultPointerStyle(pid, windowId, pointerStyle, isUiExtension);
2173 EXPECT_EQ(ret, RET_OK);
2174 windowId = -1;
2175 ret = pointerDrawingManager.UpdateDefaultPointerStyle(pid, windowId, pointerStyle, isUiExtension);
2176 }
2177
2178 /**
2179 * @tc.name: PointerDrawingManagerTest_DrawScreenCenterPointer_001
2180 * @tc.desc: Test DrawScreenCenterPointer
2181 * @tc.type: FUNC
2182 * @tc.require:
2183 */
2184 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_DrawScreenCenterPointer_001, TestSize.Level1)
2185 {
2186 CALL_TEST_DEBUG;
2187 PointerDrawingManager pointerDrawingManager;
2188 PointerStyle pointerStyle;
2189 pointerStyle.id = 0;
2190 pointerStyle.color = 0;
2191 pointerStyle.size = 2;
2192 pointerDrawingManager.hasDisplay_ = true;
2193 pointerDrawingManager.hasPointerDevice_ = true;
2194 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
2195 surfaceNodeConfig.SurfaceNodeName = "pointer window";
2196 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
2197 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
2198 ASSERT_TRUE(pointerDrawingManager.surfaceNode_ != nullptr);
2199
2200 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawScreenCenterPointer(pointerStyle));
2201 }
2202
2203 /**
2204 * @tc.name: PointerDrawingManagerTest_DrawScreenCenterPointer_002
2205 * @tc.desc: Test DrawScreenCenterPointer
2206 * @tc.type: FUNC
2207 * @tc.require:
2208 */
2209 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_DrawScreenCenterPointer_002, TestSize.Level1)
2210 {
2211 CALL_TEST_DEBUG;
2212 PointerDrawingManager pointerDrawingManager;
2213 PointerStyle pointerStyle;
2214 pointerStyle.id = 0;
2215 pointerStyle.color = 0;
2216 pointerStyle.size = 2;
2217 pointerDrawingManager.hasDisplay_ = false;
2218 pointerDrawingManager.hasPointerDevice_ = true;
2219 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
2220 surfaceNodeConfig.SurfaceNodeName = "pointer window";
2221 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
2222 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
2223 ASSERT_TRUE(pointerDrawingManager.surfaceNode_ != nullptr);
2224
2225 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawScreenCenterPointer(pointerStyle));
2226 }
2227
2228 #ifdef OHOS_BUILD_ENABLE_HARDWARE_CURSOR
2229 /**
2230 * @tc.name: PointerDrawingManagerTest_UpdateBindDisplayId_001
2231 * @tc.desc: Test UpdateBindDisplayId
2232 * @tc.type: FUNC
2233 * @tc.require:
2234 */
2235 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_UpdateBindDisplayId_001, TestSize.Level1)
2236 {
2237 CALL_TEST_DEBUG;
2238 PointerDrawingManager pointerDrawingManager;
2239 pointerDrawingManager.lastDisplayId_ = 0;
2240 int32_t displayId = 0;
2241 pointerDrawingManager.UpdateBindDisplayId(displayId);
2242 EXPECT_EQ(pointerDrawingManager.lastDisplayId_, 0);
2243 EXPECT_EQ(pointerDrawingManager.screenId_, 0);
2244
2245 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
2246 surfaceNodeConfig.SurfaceNodeName = "pointer window";
2247 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
2248 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
2249 ASSERT_TRUE(pointerDrawingManager.surfaceNode_ != nullptr);
2250 pointerDrawingManager.UpdateBindDisplayId(displayId);
2251 EXPECT_EQ(pointerDrawingManager.lastDisplayId_, 0);
2252 EXPECT_EQ(pointerDrawingManager.screenId_, 0);
2253
2254 displayId = 1;
2255 pointerDrawingManager.UpdateBindDisplayId(displayId);
2256 EXPECT_EQ(pointerDrawingManager.lastDisplayId_, 1);
2257 EXPECT_EQ(pointerDrawingManager.screenId_, 1);
2258 }
2259 #endif // OHOS_BUILD_ENABLE_HARDWARE_CURSOR
2260
2261 /**
2262 * @tc.name: PointerDrawingManagerTest_DestroyPointerWindow_001
2263 * @tc.desc: Test DestroyPointerWindow
2264 * @tc.type: FUNC
2265 * @tc.require:
2266 */
2267 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_DestroyPointerWindow_001, TestSize.Level1)
2268 {
2269 CALL_TEST_DEBUG;
2270 PointerDrawingManager pointerDrawingManager;
2271 pointerDrawingManager.delegateProxy_ = std::make_shared<DelegateInterface>(nullptr, nullptr);
2272 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
2273 surfaceNodeConfig.SurfaceNodeName = "pointer window";
2274 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
2275 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
2276 ASSERT_NE(pointerDrawingManager.delegateProxy_, nullptr);
2277 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DestroyPointerWindow());
2278 pointerDrawingManager.surfaceNode_ = nullptr;
2279 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DestroyPointerWindow());
2280 }
2281
2282 /**
2283 * @tc.name: PointerDrawingManagerTest_SetMouseHotSpot_004
2284 * @tc.desc: Test SetMouseHotSpot
2285 * @tc.type: FUNC
2286 * @tc.require:
2287 */
2288 HWTEST_F(PointerDrawingManagerTest, PointerDrawingManagerTest_SetMouseHotSpot_004, TestSize.Level1)
2289 {
2290 CALL_TEST_DEBUG;
2291 PointerDrawingManager pointerDrawingManager;
2292 auto winmgrmock = std::make_shared<InputWindowsManagerMock>();
2293 int32_t pid = 1;
2294 int32_t windowId = 2;
2295 EXPECT_CALL(*winmgrmock, CheckWindowIdPermissionByPid).WillRepeatedly(testing::Return(RET_OK));
2296 int32_t hotSpotX = 1;
2297 int32_t hotSpotY = 2;
2298 // userIcon_ == nullptr
2299 int32_t ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
2300 ASSERT_EQ(ret, RET_ERR);
2301 pointerDrawingManager.userIcon_ = std::make_unique<OHOS::Media::PixelMap>();
2302 // hotSpotX < 0
2303 hotSpotX = -1;
2304 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
2305 ASSERT_EQ(ret, RET_ERR);
2306 // hotSpotY < 0
2307 hotSpotX = 1;
2308 hotSpotY = -2;
2309 ret = pointerDrawingManager.SetMouseHotSpot(pid, windowId, hotSpotX, hotSpotY);
2310 ASSERT_EQ(ret, RET_ERR);
2311 testing::Mock::AllowLeak(winmgrmock.get());
2312 }
2313
2314 /**
2315 * @tc.name: InputWindowsManagerTest_IsPointerVisible_002
2316 * @tc.desc: Test IsPointerVisible
2317 * @tc.type: FUNC
2318 * @tc.require:
2319 */
2320 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_IsPointerVisible_002, TestSize.Level1)
2321 {
2322 CALL_TEST_DEBUG;
2323 PointerDrawingManager pointerDrawingManager;
2324 pointerDrawingManager.pidInfos_.clear();
2325 pointerDrawingManager.pid_ = 0;
2326 PointerDrawingManager::PidInfo pidInfo;
2327 for (int32_t i = 1; i < 3; i++) {
2328 pidInfo.pid = 3-i;
2329 pidInfo.visible = false;
2330 pointerDrawingManager.hapPidInfos_.push_back(pidInfo);
2331 }
2332 bool ret = pointerDrawingManager.IsPointerVisible();
2333 EXPECT_FALSE(ret);
2334 pointerDrawingManager.pid_ = 1;
2335 ret = pointerDrawingManager.IsPointerVisible();
2336 EXPECT_FALSE(ret);
2337 }
2338
2339 /**
2340 * @tc.name: InputWindowsManagerTest_SetPointerVisible_003
2341 * @tc.desc: Test SetPointerVisible
2342 * @tc.type: FUNC
2343 * @tc.require:
2344 */
2345 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerVisible_003, TestSize.Level1)
2346 {
2347 CALL_TEST_DEBUG;
2348 PointerDrawingManager pointerDrawingManager;
2349 int32_t pid = 102;
2350 int32_t priority = 1;
2351 bool visible = false;
2352 bool isHap = true;
2353 PointerDrawingManager::PidInfo pidInfo;
2354 for (int32_t i = 1; i < 101; i++) {
2355 pidInfo.pid = 3-i;
2356 pidInfo.visible = false;
2357 pointerDrawingManager.hapPidInfos_.push_back(pidInfo);
2358 }
2359 int32_t ret = pointerDrawingManager.SetPointerVisible(pid, visible, priority, isHap);
2360 ASSERT_EQ(ret, RET_OK);
2361 pid = 103;
2362 ret = pointerDrawingManager.SetPointerVisible(pid, visible, priority, isHap);
2363 ASSERT_EQ(ret, RET_OK);
2364 pid = 10;
2365 ret = pointerDrawingManager.SetPointerVisible(pid, visible, priority, isHap);
2366 ASSERT_EQ(ret, RET_OK);
2367 }
2368
2369 /**
2370 * @tc.name: InputWindowsManagerTest_DrawMovePointer_002
2371 * @tc.desc: Test the funcation DrawMovePointer
2372 * @tc.type: FUNC
2373 * @tc.require:
2374 */
2375 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_DrawMovePointer_002, TestSize.Level1)
2376 {
2377 CALL_TEST_DEBUG;
2378 PointerDrawingManager pointerDrawingManager;
2379 int32_t physicalX = 1;
2380 int32_t physicalY = 2;
2381 int32_t displayId = 3;
2382 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawMovePointer(displayId, physicalX, physicalY));
2383 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
2384 surfaceNodeConfig.SurfaceNodeName = "pointer window";
2385 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
2386 pointerDrawingManager.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
2387 ASSERT_NO_FATAL_FAILURE(pointerDrawingManager.DrawMovePointer(displayId, physicalX, physicalY));
2388 }
2389
2390 /**
2391 * @tc.name: InputWindowsManagerTest_SetPointerStyle_002
2392 * @tc.desc: Test SetPointerStyle
2393 * @tc.type: FUNC
2394 * @tc.require:
2395 */
2396 HWTEST_F(PointerDrawingManagerTest, InputWindowsManagerTest_SetPointerStyle_002, TestSize.Level1)
2397 {
2398 CALL_TEST_DEBUG;
2399 PointerDrawingManager pointerDrawingManager;
2400 PointerStyle pointerStyle;
2401 int32_t pid = 1;
2402 int32_t windowId = -2;
2403 int32_t ret = pointerDrawingManager.SetPointerStyle(pid, windowId, pointerStyle);
2404 ASSERT_EQ(ret, RET_ERR);
2405 windowId = -1;
2406 pointerStyle.id = MOUSE_ICON::DEVELOPER_DEFINED_ICON;
2407 ret = pointerDrawingManager.SetPointerStyle(pid, windowId, pointerStyle);
2408 ASSERT_EQ(ret, RET_OK);
2409 windowId = 1;
2410 ret = pointerDrawingManager.SetPointerStyle(pid, windowId, pointerStyle);
2411 ASSERT_EQ(ret, RET_ERR);
2412 IconStyle iconStyle;
2413 iconStyle.alignmentWay = 0;
2414 iconStyle.iconPath = "testpath";
2415 pointerDrawingManager.mouseIcons_.insert(std::make_pair(static_cast<MOUSE_ICON>(pointerStyle.id), iconStyle));
2416 ret = pointerDrawingManager.SetPointerStyle(pid, windowId, pointerStyle);
2417 ASSERT_EQ(ret, RET_ERR);
2418 }
2419 } // namespace MMI
2420 } // namespace OHOS
