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->GetEventHub<NG::EventHub>();
83 auto eventHubShift = frameNodeShift->GetEventHub<NG::EventHub>();
84 auto eventHubAlt = frameNodeAlt->GetEventHub<NG::EventHub>();
85 auto eventHubCtrlShift = frameNodeCtrlShift->GetEventHub<NG::EventHub>();
86
__anond8a2380e0102() 87 eventHubCtrl->SetKeyboardShortcut(CHARACTER_C, NUM_CTRL_VALUE, []() {});
__anond8a2380e0202() 88 eventHubShift->SetKeyboardShortcut(CHARACTER_A, NUM_SHIFT_VALUE, []() {});
__anond8a2380e0302() 89 eventHubAlt->SetKeyboardShortcut(CHARACTER_V, NUM_ALT_VALUE, []() {});
__anond8a2380e0402() 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->GetEventHub<EventHub>()->SetKeyboardShortcut(
__anond8a2380e0502() 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 /**
300 * @tc.steps: step2. Create FrameNode and Call TouchTest
301 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
302 */
303 AxisEvent axisEvent;
304 axisEvent.sourceType = SourceType::TOUCH;
305
306 const int nodeId = 10002;
307 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
308 TouchRestrict touchRestrict;
309
310 EXPECT_EQ(eventManager->axisTouchTestResults_.count(axisEvent.id), 0);
311 eventManager->TouchTest(axisEvent, frameNode, touchRestrict);
312 EXPECT_GT(eventManager->axisTouchTestResults_.count(axisEvent.id), 0);
313 }
314
315 /**
316 * @tc.name: EventManagerTest012
317 * @tc.desc: Test HandleGlobalEventNG
318 * @tc.type: FUNC
319 */
320 HWTEST_F(EventManagerTestNg, EventManagerTest012, TestSize.Level1)
321 {
322 /**
323 * @tc.steps: step1. Create EventManager.
324 * @tc.expected: eventManager is not null.
325 */
326 auto eventManager = AceType::MakeRefPtr<EventManager>();
327 ASSERT_NE(eventManager, nullptr);
328
329 /**
330 * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id]
331 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
332 */
333 TouchEvent touchPoint;
334 touchPoint.type = TouchType::DOWN;
335
336 const int nodeId = 10003;
337 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
338 TouchRestrict touchRestrict;
339 Offset offset;
340
341 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
342 EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
343
344 /**
345 * @tc.steps: step3. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id]
346 * @tc.expected: selectOverlayManager->touchTestResults_ is empty for do not have specific event
347 */
348 auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode);
349 NG::OffsetF rootOffset;
350 eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset);
351 EXPECT_EQ(selectOverlayManager->touchTestResults_.size(), 0);
352 }
353
354 /**
355 * @tc.name: EventManagerTest013
356 * @tc.desc: Test HandleOutOfRectCallback
357 * @tc.type: FUNC
358 */
359 HWTEST_F(EventManagerTestNg, EventManagerTest013, TestSize.Level1)
360 {
361 /**
362 * @tc.steps: step1. Create EventManager.
363 * @tc.expected: eventManager is not null.
364 */
365 auto eventManager = AceType::MakeRefPtr<EventManager>();
366 ASSERT_NE(eventManager, nullptr);
367
368 /**
369 * @tc.steps: step2. Create rectCallbackList
370 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
371 */
372 Point point(10, 20);
373 point.SetSourceType(SourceType::TOUCH);
374
__anond8a2380e0602(std::vector<Rect>& rectList) 375 auto rectGetCallback1 = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect()); };
__anond8a2380e0702(std::vector<Rect>& rectList) 376 auto rectGetCallback2 = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect(0, 0, 100, 100)); };
377
__anond8a2380e0802() 378 auto touchCallback = []() -> void {};
__anond8a2380e0902() 379 auto mouseCallback = []() -> void {};
380 std::vector<RectCallback> rectCallbackList { RectCallback(rectGetCallback1, touchCallback, mouseCallback),
381 RectCallback(rectGetCallback2, touchCallback, mouseCallback) };
382
383 /**
384 * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::TOUCH
385 * @tc.expected: rectCallbackList.size() is 1
386 */
387 eventManager->HandleOutOfRectCallback(point, rectCallbackList);
388 EXPECT_EQ(rectCallbackList.size(), 1);
389
390 /**
391 * @tc.steps: step4. Call HandleOutOfRectCallback with SourceType::MOUSE
392 * @tc.expected: rectCallbackList.size() is 0
393 */
394 point.SetSourceType(SourceType::MOUSE);
395 rectCallbackList = vector<RectCallback>({ RectCallback(rectGetCallback1, touchCallback, mouseCallback) });
396 eventManager->HandleOutOfRectCallback(point, rectCallbackList);
397 EXPECT_TRUE(rectCallbackList.empty());
398 }
399
400 /**
401 * @tc.name: EventManagerTest014
402 * @tc.desc: Test DispatchTouchEvent
403 * @tc.type: FUNC
404 */
405 HWTEST_F(EventManagerTestNg, EventManagerTest014, TestSize.Level1)
406 {
407 /**
408 * @tc.steps: step1. Create EventManager.
409 * @tc.expected: eventManager is not null.
410 */
411 auto eventManager = AceType::MakeRefPtr<EventManager>();
412 ASSERT_NE(eventManager, nullptr);
413
414 /**
415 * @tc.steps: step2. Create TouchEvent and Call DispatchTouchEvent
416 * @tc.expected: retFlag is false
417 */
418 AxisEvent event;
419 event.action = AxisAction::BEGIN;
420
421 auto retFlag = eventManager->DispatchTouchEvent(event);
422 EXPECT_FALSE(retFlag);
423
424 /**
425 * @tc.steps: step3. Create FrameNode and Call TouchTest to add axisTouchTestResults_
426 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
427 */
428 event.action = AxisAction::END;
429
430 const int nodeId = 10004;
431 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
432 TouchRestrict touchRestrict;
433
434 eventManager->TouchTest(event, frameNode, touchRestrict);
435 EXPECT_GT(eventManager->axisTouchTestResults_.count(event.id), 0);
436
437 /**
438 * @tc.steps: step4. Call DispatchTouchEvent
439 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
440 */
441 retFlag = eventManager->DispatchTouchEvent(event);
442 EXPECT_TRUE(retFlag);
443
444 /**
445 * @tc.steps: step5. Create AxisEvent and Call DispatchTouchEvent
446 * @tc.expected: retFlag is false
447 */
448 event.action = AxisAction::BEGIN;
449 Container::SetCurrentUsePartialUpdate(true);
450 AceForwardCompatibility::isNewPipeline_ = true;
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->GetEventHub<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: currHoverTestResults_ 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->currHoverTestResults_.push_back(hoverEventTarget);
548 EXPECT_FALSE(eventManager->currHoverTestResults_.empty());
549 eventManager->MouseTest(event, frameNode, touchRestrict);
550 EXPECT_TRUE(eventManager->currHoverTestResults_.empty());
551
552 /**
553 * @tc.steps: step3. Call MouseTest with MouseAction::WINDOW_ENTER
554 * @tc.expected: lastHoverTestResults_ is empty
555 */
556 event.action = MouseAction::WINDOW_ENTER;
557 eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
558 EXPECT_FALSE(eventManager->lastHoverTestResults_.empty());
559 eventManager->MouseTest(event, frameNode, touchRestrict);
560 EXPECT_TRUE(eventManager->lastHoverTestResults_.empty());
561
562 /**
563 * @tc.steps: step4. Call MouseTest with MouseAction::HOVER
564 * @tc.expected: lastHoverTestResults_ is empty and currHoverTestResults_ is empty
565 */
566 event.action = MouseAction::HOVER;
567 eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
568 eventManager->MouseTest(event, frameNode, touchRestrict);
569 EXPECT_TRUE(eventManager->lastHoverTestResults_.empty());
570 EXPECT_TRUE(eventManager->currHoverTestResults_.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: currHoverTestResults_ 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->currMouseTestResults_.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: currHoverTestResults_ 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: currHoverTestResults_ 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: currHoverTestResults_ 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->currMouseTestResults_.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->lastHoverTestResults_.push_back(hoverEventTarget);
661 eventManager->currHoverTestResults_.push_back(hoverEventTarget2);
662 eventManager->currHoverTestResults_.push_back(hoverEventTarget3);
663 eventManager->currHoverTestResults_.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->lastHoverTestResults_.clear();
674 eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
675 eventManager->currHoverTestResults_.clear();
676 eventManager->currHoverTestResults_.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 axisTestResults_ 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 axisTestResults_ not empty
717 * @tc.expected: retFlag is false
718 */
719 auto axisEventTarget = AceType::MakeRefPtr<AxisEventTarget>();
__anond8a2380e0a02(AxisInfo&) 720 auto onAxisCallback = [](AxisInfo&) -> void {};
721 axisEventTarget->SetOnAxisCallback(onAxisCallback);
722
723 eventManager->axisTestResults_.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->GetEventHub<EventHub>()->SetEnabled(true);
749 const uint8_t ctrlShift = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::SHIFT);
__anond8a2380e0b02() 750 frameNodeCtrlShift->GetEventHub<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->GetEventHub<EventHub>()->SetEnabled(true);
757 const uint8_t ctrlAlt = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::ALT);
__anond8a2380e0c02() 758 frameNodeCtrlAlt->GetEventHub<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->GetEventHub<EventHub>()->SetEnabled(true);
765 const uint8_t altShift = static_cast<uint8_t>(CtrlKeysBit::SHIFT) + static_cast<uint8_t>(CtrlKeysBit::ALT);
__anond8a2380e0d02() 766 frameNodeAltShift->GetEventHub<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->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, ctrlShift);
777 EXPECT_EQ(frameNodeCtrlAlt->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, ctrlAlt);
778 EXPECT_EQ(frameNodeAltShift->GetEventHub<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->GetEventHub<EventHub>()->SetEnabled(true);
802 const uint8_t ctrl = static_cast<uint8_t>(CtrlKeysBit::CTRL);
__anond8a2380e0e02() 803 frameNodeCtrl->GetEventHub<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->GetEventHub<EventHub>()->SetEnabled(true);
810 const uint8_t alt = static_cast<uint8_t>(CtrlKeysBit::ALT);
__anond8a2380e0f02() 811 frameNodeAlt->GetEventHub<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->GetEventHub<EventHub>()->SetEnabled(true);
818 const uint8_t shift = static_cast<uint8_t>(CtrlKeysBit::SHIFT);
__anond8a2380e1002() 819 frameNodeShift->GetEventHub<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->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, ctrl);
830 EXPECT_EQ(frameNodeAlt->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, alt);
831 EXPECT_EQ(frameNodeShift->GetEventHub<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
881 /**
882 * @tc.name: EventManagerTest024
883 * @tc.desc: Test DispatchTouchEvent
884 * @tc.type: FUNC
885 */
886 HWTEST_F(EventManagerTestNg, EventManagerTest024, TestSize.Level1)
887 {
888 /**
889 * @tc.steps: step1. Create EventManager.
890 * @tc.expected: eventManager is not null.
891 */
892 auto eventManager = AceType::MakeRefPtr<EventManager>();
893 ASSERT_NE(eventManager, nullptr);
894
895 auto currentHoverNodeId = ElementRegister::GetInstance()->MakeUniqueId();
896 auto currentHoverNode = FrameNode::GetOrCreateFrameNode(CTRL, currentHoverNodeId, nullptr);
897 eventManager->currHoverNode_ = currentHoverNode;
898 auto lastHoverNodeId = ElementRegister::GetInstance()->MakeUniqueId();
899 auto lastHoverNode = FrameNode::GetOrCreateFrameNode(SHIFT, lastHoverNodeId, nullptr);
900 eventManager->lastHoverNode_ = lastHoverNode;
901
902 /**
903 * @tc.steps: step2. Call DispatchMouseHoverAnimationNG with MouseAction::PRESS;
904 * @tc.expected: ret is false
905 */
906 MouseEvent event;
907 event.button = MouseButton::NONE_BUTTON;
908 event.action = MouseAction::PRESS;
909 eventManager->DispatchMouseHoverAnimationNG(event);
910 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
911
912 /**
913 * @tc.steps: step3. Call DispatchMouseHoverAnimationNG with MouseAction::RELEASE;
914 * @tc.expected: ret is false
915 */
916 event.action = MouseAction::RELEASE;
917 eventManager->DispatchMouseHoverAnimationNG(event);
918 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
919
920 /**
921 * @tc.steps: step4. Call DispatchMouseHoverAnimationNG with MouseAction::MOVE;
922 * @tc.expected: ret is false
923 */
924 event.action = MouseAction::MOVE;
925 eventManager->DispatchMouseHoverAnimationNG(event);
926 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
927
928 /**
929 * @tc.steps: step5. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_ENTER;
930 * @tc.expected: ret is false
931 */
932 event.action = MouseAction::WINDOW_ENTER;
933 eventManager->DispatchMouseHoverAnimationNG(event);
934 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
935
936 /**
937 * @tc.steps: step6. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_LEAVE;
938 * @tc.expected: ret is false
939 */
940 event.action = MouseAction::WINDOW_LEAVE;
941 eventManager->DispatchMouseHoverAnimationNG(event);
942 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
943 }
944
945 /**
946 * @tc.name: EventManagerTest025
947 * @tc.desc: Test FlushTouchEventsBegin
948 * @tc.type: FUNC
949 */
950 HWTEST_F(EventManagerTestNg, EventManagerTest025, 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 auto resultId = ElementRegister::GetInstance()->MakeUniqueId();
960 TouchTestResult touchTestResults;
961 touchTestResults.push_back(AceType::MakeRefPtr<MockTouchEventTarget>());
962 eventManager->touchTestResults_.emplace(resultId, touchTestResults);
963
964 TouchEvent event {};
965 event.id = resultId;
966 std::list<TouchEvent> touchEvents { event };
967 eventManager->FlushTouchEventsBegin(touchEvents);
968 EXPECT_NE(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end());
969 }
970
971 /**
972 * @tc.name: EventManagerTest026
973 * @tc.desc: Test FlushTouchEventsBegin
974 * @tc.type: FUNC
975 */
976 HWTEST_F(EventManagerTestNg, EventManagerTest026, TestSize.Level1)
977 {
978 /**
979 * @tc.steps: step1. Create EventManager.
980 * @tc.expected: eventManager is not null.
981 */
982 auto eventManager = AceType::MakeRefPtr<EventManager>();
983 ASSERT_NE(eventManager, nullptr);
984
985 auto resultId = ElementRegister::GetInstance()->MakeUniqueId();
986 TouchTestResult touchTestResults;
987 touchTestResults.push_back(AceType::MakeRefPtr<MockTouchEventTarget>());
988 eventManager->touchTestResults_.emplace(resultId, touchTestResults);
989
990 TouchEvent event {};
991 event.id = resultId;
992 std::list<TouchEvent> touchEvents { event };
993 eventManager->FlushTouchEventsEnd(touchEvents);
994 EXPECT_NE(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end());
995 }
996
997 /**
998 * @tc.name: EventManagerTest027
999 * @tc.desc: Test FlushTouchEventsBegin
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(EventManagerTestNg, EventManagerTest027, TestSize.Level1)
1003 {
1004 /**
1005 * @tc.steps: step1. Create EventManager.
1006 * @tc.expected: eventManager is not null.
1007 */
1008 auto eventManager = AceType::MakeRefPtr<EventManager>();
1009 ASSERT_NE(eventManager, nullptr);
1010
1011 AxisEvent axisEvent;
1012 axisEvent.x = 1;
1013 axisEvent.y = 2;
1014 axisEvent.sourceType = SourceType::TOUCH;
1015 auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1016 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
1017 eventManager->AxisTest(axisEvent, frameNode);
1018 EXPECT_NE(frameNode, nullptr);
1019 }
1020
1021 /**
1022 * @tc.name: EventManagerTest028
1023 * @tc.desc: Test DispatchTouchEvent:hoverNodeCur and hoverNodePre both null
1024 * @tc.type: FUNC
1025 */
1026 HWTEST_F(EventManagerTestNg, EventManagerTest028, TestSize.Level1)
1027 {
1028 /**
1029 * @tc.steps: step1. Create EventManager.
1030 * @tc.expected: eventManager is not null.
1031 */
1032 auto eventManager = AceType::MakeRefPtr<EventManager>();
1033 ASSERT_NE(eventManager, nullptr);
1034
1035 eventManager->currHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr);
1036 eventManager->lastHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr);
1037
1038 /**
1039 * @tc.steps: step2. Call DispatchMouseHoverAnimationNG with MouseAction::PRESS;
1040 * @tc.expected: ret is false
1041 */
1042 MouseEvent event;
1043 event.button = MouseButton::NONE_BUTTON;
1044 event.action = MouseAction::PRESS;
1045 eventManager->DispatchMouseHoverAnimationNG(event);
1046 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1047
1048 /**
1049 * @tc.steps: step3. Call DispatchMouseHoverAnimationNG with MouseAction::RELEASE;
1050 * @tc.expected: ret is false
1051 */
1052 event.action = MouseAction::RELEASE;
1053 eventManager->DispatchMouseHoverAnimationNG(event);
1054 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1055
1056 /**
1057 * @tc.steps: step4. Call DispatchMouseHoverAnimationNG with MouseAction::MOVE;
1058 * @tc.expected: ret is false
1059 */
1060 event.action = MouseAction::MOVE;
1061 eventManager->DispatchMouseHoverAnimationNG(event);
1062 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1063
1064 /**
1065 * @tc.steps: step5. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_ENTER;
1066 * @tc.expected: ret is false
1067 */
1068 event.action = MouseAction::WINDOW_ENTER;
1069 eventManager->DispatchMouseHoverAnimationNG(event);
1070 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1071
1072 /**
1073 * @tc.steps: step6. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_LEAVE;
1074 * @tc.expected: ret is false
1075 */
1076 event.action = MouseAction::WINDOW_LEAVE;
1077 eventManager->DispatchMouseHoverAnimationNG(event);
1078 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1079
1080 /**
1081 * @tc.steps: step6. Call DispatchMouseHoverAnimationNG with MouseAction::HOVER;
1082 * @tc.expected: ret is false
1083 */
1084 event.action = MouseAction::HOVER;
1085 eventManager->DispatchMouseHoverAnimationNG(event);
1086 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1087 }
1088
1089 /**
1090 * @tc.name: EventManagerTest029
1091 * @tc.desc: Test TouchTest
1092 * @tc.type: FUNC
1093 */
1094 HWTEST_F(EventManagerTestNg, EventManagerTest029, TestSize.Level1)
1095 {
1096 /**
1097 * @tc.steps: step1. Create EventManager.
1098 * @tc.expected: eventManager is not null.
1099 */
1100 auto eventManager = AceType::MakeRefPtr<EventManager>();
1101 ASSERT_NE(eventManager, nullptr);
1102
1103 TouchEvent touchPoint;
1104 touchPoint.id = 100;
1105 touchPoint.type = TouchType::DOWN;
1106
1107 TouchRestrict touchRestrict;
1108 Offset offset;
1109
1110 /**
1111 * @tc.steps: step1. Create renderNode.
1112 * @tc.expected: renderNode is not null.
1113 */
1114 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
1115 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
1116
1117 /**
1118 * @tc.steps: step2. Call TouchTest with MouseAction::PRESS;
1119 * @tc.expected: ret is false
1120 */
1121 eventManager->TouchTest(touchPoint, renderNode, touchRestrict, offset, 0, true);
1122 auto findIt = eventManager->touchTestResults_.find(touchPoint.id);
1123 EXPECT_EQ(findIt, eventManager->touchTestResults_.end());
1124 }
1125
1126 /**
1127 * @tc.name: EventManagerTest032
1128 * @tc.desc: Test DispatchAxisEvent
1129 * @tc.type: FUNC
1130 */
1131 HWTEST_F(EventManagerTestNg, EventManagerTest032, TestSize.Level1)
1132 {
1133 /**
1134 * @tc.steps: step1. Create EventManager.
1135 * @tc.expected: eventManager is not null.
1136 */
1137 auto eventManager = AceType::MakeRefPtr<EventManager>();
1138 ASSERT_NE(eventManager, nullptr);
1139
1140 AxisEvent axisEvent;
1141 axisEvent.horizontalAxis = 0;
1142 axisEvent.verticalAxis = 0;
1143 axisEvent.pinchAxisScale = 1.0f;
1144
1145 /**
1146 * @tc.steps: step2. Call AxisTest with SourceType::TOUCH.
1147 * @tc.expected: eventManager->axisNode_.Upgrade() is not null.
1148 */
1149 bool retFlag = eventManager->DispatchAxisEvent(axisEvent);
1150 EXPECT_TRUE(retFlag);
1151 }
1152
1153 /**
1154 * @tc.name: EventManagerTest033
1155 * @tc.desc: Test DumpEvent
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(EventManagerTestNg, EventManagerTest033, TestSize.Level1)
1159 {
1160 /**
1161 * @tc.steps: step1. Create EventManager.
1162 * @tc.expected: eventManager is not null.
1163 */
1164 auto eventManager = AceType::MakeRefPtr<EventManager>();
1165 ASSERT_NE(eventManager, nullptr);
1166
1167 /**
1168 * @tc.steps: step2. Call DumpEvent.
1169 * @tc.expected: eventManager->axisNode_.Upgrade() is not null.
1170 */
1171 eventManager->DumpEvent(EventTreeType::TOUCH);
1172 std::list<std::pair<int32_t, std::string>> dumpList;
1173 eventManager->eventTree_.Dump(dumpList, 0);
1174 EXPECT_TRUE(dumpList.empty());
1175 }
1176
1177 /**
1178 * @tc.name: EventManagerTest034
1179 * @tc.desc: Test DispatchMouseEvent
1180 * @tc.type: FUNC
1181 */
1182 HWTEST_F(EventManagerTestNg, EventManagerTest034, TestSize.Level1)
1183 {
1184 /**
1185 * @tc.steps: step1. Create EventManager.
1186 * @tc.expected: eventManager is not null.
1187 */
1188 auto eventManager = AceType::MakeRefPtr<EventManager>();
1189 ASSERT_NE(eventManager, nullptr);
1190
1191 /**
1192 * @tc.steps: step2. Call DispatchMouseEvent.
1193 * @tc.expected: retFlag is false.
1194 */
1195 MouseEvent event;
1196 event.action = MouseAction::PRESS;
1197 bool retFlag = eventManager->DispatchMouseEvent(event);
1198 EXPECT_TRUE(retFlag);
1199 }
1200
1201 /**
1202 * @tc.name: EventManagerTest0351
1203 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::PRESS branches
1204 * @tc.type: FUNC
1205 */
1206 HWTEST_F(EventManagerTestNg, EventManagerTest0351, TestSize.Level1)
1207 {
1208 /**
1209 * @tc.steps: step1. Create EventManager.
1210 * @tc.expected: eventManager is not null.
1211 */
1212 auto eventManager = AceType::MakeRefPtr<EventManager>();
1213 ASSERT_NE(eventManager, nullptr);
1214
1215 /**
1216 * @tc.steps: step2. Call DispatchMouseEvent.
1217 * @tc.expected: hoverNodeCur is not null.
1218 */
1219 MouseEvent event;
1220 event.action = MouseAction::PRESS;
1221 eventManager->DispatchMouseHoverAnimation(event);
1222 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1223 EXPECT_EQ(hoverNodeCur, nullptr);
1224 }
1225
1226 /**
1227 * @tc.name: EventManagerTest0352
1228 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::RELEASE branches
1229 * @tc.type: FUNC
1230 */
1231 HWTEST_F(EventManagerTestNg, EventManagerTest0352, TestSize.Level1)
1232 {
1233 /**
1234 * @tc.steps: step1. Create EventManager.
1235 * @tc.expected: eventManager is not null.
1236 */
1237 auto eventManager = AceType::MakeRefPtr<EventManager>();
1238 ASSERT_NE(eventManager, nullptr);
1239
1240 /**
1241 * @tc.steps: step2. Call DispatchMouseEvent.
1242 * @tc.expected: hoverNodeCur is not null.
1243 */
1244 MouseEvent event;
1245 event.action = MouseAction::RELEASE;
1246 eventManager->DispatchMouseHoverAnimation(event);
1247 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1248 EXPECT_EQ(hoverNodeCur, nullptr);
1249 }
1250
1251 /**
1252 * @tc.name: EventManagerTest0353
1253 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::WINDOW_ENTER branches
1254 * @tc.type: FUNC
1255 */
1256 HWTEST_F(EventManagerTestNg, EventManagerTest0353, TestSize.Level1)
1257 {
1258 /**
1259 * @tc.steps: step1. Create EventManager.
1260 * @tc.expected: eventManager is not null.
1261 */
1262 auto eventManager = AceType::MakeRefPtr<EventManager>();
1263 ASSERT_NE(eventManager, nullptr);
1264
1265 /**
1266 * @tc.steps: step2. Call DispatchMouseEvent.
1267 * @tc.expected: hoverNodeCur is not null.
1268 */
1269 MouseEvent event;
1270 event.action = MouseAction::WINDOW_ENTER;
1271 eventManager->DispatchMouseHoverAnimation(event);
1272 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1273 EXPECT_EQ(hoverNodeCur, nullptr);
1274 }
1275
1276 /**
1277 * @tc.name: EventManagerTest0354
1278 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::WINDOW_LEAVE branches
1279 * @tc.type: FUNC
1280 */
1281 HWTEST_F(EventManagerTestNg, EventManagerTest0354, TestSize.Level1)
1282 {
1283 /**
1284 * @tc.steps: step1. Create EventManager.
1285 * @tc.expected: eventManager is not null.
1286 */
1287 auto eventManager = AceType::MakeRefPtr<EventManager>();
1288 ASSERT_NE(eventManager, nullptr);
1289
1290 /**
1291 * @tc.steps: step2. Call DispatchMouseEvent.
1292 * @tc.expected: hoverNodeCur is not null.
1293 */
1294 MouseEvent event;
1295 event.action = MouseAction::WINDOW_LEAVE;
1296 eventManager->DispatchMouseHoverAnimation(event);
1297 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1298 EXPECT_EQ(hoverNodeCur, nullptr);
1299 }
1300
1301 /**
1302 * @tc.name: EventManagerTest0355
1303 * @tc.desc: Test DispatchMouseHoverAnimation in MouseButton::NONE_BUTTON and MouseAction::MOVE branches
1304 * @tc.type: FUNC
1305 */
1306 HWTEST_F(EventManagerTestNg, EventManagerTest0355, TestSize.Level1)
1307 {
1308 /**
1309 * @tc.steps: step1. Create EventManager.
1310 * @tc.expected: eventManager is not null.
1311 */
1312 auto eventManager = AceType::MakeRefPtr<EventManager>();
1313 ASSERT_NE(eventManager, nullptr);
1314
1315 /**
1316 * @tc.steps: step2. Call DispatchMouseEvent.
1317 * @tc.expected: hoverNodeCur is not null.
1318 */
1319 MouseEvent event;
1320 event.button = MouseButton::NONE_BUTTON;
1321 event.action = MouseAction::MOVE;
1322 eventManager->DispatchMouseHoverAnimation(event);
1323 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1324 EXPECT_EQ(hoverNodeCur, nullptr);
1325 }
1326
1327 /**
1328 * @tc.name: EventManagerTest0356
1329 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::MOVE branches
1330 * @tc.type: FUNC
1331 */
1332 HWTEST_F(EventManagerTestNg, EventManagerTest0356, TestSize.Level1)
1333 {
1334 /**
1335 * @tc.steps: step1. Create EventManager.
1336 * @tc.expected: eventManager is not null.
1337 */
1338 auto eventManager = AceType::MakeRefPtr<EventManager>();
1339 ASSERT_NE(eventManager, nullptr);
1340
1341 /**
1342 * @tc.steps: step2. Call DispatchMouseEvent.
1343 * @tc.expected: hoverNodeCur is not null.
1344 */
1345 MouseEvent event;
1346 event.action = MouseAction::MOVE;
1347 eventManager->DispatchMouseHoverAnimation(event);
1348 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1349 EXPECT_EQ(hoverNodeCur, nullptr);
1350 }
1351
1352 /**
1353 * @tc.name: EventManagerTest0357
1354 * @tc.desc: Test DispatchMouseHoverAnimation in MouseButton::NONE_BUTTON branches
1355 * @tc.type: FUNC
1356 */
1357 HWTEST_F(EventManagerTestNg, EventManagerTest0357, TestSize.Level1)
1358 {
1359 /**
1360 * @tc.steps: step1. Create EventManager.
1361 * @tc.expected: eventManager is not null.
1362 */
1363 auto eventManager = AceType::MakeRefPtr<EventManager>();
1364 ASSERT_NE(eventManager, nullptr);
1365
1366 /**
1367 * @tc.steps: step2. Call DispatchMouseEvent.
1368 * @tc.expected: hoverNodeCur is not null.
1369 */
1370 MouseEvent event;
1371 event.button = MouseButton::NONE_BUTTON;
1372 eventManager->DispatchMouseHoverAnimation(event);
1373 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1374 EXPECT_EQ(hoverNodeCur, nullptr);
1375 }
1376
1377 /**
1378 * @tc.name: EventManagerTest036
1379 * @tc.desc: Test DispatchMouseHoverEvent
1380 * @tc.type: FUNC
1381 */
1382 HWTEST_F(EventManagerTestNg, EventManagerTest036, TestSize.Level1)
1383 {
1384 /**
1385 * @tc.steps: step1. Create EventManager.
1386 * @tc.expected: eventManager is not null.
1387 */
1388 auto eventManager = AceType::MakeRefPtr<EventManager>();
1389 ASSERT_NE(eventManager, nullptr);
1390
1391 /**
1392 * @tc.steps: step2. Call DispatchMouseHoverEvent.
1393 * @tc.expected: retFlag is true.
1394 */
1395 MouseEvent event;
1396 bool retFlag = eventManager->DispatchMouseHoverEvent(event);
1397 EXPECT_TRUE(retFlag);
1398 }
1399
1400 /**
1401 * @tc.name: PanRecognizerAxisDirection001
1402 * @tc.desc: Test GetAxisDirection() of PanRecognizer.
1403 * @tc.type: FUNC
1404 */
1405 HWTEST_F(EventManagerTestNg, PanRecognizerAxisDirection001, TestSize.Level1)
1406 {
1407 /**
1408 * @tc.steps: step1. Create pan recognizers.
1409 * @tc.expected: recognizers is not null and axis direction is correct.
1410 */
1411 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1412 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1413 ASSERT_NE(panHorizontal, nullptr);
1414 EXPECT_EQ(panHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1415
1416 auto panVertical = AceType::MakeRefPtr<PanRecognizer>(
1417 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1418 ASSERT_NE(panVertical, nullptr);
1419 EXPECT_EQ(panVertical->GetAxisDirection(), Axis::VERTICAL);
1420
1421 auto panLeft = AceType::MakeRefPtr<PanRecognizer>(
1422 DEFAULT_PAN_FINGER, PanDirection { PanDirection::LEFT }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1423 ASSERT_NE(panLeft, nullptr);
1424 EXPECT_EQ(panLeft->GetAxisDirection(), Axis::HORIZONTAL);
1425
1426 auto panRight = AceType::MakeRefPtr<PanRecognizer>(
1427 DEFAULT_PAN_FINGER, PanDirection { PanDirection::RIGHT }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1428 ASSERT_NE(panRight, nullptr);
1429 EXPECT_EQ(panRight->GetAxisDirection(), Axis::HORIZONTAL);
1430
1431 auto panUp = AceType::MakeRefPtr<PanRecognizer>(
1432 DEFAULT_PAN_FINGER, PanDirection { PanDirection::UP }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1433 ASSERT_NE(panUp, nullptr);
1434 EXPECT_EQ(panUp->GetAxisDirection(), Axis::VERTICAL);
1435
1436 auto panDown = AceType::MakeRefPtr<PanRecognizer>(
1437 DEFAULT_PAN_FINGER, PanDirection { PanDirection::DOWN }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1438 ASSERT_NE(panDown, nullptr);
1439 EXPECT_EQ(panDown->GetAxisDirection(), Axis::VERTICAL);
1440
1441 auto panFree = AceType::MakeRefPtr<PanRecognizer>(
1442 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1443 ASSERT_NE(panFree, nullptr);
1444 EXPECT_EQ(panFree->GetAxisDirection(), Axis::FREE);
1445 }
1446
1447 /**
1448 * @tc.name: SwipeRecognizerAxisDirection001
1449 * @tc.desc: Test GetAxisDirection() of SwipeRecognizer.
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(EventManagerTestNg, SwipeRecognizerAxisDirection001, TestSize.Level1)
1453 {
1454 /**
1455 * @tc.steps: step1. Create swipe recognizers.
1456 * @tc.expected: recognizers is not null and axis direction is correct.
1457 */
1458 auto swipeHorizontal = AceType::MakeRefPtr<SwipeRecognizer>(1, SwipeDirection { SwipeDirection::HORIZONTAL }, 0.0);
1459 ASSERT_NE(swipeHorizontal, nullptr);
1460 EXPECT_EQ(swipeHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1461
1462 auto swipeVertical = AceType::MakeRefPtr<SwipeRecognizer>(1, SwipeDirection { SwipeDirection::VERTICAL }, 0.0);
1463 ASSERT_NE(swipeVertical, nullptr);
1464 EXPECT_EQ(swipeVertical->GetAxisDirection(), Axis::VERTICAL);
1465
1466 auto swipeFree = AceType::MakeRefPtr<SwipeRecognizer>(1, SwipeDirection { SwipeDirection::ALL }, 0.0);
1467 ASSERT_NE(swipeFree, nullptr);
1468 EXPECT_EQ(swipeFree->GetAxisDirection(), Axis::FREE);
1469 }
1470
1471 /**
1472 * @tc.name: ExclusiveRecognizerAxisDirection001
1473 * @tc.desc: Test GetAxisDirection() of ExclusiveRecognizer.
1474 * @tc.type: FUNC
1475 */
1476 HWTEST_F(EventManagerTestNg, ExclusiveRecognizerAxisDirection001, TestSize.Level1)
1477 {
1478 /**
1479 * @tc.steps: step1. Create pan recognizers.
1480 * @tc.expected: recognizers is not null and axis direction is correct.
1481 */
1482 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
1483 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1484 ASSERT_NE(panHorizontal1, nullptr);
1485 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
1486 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1487 ASSERT_NE(panHorizontal2, nullptr);
1488
1489 auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
1490 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1491 ASSERT_NE(panVertical1, nullptr);
1492 auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
1493 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1494 ASSERT_NE(panVertical2, nullptr);
1495
1496 auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
1497 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1498 ASSERT_NE(panFree1, nullptr);
1499 auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
1500 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1501 ASSERT_NE(panFree2, nullptr);
1502
1503 /**
1504 * @tc.steps: step2. Create exclusive recognizers.
1505 * @tc.expected: recognizers is not null and axis direction is correct.
1506 */
1507 std::vector<RefPtr<NGGestureRecognizer>> recognizers;
1508 recognizers.clear();
1509 recognizers.emplace_back(panHorizontal1);
1510 recognizers.emplace_back(panHorizontal2);
1511 auto exclusiveDoubleHorizontal = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1512 ASSERT_NE(exclusiveDoubleHorizontal, nullptr);
1513 EXPECT_EQ(exclusiveDoubleHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1514
1515 recognizers.clear();
1516 recognizers.emplace_back(panVertical1);
1517 recognizers.emplace_back(panVertical2);
1518 auto exclusiveDoubleVertical = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1519 ASSERT_NE(exclusiveDoubleVertical, nullptr);
1520 EXPECT_EQ(exclusiveDoubleVertical->GetAxisDirection(), Axis::VERTICAL);
1521
1522 recognizers.clear();
1523 recognizers.emplace_back(panFree1);
1524 recognizers.emplace_back(panFree2);
1525 auto exclusiveDoubleFree = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1526 ASSERT_NE(exclusiveDoubleFree, nullptr);
1527 EXPECT_EQ(exclusiveDoubleFree->GetAxisDirection(), Axis::FREE);
1528
1529 recognizers.clear();
1530 recognizers.emplace_back(panHorizontal1);
1531 recognizers.emplace_back(panVertical1);
1532 auto exclusiveHorizontalVertical = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1533 ASSERT_NE(exclusiveHorizontalVertical, nullptr);
1534 EXPECT_EQ(exclusiveHorizontalVertical->GetAxisDirection(), Axis::FREE);
1535
1536 recognizers.clear();
1537 recognizers.emplace_back(panHorizontal1);
1538 recognizers.emplace_back(panFree1);
1539 auto exclusiveHorizontalFree = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1540 ASSERT_NE(exclusiveHorizontalFree, nullptr);
1541 EXPECT_EQ(exclusiveHorizontalFree->GetAxisDirection(), Axis::FREE);
1542
1543 recognizers.clear();
1544 recognizers.emplace_back(panVertical1);
1545 recognizers.emplace_back(panFree1);
1546 auto exclusiveVerticalFree = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1547 ASSERT_NE(exclusiveVerticalFree, nullptr);
1548 EXPECT_EQ(exclusiveVerticalFree->GetAxisDirection(), Axis::FREE);
1549 }
1550
1551 /**
1552 * @tc.name: ParallelRecognizerAxisDirection001
1553 * @tc.desc: Test GetAxisDirection() of ParallelRecognizer.
1554 * @tc.type: FUNC
1555 */
1556 HWTEST_F(EventManagerTestNg, ParallelRecognizerAxisDirection001, TestSize.Level1)
1557 {
1558 /**
1559 * @tc.steps: step1. Create pan recognizers.
1560 * @tc.expected: recognizers is not null and axis direction is correct.
1561 */
1562 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
1563 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1564 ASSERT_NE(panHorizontal1, nullptr);
1565 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
1566 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1567 ASSERT_NE(panHorizontal2, nullptr);
1568
1569 auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
1570 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1571 ASSERT_NE(panVertical1, nullptr);
1572 auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
1573 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1574 ASSERT_NE(panVertical2, nullptr);
1575
1576 auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
1577 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1578 ASSERT_NE(panFree1, nullptr);
1579 auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
1580 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1581 ASSERT_NE(panFree2, nullptr);
1582
1583 /**
1584 * @tc.steps: step2. Create parallel recognizers.
1585 * @tc.expected: recognizers is not null and axis direction is correct.
1586 */
1587 std::vector<RefPtr<NGGestureRecognizer>> recognizers;
1588 recognizers.clear();
1589 recognizers.emplace_back(panHorizontal1);
1590 recognizers.emplace_back(panHorizontal2);
1591 auto parallelDoubleHorizontal = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1592 ASSERT_NE(parallelDoubleHorizontal, nullptr);
1593 EXPECT_EQ(parallelDoubleHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1594
1595 recognizers.clear();
1596 recognizers.emplace_back(panVertical1);
1597 recognizers.emplace_back(panVertical2);
1598 auto parallelDoubleVertical = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1599 ASSERT_NE(parallelDoubleVertical, nullptr);
1600 EXPECT_EQ(parallelDoubleVertical->GetAxisDirection(), Axis::VERTICAL);
1601
1602 recognizers.clear();
1603 recognizers.emplace_back(panFree1);
1604 recognizers.emplace_back(panFree2);
1605 auto parallelDoubleFree = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1606 ASSERT_NE(parallelDoubleFree, nullptr);
1607 EXPECT_EQ(parallelDoubleFree->GetAxisDirection(), Axis::FREE);
1608
1609 recognizers.clear();
1610 recognizers.emplace_back(panHorizontal1);
1611 recognizers.emplace_back(panVertical1);
1612 auto parallelHorizontalVertical = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1613 ASSERT_NE(parallelHorizontalVertical, nullptr);
1614 EXPECT_EQ(parallelHorizontalVertical->GetAxisDirection(), Axis::FREE);
1615
1616 recognizers.clear();
1617 recognizers.emplace_back(panHorizontal1);
1618 recognizers.emplace_back(panFree1);
1619 auto parallelHorizontalFree = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1620 ASSERT_NE(parallelHorizontalFree, nullptr);
1621 EXPECT_EQ(parallelHorizontalFree->GetAxisDirection(), Axis::FREE);
1622
1623 recognizers.clear();
1624 recognizers.emplace_back(panVertical1);
1625 recognizers.emplace_back(panFree1);
1626 auto parallelVerticalFree = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1627 ASSERT_NE(parallelVerticalFree, nullptr);
1628 EXPECT_EQ(parallelVerticalFree->GetAxisDirection(), Axis::FREE);
1629 }
1630
1631 /**
1632 * @tc.name: EventManagerTest090
1633 * @tc.desc: Test DispatchMouseEventNG
1634 * @tc.type: FUNC
1635 */
1636 HWTEST_F(EventManagerTestNg, EventManagerTest090, TestSize.Level1)
1637 {
1638 auto eventManager = AceType::MakeRefPtr<EventManager>();
1639 ASSERT_NE(eventManager, nullptr);
1640 MouseEvent event;
1641 event.mockFlushEvent = true;
1642 bool result = eventManager->DispatchMouseEventNG(event);
1643 EXPECT_FALSE(result);
1644 }
1645
1646 /**
1647 * @tc.name: EventManagerTest091
1648 * @tc.desc: Test DispatchMouseEventNG
1649 * @tc.type: FUNC
1650 */
1651 HWTEST_F(EventManagerTestNg, EventManagerTest091, TestSize.Level1)
1652 {
1653 auto eventManager = AceType::MakeRefPtr<EventManager>();
1654 ASSERT_NE(eventManager, nullptr);
1655 MouseEvent event;
1656 event.mockFlushEvent = false;
1657 bool result = eventManager->DispatchMouseEventNG(event);
1658 EXPECT_FALSE(result);
1659 }
1660
1661 /**
1662 * @tc.name: EventManagerTest092
1663 * @tc.desc: Test CheckAndLogLastReceivedTouchEventInfo
1664 * @tc.type: FUNC
1665 */
1666 HWTEST_F(EventManagerTestNg, EventManagerTest092, TestSize.Level1)
1667 {
1668 auto eventManager = AceType::MakeRefPtr<EventManager>();
1669 ASSERT_NE(eventManager, nullptr);
1670 int32_t eventId = 1;
1671 auto type = TouchType::MOVE;
1672 eventManager->CheckAndLogLastReceivedTouchEventInfo(eventId, type);
1673 EXPECT_EQ(eventManager->lastReceivedEvent_.eventId, eventId);
1674 }
1675
1676 /**
1677 * @tc.name: EventManagerTest093
1678 * @tc.desc: Test CheckAndLogLastConsumedTouchEventInfo
1679 * @tc.type: FUNC
1680 */
1681 HWTEST_F(EventManagerTestNg, EventManagerTest093, TestSize.Level1)
1682 {
1683 auto eventManager = AceType::MakeRefPtr<EventManager>();
1684 ASSERT_NE(eventManager, nullptr);
1685 int32_t eventId = 1;
1686 auto type = TouchType::MOVE;
1687 eventManager->CheckAndLogLastConsumedTouchEventInfo(eventId, type);
1688 EXPECT_EQ(eventManager->lastConsumedEvent_.eventId, eventId);
1689 }
1690
1691 /**
1692 * @tc.name: EventManagerTest094
1693 * @tc.desc: Test CheckAndLogLastReceivedMouseEventInfo
1694 * @tc.type: FUNC
1695 */
1696 HWTEST_F(EventManagerTestNg, EventManagerTest094, TestSize.Level1)
1697 {
1698 auto eventManager = AceType::MakeRefPtr<EventManager>();
1699 ASSERT_NE(eventManager, nullptr);
1700 int32_t eventId = 1;
1701 auto action = MouseAction::MOVE;
1702 eventManager->CheckAndLogLastReceivedMouseEventInfo(eventId, action);
1703 EXPECT_EQ(eventManager->lastReceivedEvent_.eventId, eventId);
1704 }
1705
1706 /**
1707 * @tc.name: EventManagerTest095
1708 * @tc.desc: Test CheckAndLogLastConsumedMouseEventInfo
1709 * @tc.type: FUNC
1710 */
1711 HWTEST_F(EventManagerTestNg, EventManagerTest095, TestSize.Level1)
1712 {
1713 auto eventManager = AceType::MakeRefPtr<EventManager>();
1714 ASSERT_NE(eventManager, nullptr);
1715 int32_t eventId = 1;
1716 auto action = MouseAction::MOVE;
1717 eventManager->CheckAndLogLastConsumedMouseEventInfo(eventId, action);
1718 EXPECT_EQ(eventManager->lastConsumedEvent_.eventId, eventId);
1719 }
1720
1721 /**
1722 * @tc.name: EventManagerTest096
1723 * @tc.desc: Test CheckAndLogLastReceivedAxisEventInfo
1724 * @tc.type: FUNC
1725 */
1726 HWTEST_F(EventManagerTestNg, EventManagerTest096, TestSize.Level1)
1727 {
1728 auto eventManager = AceType::MakeRefPtr<EventManager>();
1729 ASSERT_NE(eventManager, nullptr);
1730 int32_t eventId = 1;
1731 auto action = AxisAction::NONE;
1732 eventManager->CheckAndLogLastReceivedAxisEventInfo(eventId, action);
1733 EXPECT_EQ(eventManager->lastReceivedEvent_.eventId, eventId);
1734 }
1735
1736 /**
1737 * @tc.name: EventManagerTest097
1738 * @tc.desc: Test CheckAndLogLastConsumedAxisEventInfo
1739 * @tc.type: FUNC
1740 */
1741 HWTEST_F(EventManagerTestNg, EventManagerTest097, TestSize.Level1)
1742 {
1743 auto eventManager = AceType::MakeRefPtr<EventManager>();
1744 ASSERT_NE(eventManager, nullptr);
1745 int32_t eventId = 1;
1746 auto action = AxisAction::NONE;
1747 eventManager->CheckAndLogLastConsumedAxisEventInfo(eventId, action);
1748 EXPECT_EQ(eventManager->lastConsumedEvent_.eventId, eventId);
1749 }
1750 } // namespace OHOS::Ace::NG
1751