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 #include <gtest/gtest.h>
19 
20 #include "mmi_log.h"
21 #include "pointer_event.h"
22 #ifndef USE_ROSEN_DRAWING
23 #define USE_ROSEN_DRAWING
24 #endif
25 #include "touch_drawing_manager.h"
26 #include "window_info.h"
27 
28 #undef MMI_LOG_TAG
29 #define MMI_LOG_TAG "TouchDrawingManagerTest"
30 
31 namespace OHOS {
32 namespace MMI {
33 namespace {
34 using namespace testing::ext;
35 } // namespace
36 class TouchDrawingManagerTest : public testing::Test {
37 public:
SetUpTestCase(void)38     static void SetUpTestCase(void) {};
TearDownTestCase(void)39     static void TearDownTestCase(void) {};
SetUp(void)40     void SetUp(void) {};
41 };
42 
43 /**
44  * @tc.name: TouchDrawingManagerTest_RecordLabelsInfo
45  * @tc.desc: Test RecordLabelsInfo
46  * @tc.type: Function
47  * @tc.require:
48  */
49 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_RecordLabelsInfo, TestSize.Level1)
50 {
51     CALL_TEST_DEBUG;
52     TouchDrawingManager touchDrawMgr;
53     touchDrawMgr.pointerEvent_ = PointerEvent::Create();
54     ASSERT_NE(touchDrawMgr.pointerEvent_, nullptr);
55     PointerEvent::PointerItem item;
56     item.SetPointerId(0);
57     item.SetPressed(true);
58     item.SetDisplayX(100);
59     item.SetDisplayY(100);
60     touchDrawMgr.pointerEvent_->AddPointerItem(item);
61     touchDrawMgr.pointerEvent_->SetPointerId(0);
62     touchDrawMgr.currentPointerId_ = 1;
63     EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo());
64 
65     touchDrawMgr.currentPointerId_ = 0;
66     touchDrawMgr.isFirstDownAction_ = true;
67     touchDrawMgr.lastPointerItem_.push_back(item);
68     touchDrawMgr.pointerEvent_->SetActionTime(150);
69     touchDrawMgr.lastActionTime_ = 300;
70     EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo());
71 
72     touchDrawMgr.pointerEvent_->SetActionTime(50);
73     touchDrawMgr.lastActionTime_ = 50;
74     EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo());
75 
76     item.SetPressed(false);
77     touchDrawMgr.isFirstDownAction_ = false;
78     touchDrawMgr.pointerEvent_->SetPointerId(10);
79     touchDrawMgr.pointerEvent_->UpdatePointerItem(0, item);
80     EXPECT_NO_FATAL_FAILURE(touchDrawMgr.RecordLabelsInfo());
81 }
82 
83 /**
84  * @tc.name: TouchDrawingManagerTest_TouchDrawHandler
85  * @tc.desc: Test TouchDrawHandler
86  * @tc.type: Function
87  * @tc.require:
88  */
89 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_TouchDrawHandler, TestSize.Level1)
90 {
91     CALL_TEST_DEBUG;
92     TouchDrawingManager touchDrawMgr;
93     std::shared_ptr<PointerEvent> pointerEvent = PointerEvent::Create();
94     ASSERT_NE(pointerEvent, nullptr);
95     PointerEvent::PointerItem item;
96     touchDrawMgr.bubbleMode_.isShow = true;
97     touchDrawMgr.stopRecord_ = false;
98     touchDrawMgr.pointerMode_.isShow = true;
99     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
100     pointerEvent->AddPointerItem(item);
101     EXPECT_NO_FATAL_FAILURE(touchDrawMgr.TouchDrawHandler(pointerEvent));
102 
103     touchDrawMgr.bubbleMode_.isShow = false;
104     touchDrawMgr.pointerMode_.isShow = false;
105     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
106     EXPECT_NO_FATAL_FAILURE(touchDrawMgr.TouchDrawHandler(pointerEvent));
107 }
108 
109 /**
110  * @tc.name: TouchDrawingManagerTest_UpdateDisplayInfo
111  * @tc.desc: Test UpdateDisplayInfo
112  * @tc.type: Function
113  * @tc.require:
114  */
115 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdateDisplayInfo, TestSize.Level1)
116 {
117     CALL_TEST_DEBUG;
118     TouchDrawingManager touchDrawMgr;
119     DisplayInfo displayInfo;
120     displayInfo.direction = Direction::DIRECTION0;
121     touchDrawMgr.displayInfo_.direction = Direction::DIRECTION0;
122     displayInfo.width = 700;
123     displayInfo.height = 500;
124     EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo));
125 
126     displayInfo.direction = Direction::DIRECTION180;
127     touchDrawMgr.displayInfo_.direction = Direction::DIRECTION180;
128     EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo));
129 
130     displayInfo.direction = Direction::DIRECTION270;
131     touchDrawMgr.displayInfo_.direction = Direction::DIRECTION270;
132     EXPECT_NO_FATAL_FAILURE(touchDrawMgr.UpdateDisplayInfo(displayInfo));
133 }
134 
135 /**
136  * @tc.name: TouchDrawingManagerTest_GetOriginalTouchScreenCoordinates
137  * @tc.desc: Test GetOriginalTouchScreenCoordinates
138  * @tc.type: Function
139  * @tc.require:
140  */
141 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_GetOriginalTouchScreenCoordinates, TestSize.Level1)
142 {
143     CALL_TEST_DEBUG;
144     TouchDrawingManager touchDrawingMgr;
145     int32_t width = 720;
146     int32_t height = 1800;
147     int32_t physicalX = 300;
148     int32_t physicalY = 600;
149     Direction direction = DIRECTION0;
150     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height,
151         physicalX, physicalY));
152     direction = DIRECTION90;
153     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height,
154         physicalX, physicalY));
155     direction = DIRECTION180;
156     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height,
157         physicalX, physicalY));
158     direction = DIRECTION270;
159     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height,
160         physicalX, physicalY));
161     direction = static_cast<Direction>(10);
162     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.GetOriginalTouchScreenCoordinates(direction, width, height,
163         physicalX, physicalY));
164 }
165 
166 /**
167  * @tc.name: TouchDrawingManagerTest_UpdateLabels
168  * @tc.desc: Test UpdateLabels
169  * @tc.type: Function
170  * @tc.require:
171  */
172 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdateLabels, TestSize.Level1)
173 {
174     CALL_TEST_DEBUG;
175     TouchDrawingManager touchDrawingMgr;
176     Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
177     surfaceNodeConfig.SurfaceNodeName = "touch window";
178     Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
179     touchDrawingMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
180     ASSERT_NE(touchDrawingMgr.surfaceNode_, nullptr);
181     touchDrawingMgr.labelsCanvasNode_ = Rosen::RSCanvasNode::Create();
182     ASSERT_NE(touchDrawingMgr.labelsCanvasNode_, nullptr);
183     touchDrawingMgr.pointerMode_.isShow = true;
184     EXPECT_EQ(touchDrawingMgr.UpdateLabels(), RET_OK);
185     touchDrawingMgr.pointerMode_.isShow = false;
186     EXPECT_EQ(touchDrawingMgr.UpdateLabels(), RET_OK);
187 }
188 
189 /**
190  * @tc.name: TouchDrawingManagerTest_UpdateBubbleData
191  * @tc.desc: Test UpdateBubbleData
192  * @tc.type: Function
193  * @tc.require:
194  */
195 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdateBubbleData, TestSize.Level1)
196 {
197     CALL_TEST_DEBUG;
198     TouchDrawingManager touchDrawingMgr;
199     Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
200     surfaceNodeConfig.SurfaceNodeName = "touch window";
201     Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
202     touchDrawingMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
203     ASSERT_NE(touchDrawingMgr.surfaceNode_, nullptr);
204     touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create();
205     ASSERT_NE(touchDrawingMgr.bubbleCanvasNode_, nullptr);
206     touchDrawingMgr.bubbleMode_.isShow = false;
207     EXPECT_EQ(touchDrawingMgr.UpdateBubbleData(), RET_OK);
208 
209     touchDrawingMgr.bubbleMode_.isShow = true;
210     EXPECT_EQ(touchDrawingMgr.UpdateBubbleData(), RET_OK);
211 }
212 
213 /**
214  * @tc.name: TouchDrawingManagerTest_RotationScreen
215  * @tc.desc: Test RotationScreen
216  * @tc.type: Function
217  * @tc.require:
218  */
219 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_RotationScreen, TestSize.Level1)
220 {
221     CALL_TEST_DEBUG;
222     TouchDrawingManager touchDrawingMgr;
223     touchDrawingMgr.isChangedRotation_ = false;
224     touchDrawingMgr.isChangedMode_ = false;
225     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen());
226 
227     touchDrawingMgr.trackerCanvasNode_ = Rosen::RSCanvasNode::Create();
228     ASSERT_NE(touchDrawingMgr.trackerCanvasNode_, nullptr);
229     touchDrawingMgr.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create();
230     ASSERT_NE(touchDrawingMgr.crosshairCanvasNode_, nullptr);
231     touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create();
232     ASSERT_NE(touchDrawingMgr.bubbleCanvasNode_, nullptr);
233     touchDrawingMgr.labelsCanvasNode_ = Rosen::RSCanvasNode::Create();
234     ASSERT_NE(touchDrawingMgr.labelsCanvasNode_, nullptr);
235     touchDrawingMgr.isChangedRotation_ = true;
236     touchDrawingMgr.isChangedMode_ = true;
237     touchDrawingMgr.pointerMode_.isShow = true;
238     touchDrawingMgr.bubbleMode_.isShow = true;
239     PointerEvent::PointerItem item;
240     touchDrawingMgr.lastPointerItem_.push_back(item);
241     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen());
242 
243     touchDrawingMgr.lastPointerItem_.clear();
244     touchDrawingMgr.stopRecord_ = true;
245     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen());
246 
247     touchDrawingMgr.bubbleMode_.isShow = false;
248     touchDrawingMgr.stopRecord_ = false;
249     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen());
250 
251     touchDrawingMgr.pointerMode_.isShow = false;
252     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationScreen());
253 }
254 
255 /**
256  * @tc.name: TouchDrawingManagerTest_CreateObserver
257  * @tc.desc: Test CreateObserver
258  * @tc.type: Function
259  * @tc.require:
260  */
261 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateObserver, TestSize.Level1)
262 {
263     CALL_TEST_DEBUG;
264     TouchDrawingManager touchDrawingMgr;
265     touchDrawingMgr.hasBubbleObserver_ = false;
266     touchDrawingMgr.hasPointerObserver_ = false;
267     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateObserver());
268 }
269 
270 /**
271  * @tc.name: TouchDrawingManagerTest_CreateObserver_001
272  * @tc.desc: Test CreateObserver
273  * @tc.type: Function
274  * @tc.require:
275  */
276 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateObserver_001, TestSize.Level1)
277 {
278     CALL_TEST_DEBUG;
279     TouchDrawingManager touchDrawingMgr;
280     touchDrawingMgr.hasBubbleObserver_ = true;
281     touchDrawingMgr.hasPointerObserver_ = true;
282     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateObserver());
283 }
284 
285 /**
286  * @tc.name: TouchDrawingManagerTest_AddCanvasNode
287  * @tc.desc: Test AddCanvasNode
288  * @tc.type: Function
289  * @tc.require:
290  */
291 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_AddCanvasNode, TestSize.Level1)
292 {
293     CALL_TEST_DEBUG;
294     TouchDrawingManager touchDrawingMgr;
295     Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
296     surfaceNodeConfig.SurfaceNodeName = "touch window";
297     Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
298     touchDrawingMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
299     std::shared_ptr<Rosen::RSCanvasNode> canvasNode = Rosen::RSCanvasNode::Create();
300     ASSERT_NE(canvasNode, nullptr);
301     bool isTrackerNode = true;
302     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.AddCanvasNode(canvasNode, isTrackerNode));
303 
304     canvasNode = nullptr;
305     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.AddCanvasNode(canvasNode, isTrackerNode));
306 }
307 
308 /**
309  * @tc.name: TouchDrawingManagerTest_RotationCanvasNode
310  * @tc.desc: Test RotationCanvasNode
311  * @tc.type: Function
312  * @tc.require:
313  */
314 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_RotationCanvasNode, TestSize.Level1)
315 {
316     CALL_TEST_DEBUG;
317     TouchDrawingManager touchDrawingMgr;
318     std::shared_ptr<Rosen::RSCanvasNode> canvasNode = Rosen::RSCanvasNode::Create();
319     ASSERT_NE(canvasNode, nullptr);
320     touchDrawingMgr.displayInfo_.width = 720;
321     touchDrawingMgr.displayInfo_.height = 1800;
322     touchDrawingMgr.displayInfo_.direction = Direction::DIRECTION90;
323     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvasNode(canvasNode));
324     touchDrawingMgr.displayInfo_.direction = Direction::DIRECTION270;
325     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvasNode(canvasNode));
326     touchDrawingMgr.displayInfo_.direction = Direction::DIRECTION180;
327     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvasNode(canvasNode));
328     touchDrawingMgr.displayInfo_.direction = Direction::DIRECTION0;
329     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvasNode(canvasNode));
330 }
331 
332 /**
333  * @tc.name: TouchDrawingManagerTest_RotationCanvas
334  * @tc.desc: Test RotationCanvas
335  * @tc.type: Function
336  * @tc.require:
337  */
338 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_RotationCanvas, TestSize.Level1)
339 {
340     CALL_TEST_DEBUG;
341     TouchDrawingManager touchDrawingMgr;
342     int32_t width = 720;
343     int32_t height = 1800;
344     touchDrawingMgr.displayInfo_.width = 300;
345     touchDrawingMgr.displayInfo_.height = 100;
346     Direction direction = Direction::DIRECTION90;
347     touchDrawingMgr.labelsCanvasNode_ = Rosen::RSCanvasDrawingNode::Create();
348     auto canvas = static_cast<TouchDrawingManager::RosenCanvas *>
349         (touchDrawingMgr.labelsCanvasNode_->BeginRecording(width, height));
350     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvas(canvas, direction));
351     direction = Direction::DIRECTION180;
352     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvas(canvas, direction));
353     direction = Direction::DIRECTION270;
354     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvas(canvas, direction));
355     direction = Direction::DIRECTION0;
356     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.RotationCanvas(canvas, direction));
357 }
358 
359 /**
360  * @tc.name: TouchDrawingManagerTest_CreateTouchWindow
361  * @tc.desc: Test CreateTouchWindow
362  * @tc.type: Function
363  * @tc.require:
364  */
365 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateTouchWindow, TestSize.Level1)
366 {
367     CALL_TEST_DEBUG;
368     TouchDrawingManager touchDrawingMgr;
369     Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
370     surfaceNodeConfig.SurfaceNodeName = "touch window";
371     Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
372     touchDrawingMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
373     ASSERT_NE(touchDrawingMgr.surfaceNode_, nullptr);
374     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow());
375     touchDrawingMgr.surfaceNode_ = nullptr;
376     touchDrawingMgr.scaleW_ = 0;
377     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow());
378     touchDrawingMgr.scaleW_ = 100;
379     touchDrawingMgr.scaleH_ = 0;
380     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow());
381     touchDrawingMgr.scaleH_ = 500;
382     touchDrawingMgr.displayInfo_.id = 1000;
383     touchDrawingMgr.displayInfo_.displayMode = DisplayMode::MAIN;
384     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow());
385 }
386 
387 /**
388  * @tc.name: TouchDrawingManagerTest_CreateTouchWindow_001
389  * @tc.desc: Test CreateTouchWindow
390  * @tc.type: Function
391  * @tc.require:
392  */
393 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateTouchWindow_001, TestSize.Level1)
394 {
395     CALL_TEST_DEBUG;
396     TouchDrawingManager touchDrawingMgr;
397     touchDrawingMgr.surfaceNode_ = nullptr;
398     touchDrawingMgr.scaleW_ = 100;
399     touchDrawingMgr.scaleH_ = 500;
400     touchDrawingMgr.displayInfo_.id = 1000;
401     touchDrawingMgr.displayInfo_.displayMode = DisplayMode::FULL;
402     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow());
403 }
404 
405 /**
406  * @tc.name: TouchDrawingManagerTest_CreateTouchWindow_002
407  * @tc.desc: Test CreateTouchWindow
408  * @tc.type: Function
409  * @tc.require:
410  */
411 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_CreateTouchWindow_002, TestSize.Level1)
412 {
413     CALL_TEST_DEBUG;
414     TouchDrawingManager touchDrawingMgr;
415     touchDrawingMgr.surfaceNode_ = nullptr;
416     touchDrawingMgr.scaleW_ = 100;
417     touchDrawingMgr.scaleH_ = 500;
418     touchDrawingMgr.displayInfo_.id = 1000;
419     touchDrawingMgr.displayInfo_.displayMode = DisplayMode::UNKNOWN;
420     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.CreateTouchWindow());
421 }
422 
423 /**
424  * @tc.name: TouchDrawingManagerTest_DrawBubbleHandler
425  * @tc.desc: Test DrawBubbleHandler
426  * @tc.type: Function
427  * @tc.require:
428  */
429 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawBubbleHandler, TestSize.Level1)
430 {
431     CALL_TEST_DEBUG;
432     TouchDrawingManager touchDrawingMgr;
433     touchDrawingMgr.pointerEvent_ = PointerEvent::Create();
434     ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr);
435     touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create();
436     ASSERT_NE(touchDrawingMgr.bubbleCanvasNode_, nullptr);
437     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
438     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubbleHandler());
439 
440     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
441     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubbleHandler());
442 }
443 
444 /**
445  * @tc.name: TouchDrawingManagerTest_DrawBubble
446  * @tc.desc: Test DrawBubble
447  * @tc.type: Function
448  * @tc.require:
449  */
450 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawBubble, TestSize.Level1)
451 {
452     CALL_TEST_DEBUG;
453     TouchDrawingManager touchDrawingMgr;
454     touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create();
455     touchDrawingMgr.pointerEvent_ = PointerEvent::Create();
456     ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr);
457     PointerEvent::PointerItem item;
458     item.SetPointerId(1);
459     touchDrawingMgr.pointerEvent_->SetPointerId(1);
460     touchDrawingMgr.pointerEvent_->AddPointerItem(item);
461     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
462     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubble());
463     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
464     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubble());
465     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
466     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubble());
467 }
468 
469 /**
470  * @tc.name: TouchDrawingManagerTest_DrawBubble_001
471  * @tc.desc: Test DrawBubble
472  * @tc.type: Function
473  * @tc.require:
474  */
475 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawBubble_001, TestSize.Level1)
476 {
477     CALL_TEST_DEBUG;
478     TouchDrawingManager touchDrawingMgr;
479     touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create();
480     touchDrawingMgr.pointerEvent_ = PointerEvent::Create();
481     ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr);
482     PointerEvent::PointerItem item;
483     item.SetPointerId(1);
484     touchDrawingMgr.pointerEvent_->AddPointerItem(item);
485     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
486     item.SetPointerId(2);
487     touchDrawingMgr.pointerEvent_->SetPointerId(2);
488     touchDrawingMgr.pointerEvent_->AddPointerItem(item);
489     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawBubble());
490 }
491 
492 /**
493  * @tc.name: TouchDrawingManagerTest_DrawPointerPositionHandler
494  * @tc.desc: Test DrawPointerPositionHandler
495  * @tc.type: Function
496  * @tc.require:
497  */
498 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawPointerPositionHandler, TestSize.Level1)
499 {
500     CALL_TEST_DEBUG;
501     TouchDrawingManager touchDrawingMgr;
502     touchDrawingMgr.bubbleCanvasNode_ = Rosen::RSCanvasNode::Create();
503     touchDrawingMgr.pointerEvent_ = PointerEvent::Create();
504     ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr);
505     touchDrawingMgr.trackerCanvasNode_ = Rosen::RSCanvasNode::Create();
506     ASSERT_NE(touchDrawingMgr.trackerCanvasNode_, nullptr);
507     touchDrawingMgr.crosshairCanvasNode_ = Rosen::RSCanvasNode::Create();
508     ASSERT_NE(touchDrawingMgr.crosshairCanvasNode_, nullptr);
509     touchDrawingMgr.labelsCanvasNode_ = Rosen::RSCanvasNode::Create();
510     ASSERT_NE(touchDrawingMgr.labelsCanvasNode_, nullptr);
511     PointerEvent::PointerItem item;
512     item.SetDisplayX(300);
513     item.SetDisplayY(500);
514     item.SetPointerId(100);
515     touchDrawingMgr.scaleW_ = 720;
516     touchDrawingMgr.scaleH_ = 1800;
517     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
518     touchDrawingMgr.pointerEvent_->SetPointerId(100);
519     touchDrawingMgr.pointerEvent_->AddPointerItem(item);
520     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawPointerPositionHandler());
521 
522     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
523     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawPointerPositionHandler());
524 }
525 
526 /**
527  * @tc.name: TouchDrawingManagerTest_DrawTracker
528  * @tc.desc: Test DrawTracker
529  * @tc.type: Function
530  * @tc.require:
531  */
532 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawTracker, TestSize.Level1)
533 {
534     CALL_TEST_DEBUG;
535     TouchDrawingManager touchDrawingMgr;
536     int32_t x = 100;
537     int32_t y = 300;
538     int32_t pointerId = 10;
539     PointerEvent::PointerItem item;
540     item.SetPointerId(10);
541     item.SetDisplayX(100);
542     item.SetDisplayY(300);
543     touchDrawingMgr.isDownAction_ = true;
544     touchDrawingMgr.xVelocity_ = 200;
545     touchDrawingMgr.yVelocity_ = 400;
546     touchDrawingMgr.lastPointerItem_.push_back(item);
547     touchDrawingMgr.trackerCanvasNode_ = Rosen::RSCanvasNode::Create();
548     ASSERT_NE(touchDrawingMgr.trackerCanvasNode_, nullptr);
549     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawTracker(x, y, pointerId));
550 
551     pointerId = 20;
552     touchDrawingMgr.isDownAction_ = false;
553     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawTracker(x, y, pointerId));
554 }
555 
556 /**
557  * @tc.name: TouchDrawingManagerTest_DrawLabels
558  * @tc.desc: Test DrawLabels
559  * @tc.type: Function
560  * @tc.require:
561  */
562 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DrawLabels, TestSize.Level1)
563 {
564     CALL_TEST_DEBUG;
565     TouchDrawingManager touchDrawingMgr;
566     touchDrawingMgr.labelsCanvasNode_ = Rosen::RSCanvasNode::Create();
567     ASSERT_NE(touchDrawingMgr.labelsCanvasNode_, nullptr);
568     PointerEvent::PointerItem item;
569     touchDrawingMgr.currentPointerCount_ = 10;
570     touchDrawingMgr.maxPointerCount_ = 20;
571     touchDrawingMgr.scaleW_ = 30;
572     touchDrawingMgr.scaleH_ = 50;
573     touchDrawingMgr.xVelocity_ = 30;
574     touchDrawingMgr.yVelocity_ = 50;
575     touchDrawingMgr.pressure_ = 10;
576     touchDrawingMgr.rectTopPosition_ = 100;
577     touchDrawingMgr.itemRectW_ = 100.0;
578     touchDrawingMgr.isDownAction_ = true;
579     touchDrawingMgr.lastPointerItem_.push_back(item);
580     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawLabels());
581     touchDrawingMgr.isDownAction_ = false;
582     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawLabels());
583     touchDrawingMgr.lastPointerItem_.clear();
584     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DrawLabels());
585 }
586 
587 /**
588  * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition
589  * @tc.desc: Test UpdatePointerPosition
590  * @tc.type: Function
591  * @tc.require:
592  */
593 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdatePointerPosition, TestSize.Level1)
594 {
595     CALL_TEST_DEBUG;
596     TouchDrawingManager touchDrawingMgr;
597     touchDrawingMgr.pointerEvent_ = PointerEvent::Create();
598     ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr);
599     PointerEvent::PointerItem item;
600     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
601     touchDrawingMgr.pointerEvent_->SetPointerId(10);
602     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition());
603     touchDrawingMgr.lastPointerItem_.push_back(item);
604     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition());
605 }
606 
607 /**
608  * @tc.name: TouchDrawingManagerTest_UpdatePointerPosition_001
609  * @tc.desc: Test UpdatePointerPosition
610  * @tc.type: Function
611  * @tc.require:
612  */
613 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdatePointerPosition_001, TestSize.Level1)
614 {
615     CALL_TEST_DEBUG;
616     TouchDrawingManager touchDrawingMgr;
617     touchDrawingMgr.pointerEvent_ = PointerEvent::Create();
618     ASSERT_NE(touchDrawingMgr.pointerEvent_, nullptr);
619     PointerEvent::PointerItem item;
620     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
621     touchDrawingMgr.pointerEvent_->SetPointerId(10);
622     item.SetPointerId(20);
623     touchDrawingMgr.lastPointerItem_.push_back(item);
624     item.SetPointerId(10);
625     touchDrawingMgr.lastPointerItem_.push_back(item);
626     touchDrawingMgr.currentPointerId_ = 10;
627     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition());
628     touchDrawingMgr.lastPointerItem_.clear();
629     touchDrawingMgr.currentPointerId_ = 50;
630     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition());
631     touchDrawingMgr.pointerEvent_->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
632     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdatePointerPosition());
633 }
634 
635 /**
636  * @tc.name: TouchDrawingManagerTest_UpdateLastPointerItem
637  * @tc.desc: Test UpdateLastPointerItem
638  * @tc.type: Function
639  * @tc.require:
640  */
641 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_UpdateLastPointerItem, TestSize.Level1)
642 {
643     CALL_TEST_DEBUG;
644     TouchDrawingManager touchDrawingMgr;
645     PointerEvent::PointerItem item;
646     item.SetPressed(false);
647     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdateLastPointerItem(item));
648     item.SetPressed(true);
649     item.SetPointerId(10);
650     touchDrawingMgr.lastPointerItem_.push_back(item);
651     item.SetPointerId(20);
652     touchDrawingMgr.lastPointerItem_.push_back(item);
653     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.UpdateLastPointerItem(item));
654 }
655 
656 /**
657  * @tc.name: TouchDrawingManagerTest_DestoryTouchWindow
658  * @tc.desc: Test DestoryTouchWindow
659  * @tc.type: Function
660  * @tc.require:
661  */
662 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_DestoryTouchWindow, TestSize.Level1)
663 {
664     CALL_TEST_DEBUG;
665     TouchDrawingManager touchDrawingMgr;
666     Rosen::RSSurfaceNodeConfig surfaceNodeConfig;
667     surfaceNodeConfig.SurfaceNodeName = "touch window";
668     Rosen::RSSurfaceNodeType surfaceNodeType = Rosen::RSSurfaceNodeType::SELF_DRAWING_WINDOW_NODE;
669     touchDrawingMgr.surfaceNode_ = Rosen::RSSurfaceNode::Create(surfaceNodeConfig, surfaceNodeType);
670     ASSERT_NE(touchDrawingMgr.surfaceNode_, nullptr);
671     touchDrawingMgr.bubbleMode_.isShow = true;
672     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DestoryTouchWindow());
673     touchDrawingMgr.bubbleMode_.isShow = false;
674     touchDrawingMgr.pointerMode_.isShow = true;
675     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DestoryTouchWindow());
676     touchDrawingMgr.pointerMode_.isShow = false;
677     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.DestoryTouchWindow());
678 }
679 
680 /**
681  * @tc.name: TouchDrawingManagerTest_ClearTracker
682  * @tc.desc: Test ClearTracker
683  * @tc.type: Function
684  * @tc.require:
685  */
686 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_ClearTracker, TestSize.Level1)
687 {
688     CALL_TEST_DEBUG;
689     TouchDrawingManager touchDrawingMgr;
690     touchDrawingMgr.trackerCanvasNode_ = Rosen::RSCanvasNode::Create();
691     ASSERT_NE(touchDrawingMgr.trackerCanvasNode_, nullptr);
692     touchDrawingMgr.scaleW_ = 300;
693     touchDrawingMgr.scaleH_ = 500;
694     touchDrawingMgr.isDownAction_ = true;
695     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.ClearTracker());
696     touchDrawingMgr.isDownAction_ = false;
697     EXPECT_NO_FATAL_FAILURE(touchDrawingMgr.ClearTracker());
698 }
699 
700 /**
701  * @tc.name: TouchDrawingManagerTest_IsValidAction
702  * @tc.desc: Test IsValidAction
703  * @tc.type: Function
704  * @tc.require:
705  */
706 HWTEST_F(TouchDrawingManagerTest, TouchDrawingManagerTest_IsValidAction, TestSize.Level1)
707 {
708     CALL_TEST_DEBUG;
709     TouchDrawingManager touchDrawingMgr;
710     int32_t action = PointerEvent::POINTER_ACTION_DOWN;
711     EXPECT_TRUE(touchDrawingMgr.IsValidAction(action));
712     action = PointerEvent::POINTER_ACTION_PULL_DOWN;
713     EXPECT_TRUE(touchDrawingMgr.IsValidAction(action));
714     action = PointerEvent::POINTER_ACTION_MOVE;
715     EXPECT_TRUE(touchDrawingMgr.IsValidAction(action));
716     action = PointerEvent::POINTER_ACTION_PULL_MOVE;
717     EXPECT_TRUE(touchDrawingMgr.IsValidAction(action));
718     action = PointerEvent::POINTER_ACTION_UP;
719     EXPECT_TRUE(touchDrawingMgr.IsValidAction(action));
720     action = PointerEvent::POINTER_ACTION_PULL_UP;
721     EXPECT_TRUE(touchDrawingMgr.IsValidAction(action));
722     action = PointerEvent::POINTER_ACTION_CANCEL;
723     EXPECT_TRUE(touchDrawingMgr.IsValidAction(action));
724     action = PointerEvent::POINTER_ACTION_UNKNOWN;
725     EXPECT_FALSE(touchDrawingMgr.IsValidAction(action));
726 }
727 } // namespace MMI
728 } // namespace OHOS