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         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_KnuckleDynamicDrawHandler_001
264  * @tc.desc: Test KnuckleDynamicDrawHandler
265  * @tc.type: Function
266  * @tc.require:
267  */
268 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_001,
269     TestSize.Level1)
270 {
271     CALL_TEST_DEBUG;
272     auto pointerEvent = PointerEvent::Create();
273     EXPECT_NE(pointerEvent, nullptr);
274 
275     PointerEvent::PointerItem item;
276     item.SetPointerId(0);
277     int32_t displayX = 100;
278     int32_t displayY = 100;
279     item.SetDisplayX(displayX);
280     item.SetDisplayY(displayY);
281     item.SetToolType(PointerEvent::TOOL_TYPE_FINGER);
282     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
283     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
284     pointerEvent->SetTargetDisplayId(0);
285     pointerEvent->SetPointerId(0);
286     pointerEvent->AddPointerItem(item);
287     knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
288     EXPECT_TRUE(knuckleDynamicDrawingMgr->isDrawing_);
289 }
290 
291 /**
292  * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_002
293  * @tc.desc: Test KnuckleDynamicDrawHandler
294  * @tc.type: Function
295  * @tc.require:
296  */
297 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_002,
298     TestSize.Level1)
299 {
300     CALL_TEST_DEBUG;
301     auto pointerEvent = PointerEvent::Create();
302     EXPECT_NE(pointerEvent, nullptr);
303 
304     PointerEvent::PointerItem item;
305     item.SetPointerId(0);
306     int32_t displayX = 200;
307     int32_t displayY = 200;
308     item.SetDisplayX(displayX);
309     item.SetDisplayY(displayY);
310     item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
311     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
312     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
313     pointerEvent->SetTargetDisplayId(0);
314     pointerEvent->SetPointerId(0);
315     pointerEvent->AddPointerItem(item);
316     knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
317     EXPECT_EQ(knuckleDynamicDrawingMgr->lastUpTime_, 0);
318 }
319 
320 /**
321  * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_003
322  * @tc.desc: Test KnuckleDynamicDrawHandler
323  * @tc.type: Function
324  * @tc.require:
325  */
326 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_003,
327     TestSize.Level1)
328 {
329     CALL_TEST_DEBUG;
330     auto pointerEvent = PointerEvent::Create();
331     EXPECT_NE(pointerEvent, nullptr);
332 
333     PointerEvent::PointerItem item1;
334     item1.SetPointerId(0);
335     int32_t displayX = 100;
336     int32_t displayY = 200;
337     item1.SetDisplayX(displayX);
338     item1.SetDisplayY(displayY);
339     item1.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
340     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
341     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
342     pointerEvent->SetTargetDisplayId(0);
343     pointerEvent->SetPointerId(0);
344     pointerEvent->AddPointerItem(item1);
345 
346     PointerEvent::PointerItem item2;
347     item2.SetPointerId(1);
348     displayX = 200;
349     displayY = 200;
350     item2.SetDisplayX(displayX);
351     item2.SetDisplayY(displayY);
352     item2.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
353     pointerEvent->AddPointerItem(item2);
354     knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
355     EXPECT_TRUE(knuckleDynamicDrawingMgr->isDrawing_);
356 }
357 
358 /**
359  * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_004
360  * @tc.desc: Test KnuckleDynamicDrawHandler
361  * @tc.type: Function
362  * @tc.require:
363  */
364 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_004,
365     TestSize.Level1)
366 {
367     CALL_TEST_DEBUG;
368     auto pointerEvent = PointerEvent::Create();
369     EXPECT_NE(pointerEvent, nullptr);
370 
371     PointerEvent::PointerItem item;
372     item.SetPointerId(0);
373     int32_t displayX = 200;
374     int32_t displayY = 200;
375     item.SetDisplayX(displayX);
376     item.SetDisplayY(displayY);
377     item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
378     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
379     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
380     pointerEvent->SetTargetDisplayId(0);
381     pointerEvent->SetPointerId(0);
382     pointerEvent->AddPointerItem(item);
383     knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
384     EXPECT_EQ(knuckleDynamicDrawingMgr->firstDownTime_, 0);
385 }
386 
387 /**
388  * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_005
389  * @tc.desc: Test KnuckleDynamicDrawHandler
390  * @tc.type: Function
391  * @tc.require:
392  */
393 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_005,
394     TestSize.Level1)
395 {
396     CALL_TEST_DEBUG;
397     auto pointerEvent = PointerEvent::Create();
398     EXPECT_NE(pointerEvent, nullptr);
399 
400     PointerEvent::PointerItem item;
401     item.SetPointerId(0);
402     int32_t displayX = 200;
403     int32_t displayY = 200;
404     item.SetDisplayX(displayX);
405     item.SetDisplayY(displayY);
406     item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
407     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
408     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
409     pointerEvent->SetTargetDisplayId(0);
410     pointerEvent->SetPointerId(0);
411     pointerEvent->AddPointerItem(item);
412     knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
413     EXPECT_NE(knuckleDynamicDrawingMgr->pointCounter_, 1);
414 }
415 
416 /**
417  * @tc.name: KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_006
418  * @tc.desc: Test KnuckleDynamicDrawHandler
419  * @tc.type: Function
420  * @tc.require:
421  */
422 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_KnuckleDynamicDrawHandler_006,
423     TestSize.Level1)
424 {
425     CALL_TEST_DEBUG;
426     auto pointerEvent = PointerEvent::Create();
427     EXPECT_NE(pointerEvent, nullptr);
428 
429     PointerEvent::PointerItem item;
430     item.SetPointerId(0);
431     int32_t displayX = 200;
432     int32_t displayY = 200;
433     item.SetDisplayX(displayX);
434     item.SetDisplayY(displayY);
435     item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
436     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
437     pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
438     pointerEvent->SetTargetDisplayId(0);
439     pointerEvent->SetPointerId(0);
440     pointerEvent->AddPointerItem(item);
441     knuckleDynamicDrawingMgr->KnuckleDynamicDrawHandler(pointerEvent);
442     EXPECT_TRUE(knuckleDynamicDrawingMgr->traceControlPoints_.empty());
443 }
444 
445 /**
446  * @tc.name: KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_001
447  * @tc.desc: Test UpdateDisplayInfo
448  * @tc.type: Function
449  * @tc.require:
450  */
451 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_001, TestSize.Level1)
452 {
453     CALL_TEST_DEBUG;
454     DisplayInfo displayInfo = { .id = 1, .x = 1, .y = 1, .width = 1, .height = 1,
455         .dpi = 240, .name = "display", .uniq = "xx" };
456     knuckleDynamicDrawingMgr->UpdateDisplayInfo(displayInfo);
457     EXPECT_EQ(knuckleDynamicDrawingMgr->displayInfo_.width, 1);
458 }
459 
460 /**
461  * @tc.name: KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_002
462  * @tc.desc: Test UpdateDisplayInfo
463  * @tc.type: Function
464  * @tc.require:
465  */
466 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_UpdateDisplayInfo_002, TestSize.Level1)
467 {
468     CALL_TEST_DEBUG;
469     DisplayInfo displayInfo;
470     knuckleDynamicDrawingMgr->UpdateDisplayInfo(displayInfo);
471     EXPECT_EQ(knuckleDynamicDrawingMgr->displayInfo_.width, 0);
472 }
473 
474 /**
475  * @tc.name: KnuckleDynamicDrawingManagerTest_IsSingleKnuckle_001
476  * @tc.desc: Test Overrides IsSingleKnuckle function branches
477  * @tc.type: Function
478  * @tc.require:
479  */
480 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_IsSingleKnuckle_001, TestSize.Level1)
481 {
482     CALL_TEST_DEBUG;
483     KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
484     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
485     ASSERT_NE(pointerEvent, nullptr);
486     PointerEvent::PointerItem item;
487     item.SetPointerId(10);
488     item.SetToolType(PointerEvent::TOOL_TYPE_TOUCHPAD);
489     pointerEvent->SetPointerId(10);
490     pointerEvent->AddPointerItem(item);
491     Rosen::Drawing::Point point = Rosen::Drawing::Point();
492     knuckleDynamicDrawMgr.traceControlPoints_.push_back(point);
493     EXPECT_FALSE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
494     knuckleDynamicDrawMgr.traceControlPoints_.clear();
495     knuckleDynamicDrawMgr.isRotate_ = true;
496     item.SetPointerId(20);
497     item.SetToolType(PointerEvent::TOOL_TYPE_KNUCKLE);
498     pointerEvent->SetPointerId(20);
499     pointerEvent->AddPointerItem(item);
500     EXPECT_TRUE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
501     pointerEvent->SetPointerId(10);
502     knuckleDynamicDrawMgr.isRotate_ = true;
503     EXPECT_FALSE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
504     EXPECT_FALSE(knuckleDynamicDrawMgr.IsSingleKnuckle(pointerEvent));
505 }
506 
507 /**
508  * @tc.name: KnuckleDynamicDrawingManagerTest_CheckPointerAction
509  * @tc.desc: Test Overrides CheckPointerAction function branches
510  * @tc.type: Function
511  * @tc.require:
512  */
513 HWTEST_F(KnuckleDynamicDrawingManagerTest, KnuckleDynamicDrawingManagerTest_CheckPointerAction, TestSize.Level1)
514 {
515     CALL_TEST_DEBUG;
516     KnuckleDynamicDrawingManager knuckleDynamicDrawMgr;
517     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
518     ASSERT_NE(pointerEvent, nullptr);
519     knuckleDynamicDrawMgr.canvasNode_ = Rosen::RSCanvasDrawingNode::Create();
520     ASSERT_NE(knuckleDynamicDrawMgr.canvasNode_, nullptr);
521     Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
522     surfaceNodeConfig.SurfaceNodeName = "touch window";
523     Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
524     knuckleDynamicDrawMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
525     ASSERT_NE(knuckleDynamicDrawMgr.surfaceNode_, nullptr);
526     PointerEvent::PointerItem item;
527     item.SetPointerId(10);
528     pointerEvent->AddPointerItem(item);
529     item.SetPointerId(20);
530     pointerEvent->AddPointerItem(item);
531     knuckleDynamicDrawMgr.knuckleDrawMgr_ = std::make_shared<KnuckleDrawingManager>();
532     knuckleDynamicDrawMgr.knuckleDrawMgr_->screenReadState_.state = SCREEN_READ_ENABLE;
533     EXPECT_FALSE(knuckleDynamicDrawMgr.CheckPointerAction(pointerEvent));
534 }
535 
536 } // namespace MMI
537 } // namespace OHOS