1 /*
2  * Copyright (c) 2023 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 "test/unittest/core/event/event_manager_test_ng.h"
17 
18 using namespace testing;
19 using namespace testing::ext;
20 namespace OHOS::Ace::NG {
SetUpTestSuite()21 void EventManagerTestNg::SetUpTestSuite()
22 {
23     MockContainer::SetUp();
24     MockContainer::Current()->pipelineContext_ = nullptr;
25     MOCK_TASK_EXECUTOR = AceType::MakeRefPtr<MockTaskExecutor>();
26 }
27 
TearDownTestSuite()28 void EventManagerTestNg::TearDownTestSuite()
29 {
30     MockContainer::TearDown();
31 }
32 
33 /**
34  * @tc.name: EventManagerTest001
35  * @tc.desc: Test OnDragStart
36  * @tc.type: FUNC
37  */
38 HWTEST_F(EventManagerTestNg, EventManagerTest001, TestSize.Level1)
39 {
40     auto eventManager = AceType::MakeRefPtr<EventManager>();
41 
42     bool isCtrlC = eventManager->IsSystemKeyboardShortcut(CHARACTER_C, NUM_CTRL_VALUE);
43     bool isCtrlA = eventManager->IsSystemKeyboardShortcut(CHARACTER_A, NUM_CTRL_VALUE);
44     bool isCtrlV = eventManager->IsSystemKeyboardShortcut(CHARACTER_V, NUM_CTRL_VALUE);
45     bool isCtrl8 = eventManager->IsSystemKeyboardShortcut(CHARACTER_EIGHT, NUM_CTRL_VALUE);
46     bool isCtrlX = eventManager->IsSystemKeyboardShortcut(CHARACTER_X, NUM_CTRL_VALUE);
47     bool isShiftC = eventManager->IsSystemKeyboardShortcut(CHARACTER_C, NUM_SHIFT_VALUE);
48     bool isShiftA = eventManager->IsSystemKeyboardShortcut(CHARACTER_A, NUM_SHIFT_VALUE);
49     bool isShiftV = eventManager->IsSystemKeyboardShortcut(CHARACTER_V, NUM_SHIFT_VALUE);
50     bool isShift8 = eventManager->IsSystemKeyboardShortcut(CHARACTER_EIGHT, NUM_SHIFT_VALUE);
51     bool isShiftX = eventManager->IsSystemKeyboardShortcut(CHARACTER_X, NUM_SHIFT_VALUE);
52     bool isAltC = eventManager->IsSystemKeyboardShortcut(CHARACTER_C, NUM_ALT_VALUE);
53     bool isAltA = eventManager->IsSystemKeyboardShortcut(CHARACTER_A, NUM_ALT_VALUE);
54     bool isAltV = eventManager->IsSystemKeyboardShortcut(CHARACTER_V, NUM_ALT_VALUE);
55     bool isAlt8 = eventManager->IsSystemKeyboardShortcut(CHARACTER_EIGHT, NUM_ALT_VALUE);
56     bool isAltX = eventManager->IsSystemKeyboardShortcut(CHARACTER_X, NUM_ALT_VALUE);
57     bool isCtrlShiftC = eventManager->IsSystemKeyboardShortcut(CHARACTER_C, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
58     bool isCtrlShiftA = eventManager->IsSystemKeyboardShortcut(CHARACTER_A, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
59     bool isCtrlShiftV = eventManager->IsSystemKeyboardShortcut(CHARACTER_V, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
60     bool isCtrlShift8 = eventManager->IsSystemKeyboardShortcut(CHARACTER_EIGHT, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
61     bool isCtrlShiftX = eventManager->IsSystemKeyboardShortcut(CHARACTER_X, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
62 
63     EXPECT_TRUE(isCtrlC);
64     EXPECT_TRUE(isCtrlA);
65     EXPECT_TRUE(isCtrlV);
66     EXPECT_FALSE(isCtrl8);
67     EXPECT_TRUE(isCtrlX);
68     EXPECT_FALSE(isShiftC);
69     EXPECT_FALSE(isShiftA);
70     EXPECT_FALSE(isShiftV);
71     EXPECT_FALSE(isShift8);
72     EXPECT_FALSE(isShiftX);
73     EXPECT_FALSE(isAltC);
74     EXPECT_FALSE(isAltA);
75     EXPECT_FALSE(isAltV);
76     EXPECT_FALSE(isAlt8);
77     EXPECT_FALSE(isAltX);
78     EXPECT_FALSE(isCtrlShiftC);
79     EXPECT_FALSE(isCtrlShiftA);
80     EXPECT_FALSE(isCtrlShiftV);
81     EXPECT_FALSE(isCtrlShift8);
82     EXPECT_FALSE(isCtrlShiftX);
83 }
84 
85 /**
86  * @tc.name: EventManagerTest002
87  * @tc.desc: Test OnDragStart
88  * @tc.type: FUNC
89  */
90 HWTEST_F(EventManagerTestNg, EventManagerTest002, TestSize.Level1)
91 {
92     auto eventManager = AceType::MakeRefPtr<EventManager>();
93     KeyEvent event;
94     auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
95     auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NODEID, nullptr);
96     auto frameNodeAlt = FrameNode::GetOrCreateFrameNode(ALT, NODEID, nullptr);
97     auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, NODEID, nullptr);
98     frameNodeCtrl->SetActive(true);
99     frameNodeShift->SetActive(true);
100     frameNodeAlt->SetActive(true);
101     frameNodeCtrlShift->SetActive(true);
102 
103     auto eventHubCtrl = frameNodeCtrl->GetEventHub<NG::EventHub>();
104     auto eventHubShift = frameNodeShift->GetEventHub<NG::EventHub>();
105     auto eventHubAlt = frameNodeAlt->GetEventHub<NG::EventHub>();
106     auto eventHubCtrlShift = frameNodeCtrlShift->GetEventHub<NG::EventHub>();
107 
108     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
109     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
110     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeAlt));
111     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
__anon97ae3e060102() 112     eventHubCtrl->SetKeyboardShortcut(CHARACTER_C, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE + NUM_ALT_VALUE), []() {});
113     event.code = KeyCode::KEY_C;
114     event.action = KeyAction::DOWN;
115     event.pressedCodes.emplace_back(KeyCode::KEY_CTRL_LEFT);
116     event.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
117     event.pressedCodes.emplace_back(KeyCode::KEY_ALT_LEFT);
118     event.pressedCodes.emplace_back(KeyCode::KEY_C);
119     eventManager->DispatchKeyboardShortcut(event);
120     EXPECT_EQ(event.action, KeyAction::DOWN);
__anon97ae3e060202() 121     eventHubShift->SetKeyboardShortcut(CHARACTER_A, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE), []() {});
122     event.code = KeyCode::KEY_A;
123     event.action = KeyAction::DOWN;
124     event.pressedCodes.emplace_back(KeyCode::KEY_CTRL_LEFT);
125     event.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
126     event.pressedCodes.emplace_back(KeyCode::KEY_A);
127     eventManager->DispatchKeyboardShortcut(event);
128     EXPECT_EQ(event.action, KeyAction::DOWN);
__anon97ae3e060302() 129     eventHubAlt->SetKeyboardShortcut(CHARACTER_A, (NUM_CTRL_VALUE + NUM_ALT_VALUE), []() {});
130     event.code = KeyCode::KEY_V;
131     event.action = KeyAction::DOWN;
132     event.pressedCodes.emplace_back(KeyCode::KEY_CTRL_LEFT);
133     event.pressedCodes.emplace_back(KeyCode::KEY_V);
134     eventManager->DispatchKeyboardShortcut(event);
135     EXPECT_EQ(event.action, KeyAction::DOWN);
136 }
137 
138 /**
139  * @tc.name: EventManagerTest003
140  * @tc.desc: Test OnDragStart
141  * @tc.type: FUNC
142  */
143 HWTEST_F(EventManagerTestNg, EventManagerTest003, TestSize.Level1)
144 {
145     auto eventManager = AceType::MakeRefPtr<EventManager>();
146 
147     auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NUM_CTRL_VALUE, nullptr);
148     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
149     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
150     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
151     auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NUM_SHIFT_VALUE, nullptr);
152     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
153     auto frameNodeAlt = FrameNode::GetOrCreateFrameNode(ALT, NUM_ALT_VALUE, nullptr);
154     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeAlt));
155     auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE), nullptr);
156     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
157 
158     auto eventHubCtrl = frameNodeCtrl->GetEventHub<NG::EventHub>();
159     auto eventHubShift = frameNodeShift->GetEventHub<NG::EventHub>();
160     auto eventHubAlt = frameNodeAlt->GetEventHub<NG::EventHub>();
161     auto eventHubCtrlShift = frameNodeCtrlShift->GetEventHub<NG::EventHub>();
162 
__anon97ae3e060402() 163     eventHubCtrl->SetKeyboardShortcut(CHARACTER_C, NUM_CTRL_VALUE, []() {});
__anon97ae3e060502() 164     eventHubShift->SetKeyboardShortcut(CHARACTER_A, NUM_SHIFT_VALUE, []() {});
__anon97ae3e060602() 165     eventHubAlt->SetKeyboardShortcut(CHARACTER_V, NUM_ALT_VALUE, []() {});
__anon97ae3e060702() 166     eventHubCtrlShift->SetKeyboardShortcut(CHARACTER_Z, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE), []() {});
167 
168     bool isShortcutNodeCtrlC = eventManager->IsSameKeyboardShortcutNode(CHARACTER_C, NUM_CTRL_VALUE);
169     EXPECT_TRUE(isShortcutNodeCtrlC);
170     bool isShortcutNodeCtrlEIGHT = eventManager->IsSameKeyboardShortcutNode(CHARACTER_EIGHT, NUM_CTRL_VALUE);
171     EXPECT_FALSE(isShortcutNodeCtrlEIGHT);
172     bool isShortcutNodeShiftC = eventManager->IsSameKeyboardShortcutNode(CHARACTER_C, NUM_SHIFT_VALUE);
173     EXPECT_FALSE(isShortcutNodeShiftC);
174     bool isShortcutNodeShiftEight = eventManager->IsSameKeyboardShortcutNode(CHARACTER_EIGHT, NUM_SHIFT_VALUE);
175     EXPECT_FALSE(isShortcutNodeShiftEight);
176     bool isShortcutNodeAltC = eventManager->IsSameKeyboardShortcutNode(CHARACTER_C, NUM_ALT_VALUE);
177     EXPECT_FALSE(isShortcutNodeAltC);
178     bool isShortcutNodeAltEight = eventManager->IsSameKeyboardShortcutNode(CHARACTER_EIGHT, NUM_ALT_VALUE);
179     EXPECT_FALSE(isShortcutNodeAltEight);
180     bool isShortcutComposeC = eventManager->IsSameKeyboardShortcutNode(CHARACTER_C, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
181     EXPECT_FALSE(isShortcutComposeC);
182     bool isShortcutComposeEight =
183         eventManager->IsSameKeyboardShortcutNode(CHARACTER_EIGHT, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
184     EXPECT_FALSE(isShortcutComposeEight);
185 }
186 
187 /**
188  * @tc.name: EventManagerTest004
189  * @tc.desc: Test OnDragStart
190  * @tc.type: FUNC
191  */
192 HWTEST_F(EventManagerTestNg, EventManagerTest004, TestSize.Level1)
193 {
194     auto eventManager = AceType::MakeRefPtr<EventManager>();
195     ASSERT_NE(eventManager, nullptr);
196 
197     auto frameNodeone = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
198 
199     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeone));
200     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeone));
201     ASSERT_NE(frameNodeone, nullptr);
202 
203     auto frameNodetwo = FrameNode::GetOrCreateFrameNode(SHIFT, NODEID, nullptr);
204     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodetwo));
205     ASSERT_NE(frameNodetwo, nullptr);
206 }
207 
208 /**
209  * @tc.name: EventManagerTest005
210  * @tc.desc: Test OnDragStart
211  * @tc.type: FUNC
212  */
213 HWTEST_F(EventManagerTestNg, EventManagerTest005, TestSize.Level1)
214 {
215     auto eventManager = AceType::MakeRefPtr<EventManager>();
216     ASSERT_NE(eventManager, nullptr);
217 
218     auto frameNodeone = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
219     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeone));
220 
221     eventManager->DelKeyboardShortcutNode(frameNodeone->GetId());
222     ASSERT_NE(frameNodeone, nullptr);
223 
224     auto frameNodetwo = FrameNode::GetOrCreateFrameNode(SHIFT, NODEID, nullptr);
225     eventManager->DelKeyboardShortcutNode(frameNodetwo->GetId());
226     ASSERT_NE(frameNodetwo, nullptr);
227 }
228 
229 /**
230  * @tc.name: EventManagerTest006
231  * @tc.desc: Test GetKeyboardShortcutKeys
232  * @tc.type: FUNC
233  */
234 HWTEST_F(EventManagerTestNg, EventManagerTest006, TestSize.Level1)
235 {
236     /**
237      * @tc.steps: step1. Create EventManager.
238      * @tc.expected: eventManager is not null.
239      */
240     auto eventManager = AceType::MakeRefPtr<EventManager>();
241     ASSERT_NE(eventManager, nullptr);
242 
243     /**
244      * @tc.steps: step2. Call GetKeyboardShortcutKeys with keys.size() > KEYS_MAX_VALUE.
245      * @tc.expected: Value of ret is 0.
246      */
247     std::vector<ModifierKey> keys { ModifierKey::ALT, ModifierKey::CTRL, ModifierKey::SHIFT, ModifierKey::SHIFT };
248     auto ret = eventManager->GetKeyboardShortcutKeys(keys);
249     ASSERT_EQ(ret, 0);
250 
251     /**
252      * @tc.steps: step3. Call GetKeyboardShortcutKeys with keys CTRL SHIFT ALT.
253      * @tc.expected: Value of ret is CTRL | SHIFT | ALT.
254      */
255     keys.pop_back();
256     ret = eventManager->GetKeyboardShortcutKeys(keys);
257     uint8_t target = static_cast<uint8_t>(CtrlKeysBit::CTRL) | static_cast<uint8_t>(CtrlKeysBit::SHIFT) |
258                      static_cast<uint8_t>(CtrlKeysBit::ALT);
259     ASSERT_EQ(ret, target);
260 
261     /**
262      * @tc.steps: step4. Call GetKeyboardShortcutKeys with keys CTRL CTRL.
263      * @tc.expected: Value of ret is 0.
264      */
265     keys = std::vector<ModifierKey>({ ModifierKey::CTRL, ModifierKey::CTRL });
266     ret = eventManager->GetKeyboardShortcutKeys(keys);
267     ASSERT_EQ(ret, 0);
268 
269     /**
270      * @tc.steps: step5. Call GetKeyboardShortcutKeys with keys SHIFT SHIFT.
271      * @tc.expected: Value of ret is 0.
272      */
273     keys = std::vector<ModifierKey>({ ModifierKey::SHIFT, ModifierKey::SHIFT });
274     ret = eventManager->GetKeyboardShortcutKeys(keys);
275     ASSERT_EQ(ret, 0);
276 
277     /**
278      * @tc.steps: step6. Call GetKeyboardShortcutKeys with keys SHIFT SHIFT.
279      * @tc.expected: Value of ret is 0.
280      */
281     keys = std::vector<ModifierKey>({ ModifierKey::ALT, ModifierKey::ALT });
282     ret = eventManager->GetKeyboardShortcutKeys(keys);
283     ASSERT_EQ(ret, 0);
284 }
285 
286 /**
287  * @tc.name: EventManagerTest007
288  * @tc.desc: Test IsSystemKeyboardShortcut
289  * @tc.type: FUNC
290  */
291 HWTEST_F(EventManagerTestNg, EventManagerTest007, TestSize.Level1)
292 {
293     /**
294      * @tc.steps: step1. Create EventManager.
295      * @tc.expected: eventManager is not null.
296      */
297     auto eventManager = AceType::MakeRefPtr<EventManager>();
298     ASSERT_NE(eventManager, nullptr);
299 
300     /**
301      * @tc.steps: step2. Call IsSystemKeyboardShortcut with CTRL C.
302      * @tc.expected: retFlag is true.
303      */
304     std::string value = SHORT_CUT_VALUE_C;
305     uint8_t keys = static_cast<uint8_t>(CtrlKeysBit::CTRL);
306     auto retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
307     ASSERT_TRUE(retFlag);
308 
309     /**
310      * @tc.steps: step2. Call IsSystemKeyboardShortcut with CTRL A.
311      * @tc.expected: retFlag is true.
312      */
313     value = SHORT_CUT_VALUE_A;
314     retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
315     ASSERT_TRUE(retFlag);
316 
317     /**
318      * @tc.steps: step3. Call IsSystemKeyboardShortcut with CTRL V.
319      * @tc.expected: retFlag is true.
320      */
321     value = SHORT_CUT_VALUE_V;
322     retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
323     ASSERT_TRUE(retFlag);
324 
325     /**
326      * @tc.steps: step4. Call IsSystemKeyboardShortcut with CTRL X.
327      * @tc.expected: retFlag is true.
328      */
329     value = SHORT_CUT_VALUE_X;
330     retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
331     ASSERT_TRUE(retFlag);
332 
333     /**
334      * @tc.steps: step5. Call IsSystemKeyboardShortcut with CTRL Y.
335      * @tc.expected: retFlag is true.
336      */
337     value = SHORT_CUT_VALUE_Y;
338     retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
339     ASSERT_TRUE(retFlag);
340 
341     /**
342      * @tc.steps: step6. Call IsSystemKeyboardShortcut with CTRL Z.
343      * @tc.expected: retFlag is true.
344      */
345     value = SHORT_CUT_VALUE_Z;
346     retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
347     ASSERT_TRUE(retFlag);
348 
349     /**
350      * @tc.steps: step6. Call IsSystemKeyboardShortcut with CTRL SHIFT Z.
351      * @tc.expected: retFlag is true.
352      */
353     value = SHORT_CUT_VALUE_Z;
354     keys = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::SHIFT);
355     retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
356     ASSERT_TRUE(retFlag);
357 
358     /**
359      * @tc.steps: step6. Call IsSystemKeyboardShortcut with CTRL SHIFT A.
360      * @tc.expected: retFlag is false.
361      */
362     value = SHORT_CUT_VALUE_A;
363     keys = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::SHIFT);
364     retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
365     ASSERT_FALSE(retFlag);
366 }
367 
368 /**
369  * @tc.name: EventManagerTest009
370  * @tc.desc: Test ClearResults
371  * @tc.type: FUNC
372  */
373 HWTEST_F(EventManagerTestNg, EventManagerTest009, TestSize.Level1)
374 {
375     /**
376      * @tc.steps: step1. Create EventManager.
377      * @tc.expected: eventManager is not null.
378      */
379     auto eventManager = AceType::MakeRefPtr<EventManager>();
380     ASSERT_NE(eventManager, nullptr);
381 
382     /**
383      * @tc.steps: step2. Add KeyboardShortcutNode
384      * @tc.expected: keyboardShortcutNode_.size() > 0.
385      */
386     auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NUM_SHIFT_VALUE, nullptr);
__anon97ae3e060802() 387     frameNodeShift->eventHub_->SetKeyboardShortcut(SHORT_CUT_VALUE_A, static_cast<int>(CtrlKeysBit::SHIFT), []() {});
388     eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
389     ASSERT_GT(eventManager->keyboardShortcutNode_.size(), 0);
390 
391     /**
392      * @tc.steps: step3. Call ClearResults
393      * @tc.expected: keyboardShortcutNode_.size() = 0.
394      */
395     eventManager->ClearResults();
396     ASSERT_EQ(eventManager->keyboardShortcutNode_.size(), 0);
397 }
398 
399 /**
400  * @tc.name: EventManagerTest010
401  * @tc.desc: Test TouchTest with FrameNode
402  * @tc.type: FUNC
403  */
404 HWTEST_F(EventManagerTestNg, EventManagerTest010, TestSize.Level1)
405 {
406     /**
407      * @tc.steps: step1. Create EventManager.
408      * @tc.expected: eventManager is not null.
409      */
410     auto eventManager = AceType::MakeRefPtr<EventManager>();
411     ASSERT_NE(eventManager, nullptr);
412 
413     /**
414      * @tc.steps: step2. Create FrameNode and Call TouchTest with needAppend false
415      * @tc.expected: touchTestResults_ has the touchPoint.id of instance
416      */
417     TouchEvent touchPoint;
418     touchPoint.id = 0;
419     touchPoint.type = TouchType::DOWN;
420 
421     const int nodeId = 10001;
422     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
423     TouchRestrict touchRestrict;
424     Offset offset;
425     EXPECT_EQ(eventManager->touchTestResults_.count(touchPoint.id), 0);
426     eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, false);
427     EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
428 
429     /**
430      * @tc.steps: step2. Create FrameNode and Call TouchTest with needAppend true
431      * @tc.expected: touchTestResults_ has the touchPoint.id of instance
432      */
433     eventManager->touchTestResults_.erase(touchPoint.id);
434     EXPECT_EQ(eventManager->touchTestResults_.count(touchPoint.id), 0);
435     eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
436     EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
437 
438     /**
439      * @tc.steps: step3. Create GestureScope.
440      * @tc.expected: GestureScope is not null.
441      */
442     size_t touchId = 100;
443     RefPtr<GestureScope> scope = AceType::MakeRefPtr<GestureScope>(touchId);
444     ASSERT_NE(scope, nullptr);
445     eventManager->refereeNG_->gestureScopes_.insert(std::make_pair(touchId, scope));
446     ASSERT_TRUE(eventManager->refereeNG_->QueryAllDone(touchId));
447 }
448 
449 /**
450  * @tc.name: EventManagerTest011
451  * @tc.desc: Test TouchTest with FrameNode
452  * @tc.type: FUNC
453  */
454 HWTEST_F(EventManagerTestNg, EventManagerTest011, TestSize.Level1)
455 {
456     /**
457      * @tc.steps: step1. Create EventManager.
458      * @tc.expected: eventManager is not null.
459      */
460     auto eventManager = AceType::MakeRefPtr<EventManager>();
461     ASSERT_NE(eventManager, nullptr);
462 
463     /**
464      * @tc.steps: step2. Create FrameNode and Call TouchTest
465      * @tc.expected: touchTestResults_ has the touchPoint.id of instance
466      */
467     AxisEvent axisEvent;
468     axisEvent.sourceType = SourceType::TOUCH;
469 
470     const int nodeId = 10002;
471     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
472     TouchRestrict touchRestrict;
473 
474     EXPECT_EQ(eventManager->axisTouchTestResults_.count(axisEvent.id), 0);
475     eventManager->TouchTest(axisEvent, frameNode, touchRestrict);
476     EXPECT_GT(eventManager->axisTouchTestResults_.count(axisEvent.id), 0);
477 }
478 
479 /**
480  * @tc.name: EventManagerTest012
481  * @tc.desc: Test HandleGlobalEventNG
482  * @tc.type: FUNC
483  */
484 HWTEST_F(EventManagerTestNg, EventManagerTest012, TestSize.Level1)
485 {
486     /**
487      * @tc.steps: step1. Create EventManager.
488      * @tc.expected: eventManager is not null.
489      */
490     auto eventManager = AceType::MakeRefPtr<EventManager>();
491     ASSERT_NE(eventManager, nullptr);
492 
493     /**
494      * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id]
495      * @tc.expected: touchTestResults_ has the touchPoint.id of instance
496      */
497     TouchEvent touchPoint;
498     touchPoint.type = TouchType::DOWN;
499 
500     const int nodeId = 10003;
501     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
502     TouchRestrict touchRestrict;
503     Offset offset;
504 
505     eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
506     EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
507 
508     /**
509      * @tc.steps: step3. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id]
510      * @tc.expected: selectOverlayManager->touchTestResults_ is empty for do not have specific event
511      */
512     auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode);
513     NG::OffsetF rootOffset;
514     eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset);
515     EXPECT_EQ(selectOverlayManager->touchTestResults_.size(), 0);
516 }
517 
518 /**
519  * @tc.name: EventManagerTest013
520  * @tc.desc: Test HandleOutOfRectCallback
521  * @tc.type: FUNC
522  */
523 HWTEST_F(EventManagerTestNg, EventManagerTest013, TestSize.Level1)
524 {
525     /**
526      * @tc.steps: step1. Create EventManager.
527      * @tc.expected: eventManager is not null.
528      */
529     auto eventManager = AceType::MakeRefPtr<EventManager>();
530     ASSERT_NE(eventManager, nullptr);
531 
532     /**
533      * @tc.steps: step2. Create rectCallbackList
534      * @tc.expected: touchTestResults_ has the touchPoint.id of instance
535      */
536     Point point(10, 20);
537     point.SetSourceType(SourceType::TOUCH);
538 
__anon97ae3e060902(std::vector<Rect>& rectList) 539     auto rectGetCallback1 = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect()); };
__anon97ae3e060a02(std::vector<Rect>& rectList) 540     auto rectGetCallback2 = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect(0, 0, 100, 100)); };
541 
__anon97ae3e060b02() 542     auto touchCallback = []() -> void {};
__anon97ae3e060c02() 543     auto mouseCallback = []() -> void {};
544     std::vector<RectCallback> rectCallbackList { RectCallback(rectGetCallback1, touchCallback, mouseCallback),
545         RectCallback(rectGetCallback2, touchCallback, mouseCallback) };
546 
547     /**
548      * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::TOUCH
549      * @tc.expected: rectCallbackList.size() is 1
550      */
551     eventManager->HandleOutOfRectCallback(point, rectCallbackList);
552     EXPECT_EQ(rectCallbackList.size(), 1);
553 
554     /**
555      * @tc.steps: step4. Call HandleOutOfRectCallback with SourceType::MOUSE
556      * @tc.expected: rectCallbackList.size() is 0
557      */
558     point.SetSourceType(SourceType::MOUSE);
559     rectCallbackList = vector<RectCallback>({ RectCallback(rectGetCallback1, touchCallback, mouseCallback) });
560     eventManager->HandleOutOfRectCallback(point, rectCallbackList);
561     EXPECT_TRUE(rectCallbackList.empty());
562 }
563 
564 /**
565  * @tc.name: EventManagerTest014
566  * @tc.desc: Test DispatchTouchEvent
567  * @tc.type: FUNC
568  */
569 HWTEST_F(EventManagerTestNg, EventManagerTest014, TestSize.Level1)
570 {
571     /**
572      * @tc.steps: step1. Create EventManager.
573      * @tc.expected: eventManager is not null.
574      */
575     auto eventManager = AceType::MakeRefPtr<EventManager>();
576     ASSERT_NE(eventManager, nullptr);
577 
578     /**
579      * @tc.steps: step2. Create TouchEvent and Call DispatchTouchEvent
580      * @tc.expected: retFlag is false
581      */
582     AxisEvent event;
583     event.action = AxisAction::BEGIN;
584 
585     auto retFlag = eventManager->DispatchTouchEvent(event);
586     EXPECT_FALSE(retFlag);
587 
588     /**
589      * @tc.steps: step3. Create FrameNode and Call TouchTest to add axisTouchTestResults_
590      * @tc.expected: touchTestResults_ has the touchPoint.id of instance
591      */
592     event.action = AxisAction::END;
593 
594     const int nodeId = 10004;
595     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
596     TouchRestrict touchRestrict;
597 
598     eventManager->TouchTest(event, frameNode, touchRestrict);
599     EXPECT_GT(eventManager->axisTouchTestResults_.count(event.id), 0);
600 
601     /**
602      * @tc.steps: step4. Call DispatchTouchEvent
603      * @tc.expected: touchTestResults_ has the touchPoint.id of instance
604      */
605     retFlag = eventManager->DispatchTouchEvent(event);
606     EXPECT_TRUE(retFlag);
607 
608     /**
609      * @tc.steps: step5. Create AxisEvent and Call DispatchTouchEvent
610      * @tc.expected: retFlag is false
611      */
612     event.action = AxisAction::BEGIN;
613     Container::SetCurrentUsePartialUpdate(true);
614     AceForwardCompatibility::isNewPipeline_ = true;
615     eventManager->DispatchTouchEvent(event);
616     auto container = Container::Current();
617     container->useNewPipeline_ = true;
618     ASSERT_NE(container, nullptr);
619     retFlag = Container::IsCurrentUseNewPipeline();
620     EXPECT_TRUE(retFlag);
621 }
622 
623 /**
624  * @tc.name: EventManagerTest015
625  * @tc.desc: Test DispatchTabIndexEventNG
626  * @tc.type: FUNC
627  */
628 HWTEST_F(EventManagerTestNg, EventManagerTest015, TestSize.Level1)
629 {
630     /**
631      * @tc.steps: step1. Create EventManager.
632      * @tc.expected: eventManager is not null.
633      */
634     auto eventManager = AceType::MakeRefPtr<EventManager>();
635     ASSERT_NE(eventManager, nullptr);
636 
637     /**
638      * @tc.steps: step2. Create frameNodes
639      * @tc.expected: retFlag is false
640      */
641     const int mainNodeId = 10006;
642     auto mainNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, mainNodeId, nullptr);
643 
644     /**
645      * @tc.steps: step3. Call DispatchTabIndexEventNG
646      * @tc.expected: retFlag is false
647      */
648     KeyEvent event;
649     auto retFlag = eventManager->DispatchTabIndexEventNG(event, mainNode);
650     ASSERT_FALSE(retFlag);
651 }
652 
653 /**
654  * @tc.name: EventManagerTest016
655  * @tc.desc: Test DispatchKeyEventNG
656  * @tc.type: FUNC
657  */
658 HWTEST_F(EventManagerTestNg, EventManagerTest016, TestSize.Level1)
659 {
660     /**
661      * @tc.steps: step1. Create EventManager.
662      * @tc.expected: eventManager is not null.
663      */
664     auto eventManager = AceType::MakeRefPtr<EventManager>();
665     ASSERT_NE(eventManager, nullptr);
666 
667     /**
668      * @tc.steps: step2. Create frameNodes
669      * @tc.expected: retFlag is false
670      */
671     const int focusNodeId = 10007;
672     auto focusNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, focusNodeId, nullptr);
673     focusNode->eventHub_ = AceType::MakeRefPtr<ButtonEventHub>();
674     focusNode->eventHub_->GetOrCreateFocusHub(FocusType::NODE);
675     ASSERT_NE(focusNode->GetFocusHub(), nullptr);
676 
677     /**
678      * @tc.steps: step3. Call DispatchKeyEventNG
679      * @tc.expected: retFlag is false
680      */
681     KeyEvent event;
682     auto retFlag = eventManager->DispatchKeyEventNG(event, focusNode);
683     ASSERT_FALSE(retFlag);
684 }
685 
686 /**
687  * @tc.name: EventManagerTest017
688  * @tc.desc: Test MouseTest (frameNode)
689  * @tc.type: FUNC
690  */
691 HWTEST_F(EventManagerTestNg, EventManagerTest017, TestSize.Level1)
692 {
693     /**
694      * @tc.steps: step1. Create EventManager.
695      * @tc.expected: eventManager is not null.
696      */
697     auto eventManager = AceType::MakeRefPtr<EventManager>();
698     ASSERT_NE(eventManager, nullptr);
699 
700     /**
701      * @tc.steps: step2. Call MouseTest with MouseAction::WINDOW_LEAVE
702      * @tc.expected: currHoverTestResults_ is empty
703      */
704     MouseEvent event;
705     const int nodeId = 10008;
706     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
707     TouchRestrict touchRestrict;
708 
709     event.action = MouseAction::WINDOW_LEAVE;
710     auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(V2::LOCATION_BUTTON_ETS_TAG, nodeId);
711     eventManager->currHoverTestResults_.push_back(hoverEventTarget);
712     ASSERT_FALSE(eventManager->currHoverTestResults_.empty());
713     eventManager->MouseTest(event, frameNode, touchRestrict);
714     ASSERT_TRUE(eventManager->currHoverTestResults_.empty());
715 
716     /**
717      * @tc.steps: step3. Call MouseTest with MouseAction::WINDOW_ENTER
718      * @tc.expected: lastHoverTestResults_ is empty
719      */
720     event.action = MouseAction::WINDOW_ENTER;
721     eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
722     ASSERT_FALSE(eventManager->lastHoverTestResults_.empty());
723     eventManager->MouseTest(event, frameNode, touchRestrict);
724     ASSERT_TRUE(eventManager->lastHoverTestResults_.empty());
725 
726     /**
727      * @tc.steps: step4. Call MouseTest with MouseAction::HOVER
728      * @tc.expected: lastHoverTestResults_ is empty and currHoverTestResults_ is empty
729      */
730     event.action = MouseAction::HOVER;
731     eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
732     eventManager->MouseTest(event, frameNode, touchRestrict);
733     ASSERT_TRUE(eventManager->lastHoverTestResults_.empty());
734     ASSERT_TRUE(eventManager->currHoverTestResults_.empty());
735 }
736 
737 /**
738  * @tc.name: EventManagerTest018
739  * @tc.desc: Test DispatchMouseEventNG
740  * @tc.type: FUNC
741  */
742 HWTEST_F(EventManagerTestNg, EventManagerTest018, TestSize.Level1)
743 {
744     /**
745      * @tc.steps: step1. Create EventManager.
746      * @tc.expected: eventManager is not null.
747      */
748     auto eventManager = AceType::MakeRefPtr<EventManager>();
749     ASSERT_NE(eventManager, nullptr);
750 
751     /**
752      * @tc.steps: step2. Call DispatchMouseEventNG
753      * @tc.expected: currHoverTestResults_ is empty
754      */
755     MouseEvent event;
756     event.action = MouseAction::PRESS;
757     event.button = MouseButton::LEFT_BUTTON;
758     event.pullAction = MouseAction::MOVE;
759 
760     auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
761     eventManager->pressMouseTestResults_.push_back(mouseEventTarget);
762     eventManager->currMouseTestResults_.push_back(mouseEventTarget);
763 
764     auto retFlag = eventManager->DispatchMouseEventNG(event);
765     ASSERT_FALSE(retFlag);
766 
767     /**
768      * @tc.steps: step2. Call DispatchMouseEventNG
769      * @tc.expected: currHoverTestResults_ is empty
770      */
771     event.action = MouseAction::RELEASE;
772     event.button = MouseButton::LEFT_BUTTON;
773     event.pullAction = MouseAction::MOVE;
774     retFlag = eventManager->DispatchMouseEventNG(event);
775     ASSERT_FALSE(retFlag);
776 
777     /**
778      * @tc.steps: step3. Call DispatchMouseEventNG
779      * @tc.expected: currHoverTestResults_ is empty
780      */
781     event.action = MouseAction::MOVE;
782     event.button = MouseButton::LEFT_BUTTON;
783     event.pullAction = MouseAction::PULL_UP;
784     retFlag = eventManager->DispatchMouseEventNG(event);
785     ASSERT_FALSE(retFlag);
786 
787     /**
788      * @tc.steps: step4. Call DispatchMouseEventNG
789      * @tc.expected: currHoverTestResults_ not empty
790      */
791     event.action = MouseAction::MOVE;
792     event.button = MouseButton::LEFT_BUTTON;
793     event.pullAction = MouseAction::PULL_UP;
794 
795     auto mouseTestResult = AceType::MakeRefPtr<MouseEventTarget>(CTRL, NODEID);
796     eventManager->currMouseTestResults_.push_back(mouseTestResult);
797 
798     retFlag = eventManager->DispatchMouseEventNG(event);
799     ASSERT_FALSE(retFlag);
800 }
801 
802 /**
803  * @tc.name: EventManagerTest019
804  * @tc.desc: Test DispatchMouseHoverEventNG
805  * @tc.type: FUNC
806  */
807 HWTEST_F(EventManagerTestNg, EventManagerTest019, TestSize.Level1)
808 {
809     /**
810      * @tc.steps: step1. Create EventManager.
811      * @tc.expected: eventManager is not null.
812      */
813     auto eventManager = AceType::MakeRefPtr<EventManager>();
814     ASSERT_NE(eventManager, nullptr);
815 
816     /**
817      * @tc.steps: step2. Call DispatchMouseHoverEventNG with lastHoverTestResults != currHoverTestResults
818      * @tc.expected: retFlag is true
819      */
820     MouseEvent event;
821     auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(MOUSE, NODEID);
822     auto hoverEventTarget2 = AceType::MakeRefPtr<HoverEventTarget>(MOUSE_EVENT, NODEID_2);
823     auto hoverEventTarget3 = AceType::MakeRefPtr<HoverEventTarget>(MOUSE_EVENT_2, NODEID_3);
824     eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
825     eventManager->currHoverTestResults_.push_back(hoverEventTarget2);
826     eventManager->currHoverTestResults_.push_back(hoverEventTarget3);
827     eventManager->currHoverTestResults_.push_back(hoverEventTarget);
828     eventManager->lastHoverDispatchLength_++;
829 
830     auto retFlag = eventManager->DispatchMouseHoverEventNG(event);
831     ASSERT_TRUE(retFlag);
832 
833     /**
834      * @tc.steps: step2. Call DispatchMouseHoverEventNG with lastHoverTestResults == currHoverTestResults
835      * @tc.expected: retFlag is true
836      */
837     eventManager->lastHoverTestResults_.clear();
838     eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
839     eventManager->currHoverTestResults_.clear();
840     eventManager->currHoverTestResults_.push_back(hoverEventTarget);
841 
842     retFlag = eventManager->DispatchMouseHoverEventNG(event);
843     ASSERT_TRUE(retFlag);
844 }
845 
846 /**
847  * @tc.name: EventManagerTest020
848  * @tc.desc: Test DispatchAxisEventNG
849  * @tc.type: FUNC
850  */
851 HWTEST_F(EventManagerTestNg, EventManagerTest020, TestSize.Level1)
852 {
853     /**
854      * @tc.steps: step1. Create EventManager.
855      * @tc.expected: eventManager is not null.
856      */
857     auto eventManager = AceType::MakeRefPtr<EventManager>();
858     ASSERT_NE(eventManager, nullptr);
859 
860     /**
861      * @tc.steps: step2. Call DispatchAxisEventNG with horizontalAxis verticalAxis pinchAxisScale = 0
862      * @tc.expected: retFlag is false
863      */
864     AxisEvent event;
865     event.horizontalAxis = 0;
866     event.verticalAxis = 0;
867     event.pinchAxisScale = 0;
868     auto retFlag = eventManager->DispatchAxisEventNG(event);
869     ASSERT_FALSE(retFlag);
870 
871     /**
872      * @tc.steps: step3. Call DispatchAxisEventNG with axisTestResults_ empty
873      * @tc.expected: retFlag is false
874      */
875     event.horizontalAxis = 1;
876     retFlag = eventManager->DispatchAxisEventNG(event);
877     ASSERT_TRUE(retFlag);
878 
879     /**
880      * @tc.steps: step4. Call DispatchAxisEventNG with axisTestResults_ not empty
881      * @tc.expected: retFlag is false
882      */
883     auto axisEventTarget = AceType::MakeRefPtr<AxisEventTarget>();
__anon97ae3e060d02(AxisInfo&) 884     auto onAxisCallback = [](AxisInfo&) -> void {};
885     axisEventTarget->SetOnAxisCallback(onAxisCallback);
886 
887     eventManager->axisTestResults_.push_back(axisEventTarget);
888     retFlag = eventManager->DispatchAxisEventNG(event);
889     ASSERT_TRUE(retFlag);
890 }
891 
892 /**
893  * @tc.name: EventManagerTest021
894  * @tc.desc: Test DispatchAxisEventNG
895  * @tc.type: FUNC
896  */
897 HWTEST_F(EventManagerTestNg, EventManagerTest021, TestSize.Level1)
898 {
899     /**
900      * @tc.steps: step1. Create EventManager.
901      * @tc.expected: eventManager is not null.
902      */
903     auto eventManager = AceType::MakeRefPtr<EventManager>();
904     ASSERT_NE(eventManager, nullptr);
905 
906     /**
907      * @tc.steps: step2. AddKeyboardShortcutNode to eventManager
908      */
909     const int nodeIdCtrlShift = 10010;
910     auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRL, nodeIdCtrlShift, nullptr);
911     frameNodeCtrlShift->SetActive(true);
912     frameNodeCtrlShift->eventHub_->SetEnabled(true);
913     const uint8_t ctrlShift = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::SHIFT);
__anon97ae3e060e02() 914     frameNodeCtrlShift->eventHub_->SetKeyboardShortcut(CHARACTER_A, ctrlShift, []() {});
915     eventManager->AddKeyboardShortcutNode(frameNodeCtrlShift);
916 
917     const int nodeIdCtrlAlt = 10011;
918     auto frameNodeCtrlAlt = FrameNode::GetOrCreateFrameNode(CTRL, nodeIdCtrlAlt, nullptr);
919     frameNodeCtrlAlt->SetActive(true);
920     frameNodeCtrlAlt->eventHub_->SetEnabled(true);
921     const uint8_t ctrlAlt = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::ALT);
__anon97ae3e060f02() 922     frameNodeCtrlAlt->eventHub_->SetKeyboardShortcut(CHARACTER_A, ctrlAlt, []() {});
923     eventManager->AddKeyboardShortcutNode(frameNodeCtrlAlt);
924 
925     const int nodeIdAltShift = 10012;
926     auto frameNodeAltShift = FrameNode::GetOrCreateFrameNode(ALT, nodeIdAltShift, nullptr);
927     frameNodeAltShift->SetActive(true);
928     frameNodeAltShift->eventHub_->SetEnabled(true);
929     const uint8_t altShift = static_cast<uint8_t>(CtrlKeysBit::SHIFT) + static_cast<uint8_t>(CtrlKeysBit::ALT);
__anon97ae3e061002() 930     frameNodeAltShift->eventHub_->SetKeyboardShortcut(CHARACTER_A, altShift, []() {});
931     eventManager->AddKeyboardShortcutNode(frameNodeAltShift);
932 
933     /**
934      * @tc.steps: step3. call DispatchKeyboardShortcut
935      * @tc.expected: AddKeyboardShortcutDoubleKeys calls.
936      */
937     KeyEvent event;
938     event.action = KeyAction::DOWN;
939     eventManager->DispatchKeyboardShortcut(event);
940     ASSERT_EQ(frameNodeCtrlShift->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, ctrlShift);
941     ASSERT_EQ(frameNodeCtrlAlt->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, ctrlAlt);
942     ASSERT_EQ(frameNodeAltShift->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, altShift);
943 }
944 
945 /**
946  * @tc.name: EventManagerTest022
947  * @tc.desc: Test DispatchAxisEventNG
948  * @tc.type: FUNC
949  */
950 HWTEST_F(EventManagerTestNg, EventManagerTest022, TestSize.Level1)
951 {
952     /**
953      * @tc.steps: step1. Create EventManager.
954      * @tc.expected: eventManager is not null.
955      */
956     auto eventManager = AceType::MakeRefPtr<EventManager>();
957     ASSERT_NE(eventManager, nullptr);
958 
959     /**
960      * @tc.steps: step2. AddKeyboardShortcutNode to eventManager
961      */
962     const int nodeIdCtrl = 10013;
963     auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, nodeIdCtrl, nullptr);
964     frameNodeCtrl->SetActive(true);
965     frameNodeCtrl->eventHub_->SetEnabled(true);
966     const uint8_t ctrl = static_cast<uint8_t>(CtrlKeysBit::CTRL);
__anon97ae3e061102() 967     frameNodeCtrl->eventHub_->SetKeyboardShortcut(CHARACTER_A, ctrl, []() {});
968     eventManager->AddKeyboardShortcutNode(frameNodeCtrl);
969 
970     const int nodeIdAlt = 10014;
971     auto frameNodeAlt = FrameNode::GetOrCreateFrameNode(ALT, nodeIdAlt, nullptr);
972     frameNodeAlt->SetActive(true);
973     frameNodeAlt->eventHub_->SetEnabled(true);
974     const uint8_t alt = static_cast<uint8_t>(CtrlKeysBit::ALT);
__anon97ae3e061202() 975     frameNodeAlt->eventHub_->SetKeyboardShortcut(CHARACTER_A, alt, []() {});
976     eventManager->AddKeyboardShortcutNode(frameNodeAlt);
977 
978     const int nodeIdShift = 10015;
979     auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, nodeIdShift, nullptr);
980     frameNodeShift->SetActive(true);
981     frameNodeShift->eventHub_->SetEnabled(true);
982     const uint8_t shift = static_cast<uint8_t>(CtrlKeysBit::SHIFT);
__anon97ae3e061302() 983     frameNodeShift->eventHub_->SetKeyboardShortcut(CHARACTER_A, shift, []() {});
984     eventManager->AddKeyboardShortcutNode(frameNodeShift);
985 
986     /**
987      * @tc.steps: step3. call DispatchKeyboardShortcut
988      * @tc.expected: AddKeyboardShortcutSingleKey is called.
989      */
990     KeyEvent event;
991     event.action = KeyAction::DOWN;
992     eventManager->DispatchKeyboardShortcut(event);
993     ASSERT_EQ(frameNodeCtrl->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, ctrl);
994     ASSERT_EQ(frameNodeAlt->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, alt);
995     ASSERT_EQ(frameNodeShift->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, shift);
996 }
997 
998 /**
999  * @tc.name: EventManagerTest023
1000  * @tc.desc: Test DispatchTouchEvent
1001  * @tc.type: FUNC
1002  */
1003 HWTEST_F(EventManagerTestNg, EventManagerTest023, TestSize.Level1)
1004 {
1005     /**
1006      * @tc.steps: step1. Create EventManager.
1007      * @tc.expected: eventManager is not null.
1008      */
1009     auto eventManager = AceType::MakeRefPtr<EventManager>();
1010     ASSERT_NE(eventManager, nullptr);
1011     AceEngine& aceEngine = AceEngine::Get();
1012     aceEngine.AddContainer(CONTAINER_INSTANCE_ID, MockContainer::container_);
1013     /**
1014      * @tc.steps: step2. Call DispatchTouchEvent with TouchType::DOWN and
1015                         touchTestResults_ empty;
1016      * @tc.expected: ret is false
1017      */
1018     TouchEvent event;
1019     event.type = TouchType::DOWN;
1020     auto ret = eventManager->DispatchTouchEvent(event);
1021     EXPECT_FALSE(ret);
1022 
1023     /**
1024      * @tc.steps: step3. Call DispatchTouchEvent with TouchType::DOWN and
1025                         touchTestResults_ has element;
1026      * @tc.expected: ret is true
1027      */
1028     TouchTestResult touchTestResults;
1029     auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
1030     touchTestResults.push_back(eventTarget);
1031     eventManager->touchTestResults_.emplace(event.id, touchTestResults);
1032     ret = eventManager->DispatchTouchEvent(event);
1033     EXPECT_TRUE(ret);
1034 
1035     /**
1036      * @tc.steps: step4. Call DispatchTouchEvent with TouchType::UP and
1037                         touchTestResults_ has element;
1038      * @tc.expected: ret is true
1039      */
1040     event.type = TouchType::UP;
1041     ret = eventManager->DispatchTouchEvent(event);
1042     EXPECT_TRUE(ret);
1043 }
1044 
1045 /**
1046  * @tc.name: EventManagerTest024
1047  * @tc.desc: Test DispatchTouchEvent
1048  * @tc.type: FUNC
1049  */
1050 HWTEST_F(EventManagerTestNg, EventManagerTest024, TestSize.Level1)
1051 {
1052     /**
1053      * @tc.steps: step1. Create EventManager.
1054      * @tc.expected: eventManager is not null.
1055      */
1056     auto eventManager = AceType::MakeRefPtr<EventManager>();
1057     ASSERT_NE(eventManager, nullptr);
1058 
1059     auto currentHoverNodeId = ElementRegister::GetInstance()->MakeUniqueId();
1060     auto currentHoverNode = FrameNode::GetOrCreateFrameNode(CTRL, currentHoverNodeId, nullptr);
1061     eventManager->currHoverNode_ = currentHoverNode;
1062     auto lastHoverNodeId = ElementRegister::GetInstance()->MakeUniqueId();
1063     auto lastHoverNode = FrameNode::GetOrCreateFrameNode(SHIFT, lastHoverNodeId, nullptr);
1064     eventManager->lastHoverNode_ = lastHoverNode;
1065 
1066     /**
1067      * @tc.steps: step2. Call DispatchMouseHoverAnimationNG with MouseAction::PRESS;
1068      * @tc.expected: ret is false
1069      */
1070     MouseEvent event;
1071     event.button = MouseButton::NONE_BUTTON;
1072     event.action = MouseAction::PRESS;
1073     eventManager->DispatchMouseHoverAnimationNG(event);
1074     EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1075 
1076     /**
1077      * @tc.steps: step3. Call DispatchMouseHoverAnimationNG with MouseAction::RELEASE;
1078      * @tc.expected: ret is false
1079      */
1080     event.action = MouseAction::RELEASE;
1081     eventManager->DispatchMouseHoverAnimationNG(event);
1082     EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1083 
1084     /**
1085      * @tc.steps: step4. Call DispatchMouseHoverAnimationNG with MouseAction::MOVE;
1086      * @tc.expected: ret is false
1087      */
1088     event.action = MouseAction::MOVE;
1089     eventManager->DispatchMouseHoverAnimationNG(event);
1090     EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1091 
1092     /**
1093      * @tc.steps: step5. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_ENTER;
1094      * @tc.expected: ret is false
1095      */
1096     event.action = MouseAction::WINDOW_ENTER;
1097     eventManager->DispatchMouseHoverAnimationNG(event);
1098     EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1099 
1100     /**
1101      * @tc.steps: step6. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_LEAVE;
1102      * @tc.expected: ret is false
1103      */
1104     event.action = MouseAction::WINDOW_LEAVE;
1105     eventManager->DispatchMouseHoverAnimationNG(event);
1106     EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1107 }
1108 
1109 /**
1110  * @tc.name: EventManagerTest025
1111  * @tc.desc: Test FlushTouchEventsBegin
1112  * @tc.type: FUNC
1113  */
1114 HWTEST_F(EventManagerTestNg, EventManagerTest025, TestSize.Level1)
1115 {
1116     /**
1117      * @tc.steps: step1. Create EventManager.
1118      * @tc.expected: eventManager is not null.
1119      */
1120     auto eventManager = AceType::MakeRefPtr<EventManager>();
1121     ASSERT_NE(eventManager, nullptr);
1122 
1123     auto resultId = ElementRegister::GetInstance()->MakeUniqueId();
1124     TouchTestResult touchTestResults;
1125     touchTestResults.push_back(AceType::MakeRefPtr<MockTouchEventTarget>());
1126     eventManager->touchTestResults_.emplace(resultId, touchTestResults);
1127 
1128     TouchEvent event {};
1129     event.id = resultId;
1130     std::list<TouchEvent> touchEvents { event };
1131     eventManager->FlushTouchEventsBegin(touchEvents);
1132     EXPECT_NE(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end());
1133 }
1134 
1135 /**
1136  * @tc.name: EventManagerTest026
1137  * @tc.desc: Test FlushTouchEventsBegin
1138  * @tc.type: FUNC
1139  */
1140 HWTEST_F(EventManagerTestNg, EventManagerTest026, TestSize.Level1)
1141 {
1142     /**
1143      * @tc.steps: step1. Create EventManager.
1144      * @tc.expected: eventManager is not null.
1145      */
1146     auto eventManager = AceType::MakeRefPtr<EventManager>();
1147     ASSERT_NE(eventManager, nullptr);
1148 
1149     auto resultId = ElementRegister::GetInstance()->MakeUniqueId();
1150     TouchTestResult touchTestResults;
1151     touchTestResults.push_back(AceType::MakeRefPtr<MockTouchEventTarget>());
1152     eventManager->touchTestResults_.emplace(resultId, touchTestResults);
1153 
1154     TouchEvent event {};
1155     event.id = resultId;
1156     std::list<TouchEvent> touchEvents { event };
1157     eventManager->FlushTouchEventsEnd(touchEvents);
1158     EXPECT_NE(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end());
1159 }
1160 
1161 /**
1162  * @tc.name: EventManagerTest027
1163  * @tc.desc: Test FlushTouchEventsBegin
1164  * @tc.type: FUNC
1165  */
1166 HWTEST_F(EventManagerTestNg, EventManagerTest027, TestSize.Level1)
1167 {
1168     /**
1169      * @tc.steps: step1. Create EventManager.
1170      * @tc.expected: eventManager is not null.
1171      */
1172     auto eventManager = AceType::MakeRefPtr<EventManager>();
1173     ASSERT_NE(eventManager, nullptr);
1174 
1175     AxisEvent axisEvent;
1176     axisEvent.x = 1;
1177     axisEvent.y = 2;
1178     axisEvent.sourceType = SourceType::TOUCH;
1179     auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1180     auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
1181     eventManager->AxisTest(axisEvent, frameNode);
1182     EXPECT_NE(frameNode, nullptr);
1183 }
1184 
1185 /**
1186  * @tc.name: EventManagerTest028
1187  * @tc.desc: Test DispatchTouchEvent:hoverNodeCur and hoverNodePre both null
1188  * @tc.type: FUNC
1189  */
1190 HWTEST_F(EventManagerTestNg, EventManagerTest028, TestSize.Level1)
1191 {
1192     /**
1193      * @tc.steps: step1. Create EventManager.
1194      * @tc.expected: eventManager is not null.
1195      */
1196     auto eventManager = AceType::MakeRefPtr<EventManager>();
1197     ASSERT_NE(eventManager, nullptr);
1198 
1199     eventManager->currHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr);
1200     eventManager->lastHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr);
1201 
1202     /**
1203      * @tc.steps: step2. Call DispatchMouseHoverAnimationNG with MouseAction::PRESS;
1204      * @tc.expected: ret is false
1205      */
1206     MouseEvent event;
1207     event.button = MouseButton::NONE_BUTTON;
1208     event.action = MouseAction::PRESS;
1209     eventManager->DispatchMouseHoverAnimationNG(event);
1210     EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1211 
1212     /**
1213      * @tc.steps: step3. Call DispatchMouseHoverAnimationNG with MouseAction::RELEASE;
1214      * @tc.expected: ret is false
1215      */
1216     event.action = MouseAction::RELEASE;
1217     eventManager->DispatchMouseHoverAnimationNG(event);
1218     EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1219 
1220     /**
1221      * @tc.steps: step4. Call DispatchMouseHoverAnimationNG with MouseAction::MOVE;
1222      * @tc.expected: ret is false
1223      */
1224     event.action = MouseAction::MOVE;
1225     eventManager->DispatchMouseHoverAnimationNG(event);
1226     EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1227 
1228     /**
1229      * @tc.steps: step5. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_ENTER;
1230      * @tc.expected: ret is false
1231      */
1232     event.action = MouseAction::WINDOW_ENTER;
1233     eventManager->DispatchMouseHoverAnimationNG(event);
1234     EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1235 
1236     /**
1237      * @tc.steps: step6. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_LEAVE;
1238      * @tc.expected: ret is false
1239      */
1240     event.action = MouseAction::WINDOW_LEAVE;
1241     eventManager->DispatchMouseHoverAnimationNG(event);
1242     EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1243 
1244     /**
1245      * @tc.steps: step6. Call DispatchMouseHoverAnimationNG with MouseAction::HOVER;
1246      * @tc.expected: ret is false
1247      */
1248     event.action = MouseAction::HOVER;
1249     eventManager->DispatchMouseHoverAnimationNG(event);
1250     EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1251 }
1252 
1253 /**
1254  * @tc.name: EventManagerTest029
1255  * @tc.desc: Test TouchTest
1256  * @tc.type: FUNC
1257  */
1258 HWTEST_F(EventManagerTestNg, EventManagerTest029, TestSize.Level1)
1259 {
1260     /**
1261      * @tc.steps: step1. Create EventManager.
1262      * @tc.expected: eventManager is not null.
1263      */
1264     auto eventManager = AceType::MakeRefPtr<EventManager>();
1265     ASSERT_NE(eventManager, nullptr);
1266 
1267     TouchEvent touchPoint;
1268     touchPoint.id = 100;
1269     touchPoint.type = TouchType::DOWN;
1270 
1271     TouchRestrict touchRestrict;
1272     Offset offset;
1273 
1274     /**
1275      * @tc.steps: step1. Create renderNode.
1276      * @tc.expected: renderNode is not null.
1277      */
1278     auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
1279     auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
1280 
1281     /**
1282      * @tc.steps: step2. Call TouchTest with MouseAction::PRESS;
1283      * @tc.expected: ret is false
1284      */
1285     eventManager->TouchTest(touchPoint, renderNode, touchRestrict, offset, 0, true);
1286     auto findIt = eventManager->touchTestResults_.find(touchPoint.id);
1287     EXPECT_EQ(findIt, eventManager->touchTestResults_.end());
1288 }
1289 
1290 /**
1291  * @tc.name: EventManagerTest032
1292  * @tc.desc: Test DispatchAxisEvent
1293  * @tc.type: FUNC
1294  */
1295 HWTEST_F(EventManagerTestNg, EventManagerTest032, TestSize.Level1)
1296 {
1297     /**
1298      * @tc.steps: step1. Create EventManager.
1299      * @tc.expected: eventManager is not null.
1300      */
1301     auto eventManager = AceType::MakeRefPtr<EventManager>();
1302     ASSERT_NE(eventManager, nullptr);
1303 
1304     AxisEvent axisEvent;
1305     axisEvent.horizontalAxis = 0;
1306     axisEvent.verticalAxis = 0;
1307     axisEvent.pinchAxisScale = 1.0f;
1308 
1309     /**
1310      * @tc.steps: step2. Call AxisTest with SourceType::TOUCH.
1311      * @tc.expected: eventManager->axisNode_.Upgrade() is not null.
1312      */
1313     bool retFlag = eventManager->DispatchAxisEvent(axisEvent);
1314     ASSERT_TRUE(retFlag);
1315 }
1316 
1317 /**
1318  * @tc.name: EventManagerTest033
1319  * @tc.desc: Test DumpEvent
1320  * @tc.type: FUNC
1321  */
1322 HWTEST_F(EventManagerTestNg, EventManagerTest033, TestSize.Level1)
1323 {
1324     /**
1325      * @tc.steps: step1. Create EventManager.
1326      * @tc.expected: eventManager is not null.
1327      */
1328     auto eventManager = AceType::MakeRefPtr<EventManager>();
1329     ASSERT_NE(eventManager, nullptr);
1330 
1331     /**
1332      * @tc.steps: step2. Call DumpEvent.
1333      * @tc.expected: eventManager->axisNode_.Upgrade() is not null.
1334      */
1335     eventManager->DumpEvent(EventTreeType::TOUCH);
1336     std::list<std::pair<int32_t, std::string>> dumpList;
1337     eventManager->eventTree_.Dump(dumpList, 0);
1338     ASSERT_TRUE(dumpList.empty());
1339 }
1340 
1341 /**
1342  * @tc.name: EventManagerTest034
1343  * @tc.desc: Test DispatchMouseEvent
1344  * @tc.type: FUNC
1345  */
1346 HWTEST_F(EventManagerTestNg, EventManagerTest034, TestSize.Level1)
1347 {
1348     /**
1349      * @tc.steps: step1. Create EventManager.
1350      * @tc.expected: eventManager is not null.
1351      */
1352     auto eventManager = AceType::MakeRefPtr<EventManager>();
1353     ASSERT_NE(eventManager, nullptr);
1354 
1355     /**
1356      * @tc.steps: step2. Call DispatchMouseEvent.
1357      * @tc.expected: retFlag is false.
1358      */
1359     MouseEvent event;
1360     event.action = MouseAction::PRESS;
1361     bool retFlag = eventManager->DispatchMouseEvent(event);
1362     ASSERT_TRUE(retFlag);
1363 }
1364 
1365 /**
1366  * @tc.name: EventManagerTest0351
1367  * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::PRESS branches
1368  * @tc.type: FUNC
1369  */
1370 HWTEST_F(EventManagerTestNg, EventManagerTest0351, TestSize.Level1)
1371 {
1372     /**
1373      * @tc.steps: step1. Create EventManager.
1374      * @tc.expected: eventManager is not null.
1375      */
1376     auto eventManager = AceType::MakeRefPtr<EventManager>();
1377     ASSERT_NE(eventManager, nullptr);
1378 
1379     /**
1380      * @tc.steps: step2. Call DispatchMouseEvent.
1381      * @tc.expected: hoverNodeCur is not null.
1382      */
1383     MouseEvent event;
1384     event.action = MouseAction::PRESS;
1385     eventManager->DispatchMouseHoverAnimation(event);
1386     auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1387     EXPECT_EQ(hoverNodeCur, nullptr);
1388 }
1389 
1390 /**
1391  * @tc.name: EventManagerTest0352
1392  * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::RELEASE branches
1393  * @tc.type: FUNC
1394  */
1395 HWTEST_F(EventManagerTestNg, EventManagerTest0352, TestSize.Level1)
1396 {
1397     /**
1398      * @tc.steps: step1. Create EventManager.
1399      * @tc.expected: eventManager is not null.
1400      */
1401     auto eventManager = AceType::MakeRefPtr<EventManager>();
1402     ASSERT_NE(eventManager, nullptr);
1403 
1404     /**
1405      * @tc.steps: step2. Call DispatchMouseEvent.
1406      * @tc.expected: hoverNodeCur is not null.
1407      */
1408     MouseEvent event;
1409     event.action = MouseAction::RELEASE;
1410     eventManager->DispatchMouseHoverAnimation(event);
1411     auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1412     EXPECT_EQ(hoverNodeCur, nullptr);
1413 }
1414 
1415 /**
1416  * @tc.name: EventManagerTest0353
1417  * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::WINDOW_ENTER branches
1418  * @tc.type: FUNC
1419  */
1420 HWTEST_F(EventManagerTestNg, EventManagerTest0353, TestSize.Level1)
1421 {
1422     /**
1423      * @tc.steps: step1. Create EventManager.
1424      * @tc.expected: eventManager is not null.
1425      */
1426     auto eventManager = AceType::MakeRefPtr<EventManager>();
1427     ASSERT_NE(eventManager, nullptr);
1428 
1429     /**
1430      * @tc.steps: step2. Call DispatchMouseEvent.
1431      * @tc.expected: hoverNodeCur is not null.
1432      */
1433     MouseEvent event;
1434     event.action = MouseAction::WINDOW_ENTER;
1435     eventManager->DispatchMouseHoverAnimation(event);
1436     auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1437     EXPECT_EQ(hoverNodeCur, nullptr);
1438 }
1439 
1440 /**
1441  * @tc.name: EventManagerTest0354
1442  * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::WINDOW_LEAVE branches
1443  * @tc.type: FUNC
1444  */
1445 HWTEST_F(EventManagerTestNg, EventManagerTest0354, TestSize.Level1)
1446 {
1447     /**
1448      * @tc.steps: step1. Create EventManager.
1449      * @tc.expected: eventManager is not null.
1450      */
1451     auto eventManager = AceType::MakeRefPtr<EventManager>();
1452     ASSERT_NE(eventManager, nullptr);
1453 
1454     /**
1455      * @tc.steps: step2. Call DispatchMouseEvent.
1456      * @tc.expected: hoverNodeCur is not null.
1457      */
1458     MouseEvent event;
1459     event.action = MouseAction::WINDOW_LEAVE;
1460     eventManager->DispatchMouseHoverAnimation(event);
1461     auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1462     EXPECT_EQ(hoverNodeCur, nullptr);
1463 }
1464 
1465 /**
1466  * @tc.name: EventManagerTest0355
1467  * @tc.desc: Test DispatchMouseHoverAnimation in MouseButton::NONE_BUTTON and MouseAction::MOVE branches
1468  * @tc.type: FUNC
1469  */
1470 HWTEST_F(EventManagerTestNg, EventManagerTest0355, TestSize.Level1)
1471 {
1472     /**
1473      * @tc.steps: step1. Create EventManager.
1474      * @tc.expected: eventManager is not null.
1475      */
1476     auto eventManager = AceType::MakeRefPtr<EventManager>();
1477     ASSERT_NE(eventManager, nullptr);
1478 
1479     /**
1480      * @tc.steps: step2. Call DispatchMouseEvent.
1481      * @tc.expected: hoverNodeCur is not null.
1482      */
1483     MouseEvent event;
1484     event.button = MouseButton::NONE_BUTTON;
1485     event.action = MouseAction::MOVE;
1486     eventManager->DispatchMouseHoverAnimation(event);
1487     auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1488     EXPECT_EQ(hoverNodeCur, nullptr);
1489 }
1490 
1491 /**
1492  * @tc.name: EventManagerTest0356
1493  * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::MOVE branches
1494  * @tc.type: FUNC
1495  */
1496 HWTEST_F(EventManagerTestNg, EventManagerTest0356, TestSize.Level1)
1497 {
1498     /**
1499      * @tc.steps: step1. Create EventManager.
1500      * @tc.expected: eventManager is not null.
1501      */
1502     auto eventManager = AceType::MakeRefPtr<EventManager>();
1503     ASSERT_NE(eventManager, nullptr);
1504 
1505     /**
1506      * @tc.steps: step2. Call DispatchMouseEvent.
1507      * @tc.expected: hoverNodeCur is not null.
1508      */
1509     MouseEvent event;
1510     event.action = MouseAction::MOVE;
1511     eventManager->DispatchMouseHoverAnimation(event);
1512     auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1513     EXPECT_EQ(hoverNodeCur, nullptr);
1514 }
1515 
1516 /**
1517  * @tc.name: EventManagerTest0357
1518  * @tc.desc: Test DispatchMouseHoverAnimation in MouseButton::NONE_BUTTON branches
1519  * @tc.type: FUNC
1520  */
1521 HWTEST_F(EventManagerTestNg, EventManagerTest0357, TestSize.Level1)
1522 {
1523     /**
1524      * @tc.steps: step1. Create EventManager.
1525      * @tc.expected: eventManager is not null.
1526      */
1527     auto eventManager = AceType::MakeRefPtr<EventManager>();
1528     ASSERT_NE(eventManager, nullptr);
1529 
1530     /**
1531      * @tc.steps: step2. Call DispatchMouseEvent.
1532      * @tc.expected: hoverNodeCur is not null.
1533      */
1534     MouseEvent event;
1535     event.button = MouseButton::NONE_BUTTON;
1536     eventManager->DispatchMouseHoverAnimation(event);
1537     auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1538     EXPECT_EQ(hoverNodeCur, nullptr);
1539 }
1540 
1541 /**
1542  * @tc.name: EventManagerTest036
1543  * @tc.desc: Test DispatchMouseHoverEvent
1544  * @tc.type: FUNC
1545  */
1546 HWTEST_F(EventManagerTestNg, EventManagerTest036, TestSize.Level1)
1547 {
1548     /**
1549      * @tc.steps: step1. Create EventManager.
1550      * @tc.expected: eventManager is not null.
1551      */
1552     auto eventManager = AceType::MakeRefPtr<EventManager>();
1553     ASSERT_NE(eventManager, nullptr);
1554 
1555     /**
1556      * @tc.steps: step2. Call DispatchMouseHoverEvent.
1557      * @tc.expected: retFlag is true.
1558      */
1559     MouseEvent event;
1560     bool retFlag = eventManager->DispatchMouseHoverEvent(event);
1561     ASSERT_TRUE(retFlag);
1562 }
1563 
1564 /**
1565  * @tc.name: PanRecognizerAxisDirection001
1566  * @tc.desc: Test GetAxisDirection() of PanRecognizer.
1567  * @tc.type: FUNC
1568  */
1569 HWTEST_F(EventManagerTestNg, PanRecognizerAxisDirection001, TestSize.Level1)
1570 {
1571     /**
1572      * @tc.steps: step1. Create pan recognizers.
1573      * @tc.expected: recognizers is not null and axis direction is correct.
1574      */
1575     auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1576         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1577     ASSERT_NE(panHorizontal, nullptr);
1578     EXPECT_EQ(panHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1579 
1580     auto panVertical = AceType::MakeRefPtr<PanRecognizer>(
1581         DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1582     ASSERT_NE(panVertical, nullptr);
1583     EXPECT_EQ(panVertical->GetAxisDirection(), Axis::VERTICAL);
1584 
1585     auto panLeft = AceType::MakeRefPtr<PanRecognizer>(
1586         DEFAULT_PAN_FINGER, PanDirection { PanDirection::LEFT }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1587     ASSERT_NE(panLeft, nullptr);
1588     EXPECT_EQ(panLeft->GetAxisDirection(), Axis::HORIZONTAL);
1589 
1590     auto panRight = AceType::MakeRefPtr<PanRecognizer>(
1591         DEFAULT_PAN_FINGER, PanDirection { PanDirection::RIGHT }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1592     ASSERT_NE(panRight, nullptr);
1593     EXPECT_EQ(panRight->GetAxisDirection(), Axis::HORIZONTAL);
1594 
1595     auto panUp = AceType::MakeRefPtr<PanRecognizer>(
1596         DEFAULT_PAN_FINGER, PanDirection { PanDirection::UP }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1597     ASSERT_NE(panUp, nullptr);
1598     EXPECT_EQ(panUp->GetAxisDirection(), Axis::VERTICAL);
1599 
1600     auto panDown = AceType::MakeRefPtr<PanRecognizer>(
1601         DEFAULT_PAN_FINGER, PanDirection { PanDirection::DOWN }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1602     ASSERT_NE(panDown, nullptr);
1603     EXPECT_EQ(panDown->GetAxisDirection(), Axis::VERTICAL);
1604 
1605     auto panFree = AceType::MakeRefPtr<PanRecognizer>(
1606         DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1607     ASSERT_NE(panFree, nullptr);
1608     EXPECT_EQ(panFree->GetAxisDirection(), Axis::FREE);
1609 }
1610 
1611 /**
1612  * @tc.name: SwipeRecognizerAxisDirection001
1613  * @tc.desc: Test GetAxisDirection() of SwipeRecognizer.
1614  * @tc.type: FUNC
1615  */
1616 HWTEST_F(EventManagerTestNg, SwipeRecognizerAxisDirection001, TestSize.Level1)
1617 {
1618     /**
1619      * @tc.steps: step1. Create swipe recognizers.
1620      * @tc.expected: recognizers is not null and axis direction is correct.
1621      */
1622     auto swipeHorizontal = AceType::MakeRefPtr<SwipeRecognizer>(1, SwipeDirection { SwipeDirection::HORIZONTAL }, 0.0);
1623     ASSERT_NE(swipeHorizontal, nullptr);
1624     EXPECT_EQ(swipeHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1625 
1626     auto swipeVertical = AceType::MakeRefPtr<SwipeRecognizer>(1, SwipeDirection { SwipeDirection::VERTICAL }, 0.0);
1627     ASSERT_NE(swipeVertical, nullptr);
1628     EXPECT_EQ(swipeVertical->GetAxisDirection(), Axis::VERTICAL);
1629 
1630     auto swipeFree = AceType::MakeRefPtr<SwipeRecognizer>(1, SwipeDirection { SwipeDirection::ALL }, 0.0);
1631     ASSERT_NE(swipeFree, nullptr);
1632     EXPECT_EQ(swipeFree->GetAxisDirection(), Axis::FREE);
1633 }
1634 
1635 /**
1636  * @tc.name: ExclusiveRecognizerAxisDirection001
1637  * @tc.desc: Test GetAxisDirection() of ExclusiveRecognizer.
1638  * @tc.type: FUNC
1639  */
1640 HWTEST_F(EventManagerTestNg, ExclusiveRecognizerAxisDirection001, TestSize.Level1)
1641 {
1642     /**
1643      * @tc.steps: step1. Create pan recognizers.
1644      * @tc.expected: recognizers is not null and axis direction is correct.
1645      */
1646     auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
1647         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1648     ASSERT_NE(panHorizontal1, nullptr);
1649     auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
1650         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1651     ASSERT_NE(panHorizontal2, nullptr);
1652 
1653     auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
1654         DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1655     ASSERT_NE(panVertical1, nullptr);
1656     auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
1657         DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1658     ASSERT_NE(panVertical2, nullptr);
1659 
1660     auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
1661         DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1662     ASSERT_NE(panFree1, nullptr);
1663     auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
1664         DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1665     ASSERT_NE(panFree2, nullptr);
1666 
1667     /**
1668      * @tc.steps: step2. Create exclusive recognizers.
1669      * @tc.expected: recognizers is not null and axis direction is correct.
1670      */
1671     std::vector<RefPtr<NGGestureRecognizer>> recognizers;
1672     recognizers.clear();
1673     recognizers.emplace_back(panHorizontal1);
1674     recognizers.emplace_back(panHorizontal2);
1675     auto exclusiveDoubleHorizontal = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1676     ASSERT_NE(exclusiveDoubleHorizontal, nullptr);
1677     EXPECT_EQ(exclusiveDoubleHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1678 
1679     recognizers.clear();
1680     recognizers.emplace_back(panVertical1);
1681     recognizers.emplace_back(panVertical2);
1682     auto exclusiveDoubleVertical = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1683     ASSERT_NE(exclusiveDoubleVertical, nullptr);
1684     EXPECT_EQ(exclusiveDoubleVertical->GetAxisDirection(), Axis::VERTICAL);
1685 
1686     recognizers.clear();
1687     recognizers.emplace_back(panFree1);
1688     recognizers.emplace_back(panFree2);
1689     auto exclusiveDoubleFree = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1690     ASSERT_NE(exclusiveDoubleFree, nullptr);
1691     EXPECT_EQ(exclusiveDoubleFree->GetAxisDirection(), Axis::FREE);
1692 
1693     recognizers.clear();
1694     recognizers.emplace_back(panHorizontal1);
1695     recognizers.emplace_back(panVertical1);
1696     auto exclusiveHorizontalVertical = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1697     ASSERT_NE(exclusiveHorizontalVertical, nullptr);
1698     EXPECT_EQ(exclusiveHorizontalVertical->GetAxisDirection(), Axis::FREE);
1699 
1700     recognizers.clear();
1701     recognizers.emplace_back(panHorizontal1);
1702     recognizers.emplace_back(panFree1);
1703     auto exclusiveHorizontalFree = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1704     ASSERT_NE(exclusiveHorizontalFree, nullptr);
1705     EXPECT_EQ(exclusiveHorizontalFree->GetAxisDirection(), Axis::FREE);
1706 
1707     recognizers.clear();
1708     recognizers.emplace_back(panVertical1);
1709     recognizers.emplace_back(panFree1);
1710     auto exclusiveVerticalFree = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1711     ASSERT_NE(exclusiveVerticalFree, nullptr);
1712     EXPECT_EQ(exclusiveVerticalFree->GetAxisDirection(), Axis::FREE);
1713 }
1714 
1715 /**
1716  * @tc.name: ParallelRecognizerAxisDirection001
1717  * @tc.desc: Test GetAxisDirection() of ParallelRecognizer.
1718  * @tc.type: FUNC
1719  */
1720 HWTEST_F(EventManagerTestNg, ParallelRecognizerAxisDirection001, TestSize.Level1)
1721 {
1722     /**
1723      * @tc.steps: step1. Create pan recognizers.
1724      * @tc.expected: recognizers is not null and axis direction is correct.
1725      */
1726     auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
1727         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1728     ASSERT_NE(panHorizontal1, nullptr);
1729     auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
1730         DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1731     ASSERT_NE(panHorizontal2, nullptr);
1732 
1733     auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
1734         DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1735     ASSERT_NE(panVertical1, nullptr);
1736     auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
1737         DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1738     ASSERT_NE(panVertical2, nullptr);
1739 
1740     auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
1741         DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1742     ASSERT_NE(panFree1, nullptr);
1743     auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
1744         DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1745     ASSERT_NE(panFree2, nullptr);
1746 
1747     /**
1748      * @tc.steps: step2. Create parallel recognizers.
1749      * @tc.expected: recognizers is not null and axis direction is correct.
1750      */
1751     std::vector<RefPtr<NGGestureRecognizer>> recognizers;
1752     recognizers.clear();
1753     recognizers.emplace_back(panHorizontal1);
1754     recognizers.emplace_back(panHorizontal2);
1755     auto parallelDoubleHorizontal = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1756     ASSERT_NE(parallelDoubleHorizontal, nullptr);
1757     EXPECT_EQ(parallelDoubleHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1758 
1759     recognizers.clear();
1760     recognizers.emplace_back(panVertical1);
1761     recognizers.emplace_back(panVertical2);
1762     auto parallelDoubleVertical = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1763     ASSERT_NE(parallelDoubleVertical, nullptr);
1764     EXPECT_EQ(parallelDoubleVertical->GetAxisDirection(), Axis::VERTICAL);
1765 
1766     recognizers.clear();
1767     recognizers.emplace_back(panFree1);
1768     recognizers.emplace_back(panFree2);
1769     auto parallelDoubleFree = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1770     ASSERT_NE(parallelDoubleFree, nullptr);
1771     EXPECT_EQ(parallelDoubleFree->GetAxisDirection(), Axis::FREE);
1772 
1773     recognizers.clear();
1774     recognizers.emplace_back(panHorizontal1);
1775     recognizers.emplace_back(panVertical1);
1776     auto parallelHorizontalVertical = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1777     ASSERT_NE(parallelHorizontalVertical, nullptr);
1778     EXPECT_EQ(parallelHorizontalVertical->GetAxisDirection(), Axis::FREE);
1779 
1780     recognizers.clear();
1781     recognizers.emplace_back(panHorizontal1);
1782     recognizers.emplace_back(panFree1);
1783     auto parallelHorizontalFree = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1784     ASSERT_NE(parallelHorizontalFree, nullptr);
1785     EXPECT_EQ(parallelHorizontalFree->GetAxisDirection(), Axis::FREE);
1786 
1787     recognizers.clear();
1788     recognizers.emplace_back(panVertical1);
1789     recognizers.emplace_back(panFree1);
1790     auto parallelVerticalFree = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1791     ASSERT_NE(parallelVerticalFree, nullptr);
1792     EXPECT_EQ(parallelVerticalFree->GetAxisDirection(), Axis::FREE);
1793 }
1794 } // namespace OHOS::Ace::NG
1795