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