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 <gtest/gtest.h>
17
18 #include "image_source.h"
19 #include "image_type.h"
20 #include "image_utils.h"
21
22 #include "mmi_log.h"
23 #include "pointer_event.h"
24 #include "knuckle_dynamic_drawing_manager.h"
25
26 #undef MMI_LOG_TAG
27 #define MMI_LOG_TAG "KnuckleDynamicDrawingManagerTest"
28
29 namespace OHOS {
30 namespace MMI {
31 namespace {
32 using namespace testing::ext;
33 constexpr int32_t POINT_SYSTEM_SIZE = 50;
34 constexpr int32_t MAX_DIVERGENCE_NUM = 10;
35 constexpr int32_t MAX_POINTER_COLOR = 0xff00ff;
36 constexpr std::string_view SCREEN_READ_ENABLE { "1" };
37 } // namespace
38
39 class KnuckleDynamicDrawingManagerTest : public testing::Test {
40 public:
SetUpTestCase(void)41 static void SetUpTestCase(void) {};
TearDownTestCase(void)42 static void TearDownTestCase(void) {};
SetUp(void)43 void SetUp(void)
44 {
45 OLD::DisplayInfo displayInfo = { .id = 1, .x = 1, .y = 1, .width = 1, .height = 1,
46 .dpi = 240, .name = "display", .uniq = "xx" };
47 if (knuckleDynamicDrawingMgr == nullptr) {
48 knuckleDynamicDrawingMgr = std::make_shared<KnuckleDynamicDrawingManager>();
49 }
50 knuckleDynamicDrawingMgr->UpdateDisplayInfo(displayInfo);
51 }
52
53 std::shared_ptr<Media::PixelMap> DecodeImageToPixelMap(const std::string &imagePath);
54 private:
55 std::shared_ptr<KnuckleDynamicDrawingManager> knuckleDynamicDrawingMgr { nullptr };
56 };
57
DecodeImageToPixelMap(const std::string & imagePath)58 std::shared_ptr<Media::PixelMap> KnuckleDynamicDrawingManagerTest::DecodeImageToPixelMap(const std::string &imagePath)
59 {
60 CALL_DEBUG_ENTER;
61 OHOS::Media::SourceOptions opts;
62 uint32_t ret = 0;
63 auto imageSource = OHOS::Media::ImageSource::CreateImageSource(imagePath, opts, ret);
64 CHKPP(imageSource);
65 std::set<std::string> formats;
66 ret = imageSource->GetSupportedFormats(formats);
67 OHOS::Media::DecodeOptions decodeOpts;
68 decodeOpts.desiredSize = {
69 .width = 80,
70 .height = 80
71 };
72
73 decodeOpts.SVGOpts.fillColor = {.isValidColor = false, .color = MAX_POINTER_COLOR};
74 decodeOpts.SVGOpts.strokeColor = {.isValidColor = false, .color = MAX_POINTER_COLOR};
75
76 std::shared_ptr<OHOS::Media::PixelMap> pixelMap = imageSource->CreatePixelMap(decodeOpts, ret);
77 if (pixelMap == nullptr) {
78 MMI_HILOGE("The pixelMap is nullptr");
79 }
80 return pixelMap;
81 }
82
83 /**
84 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_Normal
85 * @tc.desc: Test Normal branch of covering KnuckleDynamicDrawHandler function
86 * @tc.type: Function
87 * @tc.require:
88 */
89 HWTEST_F(KnuckleDynamicDrawingManagerTest,
90 KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_Normal, TestSize.Level1)
91 {
92 CALL_TEST_DEBUG;
93 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
94 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
95 ASSERT_NE(pointerEvent, nullptr);
96 PointerEvent::PointerItem item;
97 item.SetPointerId(1);
98 item.SetToolType(PointerEvent::TOOL_TYPE_MOUSE);
99 pointerEvent->SetPointerId(1);
100 pointerEvent->AddPointerItem(item);
101 knuckleDynamicDrawMgr.KnuckleDynamicDrawHandler(pointerEvent);
102 EXPECT_FALSE(knuckleDynamicDrawMgr.isStop_);
103 }
104
105 /**
106 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_Abnormal
107 * @tc.desc: Test Abnormal branch of covering KnuckleDynamicDrawHandler function
108 * @tc.type: Function
109 * @tc.require:
110 */
111 HWTEST_F(KnuckleDynamicDrawingManagerTest,
112 KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_Abnormal, TestSize.Level1)
113 {
114 CALL_TEST_DEBUG;
115 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
116 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
117 ASSERT_NE(pointerEvent, nullptr);
118 PointerEvent::PointerItem item;
119 item.SetPointerId(1);
120 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
121 pointerEvent->SetPointerId(1);
122 pointerEvent->AddPointerItem(item);
123 pointerEvent->SetTargetDisplayId(50);
124 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_DOWN);
125 knuckleDynamicDrawMgr.KnuckleDynamicDrawHandler(pointerEvent);
126 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_SWIPE_END);
127 knuckleDynamicDrawMgr.KnuckleDynamicDrawHandler(pointerEvent);
128 EXPECT_TRUE(knuckleDynamicDrawMgr.isDrawing_);
129 }
130
131 /**
132 * @tc.name: KnuckleDynamicDrawingManagerTest_InitPointerPathPaint
133 * @tc.desc: Test Overrides InitPointerPathPaint function branches
134 * @tc.type: Function
135 * @tc.require:
136 */
137 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_InitPointerPathPaint, TestSize.Level1)
138 {
139 CALL_TEST_DEBUG;
140 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
141 knuckleDynamicDrawMgr.glowTraceSystem_ = nullptr;
142 knuckleDynamicDrawMgr.InitPointerPathPaint();
143 std::string imagePath = "/system/etc/multimodalinput/mouse_icon/Default.svg";
144 auto pixelMap = DecodeImageToPixelMap(imagePath);
145 ASSERT_NE(pixelMap, nullptr);
146 knuckleDynamicDrawMgr.glowTraceSystem_ =
147 std::make_shared<KnuckleGlowTraceSystem>(POINT_SYSTEM_SIZE, pixelMap, MAX_DIVERGENCE_NUM);
148 knuckleDynamicDrawMgr.InitPointerPathPaint();
149 }
150
151 /**
152 * @tc.name: KnuckleDynamicDrawingManagerTest_IsSingleKnuckle
153 * @tc.desc: Test Overrides IsSingleKnuckle function branches
154 * @tc.type: Function
155 * @tc.require:
156 */
157 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_IsSingleKnuckle, TestSize.Level1)
158 {
159 CALL_TEST_DEBUG;
160 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
161 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
162 ASSERT_NE(pointerEvent, nullptr);
163 PointerEvent::PointerItem item;
164 item.SetPointerId(1);
165 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
166 pointerEvent->SetPointerId(1);
167 pointerEvent->AddPointerItem(item);
168 ASSERT_TRUE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
169
170 item.SetPointerId(2);
171 item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD);
172 pointerEvent->SetPointerId(2);
173 pointerEvent->AddPointerItem(item);
174 knuckleDynamicDrawMgr.canvasNode_ = nullptr;
175 ASSERT_FALSE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
176
177 knuckleDynamicDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create();
178 ASSERT_NE(knuckleDynamicDrawMgr.canvasNode_, nullptr);
179 ASSERT_FALSE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
180 }
181
182 /**
183 * @tc.name: KnuckleDrawingManagerTest_StartTouchDraw
184 * @tc.desc: Test Overrides StartTouchDraw function branches
185 * @tc.type: Function
186 * @tc.require:
187 */
188 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_StartTouchDraw, TestSize.Level1)
189 {
190 CALL_TEST_DEBUG;
191 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
192 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
193 ASSERT_NE(pointerEvent, nullptr);
194 pointerEvent->SetPointerId(1);
195 knuckleDynamicDrawMgr.StartTouchDraw(pointerEvent);
196
197 knuckleDynamicDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create();
198 ASSERT_NE(knuckleDynamicDrawMgr.canvasNode_, nullptr);
199 knuckleDynamicDrawMgr.displayInfo_.width = 200;
200 knuckleDynamicDrawMgr.displayInfo_.height = 200;
201 std::string imagePath = "/system/etc/multimodalinput/mouse_icon/Default.svg";
202 auto pixelMap = DecodeImageToPixelMap(imagePath);
203 knuckleDynamicDrawMgr.glowTraceSystem_ =
204 std::make_shared<KnuckleGlowTraceSystem>(POINT_SYSTEM_SIZE, pixelMap, MAX_DIVERGENCE_NUM);
205 knuckleDynamicDrawMgr.isDrawing_ = true;
206 knuckleDynamicDrawMgr.StartTouchDraw(pointerEvent);
207 }
208
209 /**
210 * @tc.name: KnuckleDynamicDrawingManagerTest_DrawGraphic
211 * @tc.name: KnuckleDrawingManagerTest_DrawGraphic
212 * @tc.desc: Test Overrides DrawGraphic function branches
213 * @tc.type: Function
214 * @tc.require:
215 */
216 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_DrawGraphic, TestSize.Level1)
217 {
218 CALL_TEST_DEBUG;
219 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
220 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
221 ASSERT_NE(pointerEvent, nullptr);
222 pointerEvent->SetPointerId(1);
223
224 knuckleDynamicDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create();
225 ASSERT_NE(knuckleDynamicDrawMgr.canvasNode_, nullptr);
226 knuckleDynamicDrawMgr.displayInfo_.width = 200;
227 knuckleDynamicDrawMgr.displayInfo_.height = 200;
228 std::string imagePath = "/system/etc/multimodalinput/mouse_icon/Default.svg";
229 auto pixelMap = DecodeImageToPixelMap(imagePath);
230 knuckleDynamicDrawMgr.glowTraceSystem_ =
231 std::make_shared<KnuckleGlowTraceSystem>(POINT_SYSTEM_SIZE, pixelMap, MAX_DIVERGENCE_NUM);
232 knuckleDynamicDrawMgr.isDrawing_ = false;
233 ASSERT_EQ(knuckleDynamicDrawMgr.DrawGraphic(pointerEvent), RET_OK);
234 knuckleDynamicDrawMgr.isDrawing_ = true;
235 ASSERT_EQ(knuckleDynamicDrawMgr.DrawGraphic(pointerEvent), RET_ERR);
236 }
237
238 /**
239 * @tc.name: KnuckleDynamicDrawingManagerTest_CreateTouchWindow
240 * @tc.desc: Test Overrides CreateTouchWindow function branches
241 * @tc.type: Function
242 * @tc.require:
243 */
244 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_CreateTouchWindow, TestSize.Level1)
245 {
246 CALL_TEST_DEBUG;
247 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
248 int32_t displayId = 10;
249 knuckleDynamicDrawMgr.surfaceNode_ = nullptr;
250 knuckleDynamicDrawMgr.displayInfo_.width = 200;
251 knuckleDynamicDrawMgr.displayInfo_.height = 200;
252 knuckleDynamicDrawMgr.CreateTouchWindow(displayId);
253
254 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
255 surfaceNodeConfig.SurfaceNodeName = "touch window";
256 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
257 knuckleDynamicDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
258 ASSERT_NE(knuckleDynamicDrawMgr.surfaceNode_, nullptr);
259 knuckleDynamicDrawMgr.CreateTouchWindow(displayId);
260 }
261
262 /**
263 * @tc.name: KnuckleDynamicDrawingManagerTest_CreateTouchWindow_002
264 * @tc.desc: Test Overrides CreateTouchWindow function branches
265 * @tc.type: Function
266 * @tc.require:
267 */
268 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_CreateTouchWindow_002, TestSize.Level1)
269 {
270 CALL_TEST_DEBUG;
271 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
272 int32_t displayId = 10;
273 knuckleDynamicDrawMgr.surfaceNode_ = nullptr;
274 knuckleDynamicDrawMgr.displayInfo_.width = 200;
275 knuckleDynamicDrawMgr.displayInfo_.height = 200;
276 knuckleDynamicDrawMgr.displayInfo_.displayMode = DisplayMode::MAIN;
277 knuckleDynamicDrawMgr.CreateTouchWindow(displayId);
278 EXPECT_EQ(knuckleDynamicDrawMgr.screenId_, 5);
279
280 knuckleDynamicDrawMgr.knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>();
281 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawMgr.CreateTouchWindow(displayId));
282 }
283
284 /**
285 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_001
286 * @tc.desc: Test KnuckleDynamicDrawHandler
287 * @tc.type: Function
288 * @tc.require:
289 */
290 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_001,
291 TestSize.Level1)
292 {
293 CALL_TEST_DEBUG;
294 auto pointerEvent = PointerEvent::Create();
295 EXPECT_NE(pointerEvent, nullptr);
296
297 PointerEvent::PointerItem item;
298 item.SetPointerId(0);
299 int32_t displayX = 100;
300 int32_t displayY = 100;
301 item.SetDisplayX(displayX);
302 item.SetDisplayY(displayY);
303 item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
304 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
305 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
306 pointerEvent->SetTargetDisplayId(0);
307 pointerEvent->SetPointerId(0);
308 pointerEvent->AddPointerItem(item);
309 knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
310 EXPECT_TRUE(knuckleDynamicDrawingMgr->isDrawing_);
311 }
312
313 /**
314 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_002
315 * @tc.desc: Test KnuckleDynamicDrawHandler
316 * @tc.type: Function
317 * @tc.require:
318 */
319 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_002,
320 TestSize.Level1)
321 {
322 CALL_TEST_DEBUG;
323 auto pointerEvent = PointerEvent::Create();
324 EXPECT_NE(pointerEvent, nullptr);
325
326 PointerEvent::PointerItem item;
327 item.SetPointerId(0);
328 int32_t displayX = 200;
329 int32_t displayY = 200;
330 item.SetDisplayX(displayX);
331 item.SetDisplayY(displayY);
332 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
333 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
334 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
335 pointerEvent->SetTargetDisplayId(0);
336 pointerEvent->SetPointerId(0);
337 pointerEvent->AddPointerItem(item);
338 knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
339 EXPECT_EQ(knuckleDynamicDrawingMgr->lastUpTime_, 0);
340 }
341
342 /**
343 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_003
344 * @tc.desc: Test KnuckleDynamicDrawHandler
345 * @tc.type: Function
346 * @tc.require:
347 */
348 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_003,
349 TestSize.Level1)
350 {
351 CALL_TEST_DEBUG;
352 auto pointerEvent = PointerEvent::Create();
353 EXPECT_NE(pointerEvent, nullptr);
354
355 PointerEvent::PointerItem item1;
356 item1.SetPointerId(0);
357 int32_t displayX = 100;
358 int32_t displayY = 200;
359 item1.SetDisplayX(displayX);
360 item1.SetDisplayY(displayY);
361 item1.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
362 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
363 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
364 pointerEvent->SetTargetDisplayId(0);
365 pointerEvent->SetPointerId(0);
366 pointerEvent->AddPointerItem(item1);
367
368 PointerEvent::PointerItem item2;
369 item2.SetPointerId(1);
370 displayX = 200;
371 displayY = 200;
372 item2.SetDisplayX(displayX);
373 item2.SetDisplayY(displayY);
374 item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
375 pointerEvent->AddPointerItem(item2);
376 knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
377 EXPECT_TRUE(knuckleDynamicDrawingMgr->isDrawing_);
378 }
379
380 /**
381 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_004
382 * @tc.desc: Test KnuckleDynamicDrawHandler
383 * @tc.type: Function
384 * @tc.require:
385 */
386 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_004,
387 TestSize.Level1)
388 {
389 CALL_TEST_DEBUG;
390 auto pointerEvent = PointerEvent::Create();
391 EXPECT_NE(pointerEvent, nullptr);
392
393 PointerEvent::PointerItem item;
394 item.SetPointerId(0);
395 int32_t displayX = 200;
396 int32_t displayY = 200;
397 item.SetDisplayX(displayX);
398 item.SetDisplayY(displayY);
399 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
400 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
401 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
402 pointerEvent->SetTargetDisplayId(0);
403 pointerEvent->SetPointerId(0);
404 pointerEvent->AddPointerItem(item);
405 knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
406 EXPECT_EQ(knuckleDynamicDrawingMgr->firstDownTime_, 0);
407 }
408
409 /**
410 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_005
411 * @tc.desc: Test KnuckleDynamicDrawHandler
412 * @tc.type: Function
413 * @tc.require:
414 */
415 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_005,
416 TestSize.Level1)
417 {
418 CALL_TEST_DEBUG;
419 auto pointerEvent = PointerEvent::Create();
420 EXPECT_NE(pointerEvent, nullptr);
421
422 PointerEvent::PointerItem item;
423 item.SetPointerId(0);
424 int32_t displayX = 200;
425 int32_t displayY = 200;
426 item.SetDisplayX(displayX);
427 item.SetDisplayY(displayY);
428 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
429 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
430 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
431 pointerEvent->SetTargetDisplayId(0);
432 pointerEvent->SetPointerId(0);
433 pointerEvent->AddPointerItem(item);
434 knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
435 EXPECT_NE(knuckleDynamicDrawingMgr->pointCounter_, 1);
436 }
437
438 /**
439 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_006
440 * @tc.desc: Test KnuckleDynamicDrawHandler
441 * @tc.type: Function
442 * @tc.require:
443 */
444 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_006,
445 TestSize.Level1)
446 {
447 CALL_TEST_DEBUG;
448 auto pointerEvent = PointerEvent::Create();
449 EXPECT_NE(pointerEvent, nullptr);
450
451 PointerEvent::PointerItem item;
452 item.SetPointerId(0);
453 int32_t displayX = 200;
454 int32_t displayY = 200;
455 item.SetDisplayX(displayX);
456 item.SetDisplayY(displayY);
457 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
458 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
459 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
460 pointerEvent->SetTargetDisplayId(0);
461 pointerEvent->SetPointerId(0);
462 pointerEvent->AddPointerItem(item);
463 knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
464 EXPECT_TRUE(knuckleDynamicDrawingMgr->traceControlPoints_.empty());
465 }
466
467 /**
468 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_007
469 * @tc.desc: Test KnuckleDynamicDrawHandler
470 * @tc.type: Function
471 * @tc.require:
472 */
473 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_007,
474 TestSize.Level1)
475 {
476 CALL_TEST_DEBUG;
477 auto pointerEvent = PointerEvent::Create();
478 EXPECT_NE(pointerEvent, nullptr);
479
480 PointerEvent::PointerItem item;
481 item.SetPointerId(0);
482 int32_t displayX = 100;
483 int32_t displayY = 100;
484 item.SetDisplayX(displayX);
485 item.SetDisplayY(displayY);
486 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
487 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
488 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
489 pointerEvent->SetTargetDisplayId(0);
490 pointerEvent->SetPointerId(0);
491 pointerEvent->AddPointerItem(item);
492 int32_t rsId = 0;
493 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent, rsId));
494 }
495
496 /**
497 * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_008
498 * @tc.desc: Test KnuckleDynamicDrawHandler
499 * @tc.type: Function
500 * @tc.require:
501 */
502 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_008,
503 TestSize.Level1)
504 {
505 CALL_TEST_DEBUG;
506 auto pointerEvent = PointerEvent::Create();
507 EXPECT_NE(pointerEvent, nullptr);
508
509 PointerEvent::PointerItem item;
510 item.SetPointerId(0);
511 int32_t displayX = 100;
512 int32_t displayY = 100;
513 item.SetDisplayX(displayX);
514 item.SetDisplayY(displayY);
515 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
516 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
517 pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
518 pointerEvent->SetTargetDisplayId(0);
519 pointerEvent->SetPointerId(0);
520 pointerEvent->AddPointerItem(item);
521 knuckleDynamicDrawingMgr->isRotate_ = false;
522 int32_t rsId = 0;
523 knuckleDynamicDrawingMgr->knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>();
524 EXPECT_TRUE(knuckleDynamicDrawingMgr->IsSingleKnuckle(pointerEvent));
525 EXPECT_TRUE(knuckleDynamicDrawingMgr->CheckPointerAction(pointerEvent));
526 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent, rsId));
527 }
528
529 /**
530 * @tc.name: KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_001
531 * @tc.desc: Test UpdateDisplayInfo
532 * @tc.type: Function
533 * @tc.require:
534 */
535 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_001, TestSize.Level1)
536 {
537 CALL_TEST_DEBUG;
538 OLD::DisplayInfo displayInfo = { .id = 1, .x = 1, .y = 1, .width = 1, .height = 1,
539 .dpi = 240, .name = "display", .uniq = "xx" };
540 knuckleDynamicDrawingMgr->UpdateDisplayInfo(displayInfo);
541 EXPECT_EQ(knuckleDynamicDrawingMgr->displayInfo_.width, 1);
542 }
543
544 /**
545 * @tc.name: KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_002
546 * @tc.desc: Test UpdateDisplayInfo
547 * @tc.type: Function
548 * @tc.require:
549 */
550 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_002, TestSize.Level1)
551 {
552 CALL_TEST_DEBUG;
553 OLD::DisplayInfo displayInfo;
554 knuckleDynamicDrawingMgr->UpdateDisplayInfo(displayInfo);
555 EXPECT_EQ(knuckleDynamicDrawingMgr->displayInfo_.width, 0);
556 }
557
558 /**
559 * @tc.name: KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_003
560 * @tc.desc: Test UpdateDisplayInfo
561 * @tc.type: Function
562 * @tc.require:
563 */
564 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_003, TestSize.Level1)
565 {
566 CALL_TEST_DEBUG;
567 OLD::DisplayInfo displayInfo;
568 displayInfo.direction = Direction::DIRECTION90;
569 knuckleDynamicDrawingMgr->displayInfo_.direction = Direction::DIRECTION0;
570 knuckleDynamicDrawingMgr->UpdateDisplayInfo(displayInfo);
571 EXPECT_TRUE(knuckleDynamicDrawingMgr->isRotate_);
572 }
573
574 /**
575 * @tc.name: KnuckleDynamicDrawingManagerTest_DestoryWindow_002
576 * @tc.desc: Test DestoryWindow
577 * @tc.type: Function
578 * @tc.require:
579 */
580 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_DestoryWindow_002, TestSize.Level1)
581 {
582 CALL_TEST_DEBUG;
583 knuckleDynamicDrawingMgr->canvasNode_ = nullptr;
584 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
585 surfaceNodeConfig.SurfaceNodeName = "knuckle window";
586 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
587 knuckleDynamicDrawingMgr->surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
588 ASSERT_NE(knuckleDynamicDrawingMgr->surfaceNode_, nullptr);
589 knuckleDynamicDrawingMgr->canvasNode_ = Rosen::RSCanvasDrawingNode::Create();
590 ASSERT_NE(knuckleDynamicDrawingMgr->canvasNode_, nullptr);
591 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawingMgr->DestoryWindow());
592 }
593
594 /**
595 * @tc.name: KnuckleDynamicDrawingManagerTest_IsSingleKnuckle_001
596 * @tc.desc: Test Overrides IsSingleKnuckle function branches
597 * @tc.type: Function
598 * @tc.require:
599 */
600 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_IsSingleKnuckle_001, TestSize.Level1)
601 {
602 CALL_TEST_DEBUG;
603 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
604 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
605 ASSERT_NE(pointerEvent, nullptr);
606 PointerEvent::PointerItem item;
607 item.SetPointerId(10);
608 item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD);
609 pointerEvent->SetPointerId(10);
610 pointerEvent->AddPointerItem(item);
611 Rosen::Drawing::Point point = Rosen::Drawing::Point();
612 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
613 EXPECT_FALSE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
614 knuckleDynamicDrawMgr.traceControlPoints_.clear();
615 knuckleDynamicDrawMgr.isRotate_ = true;
616 item.SetPointerId(20);
617 item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
618 pointerEvent->SetPointerId(20);
619 pointerEvent->AddPointerItem(item);
620 EXPECT_TRUE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
621 pointerEvent->SetPointerId(10);
622 knuckleDynamicDrawMgr.isRotate_ = true;
623 EXPECT_FALSE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
624 EXPECT_FALSE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
625 }
626
627 /**
628 * @tc.name: KnuckleDynamicDrawingManagerTest_CheckPointerAction
629 * @tc.desc: Test Overrides CheckPointerAction function branches
630 * @tc.type: Function
631 * @tc.require:
632 */
633 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_CheckPointerAction, TestSize.Level1)
634 {
635 CALL_TEST_DEBUG;
636 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
637 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
638 ASSERT_NE(pointerEvent, nullptr);
639 knuckleDynamicDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create();
640 ASSERT_NE(knuckleDynamicDrawMgr.canvasNode_, nullptr);
641 Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
642 surfaceNodeConfig.SurfaceNodeName = "touch window";
643 Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
644 knuckleDynamicDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
645 ASSERT_NE(knuckleDynamicDrawMgr.surfaceNode_, nullptr);
646 PointerEvent::PointerItem item;
647 item.SetPointerId(10);
648 pointerEvent->AddPointerItem(item);
649 item.SetPointerId(20);
650 pointerEvent->AddPointerItem(item);
651 knuckleDynamicDrawMgr.knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>();
652 knuckleDynamicDrawMgr.knuckleDrawMgr_->screenReadState_.state = SCREEN_READ_ENABLE;
653 EXPECT_FALSE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
654 }
655
656 /**
657 * @tc.name: KnuckleDynamicDrawingManagerTest_CheckPointerAction_001
658 * @tc.desc: Test Overrides CheckPointerAction function branches
659 * @tc.type: Function
660 * @tc.require:
661 */
662 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_CheckPointerAction_001, TestSize.Level1)
663 {
664 CALL_TEST_DEBUG;
665 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
666 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
667 ASSERT_NE(pointerEvent, nullptr);
668 PointerEvent::PointerItem item;
669 item.SetPointerId(10);
670 pointerEvent->AddPointerItem(item);
671 knuckleDynamicDrawMgr.knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>();
672 knuckleDynamicDrawMgr.knuckleDrawMgr_->screenReadState_.state = "0";
673 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
674 EXPECT_TRUE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
675 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
676 EXPECT_TRUE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
677 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
678 EXPECT_TRUE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
679 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_DOWN);
680 EXPECT_TRUE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
681 knuckleDynamicDrawMgr.isStop_ = true;
682 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
683 EXPECT_FALSE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
684 knuckleDynamicDrawMgr.isStop_ = false;
685 knuckleDynamicDrawMgr.traceControlPoints_.clear();
686 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_MOVE);
687 EXPECT_FALSE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
688 Rosen::Drawing::Point point = Rosen::Drawing::Point();
689 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
690 EXPECT_TRUE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
691 pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
692 EXPECT_FALSE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
693 }
694
695 /**
696 * @tc.name: KnuckleDynamicDrawingManagerTest_ProcessUpAndCancelEvent
697 * @tc.desc: Test Overrides ProcessUpAndCancelEvent function branches
698 * @tc.type: Function
699 * @tc.require:
700 */
701 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_ProcessUpAndCancelEvent, TestSize.Level1)
702 {
703 CALL_TEST_DEBUG;
704 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
705 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
706 ASSERT_NE(pointerEvent, nullptr);
707 std::string imagePath = "/system/etc/multimodalinput/mouse_icon/Default.svg";
708 auto pixelMap = DecodeImageToPixelMap(imagePath);
709 knuckleDynamicDrawMgr.glowTraceSystem_ = std::make_shared<KnuckleGlowTraceSystem>(POINT_SYSTEM_SIZE,
710 pixelMap, MAX_DIVERGENCE_NUM);
711 pointerEvent->SetPointerId(10);
712 pointerEvent->SetActionTime(1000);
713 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawMgr.ProcessUpAndCancelEvent(pointerEvent));
714 }
715
716 /**
717 * @tc.name: KnuckleDynamicDrawingManagerTest_SetKnuckleDrawingManager
718 * @tc.desc: Test SetKnuckleDrawingManager
719 * @tc.type: Function
720 * @tc.require:
721 */
722 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_SetKnuckleDrawingManager, TestSize.Level1)
723 {
724 CALL_TEST_DEBUG;
725 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
726 knuckleDynamicDrawMgr.knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>();
727 knuckleDynamicDrawMgr.knuckleDrawMgr_->screenReadState_.state = "0";
728 knuckleDynamicDrawMgr.pointCounter_ = MAX_DIVERGENCE_NUM;
729 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawMgr.SetKnuckleDrawingManager(knuckleDynamicDrawMgr.knuckleDrawMgr_));
730 }
731
732 /**
733 * @tc.name: KnuckleDynamicDrawingManagerTest_ProcessMoveEvent
734 * @tc.desc: Test ProcessMoveEvent
735 * @tc.type: Function
736 * @tc.require:
737 */
738 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_ProcessMoveEvent, TestSize.Level1)
739 {
740 CALL_TEST_DEBUG;
741 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
742 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
743 knuckleDynamicDrawMgr.pointCounter_ = MAX_DIVERGENCE_NUM;
744 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawMgr.ProcessMoveEvent(pointerEvent));
745 }
746
747 /**
748 * @tc.name: KnuckleDynamicDrawingManagerTest_ProcessMoveEvent_002
749 * @tc.desc: Test ProcessMoveEvent
750 * @tc.type: Function
751 * @tc.require:
752 */
753 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_ProcessMoveEvent_002, TestSize.Level1)
754 {
755 CALL_TEST_DEBUG;
756 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
757 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
758 knuckleDynamicDrawMgr.pointCounter_ = 0;
759 pointerEvent->SetActionTime(200001);
760 knuckleDynamicDrawMgr.firstDownTime_ = 100000;
761
762 std::string imagePath = "/system/etc/multimodalinput/mouse_icon/Default.svg";
763 auto pixelMap = DecodeImageToPixelMap(imagePath);
764 ASSERT_NE(pixelMap, nullptr);
765 knuckleDynamicDrawMgr.glowTraceSystem_ =
766 std::make_shared<KnuckleGlowTraceSystem>(POINT_SYSTEM_SIZE, pixelMap, MAX_DIVERGENCE_NUM);
767 Rosen::Drawing::Point point = Rosen::Drawing::Point();
768 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
769
770 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawMgr.ProcessMoveEvent(pointerEvent));
771 EXPECT_FALSE(knuckleDynamicDrawMgr.isDrawing_);
772 }
773
774 /**
775 * @tc.name: KnuckleDynamicDrawingManagerTest_ProcessMoveEvent_003
776 * @tc.desc: Test ProcessMoveEvent
777 * @tc.type: Function
778 * @tc.require:
779 */
780 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_ProcessMoveEvent_003, TestSize.Level1)
781 {
782 CALL_TEST_DEBUG;
783 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
784 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
785 knuckleDynamicDrawMgr.pointCounter_ = 3;
786 pointerEvent->SetActionTime(200001);
787 knuckleDynamicDrawMgr.firstDownTime_ = 100000;
788
789 std::string imagePath = "/system/etc/multimodalinput/mouse_icon/Default.svg";
790 auto pixelMap = DecodeImageToPixelMap(imagePath);
791 ASSERT_NE(pixelMap, nullptr);
792 knuckleDynamicDrawMgr.glowTraceSystem_ =
793 std::make_shared<KnuckleGlowTraceSystem>(POINT_SYSTEM_SIZE, pixelMap, MAX_DIVERGENCE_NUM);
794 Rosen::Drawing::Point point = Rosen::Drawing::Point();
795 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
796 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
797 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
798 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
799
800 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawMgr.ProcessMoveEvent(pointerEvent));
801 EXPECT_EQ(knuckleDynamicDrawMgr.pointCounter_, 1);
802 }
803
804 /**
805 * @tc.name: KnuckleDynamicDrawingManagerTest_ProcessMoveEvent_004
806 * @tc.desc: Test ProcessMoveEvent
807 * @tc.type: Function
808 * @tc.require:
809 */
810 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_ProcessMoveEvent_004, TestSize.Level1)
811 {
812 CALL_TEST_DEBUG;
813 KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
814 std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
815 knuckleDynamicDrawMgr.pointCounter_ = 3;
816 pointerEvent->SetActionTime(100001);
817 knuckleDynamicDrawMgr.firstDownTime_ = 100000;
818
819 std::string imagePath = "/system/etc/multimodalinput/mouse_icon/Default.svg";
820 auto pixelMap = DecodeImageToPixelMap(imagePath);
821 ASSERT_NE(pixelMap, nullptr);
822 knuckleDynamicDrawMgr.glowTraceSystem_ =
823 std::make_shared<KnuckleGlowTraceSystem>(POINT_SYSTEM_SIZE, pixelMap, MAX_DIVERGENCE_NUM);
824 Rosen::Drawing::Point point = Rosen::Drawing::Point();
825 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
826 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
827 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
828 knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
829
830 EXPECT_NO_FATAL_FAILURE(knuckleDynamicDrawMgr.ProcessMoveEvent(pointerEvent));
831 EXPECT_EQ(knuckleDynamicDrawMgr.pointCounter_, 1);
832 }
833 } // namespace MMI
834 } // namespace OHOS
