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 #include "test/unittest/core/event/event_manager_test_ng.h"
16 
17 using namespace testing;
18 using namespace testing::ext;
19 namespace OHOS::Ace::NG {
20 namespace {
CreateFrameNodeGroup(int32_t targetId,size_t childCount)21 RefPtr<FrameNode> CreateFrameNodeGroup(int32_t targetId, size_t childCount)
22 {
23     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
24     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, targetId, pagePattern);
25     for (size_t i = 0; i < childCount; ++i) {
26         ++targetId;
27         auto childNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, targetId, nullptr);
28         childNode->MountToParent(pageNode);
29     }
30     return pageNode;
31 }
32 
CreateRecognizerGroup(const RefPtr<NG::FrameNode> & parentNode)33 RefPtr<NG::NGGestureRecognizer> CreateRecognizerGroup(const RefPtr<NG::FrameNode>& parentNode)
34 {
35     CHECK_NULL_RETURN(parentNode, nullptr);
36     std::list<RefPtr<NGGestureRecognizer>> recognizers;
37     for (const auto& childNode : parentNode->GetChildren()) {
38         auto childFrameNode = AceType::DynamicCast<FrameNode>(childNode);
39         if (childFrameNode) {
40             auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
41             clickRecognizer->AttachFrameNode(childFrameNode);
42             recognizers.emplace_back(clickRecognizer);
43         }
44     }
45     auto recognizerGroup = AceType::MakeRefPtr<NG::ParallelRecognizer>(std::move(recognizers));
46     if (recognizerGroup) {
47         recognizerGroup->AttachFrameNode(parentNode);
48     }
49     return recognizerGroup;
50 }
51 } // namespace
52 
53 /**
54  * @tc.name: SequenceRecognizerAxisDirection001
55  * @tc.desc: Test GetAxisDirection() of SequenceRecognizer.
56  * @tc.type: FUNC
57  */
58 HWTEST_F(EventManagerTestNg, SequenceRecognizerAxisDirection001, TestSize.Level1)
59 {
60     /**
61      * @tc.steps: step1. Create pan recognizers.
62      * @tc.expected: recognizers is not null and axis direction is correct.
63      */
64     auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
65         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
66     ASSERT_NE(panHorizontal1, nullptr);
67     auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
68         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
69     ASSERT_NE(panHorizontal2, nullptr);
70 
71     auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
72         DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
73     ASSERT_NE(panVertical1, nullptr);
74     auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
75         DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
76     ASSERT_NE(panVertical2, nullptr);
77 
78     auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
79         DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
80     ASSERT_NE(panFree1, nullptr);
81     auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
82         DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
83     ASSERT_NE(panFree2, nullptr);
84 
85     /**
86      * @tc.steps: step2. Create sequence recognizers.
87      * @tc.expected: recognizers is not null and axis direction is correct.
88      */
89     std::vector<RefPtr<NGGestureRecognizer>> recognizers;
90     recognizers.clear();
91     recognizers.emplace_back(panHorizontal1);
92     recognizers.emplace_back(panHorizontal2);
93     auto sequenceDoubleHorizontal = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
94     ASSERT_NE(sequenceDoubleHorizontal, nullptr);
95     EXPECT_EQ(sequenceDoubleHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
96 
97     recognizers.clear();
98     recognizers.emplace_back(panVertical1);
99     recognizers.emplace_back(panVertical2);
100     auto sequenceDoubleVertical = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
101     ASSERT_NE(sequenceDoubleVertical, nullptr);
102     EXPECT_EQ(sequenceDoubleVertical->GetAxisDirection(), Axis::VERTICAL);
103 
104     recognizers.clear();
105     recognizers.emplace_back(panFree1);
106     recognizers.emplace_back(panFree2);
107     auto sequenceDoubleFree = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
108     ASSERT_NE(sequenceDoubleFree, nullptr);
109     EXPECT_EQ(sequenceDoubleFree->GetAxisDirection(), Axis::FREE);
110 
111     recognizers.clear();
112     recognizers.emplace_back(panHorizontal1);
113     recognizers.emplace_back(panVertical1);
114     auto sequenceHorizontalVertical = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
115     ASSERT_NE(sequenceHorizontalVertical, nullptr);
116     EXPECT_EQ(sequenceHorizontalVertical->GetAxisDirection(), Axis::FREE);
117 
118     recognizers.clear();
119     recognizers.emplace_back(panHorizontal1);
120     recognizers.emplace_back(panFree1);
121     auto sequenceHorizontalFree = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
122     ASSERT_NE(sequenceHorizontalFree, nullptr);
123     EXPECT_EQ(sequenceHorizontalFree->GetAxisDirection(), Axis::FREE);
124 
125     recognizers.clear();
126     recognizers.emplace_back(panVertical1);
127     recognizers.emplace_back(panFree1);
128     auto sequenceVerticalFree = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
129     ASSERT_NE(sequenceVerticalFree, nullptr);
130     EXPECT_EQ(sequenceVerticalFree->GetAxisDirection(), Axis::FREE);
131 }
132 
133 /**
134  * @tc.name: HasDifferentDirectionGesture001
135  * @tc.desc: Test HasDifferentDirectionGesture() of EventManager.
136  * @tc.type: FUNC
137  */
138 HWTEST_F(EventManagerTestNg, HasDifferentDirectionGesture001, TestSize.Level1)
139 {
140     /**
141      * @tc.steps: step1. Create pan recognizers.
142      * @tc.expected: recognizers is not null and axis direction is correct.
143      */
144     auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
145         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
146     ASSERT_NE(panHorizontal1, nullptr);
147     auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
148         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
149     ASSERT_NE(panHorizontal2, nullptr);
150 
151     auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
152         DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
153     ASSERT_NE(panVertical1, nullptr);
154     auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
155         DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
156     ASSERT_NE(panVertical2, nullptr);
157 
158     auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
159         DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
160     ASSERT_NE(panFree1, nullptr);
161     auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
162         DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
163     ASSERT_NE(panFree2, nullptr);
164 
165     /**
166      * @tc.steps: step2. Create EventManager.
167      * @tc.expected: eventManager is not null.
168      */
169     auto eventManager = AceType::MakeRefPtr<EventManager>();
170     ASSERT_NE(eventManager, nullptr);
171     TouchTestResult hitTestResult;
172 
173     /**
174      * @tc.steps: step3. Add 2 horizontal recognizer to axisTouchTestResults_
175      * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is false.
176      */
177     hitTestResult.clear();
178     eventManager->axisTouchTestResults_.clear();
179     hitTestResult.emplace_back(panHorizontal1);
180     hitTestResult.emplace_back(panHorizontal2);
181     eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
182     EXPECT_FALSE(eventManager->HasDifferentDirectionGesture());
183 
184     /**
185      * @tc.steps: step4. Add 2 vertical recognizer to axisTouchTestResults_
186      * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is false.
187      */
188     hitTestResult.clear();
189     eventManager->axisTouchTestResults_.clear();
190     hitTestResult.emplace_back(panVertical1);
191     hitTestResult.emplace_back(panVertical2);
192     eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
193     EXPECT_FALSE(eventManager->HasDifferentDirectionGesture());
194 
195     /**
196      * @tc.steps: step5. Add horizontal and vertical recognizer to axisTouchTestResults_
197      * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
198      */
199     hitTestResult.clear();
200     eventManager->axisTouchTestResults_.clear();
201     hitTestResult.emplace_back(panHorizontal1);
202     hitTestResult.emplace_back(panVertical1);
203     eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
204     EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
205 
206     /**
207      * @tc.steps: step6. Add horizontal and free recognizer to axisTouchTestResults_
208      * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
209      */
210     hitTestResult.clear();
211     eventManager->axisTouchTestResults_.clear();
212     hitTestResult.emplace_back(panHorizontal1);
213     hitTestResult.emplace_back(panFree1);
214     eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
215     EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
216 
217     /**
218      * @tc.steps: step6. Add vertical and free recognizer to axisTouchTestResults_
219      * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
220      */
221     hitTestResult.clear();
222     eventManager->axisTouchTestResults_.clear();
223     hitTestResult.emplace_back(panVertical1);
224     hitTestResult.emplace_back(panFree1);
225     eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
226     EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
227 
228     /**
229      * @tc.steps: step6. Add free and free recognizer to axisTouchTestResults_
230      * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
231      */
232     hitTestResult.clear();
233     eventManager->axisTouchTestResults_.clear();
234     hitTestResult.emplace_back(panFree1);
235     hitTestResult.emplace_back(panFree2);
236     eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
237     EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
238 }
239 
240 /**
241  * @tc.name: EventManagerTest038
242  * @tc.desc: Test DispatchRotationEvent
243  * @tc.type: FUNC
244  */
245 HWTEST_F(EventManagerTestNg, EventManagerTest038, TestSize.Level1)
246 {
247     /**
248      * @tc.steps: step1. Create EventManager.
249      * @tc.expected: eventManager is not null.
250      */
251     auto eventManager = AceType::MakeRefPtr<EventManager>();
252     ASSERT_NE(eventManager, nullptr);
253 
254     /**
255      * @tc.steps: step2. Call DispatchRotationEvent.
256      * @tc.expected: ret is false.
257      */
258     RotationEvent event;
259     event.value = 0.1;
260     auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
261     auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
262     const RefPtr<RenderNode> requestNode = nullptr;
263     auto ret = eventManager->DispatchRotationEvent(event, renderNode, requestNode);
264     EXPECT_FALSE(ret);
265 }
266 
267 /**
268  * @tc.name: EventManagerTest039
269  * @tc.desc: Test PostEventDispatchTouchEvent
270  * @tc.type: FUNC
271  */
272 HWTEST_F(EventManagerTestNg, EventManagerTest039, TestSize.Level1)
273 {
274     /**
275      * @tc.steps: step1. Create EventManager.
276      * @tc.expected: eventManager is not null.
277      */
278     auto eventManager = AceType::MakeRefPtr<EventManager>();
279     ASSERT_NE(eventManager, nullptr);
280     AceEngine& aceEngine = AceEngine::Get();
281     aceEngine.AddContainer(CONTAINER_INSTANCE_ID, MockContainer::container_);
282 
283     /**
284      * @tc.steps: step2. Call PostEventDispatchTouchEvent with event.
285      * @tc.expected: ret is true
286      */
287     TouchEvent event;
288     event.type = TouchType::DOWN;
289     TouchTestResult touchTestResults;
290     auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
291     touchTestResults.push_back(eventTarget);
292     eventManager->postEventTouchTestResults_.emplace(event.id, touchTestResults);
293     auto ret = eventManager->PostEventDispatchTouchEvent(event);
294     EXPECT_TRUE(ret);
295 
296     /**
297     * @tc.steps: step3. Call PostEventDispatchTouchEvent event.
298     * @tc.expected: ret is true
299     */
300     event.type = TouchType::UP;
301     touchTestResults.push_back(eventTarget);
302     eventManager->postEventTouchTestResults_.emplace(event.id, touchTestResults);
303     ret = eventManager->PostEventDispatchTouchEvent(event);
304     EXPECT_TRUE(ret);
305 
306     /**
307     * @tc.steps: step4. Call PostEventDispatchTouchEvent event.
308     * @tc.expected: ret is true
309     */
310     event.type = TouchType::CANCEL;
311     touchTestResults.push_back(eventTarget);
312     eventManager->postEventTouchTestResults_.emplace(event.id, touchTestResults);
313     ret = eventManager->PostEventDispatchTouchEvent(event);
314     EXPECT_TRUE(ret);
315 }
316 
317 /**
318  * @tc.name: EventManagerTest040
319  * @tc.desc: Test DispatchMouseEvent
320  * @tc.type: FUNC
321  */
322 HWTEST_F(EventManagerTestNg, EventManagerTest040, TestSize.Level1)
323 {
324     /**
325      * @tc.steps: step1. Create EventManager.
326      * @tc.expected: eventManager is not null.
327      */
328     auto eventManager = AceType::MakeRefPtr<EventManager>();
329     ASSERT_NE(eventManager, nullptr);
330 
331     /**
332      * @tc.steps: step2. Call DispatchMouseEvent.
333      * @tc.expected: retFlag is true.
334      */
335     MouseEvent event;
336     event.action = MouseAction::MOVE;
337     bool retFlag = eventManager->DispatchMouseEvent(event);
338     ASSERT_TRUE(retFlag);
339 }
340 
341 /**
342  * @tc.name: EventManagerTest041
343  * @tc.desc: Test HandleGlobalEventNG
344  * @tc.type: FUNC
345  */
346 HWTEST_F(EventManagerTestNg, EventManagerTest041, TestSize.Level1)
347 {
348     /**
349      * @tc.steps: step1. Create EventManager.
350      * @tc.expected: eventManager is not null.
351      */
352     auto eventManager = AceType::MakeRefPtr<EventManager>();
353     ASSERT_NE(eventManager, nullptr);
354 
355     /**
356      * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id].
357      * @tc.expected: touchTestResults_ has the touchPoint.id of instance.
358      */
359     TouchEvent touchPoint;
360     touchPoint.id = 1000;
361     touchPoint.type = TouchType::DOWN;
362 
363     const int nodeId = 10003;
364     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
365     TouchRestrict touchRestrict;
366     Offset offset;
367 
368     eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
369     EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
370     TouchTestResult touchTestResults;
371     auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
372     touchTestResults.push_back(eventTarget);
373     eventManager->touchTestResults_.emplace(touchPoint.id, touchTestResults);
374 
375     /**
376      * @tc.steps: step3. Create FrameNode and Call HandleGlobalEventNG.
377      * @tc.expected: touchTestResults_.size() is equal to 1.
378      */
379     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode);
380     NG::OffsetF rootOffset;
381     eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset);
382     EXPECT_EQ(eventManager->touchTestResults_.size(), 1);
383 }
384 
385 /**
386  * @tc.name: EventManagerTest042
387  * @tc.desc: Test DispatchMouseHoverAnimation in MouseButton::NONE_BUTTON branches
388  * @tc.type: FUNC
389  */
390 HWTEST_F(EventManagerTestNg, EventManagerTest042, TestSize.Level1)
391 {
392     /**
393      * @tc.steps: step1. Create EventManager.
394      * @tc.expected: eventManager is not null.
395      */
396     auto eventManager = AceType::MakeRefPtr<EventManager>();
397     ASSERT_NE(eventManager, nullptr);
398 
399     /**
400      * @tc.steps: step2. Call DispatchMouseHoverAnimation with event.
401      * @tc.expected: hoverNodeCur is null.
402      */
403     MouseEvent event;
404     event.button = MouseButton::NONE_BUTTON;
405     eventManager->DispatchMouseHoverAnimation(event);
406     auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
407     EXPECT_EQ(hoverNodeCur, nullptr);
408 }
409 
410 /**
411  * @tc.name: EventManagerTest043
412  * @tc.desc: Test DispatchTouchEvent
413  * @tc.type: FUNC
414  */
415 HWTEST_F(EventManagerTestNg, EventManagerTest043, TestSize.Level1)
416 {
417     /**
418      * @tc.steps: step1. Create EventManager.
419      * @tc.expected: eventManager is not null.
420      */
421     auto eventManager = AceType::MakeRefPtr<EventManager>();
422     ASSERT_NE(eventManager, nullptr);
423     AceEngine& aceEngine = AceEngine::Get();
424     aceEngine.AddContainer(CONTAINER_INSTANCE_ID, MockContainer::container_);
425 
426     /**
427      * @tc.steps: step2. Call DispatchTouchEvent with TouchType::DOWN.
428      * @tc.expected: ret is false.
429      */
430     TouchEvent event;
431     event.type = TouchType::DOWN;
432     auto ret = eventManager->DispatchTouchEvent(event);
433     EXPECT_FALSE(ret);
434 
435     /**
436      * @tc.steps: step3. Call DispatchTouchEvent with TouchType::DOWN and
437                         touchTestResults_ has element;
438      * @tc.expected: ret is true
439      */
440     TouchTestResult touchTestResults;
441     auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
442     touchTestResults.push_back(eventTarget);
443     eventManager->touchTestResults_.emplace(event.id, touchTestResults);
444     ret = eventManager->DispatchTouchEvent(event);
445     EXPECT_TRUE(ret);
446 
447     /**
448      * @tc.steps: step4. Call DispatchTouchEvent with TouchType::PULL_MOVE and
449                         touchTestResults_ has element;
450      * @tc.expected: ret is true
451      */
452     event.type = TouchType::PULL_MOVE;
453     ret = eventManager->DispatchTouchEvent(event);
454     EXPECT_TRUE(ret);
455 
456     /**
457      * @tc.steps: step5. Call DispatchTouchEvent with TouchType::PULL_MOVE and
458                         touchTestResults_ has element;
459      * @tc.expected: ret is false.
460      */
461     event.pullType = TouchType::PULL_MOVE;
462     ret = eventManager->DispatchTouchEvent(event);
463     EXPECT_FALSE(ret);
464 }
465 
466 /**
467  * @tc.name: EventManagerTest057
468  * @tc.desc: Test AddGestureSnapshot function.
469  * @tc.type: FUNC
470  */
471 HWTEST_F(EventManagerTestNg, EventManagerTest057, TestSize.Level1)
472 {
473     /**
474      * @tc.steps: step1. Create EventManager.
475      * @tc.expected: eventManager is not null.
476      */
477     auto eventManager = AceType::MakeRefPtr<EventManager>();
478     ASSERT_NE(eventManager, nullptr);
479     auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
480         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
481     eventManager->AddGestureSnapshot(1, 1, panHorizontal1, EventTreeType::TOUCH);
482 
483     auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
484     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
485     mouseEventTarget->node_ = frameNode;
486     eventManager->AddGestureSnapshot(1, 1, mouseEventTarget, EventTreeType::TOUCH);
487 
488     eventManager->AddGestureSnapshot(1, 1, nullptr, EventTreeType::TOUCH);
489     ASSERT_TRUE(eventManager->eventTree_.eventTreeList.empty());
490 }
491 
492 /**
493  * @tc.name: EventManagerTest058
494  * @tc.desc: Test SetHittedFrameNode function.
495  * @tc.type: FUNC
496  */
497 HWTEST_F(EventManagerTestNg, EventManagerTest058, TestSize.Level1)
498 {
499     /**
500      * @tc.steps: step1. Create EventManager.
501      * @tc.expected: eventManager is not null.
502      */
503     auto eventManager = AceType::MakeRefPtr<EventManager>();
504     ASSERT_NE(eventManager, nullptr);
505 
506     auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
507         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
508     auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
509         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
510     std::list<RefPtr<NG::NGGestureRecognizer>> touchTestResults;
511     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
512     panHorizontal1->node_ = frameNode;
513     touchTestResults.emplace_back(panHorizontal1);
514     touchTestResults.emplace_back(panHorizontal2);
515     eventManager->SetHittedFrameNode(touchTestResults);
516     ASSERT_TRUE(eventManager->eventTree_.eventTreeList.empty());
517 }
518 
519 /**
520  * @tc.name: EventManagerTest059
521  * @tc.desc: Test CleanGestureEventHub function.
522  * @tc.type: FUNC
523  */
524 HWTEST_F(EventManagerTestNg, EventManagerTest059, TestSize.Level1)
525 {
526     /**
527      * @tc.steps: step1. Create EventManager.
528      * @tc.expected: eventManager is not null.
529      */
530     auto eventManager = AceType::MakeRefPtr<EventManager>();
531     ASSERT_NE(eventManager, nullptr);
532     std::set<WeakPtr<FrameNode>> hittedFrameNode;
533     eventManager->hittedFrameNode_ = hittedFrameNode;
534     eventManager->CleanGestureEventHub();
535     ASSERT_TRUE(eventManager->hittedFrameNode_.empty());
536 
537     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
538     auto frameNode2 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
539     auto eventHub = AceType::MakeRefPtr<EventHub>();
540     frameNode2->eventHub_ = eventHub;
541     hittedFrameNode.insert(frameNode);
542     hittedFrameNode.insert(frameNode2);
543     hittedFrameNode.insert(nullptr);
544     eventManager->hittedFrameNode_ = hittedFrameNode;
545     eventManager->CleanGestureEventHub();
546     ASSERT_TRUE(eventManager->hittedFrameNode_.empty());
547 }
548 
549 /**
550  * @tc.name: EventManagerTest060
551  * @tc.desc: Test CheckAndLogLastReceivedEventInfo function.
552  * @tc.type: FUNC
553  */
554 HWTEST_F(EventManagerTestNg, EventManagerTest060, TestSize.Level1)
555 {
556     /**
557      * @tc.steps: step1. Create EventManager.
558      * @tc.expected: eventManager is not null.
559      */
560     auto eventManager = AceType::MakeRefPtr<EventManager>();
561     ASSERT_NE(eventManager, nullptr);
562     int eventId = 1;
563     bool logImmediately = true;
564 
565     eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
566     ASSERT_TRUE(eventManager->lastReceivedEvent_.eventId == -1);
567 
568     logImmediately = false;
569     eventManager->lastReceivedEvent_.lastLogTimeStamp = 0;
570     eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
571     ASSERT_TRUE(eventManager->lastReceivedEvent_.eventId == 1);
572 
573     auto currentTime = GetSysTimestamp();
574     auto lastLogTimeStamp = currentTime - 1000 * 1000000 - 1000;
575     eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp;
576     eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
577 
578     eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000;
579     eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
580     ASSERT_TRUE(eventManager->lastReceivedEvent_.lastLogTimeStamp == lastLogTimeStamp + 20000);
581 }
582 
583 /**
584  * @tc.name: EventManagerTest061
585  * @tc.desc: Test CheckAndLogLastConsumedEventInfo function.
586  * @tc.type: FUNC
587  */
588 HWTEST_F(EventManagerTestNg, EventManagerTest061, TestSize.Level1)
589 {
590     /**
591      * @tc.steps: step1. Create EventManager.
592      * @tc.expected: eventManager is not null.
593      */
594     auto eventManager = AceType::MakeRefPtr<EventManager>();
595     ASSERT_NE(eventManager, nullptr);
596     int eventId = 1;
597     bool logImmediately = true;
598 
599     eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
600 
601     logImmediately = false;
602     eventManager->lastConsumedEvent_.lastLogTimeStamp = 0;
603     eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
604     ASSERT_TRUE(eventManager->lastConsumedEvent_.eventId == 1);
605 
606     auto currentTime = GetSysTimestamp();
607     auto lastLogTimeStamp = currentTime - 1000 * 1000000 - 1000;
608     eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp;
609     eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
610 
611     eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000;
612     eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000;
613     eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
614     ASSERT_TRUE(eventManager->lastConsumedEvent_.lastLogTimeStamp == lastLogTimeStamp + 20000);
615 }
616 
617 /**
618  * @tc.name: EventManagerTest062
619  * @tc.desc: Test SetResponseLinkRecognizers function.
620  * @tc.type: FUNC
621  */
622 HWTEST_F(EventManagerTestNg, EventManagerTest062, TestSize.Level1)
623 {
624     /**
625      * @tc.steps: step1. Create EventManager.
626      * @tc.expected: eventManager is not null.
627      */
628     auto eventManager = AceType::MakeRefPtr<EventManager>();
629     ASSERT_NE(eventManager, nullptr);
630 
631     auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
632         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
633     std::list<RefPtr<TouchEventTarget>> result;
634     ResponseLinkResult responseLinkRecognizers;
635     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
636     panHorizontal1->node_ = frameNode;
637     result.emplace_back(panHorizontal1);
638     result.emplace_back(nullptr);
639     responseLinkRecognizers.emplace_back(panHorizontal1);
640 
641     eventManager->SetResponseLinkRecognizers(result, responseLinkRecognizers);
642     ASSERT_TRUE(responseLinkRecognizers.size() == 1);
643 }
644 
645 /**
646  * @tc.name: EventManagerTest063
647  * @tc.desc: Test touchtest
648  * @tc.type: FUNC
649  */
650 HWTEST_F(EventManagerTestNg, EventManagerTest063, TestSize.Level1)
651 {
652     /**
653      * @tc.steps: step1. Create EventManager.
654      * @tc.expected: eventManager is not null.
655      */
656     auto eventManager = AceType::MakeRefPtr<EventManager>();
657     ASSERT_NE(eventManager, nullptr);
658 
659     /**
660      * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id].
661      * @tc.expected: touchTestResults_ has the touchPoint.id of instance.
662      */
663     TouchEvent touchPoint;
664     touchPoint.id = 1;
665     touchPoint.type = TouchType::DOWN;
666     touchPoint.sourceType = SourceType::TOUCH;
667     auto currentTime = GetSysTimestamp();
668     auto lastTime = currentTime - 1000 * 1000000 - 1000;
669     TimeStamp lastTimeStamp((std::chrono::milliseconds(lastTime)));
670     TimeStamp currentTimeStamp((std::chrono::milliseconds(currentTime)));
671     eventManager->lastEventTime_ = lastTimeStamp;
672     touchPoint.time = currentTimeStamp;
673     const int nodeId = 1;
674     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, nodeId, nullptr);
675     TouchRestrict touchRestrict;
676     Offset offset;
677     auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
678     ASSERT_NE(clickRecognizer, nullptr);
679     clickRecognizer->OnRejected();
680     auto gestureRefereeNg = eventManager->GetGestureRefereeNG(clickRecognizer);
681     ASSERT_NE(gestureRefereeNg, nullptr);
682     gestureRefereeNg->CheckSourceTypeChange(SourceType::NONE, true);
683     TouchTestResult resultList = { clickRecognizer };
684     eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
685     EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
686 }
687 
688 /**
689  * @tc.name: EventManagerTest064
690  * @tc.desc: Test LogTouchTestResultRecognizers
691  * @tc.type: FUNC
692  */
693 HWTEST_F(EventManagerTestNg, EventManagerTest064, TestSize.Level1)
694 {
695     /**
696      * @tc.steps: step1. Create EventManager.
697      * @tc.expected: eventManager is not null.
698      */
699     auto eventManager = AceType::MakeRefPtr<EventManager>();
700     ASSERT_NE(eventManager, nullptr);
701 
702     /**
703      * @tc.steps: step2. Call LogTouchTestResultRecognizers.
704      * @tc.expected: ret is false.
705      */
706     TouchEvent event;
707     event.type = TouchType::DOWN;
708     event.id = 1;
709     TouchTestResult resultList;
710     auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
711         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
712     ASSERT_NE(panHorizontal, nullptr);
713     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
714     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
715     panHorizontal->AttachFrameNode(pageNode);
716     resultList.emplace_back(panHorizontal);
717     eventManager->LogTouchTestResultRecognizers(resultList, 1);
718     ASSERT_FALSE(panHorizontal->isFlushTouchEventsEnd_);
719 }
720 
721 /**
722  * @tc.name: EventManagerTest065
723  * @tc.desc: Test HandleGlobalEventNG whith mouse
724  * @tc.type: FUNC
725  */
726 HWTEST_F(EventManagerTestNg, EventManagerTest065, TestSize.Level1)
727 {
728     /**
729      * @tc.steps: step1. Create EventManager.
730      * @tc.expected: eventManager is not null.
731      */
732     auto eventManager = AceType::MakeRefPtr<EventManager>();
733     ASSERT_NE(eventManager, nullptr);
734 
735     /**
736      * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id].
737      * @tc.expected: touchTestResults_ has the touchPoint.id of instance.
738      */
739     TouchEvent touchPoint;
740     touchPoint.id = 1000;
741     touchPoint.type = TouchType::DOWN;
742     touchPoint.sourceType = SourceType::MOUSE;
743 
744     const int nodeId = 10003;
745     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
746     TouchRestrict touchRestrict;
747     Offset offset;
748 
749     auto eventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE_EVENT, nodeId);
750     eventManager->currMouseTestResults_.emplace_back(eventTarget);
751 
752     /**
753      * @tc.steps: step3. Create FrameNode and Call HandleGlobalEventNG.
754      * @tc.expected: currMouseTestResults_.size is equal to 1.
755      */
756     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode);
757     NG::OffsetF rootOffset;
758     eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset);
759     EXPECT_EQ(eventManager->currMouseTestResults_.size(), 1);
760 }
761 
762 /**
763  * @tc.name: EventManagerTest066
764  * @tc.desc: Test GetTouchTestIds function.
765  * @tc.type: FUNC
766  */
767 HWTEST_F(EventManagerTestNg, EventManagerTest066, TestSize.Level1)
768 {
769     /**
770      * @tc.steps: step1. Create EventManager.
771      * @tc.expected: eventManager is not null.
772      */
773     auto eventManager = AceType::MakeRefPtr<EventManager>();
774     ASSERT_NE(eventManager, nullptr);
775 
776     TouchEvent event;
777     event.type = TouchType::DOWN;
778     event.id = 1;
779     std::vector<std::string> touchTestIds;
780     auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
781         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
782     ASSERT_NE(panHorizontal, nullptr);
__anon8f55066f0202() 783     panHorizontal->SetGetEventTargetImpl([]() -> std::optional<EventTarget> {
784         struct EventTarget eventTarget = {
785             .id = "eventTargetCallback",
786             .type = "eventTargetType"
787         };
788         std::optional<EventTarget> eventTargetCallback = eventTarget;
789         return eventTargetCallback;
790     });
791 
792     TouchTestResult hitTestResult;
793     hitTestResult.emplace_back(panHorizontal);
794     eventManager->touchTestResults_.insert({event.id, hitTestResult});
795     bool isMousePressAtSelectedNode = false;
796     eventManager->GetTouchTestIds(event, touchTestIds, isMousePressAtSelectedNode, 1);
797     ASSERT_FALSE(isMousePressAtSelectedNode);
798     ASSERT_FALSE(touchTestIds.empty());
799 }
800 
801 /**
802  * @tc.name: EventManagerTest067
803  * @tc.desc: Test HandleOutOfRectCallback
804  * @tc.type: FUNC
805  */
806 HWTEST_F(EventManagerTestNg, EventManagerTest067, TestSize.Level2)
807 {
808     /**
809      * @tc.steps: step1. Create EventManager.
810      * @tc.expected: eventManager is not null.
811      */
812     auto eventManager = AceType::MakeRefPtr<EventManager>();
813     ASSERT_NE(eventManager, nullptr);
814 
815     /**
816      * @tc.steps: step2. Create rectCallbackList
817      * @tc.expected: touchTestResults_ has the touchPoint.id of instance
818      */
819     Point point(10, 20);
820     point.SetSourceType(SourceType::TOUCH);
821 
__anon8f55066f0302(std::vector<Rect>& rectList) 822     auto rectGetCallback = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect()); };
823 
__anon8f55066f0402() 824     auto touchCallback = []() -> void {};
__anon8f55066f0502() 825     auto mouseCallback = []() -> void {};
826     std::vector<RectCallback> rectCallbackList {
827         RectCallback(rectGetCallback, touchCallback, nullptr),
828         RectCallback(rectGetCallback, nullptr, mouseCallback)
829     };
830 
831     /**
832      * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::TOUCH
833      * @tc.expected: rectCallbackList.size() is 1
834      */
835     eventManager->HandleOutOfRectCallback(point, rectCallbackList);
836     EXPECT_EQ(rectCallbackList.size(), 1);
837 
838     /**
839      * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::MOUSE
840      * @tc.expected: rectCallbackList is empty
841      */
842     point.SetSourceType(SourceType::MOUSE);
843     eventManager->HandleOutOfRectCallback(point, rectCallbackList);
844     EXPECT_TRUE(rectCallbackList.empty());
845 }
846 
847 /**
848  * @tc.name: EventManagerTest068
849  * @tc.desc: Test DispatchTouchEventToTouchTestResult
850  * @tc.type: FUNC
851  */
852 HWTEST_F(EventManagerTestNg, EventManagerTest068, TestSize.Level1)
853 {
854     auto eventManager = AceType::MakeRefPtr<EventManager>();
855     ASSERT_NE(eventManager, nullptr);
856     auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
857         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
858     ASSERT_NE(panHorizontal, nullptr);
859     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
860     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
861     int64_t deviceId = 20240711;
862     TouchEvent event;
863     event.type = TouchType::DOWN;
864     event.deviceId = deviceId;
865     event.sourceType = SourceType::TOUCH;
866     panHorizontal->AttachFrameNode(pageNode);
867 
868     TouchTestResult resultList;
869     resultList.emplace_back(panHorizontal);
870     eventManager->DispatchTouchEventToTouchTestResult(event, resultList, false);
871     EXPECT_EQ(panHorizontal->deviceId_, deviceId);
872     EXPECT_TRUE(panHorizontal->deviceType_ == SourceType::TOUCH);
873 }
874 
875 /**
876  * @tc.name: EventManagerTest070
877  * @tc.desc: Test MouseTest For API12.
878  * @tc.type: FUNC
879  */
880 HWTEST_F(EventManagerTestNg, EventManagerTest070, TestSize.Level1)
881 {
882     /**
883      * @tc.steps: step1. Create EventManager.
884      * @tc.expected: eventManager is not null.
885      */
886     auto eventManager = AceType::MakeRefPtr<EventManager>();
887     ASSERT_NE(eventManager, nullptr);
888     int32_t settingApiVersion = 12;
889     int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion();
890     AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion);
891 
892     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
893     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
894 
895     MouseEvent event;
896     event.action = MouseAction::MOVE;
897     event.button = MouseButton::RIGHT_BUTTON;
898     TouchRestrict touchRestrict;
899     eventManager->MouseTest(event, pageNode, touchRestrict);
900 
901     event.action = MouseAction::WINDOW_ENTER;
902     eventManager->MouseTest(event, pageNode, touchRestrict);
903     EXPECT_TRUE(touchRestrict.touchEvent.isMouseTouchTest);
904     AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion);
905 }
906 
907 /**
908  * @tc.name: EventManagerTest071
909  * @tc.desc: Test UpdateHoverNode
910  * @tc.type: FUNC
911  */
912 HWTEST_F(EventManagerTestNg, EventManagerTest071, TestSize.Level1)
913 {
914     auto eventManager = AceType::MakeRefPtr<EventManager>();
915     ASSERT_NE(eventManager, nullptr);
916 
917     MouseEvent event;
918     auto hoverEffectTarget = AceType::MakeRefPtr<HoverEffectTarget>(CTRLSHIFT, NODEID);
919     std::list<RefPtr<TouchEventTarget>> testResult = { hoverEffectTarget };
920     eventManager->UpdateHoverNode(event, testResult);
921     EXPECT_TRUE(eventManager->currMouseTestResults_.empty());
922 }
923 
924 /**
925  * @tc.name: EventManagerTest072
926  * @tc.desc: Test UpdateHoverNode
927  * @tc.type: FUNC
928  */
929 HWTEST_F(EventManagerTestNg, EventManagerTest072, TestSize.Level1)
930 {
931     auto eventManager = AceType::MakeRefPtr<EventManager>();
932     ASSERT_NE(eventManager, nullptr);
933 
934     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
935     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
936     EXPECT_FALSE(eventManager->IsSkipEventNode(pageNode));
937 }
938 
939 /**
940  * @tc.name: EventManagerTest073
941  * @tc.desc: Test AddKeyboardShortcutNode
942  * @tc.type: FUNC
943  */
944 HWTEST_F(EventManagerTestNg, EventManagerTest073, TestSize.Level2)
945 {
946     auto eventManager = AceType::MakeRefPtr<EventManager>();
947     auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
948     auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, NODEID, nullptr);
949     frameNodeCtrl->SetActive(true);
950     frameNodeCtrlShift->SetActive(true);
951 
952     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
953     eventManager->AddKeyboardShortcutNode(nullptr);
954     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
955     EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
956 }
957 
958 /**
959  * @tc.name: EventManagerTest074
960  * @tc.desc: Test DispatchKeyboardShortcut
961  * @tc.type: FUNC
962  */
963 HWTEST_F(EventManagerTestNg, EventManagerTest074, TestSize.Level1)
964 {
965     auto eventManager = AceType::MakeRefPtr<EventManager>();
966     KeyEvent event;
967     auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
968     auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NODEID, nullptr);
969     auto frameNodeAlt = FrameNode::GetOrCreateFrameNode(ALT, NODEID, nullptr);
970     auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, NODEID, nullptr);
971     frameNodeCtrl->SetActive(true);
972     frameNodeShift->SetActive(true);
973     frameNodeAlt->SetActive(true);
974     frameNodeCtrlShift->SetActive(true);
975 
976     auto eventHubCtrl = frameNodeCtrl->GetEventHub<NG::EventHub>();
977     auto eventHubShift = frameNodeShift->GetEventHub<NG::EventHub>();
978     auto eventHubAlt = frameNodeAlt->GetEventHub<NG::EventHub>();
979     auto eventHubCtrlShift = frameNodeCtrlShift->GetEventHub<NG::EventHub>();
980 
981     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
982     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
983     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeAlt));
984     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
985     eventHubCtrl->SetKeyboardShortcut(CHARACTER_C, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE + NUM_ALT_VALUE), nullptr);
986     event.code = KeyCode::KEY_C;
987     event.action = KeyAction::DOWN;
988     event.pressedCodes.emplace_back(KeyCode::KEY_CTRL_LEFT);
989     event.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
990     event.pressedCodes.emplace_back(KeyCode::KEY_ALT_LEFT);
991     event.pressedCodes.emplace_back(KeyCode::KEY_C);
992     eventManager->DispatchKeyboardShortcut(event);
993     EXPECT_EQ(event.action, KeyAction::DOWN);
994 }
995 
996 /**
997  * @tc.name: EventManagerTest075
998  * @tc.desc: Test DispatchKeyboardShortcut
999  * @tc.type: FUNC
1000  */
1001 HWTEST_F(EventManagerTestNg, EventManagerTest075, TestSize.Level2)
1002 {
1003     auto eventManager = AceType::MakeRefPtr<EventManager>();
1004     KeyEvent event;
1005     event.action = KeyAction::CLICK;
1006     EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1007 
1008     auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
1009     auto eventHubCtrl = frameNodeCtrl->GetEventHub<NG::EventHub>();
1010     frameNodeCtrl->SetActive(true);
1011 
1012     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
1013     uint8_t singleKeys = 0;
1014     eventHubCtrl->SetKeyboardShortcut(CTRL, singleKeys, nullptr);
1015     event.action = KeyAction::DOWN;
1016     event.code = KeyCode::KEY_ESCAPE;
1017     EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1018 
1019     eventHubCtrl->SetKeyboardShortcut(std::string(), (NUM_CTRL_VALUE + NUM_SHIFT_VALUE), nullptr);
1020     EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1021 
1022     eventHubCtrl->SetEnabled(false);
1023     EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1024 }
1025 
1026 /**
1027  * @tc.name: EventManagerTest076
1028  * @tc.desc: Test EventManager constructor fire callBack
1029  * @tc.type: FUNC
1030  */
1031 HWTEST_F(EventManagerTestNg, EventManagerTest076, TestSize.Level1)
1032 {
1033     auto eventManager = AceType::MakeRefPtr<EventManager>();
1034     ASSERT_NE(eventManager, nullptr);
1035     auto referee = eventManager->GetGestureReferee();
1036     ASSERT_NE(referee, nullptr);
1037     int32_t touchId = 10;
1038     ASSERT_NE(referee->queryStateFunc_, nullptr);
1039     referee->queryStateFunc_(touchId);
1040     auto gestureRefereeNg = eventManager->GetGestureRefereeNG(AceType::MakeRefPtr<ClickRecognizer>());
1041     ASSERT_NE(gestureRefereeNg, nullptr);
1042     ASSERT_NE(gestureRefereeNg->queryStateFunc_, nullptr);
1043     gestureRefereeNg->queryStateFunc_(touchId);
1044 }
1045 
1046 /**
1047  * @tc.name: EventManagerTest077
1048  * @tc.desc: Test AddGestureSnapshot
1049  * @tc.type: FUNC
1050  */
1051 HWTEST_F(EventManagerTestNg, EventManagerTest077, TestSize.Level1)
1052 {
1053     auto eventManager = AceType::MakeRefPtr<EventManager>();
1054     ASSERT_NE(eventManager, nullptr);
1055     auto eventTree = eventManager->GetEventTreeRecord(EventTreeType::TOUCH);
1056     TouchEvent event;
1057     event.type = Ace::TouchType::DOWN;
1058     event.id = 1;
1059     eventTree.AddTouchPoint(event);
1060     eventManager->DumpEvent(EventTreeType::TOUCH);
1061 
1062     int32_t finger = 1;
1063     int32_t depth = 0;
1064     int32_t nodeId = 16;
1065     eventManager->AddGestureSnapshot(finger, depth, nullptr, EventTreeType::TOUCH);
1066     auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1067     auto recognizerGroup = CreateRecognizerGroup(parentNode);
1068     eventManager->AddGestureSnapshot(finger, depth, recognizerGroup, EventTreeType::TOUCH);
1069     EXPECT_FALSE(eventTree.eventTreeList.empty());
1070 }
1071 
1072 /**
1073  * @tc.name: EventManagerTest078
1074  * @tc.desc: Test SetHittedFrameNode
1075  * @tc.type: FUNC
1076  */
1077 HWTEST_F(EventManagerTestNg, EventManagerTest078, TestSize.Level1)
1078 {
1079     auto eventManager = AceType::MakeRefPtr<EventManager>();
1080     ASSERT_NE(eventManager, nullptr);
1081 
1082     int32_t nodeId = 16;
1083     auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1084     auto recognizerGroup = CreateRecognizerGroup(parentNode);
1085 
1086     std::list<RefPtr<NG::NGGestureRecognizer>> gestureRecognizers;
1087     eventManager->SetHittedFrameNode(gestureRecognizers);
1088     EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
1089 
1090     gestureRecognizers.emplace_back(recognizerGroup);
1091     eventManager->SetHittedFrameNode(gestureRecognizers);
1092     EXPECT_FALSE(eventManager->hittedFrameNode_.empty());
1093 }
1094 
1095 /**
1096  * @tc.name: EventManagerTest079
1097  * @tc.desc: Test CleanGestureEventHub
1098  * @tc.type: FUNC
1099  */
1100 HWTEST_F(EventManagerTestNg, EventManagerTest079, TestSize.Level1)
1101 {
1102     auto eventManager = AceType::MakeRefPtr<EventManager>();
1103     ASSERT_NE(eventManager, nullptr);
1104 
1105     int32_t nodeId = 16;
1106     auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1107     auto recognizerGroup = CreateRecognizerGroup(parentNode);
1108 
1109     std::list<RefPtr<NG::NGGestureRecognizer>> gestureRecognizers;
1110     gestureRecognizers.emplace_back(recognizerGroup);
1111     eventManager->SetHittedFrameNode(gestureRecognizers);
1112     EXPECT_FALSE(eventManager->hittedFrameNode_.empty());
1113     eventManager->CleanGestureEventHub();
1114     EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
1115 }
1116 
1117 /**
1118  * @tc.name: EventManagerTest080
1119  * @tc.desc: Test SetResponseLinkRecognizers
1120  * @tc.type: FUNC
1121  */
1122 HWTEST_F(EventManagerTestNg, EventManagerTest080, TestSize.Level1)
1123 {
1124     auto eventManager = AceType::MakeRefPtr<EventManager>();
1125     ASSERT_NE(eventManager, nullptr);
1126 
1127     int32_t nodeId = 16;
1128     auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1129     auto recognizerGroup = CreateRecognizerGroup(parentNode);
1130     auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1131         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1132     auto targetLinkHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1133         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1134 
1135     TouchTestResult resultList;
1136     ResponseLinkResult responseLinkRecognizers;
1137     resultList.emplace_back(recognizerGroup);
1138     resultList.emplace_back(panHorizontal);
1139     responseLinkRecognizers.emplace_back(targetLinkHorizontal);
1140     eventManager->SetResponseLinkRecognizers(resultList, responseLinkRecognizers);
1141     EXPECT_TRUE(responseLinkRecognizers.size() == 1);
1142 }
1143 
1144 /**
1145  * @tc.name: EventManagerTest081
1146  * @tc.desc: Test FalsifyCancelEventAndDispatch
1147  * @tc.type: FUNC
1148  */
1149 HWTEST_F(EventManagerTestNg, EventManagerTest081, TestSize.Level1)
1150 {
1151     auto eventManager = AceType::MakeRefPtr<EventManager>();
1152     ASSERT_NE(eventManager, nullptr);
1153 
1154     int32_t nodeId = 32;
1155     auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1156     auto recognizerGroup = CreateRecognizerGroup(parentNode);
1157     auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1158         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1159     TouchTestResult resultList;
1160     resultList.emplace_back(recognizerGroup);
1161     resultList.emplace_back(panHorizontal);
1162     eventManager->axisTouchTestResults_.clear();
1163     eventManager->axisTouchTestResults_[0] = resultList;
1164     AxisEvent event;
1165     eventManager->FalsifyCancelEventAndDispatch(event);
1166     EXPECT_TRUE(eventManager->axisTouchTestResults_.empty());
1167 }
1168 
1169 /**
1170  * @tc.name: GetSetPressedKeyCodesTest001
1171  * @tc.desc: Test GetPressedKeyCodes and SetPressedKeyCodes function.
1172  * @tc.type: FUNC
1173  */
1174 HWTEST_F(EventManagerTestNg, GetSetPressedKeyCodesTest001, TestSize.Level1)
1175 {
1176     /**
1177      * @tc.steps: step2. Call SetPressedKeyCodes GetPressedKeyCodes with event.
1178      * @tc.expected: pressedKeyCodes size is 2.
1179      */
1180     BaseEventInfo event("test");
1181     event.SetPressedKeyCodes({KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_CTRL_RIGHT});
1182     auto pressedKeyCodes = event.GetPressedKeyCodes();
1183     EXPECT_EQ(pressedKeyCodes.size(), 2);
1184     EXPECT_EQ(pressedKeyCodes[1], KeyCode::KEY_CTRL_RIGHT);
1185 }
1186 } // namespace OHOS::Ace::NG