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