1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "gtest/gtest.h"
16 #include "test/unittest/core/event/event_manager_test_ng.h"
17 #include "test/mock/core/pipeline/mock_pipeline_context.h"
18 #include "test/mock/core/common/mock_window.h"
19 #include "test/mock/core/common/mock_frontend.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23 namespace OHOS::Ace::NG {
24 namespace {
CreateFrameNodeGroup(int32_t targetId,size_t childCount)25 RefPtr<FrameNode> CreateFrameNodeGroup(int32_t targetId, size_t childCount)
26 {
27 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
28 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, targetId, pagePattern);
29 for (size_t i = 0; i < childCount; ++i) {
30 ++targetId;
31 auto childNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, targetId, nullptr);
32 childNode->MountToParent(pageNode);
33 }
34 return pageNode;
35 }
36
CreateRecognizerGroup(const RefPtr<NG::FrameNode> & parentNode)37 RefPtr<NG::NGGestureRecognizer> CreateRecognizerGroup(const RefPtr<NG::FrameNode>& parentNode)
38 {
39 CHECK_NULL_RETURN(parentNode, nullptr);
40 std::list<RefPtr<NGGestureRecognizer>> recognizers;
41 for (const auto& childNode : parentNode->GetChildren()) {
42 auto childFrameNode = AceType::DynamicCast<FrameNode>(childNode);
43 if (childFrameNode) {
44 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
45 clickRecognizer->AttachFrameNode(childFrameNode);
46 recognizers.emplace_back(clickRecognizer);
47 }
48 }
49 auto recognizerGroup = AceType::MakeRefPtr<NG::ParallelRecognizer>(std::move(recognizers));
50 if (recognizerGroup) {
51 recognizerGroup->AttachFrameNode(parentNode);
52 }
53 return recognizerGroup;
54 }
55 } // namespace
56
57 /**
58 * @tc.name: SequenceRecognizerAxisDirection001
59 * @tc.desc: Test GetAxisDirection() of SequenceRecognizer.
60 * @tc.type: FUNC
61 */
62 HWTEST_F(EventManagerTestNg, SequenceRecognizerAxisDirection001, TestSize.Level1)
63 {
64 /**
65 * @tc.steps: step1. Create pan recognizers.
66 * @tc.expected: recognizers is not null and axis direction is correct.
67 */
68 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
69 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
70 ASSERT_NE(panHorizontal1, nullptr);
71 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
72 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
73 ASSERT_NE(panHorizontal2, nullptr);
74
75 auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
76 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
77 ASSERT_NE(panVertical1, nullptr);
78 auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
79 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
80 ASSERT_NE(panVertical2, nullptr);
81
82 auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
83 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
84 ASSERT_NE(panFree1, nullptr);
85 auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
86 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
87 ASSERT_NE(panFree2, nullptr);
88
89 /**
90 * @tc.steps: step2. Create sequence recognizers.
91 * @tc.expected: recognizers is not null and axis direction is correct.
92 */
93 std::vector<RefPtr<NGGestureRecognizer>> recognizers;
94 recognizers.clear();
95 recognizers.emplace_back(panHorizontal1);
96 recognizers.emplace_back(panHorizontal2);
97 auto sequenceDoubleHorizontal = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
98 ASSERT_NE(sequenceDoubleHorizontal, nullptr);
99 EXPECT_EQ(sequenceDoubleHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
100
101 recognizers.clear();
102 recognizers.emplace_back(panVertical1);
103 recognizers.emplace_back(panVertical2);
104 auto sequenceDoubleVertical = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
105 ASSERT_NE(sequenceDoubleVertical, nullptr);
106 EXPECT_EQ(sequenceDoubleVertical->GetAxisDirection(), Axis::VERTICAL);
107
108 recognizers.clear();
109 recognizers.emplace_back(panFree1);
110 recognizers.emplace_back(panFree2);
111 auto sequenceDoubleFree = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
112 ASSERT_NE(sequenceDoubleFree, nullptr);
113 EXPECT_EQ(sequenceDoubleFree->GetAxisDirection(), Axis::FREE);
114
115 recognizers.clear();
116 recognizers.emplace_back(panHorizontal1);
117 recognizers.emplace_back(panVertical1);
118 auto sequenceHorizontalVertical = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
119 ASSERT_NE(sequenceHorizontalVertical, nullptr);
120 EXPECT_EQ(sequenceHorizontalVertical->GetAxisDirection(), Axis::FREE);
121
122 recognizers.clear();
123 recognizers.emplace_back(panHorizontal1);
124 recognizers.emplace_back(panFree1);
125 auto sequenceHorizontalFree = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
126 ASSERT_NE(sequenceHorizontalFree, nullptr);
127 EXPECT_EQ(sequenceHorizontalFree->GetAxisDirection(), Axis::FREE);
128
129 recognizers.clear();
130 recognizers.emplace_back(panVertical1);
131 recognizers.emplace_back(panFree1);
132 auto sequenceVerticalFree = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
133 ASSERT_NE(sequenceVerticalFree, nullptr);
134 EXPECT_EQ(sequenceVerticalFree->GetAxisDirection(), Axis::FREE);
135 }
136
137 /**
138 * @tc.name: HasDifferentDirectionGesture001
139 * @tc.desc: Test HasDifferentDirectionGesture() of EventManager.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(EventManagerTestNg, HasDifferentDirectionGesture001, TestSize.Level1)
143 {
144 /**
145 * @tc.steps: step1. Create pan recognizers.
146 * @tc.expected: recognizers is not null and axis direction is correct.
147 */
148 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
149 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
150 ASSERT_NE(panHorizontal1, nullptr);
151 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
152 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
153 ASSERT_NE(panHorizontal2, nullptr);
154
155 auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
156 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
157 ASSERT_NE(panVertical1, nullptr);
158 auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
159 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
160 ASSERT_NE(panVertical2, nullptr);
161
162 auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
163 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
164 ASSERT_NE(panFree1, nullptr);
165 auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
166 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
167 ASSERT_NE(panFree2, nullptr);
168
169 /**
170 * @tc.steps: step2. Create EventManager.
171 * @tc.expected: eventManager is not null.
172 */
173 auto eventManager = AceType::MakeRefPtr<EventManager>();
174 ASSERT_NE(eventManager, nullptr);
175 TouchTestResult hitTestResult;
176
177 /**
178 * @tc.steps: step3. Add 2 horizontal recognizer to axisTouchTestResults_
179 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is false.
180 */
181 hitTestResult.clear();
182 eventManager->axisTouchTestResults_.clear();
183 hitTestResult.emplace_back(panHorizontal1);
184 hitTestResult.emplace_back(panHorizontal2);
185 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
186 EXPECT_FALSE(eventManager->HasDifferentDirectionGesture());
187
188 /**
189 * @tc.steps: step4. Add 2 vertical recognizer to axisTouchTestResults_
190 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is false.
191 */
192 hitTestResult.clear();
193 eventManager->axisTouchTestResults_.clear();
194 hitTestResult.emplace_back(panVertical1);
195 hitTestResult.emplace_back(panVertical2);
196 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
197 EXPECT_FALSE(eventManager->HasDifferentDirectionGesture());
198
199 /**
200 * @tc.steps: step5. Add horizontal and vertical recognizer to axisTouchTestResults_
201 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
202 */
203 hitTestResult.clear();
204 eventManager->axisTouchTestResults_.clear();
205 hitTestResult.emplace_back(panHorizontal1);
206 hitTestResult.emplace_back(panVertical1);
207 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
208 EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
209
210 /**
211 * @tc.steps: step6. Add horizontal and free recognizer to axisTouchTestResults_
212 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
213 */
214 hitTestResult.clear();
215 eventManager->axisTouchTestResults_.clear();
216 hitTestResult.emplace_back(panHorizontal1);
217 hitTestResult.emplace_back(panFree1);
218 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
219 EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
220
221 /**
222 * @tc.steps: step6. Add vertical and free recognizer to axisTouchTestResults_
223 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
224 */
225 hitTestResult.clear();
226 eventManager->axisTouchTestResults_.clear();
227 hitTestResult.emplace_back(panVertical1);
228 hitTestResult.emplace_back(panFree1);
229 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
230 EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
231
232 /**
233 * @tc.steps: step6. Add free and free recognizer to axisTouchTestResults_
234 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
235 */
236 hitTestResult.clear();
237 eventManager->axisTouchTestResults_.clear();
238 hitTestResult.emplace_back(panFree1);
239 hitTestResult.emplace_back(panFree2);
240 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
241 EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
242 }
243
244 /**
245 * @tc.name: EventManagerTest038
246 * @tc.desc: Test DispatchRotationEvent
247 * @tc.type: FUNC
248 */
249 HWTEST_F(EventManagerTestNg, EventManagerTest038, TestSize.Level1)
250 {
251 /**
252 * @tc.steps: step1. Create EventManager.
253 * @tc.expected: eventManager is not null.
254 */
255 auto eventManager = AceType::MakeRefPtr<EventManager>();
256 ASSERT_NE(eventManager, nullptr);
257
258 /**
259 * @tc.steps: step2. Call DispatchRotationEvent.
260 * @tc.expected: ret is false.
261 */
262 RotationEvent event;
263 event.value = 0.1;
264 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
265 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
266 const RefPtr<RenderNode> requestNode = nullptr;
267 auto ret = eventManager->DispatchRotationEvent(event, renderNode, requestNode);
268 EXPECT_FALSE(ret);
269 }
270
271 /**
272 * @tc.name: EventManagerTest039
273 * @tc.desc: Test PostEventDispatchTouchEvent
274 * @tc.type: FUNC
275 */
276 HWTEST_F(EventManagerTestNg, EventManagerTest039, TestSize.Level1)
277 {
278 /**
279 * @tc.steps: step1. Create EventManager.
280 * @tc.expected: eventManager is not null.
281 */
282 auto eventManager = AceType::MakeRefPtr<EventManager>();
283 ASSERT_NE(eventManager, nullptr);
284 AceEngine& aceEngine = AceEngine::Get();
285 aceEngine.AddContainer(CONTAINER_INSTANCE_ID, MockContainer::container_);
286
287 /**
288 * @tc.steps: step2. Call PostEventDispatchTouchEvent with event.
289 * @tc.expected: ret is true
290 */
291 TouchEvent event;
292 event.type = TouchType::DOWN;
293 TouchTestResult touchTestResults;
294 auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
295 touchTestResults.push_back(eventTarget);
296 eventManager->postEventTouchTestResults_.emplace(event.id, touchTestResults);
297 auto ret = eventManager->PostEventDispatchTouchEvent(event);
298 EXPECT_TRUE(ret);
299
300 /**
301 * @tc.steps: step3. Call PostEventDispatchTouchEvent event.
302 * @tc.expected: ret is true
303 */
304 event.type = TouchType::UP;
305 touchTestResults.push_back(eventTarget);
306 eventManager->postEventTouchTestResults_.emplace(event.id, touchTestResults);
307 ret = eventManager->PostEventDispatchTouchEvent(event);
308 EXPECT_TRUE(ret);
309
310 /**
311 * @tc.steps: step4. Call PostEventDispatchTouchEvent event.
312 * @tc.expected: ret is true
313 */
314 event.type = TouchType::CANCEL;
315 touchTestResults.push_back(eventTarget);
316 eventManager->postEventTouchTestResults_.emplace(event.id, touchTestResults);
317 ret = eventManager->PostEventDispatchTouchEvent(event);
318 EXPECT_TRUE(ret);
319 }
320
321 /**
322 * @tc.name: EventManagerTest040
323 * @tc.desc: Test DispatchMouseEvent
324 * @tc.type: FUNC
325 */
326 HWTEST_F(EventManagerTestNg, EventManagerTest040, TestSize.Level1)
327 {
328 /**
329 * @tc.steps: step1. Create EventManager.
330 * @tc.expected: eventManager is not null.
331 */
332 auto eventManager = AceType::MakeRefPtr<EventManager>();
333 ASSERT_NE(eventManager, nullptr);
334
335 /**
336 * @tc.steps: step2. Call DispatchMouseEvent.
337 * @tc.expected: retFlag is true.
338 */
339 MouseEvent event;
340 event.action = MouseAction::MOVE;
341 bool retFlag = eventManager->DispatchMouseEvent(event);
342 EXPECT_TRUE(retFlag);
343 }
344
345 /**
346 * @tc.name: EventManagerTest041
347 * @tc.desc: Test HandleGlobalEventNG
348 * @tc.type: FUNC
349 */
350 HWTEST_F(EventManagerTestNg, EventManagerTest041, TestSize.Level1)
351 {
352 /**
353 * @tc.steps: step1. Create EventManager.
354 * @tc.expected: eventManager is not null.
355 */
356 auto eventManager = AceType::MakeRefPtr<EventManager>();
357 ASSERT_NE(eventManager, nullptr);
358
359 /**
360 * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id].
361 * @tc.expected: touchTestResults_ has the touchPoint.id of instance.
362 */
363 TouchEvent touchPoint;
364 touchPoint.id = 1000;
365 touchPoint.type = TouchType::DOWN;
366
367 const int nodeId = 10003;
368 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
369 TouchRestrict touchRestrict;
370 Offset offset;
371
372 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
373 EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
374 TouchTestResult touchTestResults;
375 auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
376 touchTestResults.push_back(eventTarget);
377 eventManager->touchTestResults_.emplace(touchPoint.id, touchTestResults);
378
379 /**
380 * @tc.steps: step3. Create FrameNode and Call HandleGlobalEventNG.
381 * @tc.expected: touchTestResults_.size() is equal to 1.
382 */
383 auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode);
384 NG::OffsetF rootOffset;
385 eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset);
386 EXPECT_EQ(eventManager->touchTestResults_.size(), 1);
387 }
388
389 /**
390 * @tc.name: EventManagerTest042
391 * @tc.desc: Test DispatchMouseHoverAnimation in MouseButton::NONE_BUTTON branches
392 * @tc.type: FUNC
393 */
394 HWTEST_F(EventManagerTestNg, EventManagerTest042, TestSize.Level1)
395 {
396 /**
397 * @tc.steps: step1. Create EventManager.
398 * @tc.expected: eventManager is not null.
399 */
400 auto eventManager = AceType::MakeRefPtr<EventManager>();
401 ASSERT_NE(eventManager, nullptr);
402
403 /**
404 * @tc.steps: step2. Call DispatchMouseHoverAnimation with event.
405 * @tc.expected: hoverNodeCur is null.
406 */
407 MouseEvent event;
408 event.button = MouseButton::NONE_BUTTON;
409 eventManager->DispatchMouseHoverAnimation(event);
410 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
411 EXPECT_EQ(hoverNodeCur, nullptr);
412 }
413
414 /**
415 * @tc.name: EventManagerTest043
416 * @tc.desc: Test DispatchTouchEvent
417 * @tc.type: FUNC
418 */
419 HWTEST_F(EventManagerTestNg, EventManagerTest043, TestSize.Level1)
420 {
421 /**
422 * @tc.steps: step1. Create EventManager.
423 * @tc.expected: eventManager is not null.
424 */
425 auto eventManager = AceType::MakeRefPtr<EventManager>();
426 ASSERT_NE(eventManager, nullptr);
427 AceEngine& aceEngine = AceEngine::Get();
428 aceEngine.AddContainer(CONTAINER_INSTANCE_ID, MockContainer::container_);
429
430 /**
431 * @tc.steps: step2. Call DispatchTouchEvent with TouchType::DOWN.
432 * @tc.expected: ret is false.
433 */
434 TouchEvent event;
435 event.type = TouchType::DOWN;
436 auto ret = eventManager->DispatchTouchEvent(event);
437 EXPECT_FALSE(ret);
438
439 /**
440 * @tc.steps: step3. Call DispatchTouchEvent with TouchType::DOWN and
441 touchTestResults_ has element;
442 * @tc.expected: ret is true
443 */
444 TouchTestResult touchTestResults;
445 auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
446 touchTestResults.push_back(eventTarget);
447 eventManager->touchTestResults_.emplace(event.id, touchTestResults);
448 ret = eventManager->DispatchTouchEvent(event);
449 EXPECT_TRUE(ret);
450
451 /**
452 * @tc.steps: step4. Call DispatchTouchEvent with TouchType::PULL_MOVE and
453 touchTestResults_ has element;
454 * @tc.expected: ret is true
455 */
456 event.type = TouchType::PULL_MOVE;
457 ret = eventManager->DispatchTouchEvent(event);
458 EXPECT_TRUE(ret);
459
460 /**
461 * @tc.steps: step5. Call DispatchTouchEvent with TouchType::PULL_MOVE and
462 touchTestResults_ has element;
463 * @tc.expected: ret is false.
464 */
465 event.pullType = TouchType::PULL_MOVE;
466 ret = eventManager->DispatchTouchEvent(event);
467 EXPECT_FALSE(ret);
468
469 event.type = TouchType::CANCEL;
470 ret = eventManager->DispatchTouchEvent(event);
471 EXPECT_FALSE(ret);
472 }
473
474 /**
475 * @tc.name: GetSetPressedKeyCodesTest001
476 * @tc.desc: Test GetPressedKeyCodes and SetPressedKeyCodes function.
477 * @tc.type: FUNC
478 */
479 HWTEST_F(EventManagerTestNg, GetSetPressedKeyCodesTest001, TestSize.Level1)
480 {
481 /**
482 * @tc.steps: step2. Call SetPressedKeyCodes GetPressedKeyCodes with event.
483 * @tc.expected: pressedKeyCodes size is 2.
484 */
485 BaseEventInfo event("test");
486 event.SetPressedKeyCodes({KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_CTRL_RIGHT});
487 auto pressedKeyCodes = event.GetPressedKeyCodes();
488 EXPECT_EQ(pressedKeyCodes.size(), 2);
489 EXPECT_EQ(pressedKeyCodes[1], KeyCode::KEY_CTRL_RIGHT);
490 }
491
492 /**
493 * @tc.name: EventManagerTest045
494 * @tc.desc: Test PostEventFlushTouchEventEnd function.
495 * @tc.type: FUNC
496 */
497 HWTEST_F(EventManagerTestNg, EventManagerTest045, TestSize.Level1)
498 {
499 /**
500 * @tc.steps: step1. Create EventManager.
501 * @tc.expected: eventManager is not null.
502 */
503 auto eventManager = AceType::MakeRefPtr<EventManager>();
504 ASSERT_NE(eventManager, nullptr);
505
506 /**
507 * @tc.steps: step2. Call PostEventFlushTouchEventEnd with TouchType::DOWN.
508 * @tc.expected: ret is false.
509 */
510 TouchEvent event;
511 event.type = TouchType::DOWN;
512 event.id = 1;
513 TouchTestResult hitTestResult;
514 eventManager->PostEventFlushTouchEventEnd(event);
515
516 /**
517 * @tc.steps: step3. Create pan recognizers.
518 * @tc.expected: recognizers is not null and axis direction is correct.
519 */
520 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
521 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
522 ASSERT_NE(panHorizontal1, nullptr);
523 hitTestResult.emplace_back(panHorizontal1);
524 eventManager->postEventTouchTestResults_[1] = hitTestResult;
525
526 eventManager->PostEventFlushTouchEventEnd(event);
527 EXPECT_TRUE(panHorizontal1->isFlushTouchEventsEnd_);
528 }
529
530 /**
531 * @tc.name: EventManagerTest046
532 * @tc.desc: Test LogTouchTestResultRecognizers function.
533 * @tc.type: FUNC
534 */
535 HWTEST_F(EventManagerTestNg, EventManagerTest046, TestSize.Level1)
536 {
537 /**
538 * @tc.steps: step1. Create EventManager.
539 * @tc.expected: eventManager is not null.
540 */
541 auto eventManager = AceType::MakeRefPtr<EventManager>();
542 ASSERT_NE(eventManager, nullptr);
543
544 /**
545 * @tc.steps: step2. Call LogTouchTestResultRecognizers.
546 * @tc.expected: ret is false.
547 */
548 TouchEvent event;
549 event.type = TouchType::DOWN;
550 event.id = 1;
551 TouchTestResult hitTestResult;
552 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
553 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
554 ASSERT_NE(panHorizontal1, nullptr);
555 hitTestResult.emplace_back(panHorizontal1);
556 std::list<RefPtr<NGGestureRecognizer>> combined;
557 auto exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(std::move(combined));
558 auto exclusiveRecognizer1 = AceType::MakeRefPtr<ExclusiveRecognizer>(std::move(combined));
559 hitTestResult.emplace_back(exclusiveRecognizer);
560 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
561 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
562 exclusiveRecognizer1->node_ = pageNode;
563 hitTestResult.emplace_back(exclusiveRecognizer1);
564 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
565 hitTestResult.emplace_back(clickRecognizer);
566
567 eventManager->LogTouchTestResultRecognizers(hitTestResult, 1);
568 EXPECT_FALSE(panHorizontal1->isFlushTouchEventsEnd_);
569 }
570
571 /**
572 * @tc.name: EventManagerTest047
573 * @tc.desc: Test DispatchMouseHoverAnimation function.
574 * @tc.type: FUNC
575 */
576 HWTEST_F(EventManagerTestNg, EventManagerTest047, TestSize.Level1)
577 {
578 /**
579 * @tc.steps: step1. Create EventManager.
580 * @tc.expected: eventManager is not null.
581 */
582 auto eventManager = AceType::MakeRefPtr<EventManager>();
583 ASSERT_NE(eventManager, nullptr);
584
585 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
586 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
587 eventManager->mouseHoverNode_ = renderNode;
588
589 MouseEvent event;
590 event.action = MouseAction::PRESS;
591 eventManager->DispatchMouseHoverAnimation(event);
592
593 event.action = MouseAction::RELEASE;
594 eventManager->DispatchMouseHoverAnimation(event);
595
596 event.action = MouseAction::WINDOW_ENTER;
597 eventManager->DispatchMouseHoverAnimation(event);
598
599 event.action = MouseAction::WINDOW_LEAVE;
600
601 eventManager->DispatchMouseHoverAnimation(event);
602 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
603 EXPECT_EQ(hoverNodeCur, nullptr);
604 }
605
606 /**
607 * @tc.name: EventManagerTest048
608 * @tc.desc: Test GetTouchTestIds function.
609 * @tc.type: FUNC
610 */
611 HWTEST_F(EventManagerTestNg, EventManagerTest048, TestSize.Level1)
612 {
613 /**
614 * @tc.steps: step1. Create EventManager.
615 * @tc.expected: eventManager is not null.
616 */
617 auto eventManager = AceType::MakeRefPtr<EventManager>();
618 ASSERT_NE(eventManager, nullptr);
619
620 TouchEvent event;
621 event.type = TouchType::DOWN;
622 event.id = 1;
623 std::vector<std::string> touchTestIds = {"1", "2"};
624 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
625 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
626 ASSERT_NE(panHorizontal1, nullptr);
627 panHorizontal1->getEventTargetImpl_ = std::function<std::optional<EventTarget>()>{};
628
629 TouchTestResult hitTestResult;
630 hitTestResult.emplace_back(panHorizontal1);
631 eventManager->touchTestResults_.emplace(event.id, hitTestResult);
632 bool isMousePressAtSelectedNode = false;
633 eventManager->GetTouchTestIds(event, touchTestIds, isMousePressAtSelectedNode, 1);
634 EXPECT_FALSE(isMousePressAtSelectedNode);
635
636 EXPECT_EQ(touchTestIds.size(), 2);
637 auto num = std::stoi(touchTestIds.back());
638 eventManager->GetTouchTestIds(event, touchTestIds, isMousePressAtSelectedNode, num);
639 EXPECT_FALSE(isMousePressAtSelectedNode);
640 }
641
642 /**
643 * @tc.name: EventManagerTest049
644 * @tc.desc: Test FlushTouchEventsBegin function.
645 * @tc.type: FUNC
646 */
647 HWTEST_F(EventManagerTestNg, EventManagerTest049, TestSize.Level1)
648 {
649 /**
650 * @tc.steps: step1. Create EventManager.
651 * @tc.expected: eventManager is not null.
652 */
653 auto eventManager = AceType::MakeRefPtr<EventManager>();
654 ASSERT_NE(eventManager, nullptr);
655
656 TouchEvent event;
657 event.type = TouchType::DOWN;
658 event.id = 1;
659 std::list<TouchEvent> touchEvents = {event};
660 TouchTestResult hitTestResult;
661 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
662 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
663 hitTestResult.emplace_back(panHorizontal1);
664 eventManager->touchTestResults_[2] = hitTestResult;
665 eventManager->FlushTouchEventsBegin(touchEvents);
666 EXPECT_TRUE(eventManager->touchTestResults_.count(2) == 1);
667 }
668
669 /**
670 * @tc.name: EventManagerTest050
671 * @tc.desc: Test CheckMouseTestResults function.
672 * @tc.type: FUNC
673 */
674 HWTEST_F(EventManagerTestNg, EventManagerTest050, TestSize.Level1)
675 {
676 /**
677 * @tc.steps: step1. Create EventManager.
678 * @tc.expected: eventManager is not null.
679 */
680 auto eventManager = AceType::MakeRefPtr<EventManager>();
681 ASSERT_NE(eventManager, nullptr);
682
683 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
684 std::list<RefPtr<MouseEventTarget>> mouseTestResult = {mouseEventTarget};
685 eventManager->currMouseTestResultsMap_[0] = mouseTestResult;
686
687 bool isMousePressAtSelectedNode = false;
688 eventManager->CheckMouseTestResults(isMousePressAtSelectedNode, NODEID, 0);
689 EXPECT_TRUE(isMousePressAtSelectedNode);
690 isMousePressAtSelectedNode = false;
691 eventManager->CheckMouseTestResults(isMousePressAtSelectedNode, NODEID + 1, 0);
692 EXPECT_FALSE(isMousePressAtSelectedNode);
693 }
694
695 /**
696 * @tc.name: EventManagerTest051
697 * @tc.desc: Test MouseTest function.
698 * @tc.type: FUNC
699 */
700 HWTEST_F(EventManagerTestNg, EventManagerTest051, TestSize.Level1)
701 {
702 /**
703 * @tc.steps: step1. Create EventManager.
704 * @tc.expected: eventManager is not null.
705 */
706 auto eventManager = AceType::MakeRefPtr<EventManager>();
707 ASSERT_NE(eventManager, nullptr);
708
709 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
710 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
711
712 MouseEvent event;
713 event.action = MouseAction::WINDOW_LEAVE;
714 std::list<WeakPtr<RenderNode>> MouseHoverTestList;
715
716 eventManager->MouseTest(event, renderNode);
717
718 event.action = MouseAction::WINDOW_ENTER;
719 eventManager->MouseTest(event, renderNode);
720
721 event.action = MouseAction::NONE;
722 eventManager->MouseTest(event, renderNode);
723 EXPECT_TRUE(eventManager->mouseHoverTestResults_.empty());
724 }
725
726 /**
727 * @tc.name: EventManagerTest052
728 * @tc.desc: Test DispatchMouseEvent function.
729 * @tc.type: FUNC
730 */
731 HWTEST_F(EventManagerTestNg, EventManagerTest052, TestSize.Level1)
732 {
733 /**
734 * @tc.steps: step1. Create EventManager.
735 * @tc.expected: eventManager is not null.
736 */
737 auto eventManager = AceType::MakeRefPtr<EventManager>();
738 ASSERT_NE(eventManager, nullptr);
739
740 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
741 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
742 std::list<WeakPtr<RenderNode>> mouseHoverTestList = {renderNode};
743 MouseEvent event;
744 event.action = MouseAction::WINDOW_LEAVE;
745 EXPECT_FALSE(eventManager->DispatchMouseEvent(event));
746
747 eventManager->mouseHoverTestResults_ = mouseHoverTestList;
748 event.action = MouseAction::MOVE;
749 EXPECT_TRUE(eventManager->DispatchMouseEvent(event));
750 }
751
752 /**
753 * @tc.name: EventManagerTest053
754 * @tc.desc: Test LogPrintMouseTest function.
755 * @tc.type: FUNC
756 */
757 HWTEST_F(EventManagerTestNg, EventManagerTest053, TestSize.Level1)
758 {
759 /**
760 * @tc.steps: step1. Create EventManager.
761 * @tc.expected: eventManager is not null.
762 */
763 auto eventManager = AceType::MakeRefPtr<EventManager>();
764 ASSERT_NE(eventManager, nullptr);
765 SystemProperties::debugEnabled_ = true;
766
767 eventManager->LogPrintMouseTest();
768 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
769 std::list<RefPtr<MouseEventTarget>> MouseTestResult = {};
770 eventManager->currMouseTestResultsMap_[0] = MouseTestResult;
771 eventManager->LogPrintMouseTest();
772 MouseTestResult = {mouseEventTarget};
773 eventManager->currMouseTestResultsMap_[0] = MouseTestResult;
774 eventManager->LogPrintMouseTest();
775
776 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(MOUSE, NODEID);
777 std::list<RefPtr<HoverEventTarget>> HoverTestResult = {hoverEventTarget};
778 eventManager->lastHoverTestResultsMap_[0] = HoverTestResult;
779 eventManager->currHoverTestResultsMap_[0] = HoverTestResult;
780 eventManager->LogPrintMouseTest();
781 }
782
783 /**
784 * @tc.name: EventManagerTest054
785 * @tc.desc: Test UpdateHoverNode function.
786 * @tc.type: FUNC
787 */
788 HWTEST_F(EventManagerTestNg, EventManagerTest054, TestSize.Level1)
789 {
790 /**
791 * @tc.steps: step1. Create EventManager.
792 * @tc.expected: eventManager is not null.
793 */
794 auto eventManager = AceType::MakeRefPtr<EventManager>();
795 ASSERT_NE(eventManager, nullptr);
796
797 MouseEvent event;
798 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
799 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(MOUSE, NODEID);
800 std::list<RefPtr<TouchEventTarget>> testResult = {AceType::MakeRefPtr<MockTouchEventTarget>(),
801 mouseEventTarget, hoverEventTarget};
802 eventManager->UpdateHoverNode(event, testResult);
803 EXPECT_FALSE((eventManager->currMouseTestResultsMap_[0]).empty());
804 }
805
806 /**
807 * @tc.name: EventManagerTest055
808 * @tc.desc: Test DispatchKeyboardShortcut function.
809 * @tc.type: FUNC
810 */
811 HWTEST_F(EventManagerTestNg, EventManagerTest055, TestSize.Level1)
812 {
813 /**
814 * @tc.steps: step1. Create EventManager.
815 * @tc.expected: eventManager is not null.
816 */
817 auto eventManager = AceType::MakeRefPtr<EventManager>();
818 ASSERT_NE(eventManager, nullptr);
819
820 KeyEvent event;
821 event.action = KeyAction::UP;
822 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
823
824 event.action = KeyAction::DOWN;
825 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
826 frameNode->isActive_ = false;
827
828 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
829 auto frameNode3 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
830 auto eventHub = AceType::MakeRefPtr<EventHub>();
831 frameNode3->eventHub_ = eventHub;
832 eventHub->enabled_ = false;
833
834 std::list<WeakPtr<NG::FrameNode>> keyboardShortcutNode = {nullptr, frameNode, frameNode2, frameNode3};
835 eventManager->keyboardShortcutNode_ = keyboardShortcutNode;
836 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
837 }
838
839 /**
840 * @tc.name: EventManagerTest056
841 * @tc.desc: Test DelKeyboardShortcutNode function.
842 * @tc.type: FUNC
843 */
844 HWTEST_F(EventManagerTestNg, EventManagerTest056, TestSize.Level1)
845 {
846 /**
847 * @tc.steps: step1. Create EventManager.
848 * @tc.expected: eventManager is not null.
849 */
850 auto eventManager = AceType::MakeRefPtr<EventManager>();
851 ASSERT_NE(eventManager, nullptr);
852 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
853 std::list<WeakPtr<NG::FrameNode>> keyboardShortcutNode = {nullptr, frameNode};
854 eventManager->keyboardShortcutNode_ = keyboardShortcutNode;
855
856 eventManager->DelKeyboardShortcutNode(2);
857 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
858 }
859
860 /**
861 * @tc.name: EventManagerTest057
862 * @tc.desc: Test AddGestureSnapshot function.
863 * @tc.type: FUNC
864 */
865 HWTEST_F(EventManagerTestNg, EventManagerTest057, TestSize.Level1)
866 {
867 /**
868 * @tc.steps: step1. Create EventManager.
869 * @tc.expected: eventManager is not null.
870 */
871 auto eventManager = AceType::MakeRefPtr<EventManager>();
872 ASSERT_NE(eventManager, nullptr);
873 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
874 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
875 eventManager->AddGestureSnapshot(1, 1, panHorizontal1, EventTreeType::TOUCH);
876
877 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
878 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
879 mouseEventTarget->node_ = frameNode;
880 eventManager->AddGestureSnapshot(1, 1, mouseEventTarget, EventTreeType::TOUCH);
881
882 eventManager->AddGestureSnapshot(1, 1, nullptr, EventTreeType::TOUCH);
883 EXPECT_TRUE(eventManager->eventTree_.eventTreeList.empty());
884 }
885
886 /**
887 * @tc.name: EventManagerTest058
888 * @tc.desc: Test SetHittedFrameNode function.
889 * @tc.type: FUNC
890 */
891 HWTEST_F(EventManagerTestNg, EventManagerTest058, 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 panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
901 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
902 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
903 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
904 std::list<RefPtr<NG::NGGestureRecognizer>> touchTestResults;
905 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
906 panHorizontal1->node_ = frameNode;
907 touchTestResults.emplace_back(panHorizontal1);
908 touchTestResults.emplace_back(panHorizontal2);
909 eventManager->SetHittedFrameNode(touchTestResults);
910 EXPECT_TRUE(eventManager->eventTree_.eventTreeList.empty());
911 }
912
913 /**
914 * @tc.name: EventManagerTest059
915 * @tc.desc: Test CleanGestureEventHub function.
916 * @tc.type: FUNC
917 */
918 HWTEST_F(EventManagerTestNg, EventManagerTest059, TestSize.Level1)
919 {
920 /**
921 * @tc.steps: step1. Create EventManager.
922 * @tc.expected: eventManager is not null.
923 */
924 auto eventManager = AceType::MakeRefPtr<EventManager>();
925 ASSERT_NE(eventManager, nullptr);
926 std::set<WeakPtr<FrameNode>> hittedFrameNode;
927 eventManager->hittedFrameNode_ = hittedFrameNode;
928 eventManager->CleanGestureEventHub();
929 EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
930
931 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
932 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
933 auto eventHub = AceType::MakeRefPtr<EventHub>();
934 frameNode2->eventHub_ = eventHub;
935 hittedFrameNode.insert(frameNode);
936 hittedFrameNode.insert(frameNode2);
937 hittedFrameNode.insert(nullptr);
938 eventManager->hittedFrameNode_ = hittedFrameNode;
939 eventManager->CleanGestureEventHub();
940 EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
941 }
942
943 /**
944 * @tc.name: EventManagerTest060
945 * @tc.desc: Test CheckAndLogLastReceivedEventInfo function.
946 * @tc.type: FUNC
947 */
948 HWTEST_F(EventManagerTestNg, EventManagerTest060, TestSize.Level1)
949 {
950 /**
951 * @tc.steps: step1. Create EventManager.
952 * @tc.expected: eventManager is not null.
953 */
954 auto eventManager = AceType::MakeRefPtr<EventManager>();
955 ASSERT_NE(eventManager, nullptr);
956 int eventId = 1;
957 bool logImmediately = true;
958
959 SystemProperties::debugEnabled_ = false;
960 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
961 EXPECT_TRUE(eventManager->lastReceivedEvent_.eventId == -1);
962
963 SystemProperties::debugEnabled_ = true;
964 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
965 EXPECT_TRUE(eventManager->lastReceivedEvent_.eventId == -1);
966
967 logImmediately = false;
968 eventManager->lastReceivedEvent_.lastLogTimeStamp = 0;
969 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
970 EXPECT_TRUE(eventManager->lastReceivedEvent_.eventId == 1);
971
972 auto currentTime = GetSysTimestamp();
973 auto lastLogTimeStamp = currentTime - 1000 * 1000000 - 1000;
974 eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp;
975 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
976 EXPECT_FALSE(eventManager->lastReceivedEvent_.lastLogTimeStamp > currentTime);
977
978 eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp - 1;
979 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
980 EXPECT_FALSE(eventManager->lastReceivedEvent_.lastLogTimeStamp == currentTime);
981
982 SystemProperties::debugEnabled_ = false;
983 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
984 EXPECT_FALSE(eventManager->lastReceivedEvent_.lastLogTimeStamp == currentTime);
985
986 eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000;
987 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
988 EXPECT_TRUE(eventManager->lastReceivedEvent_.lastLogTimeStamp == lastLogTimeStamp + 20000);
989 }
990
991 /**
992 * @tc.name: EventManagerTest061
993 * @tc.desc: Test CheckAndLogLastConsumedEventInfo function.
994 * @tc.type: FUNC
995 */
996 HWTEST_F(EventManagerTestNg, EventManagerTest061, TestSize.Level1)
997 {
998 /**
999 * @tc.steps: step1. Create EventManager.
1000 * @tc.expected: eventManager is not null.
1001 */
1002 auto eventManager = AceType::MakeRefPtr<EventManager>();
1003 ASSERT_NE(eventManager, nullptr);
1004 int eventId = 1;
1005 bool logImmediately = true;
1006
1007 eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
1008
1009 logImmediately = false;
1010 eventManager->lastConsumedEvent_.lastLogTimeStamp = 0;
1011 eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
1012 EXPECT_TRUE(eventManager->lastConsumedEvent_.eventId == 1);
1013
1014 auto currentTime = GetSysTimestamp();
1015 auto lastLogTimeStamp = currentTime - 1000 * 1000000 - 1000;
1016 eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp;
1017 eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
1018 EXPECT_FALSE(eventManager->lastConsumedEvent_.lastLogTimeStamp > currentTime);
1019
1020 eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp - 1;
1021 eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
1022 EXPECT_FALSE(eventManager->lastConsumedEvent_.lastLogTimeStamp == currentTime);
1023
1024 eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000;
1025 eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000;
1026 eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
1027 EXPECT_TRUE(eventManager->lastConsumedEvent_.lastLogTimeStamp == lastLogTimeStamp + 20000);
1028 }
1029
1030 /**
1031 * @tc.name: EventManagerTest062
1032 * @tc.desc: Test SetResponseLinkRecognizers function.
1033 * @tc.type: FUNC
1034 */
1035 HWTEST_F(EventManagerTestNg, EventManagerTest062, TestSize.Level1)
1036 {
1037 /**
1038 * @tc.steps: step1. Create EventManager.
1039 * @tc.expected: eventManager is not null.
1040 */
1041 auto eventManager = AceType::MakeRefPtr<EventManager>();
1042 ASSERT_NE(eventManager, nullptr);
1043
1044 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
1045 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1046 std::list<RefPtr<TouchEventTarget>> result;
1047 ResponseLinkResult responseLinkRecognizers;
1048 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
1049 panHorizontal1->node_ = frameNode;
1050 result.emplace_back(panHorizontal1);
1051 result.emplace_back(nullptr);
1052 responseLinkRecognizers.emplace_back(panHorizontal1);
1053
1054 eventManager->SetResponseLinkRecognizers(result, responseLinkRecognizers);
1055 EXPECT_TRUE(responseLinkRecognizers.size() == 1);
1056 }
1057
1058 /**
1059 * @tc.name: EventManagerTest063
1060 * @tc.desc: Test touchtest
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(EventManagerTestNg, EventManagerTest063, TestSize.Level1)
1064 {
1065 /**
1066 * @tc.steps: step1. Create EventManager.
1067 * @tc.expected: eventManager is not null.
1068 */
1069 auto eventManager = AceType::MakeRefPtr<EventManager>();
1070 ASSERT_NE(eventManager, nullptr);
1071
1072 /**
1073 * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id].
1074 * @tc.expected: touchTestResults_ has the touchPoint.id of instance.
1075 */
1076 TouchEvent touchPoint;
1077 touchPoint.id = 1;
1078 touchPoint.type = TouchType::DOWN;
1079 touchPoint.sourceType = SourceType::TOUCH;
1080 auto currentTime = GetSysTimestamp();
1081 auto lastTime = currentTime - 1000 * 1000000 - 1000;
1082 TimeStamp lastTimeStamp((std::chrono::milliseconds(lastTime)));
1083 TimeStamp currentTimeStamp((std::chrono::milliseconds(currentTime)));
1084 eventManager->lastEventTime_ = lastTimeStamp;
1085 touchPoint.time = currentTimeStamp;
1086 const int nodeId = 1;
1087 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, nodeId, nullptr);
1088 TouchRestrict touchRestrict;
1089 Offset offset;
1090 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
1091 ASSERT_NE(clickRecognizer, nullptr);
1092 clickRecognizer->OnRejected();
1093 auto gestureRefereeNg = eventManager->GetGestureRefereeNG(clickRecognizer);
1094 ASSERT_NE(gestureRefereeNg, nullptr);
1095 gestureRefereeNg->CheckSourceTypeChange(SourceType::NONE, true);
1096 TouchTestResult resultList = { clickRecognizer };
1097 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
1098 EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
1099 }
1100
1101 /**
1102 * @tc.name: EventManagerTest064
1103 * @tc.desc: Test LogTouchTestResultRecognizers
1104 * @tc.type: FUNC
1105 */
1106 HWTEST_F(EventManagerTestNg, EventManagerTest064, TestSize.Level1)
1107 {
1108 /**
1109 * @tc.steps: step1. Create EventManager.
1110 * @tc.expected: eventManager is not null.
1111 */
1112 auto eventManager = AceType::MakeRefPtr<EventManager>();
1113 ASSERT_NE(eventManager, nullptr);
1114
1115 /**
1116 * @tc.steps: step2. Call LogTouchTestResultRecognizers.
1117 * @tc.expected: ret is false.
1118 */
1119 TouchEvent event;
1120 event.type = TouchType::DOWN;
1121 event.id = 1;
1122 TouchTestResult resultList;
1123 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1124 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1125 ASSERT_NE(panHorizontal, nullptr);
1126 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1127 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
1128 panHorizontal->AttachFrameNode(pageNode);
1129 resultList.emplace_back(panHorizontal);
1130 eventManager->LogTouchTestResultRecognizers(resultList, 1);
1131 EXPECT_FALSE(panHorizontal->isFlushTouchEventsEnd_);
1132 }
1133
1134 /**
1135 * @tc.name: EventManagerTest065
1136 * @tc.desc: Test HandleGlobalEventNG whith mouse
1137 * @tc.type: FUNC
1138 */
1139 HWTEST_F(EventManagerTestNg, EventManagerTest065, TestSize.Level1)
1140 {
1141 /**
1142 * @tc.steps: step1. Create EventManager.
1143 * @tc.expected: eventManager is not null.
1144 */
1145 auto eventManager = AceType::MakeRefPtr<EventManager>();
1146 ASSERT_NE(eventManager, nullptr);
1147
1148 /**
1149 * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id].
1150 * @tc.expected: touchTestResults_ has the touchPoint.id of instance.
1151 */
1152 TouchEvent touchPoint;
1153 touchPoint.id = 1000;
1154 touchPoint.type = TouchType::DOWN;
1155 touchPoint.sourceType = SourceType::MOUSE;
1156
1157 const int nodeId = 10003;
1158 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
1159 TouchRestrict touchRestrict;
1160 Offset offset;
1161
1162 auto eventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE_EVENT, nodeId);
1163 eventManager->currMouseTestResultsMap_[0].emplace_back(eventTarget);
1164
1165 /**
1166 * @tc.steps: step3. Create FrameNode and Call HandleGlobalEventNG.
1167 * @tc.expected: currMouseTestResultsMap_[0].size is equal to 1.
1168 */
1169 auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode);
1170 NG::OffsetF rootOffset;
1171 eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset);
1172 EXPECT_EQ(eventManager->currMouseTestResultsMap_[0].size(), 1);
1173 }
1174
1175 /**
1176 * @tc.name: EventManagerTest066
1177 * @tc.desc: Test GetTouchTestIds function.
1178 * @tc.type: FUNC
1179 */
1180 HWTEST_F(EventManagerTestNg, EventManagerTest066, TestSize.Level1)
1181 {
1182 /**
1183 * @tc.steps: step1. Create EventManager.
1184 * @tc.expected: eventManager is not null.
1185 */
1186 auto eventManager = AceType::MakeRefPtr<EventManager>();
1187 ASSERT_NE(eventManager, nullptr);
1188
1189 TouchEvent event;
1190 event.type = TouchType::DOWN;
1191 event.id = 1;
1192 std::vector<std::string> touchTestIds;
1193 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1194 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1195 ASSERT_NE(panHorizontal, nullptr);
__anon7341f9d90202() 1196 panHorizontal->SetGetEventTargetImpl([]() -> std::optional<EventTarget> {
1197 struct EventTarget eventTarget = {
1198 .id = "eventTargetCallback",
1199 .type = "eventTargetType"
1200 };
1201 std::optional<EventTarget> eventTargetCallback = eventTarget;
1202 return eventTargetCallback;
1203 });
1204
1205 TouchTestResult hitTestResult;
1206 hitTestResult.emplace_back(panHorizontal);
1207 eventManager->touchTestResults_.insert({event.id, hitTestResult});
1208 bool isMousePressAtSelectedNode = false;
1209 eventManager->GetTouchTestIds(event, touchTestIds, isMousePressAtSelectedNode, 1);
1210 EXPECT_FALSE(isMousePressAtSelectedNode);
1211 EXPECT_FALSE(touchTestIds.empty());
1212 }
1213
1214 /**
1215 * @tc.name: EventManagerTest067
1216 * @tc.desc: Test HandleOutOfRectCallback
1217 * @tc.type: FUNC
1218 */
1219 HWTEST_F(EventManagerTestNg, EventManagerTest067, TestSize.Level2)
1220 {
1221 /**
1222 * @tc.steps: step1. Create EventManager.
1223 * @tc.expected: eventManager is not null.
1224 */
1225 auto eventManager = AceType::MakeRefPtr<EventManager>();
1226 ASSERT_NE(eventManager, nullptr);
1227
1228 /**
1229 * @tc.steps: step2. Create rectCallbackList
1230 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
1231 */
1232 Point point(10, 20);
1233 point.SetSourceType(SourceType::TOUCH);
1234
__anon7341f9d90302(std::vector<Rect>& rectList) 1235 auto rectGetCallback = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect()); };
1236
__anon7341f9d90402() 1237 auto touchCallback = []() -> void {};
__anon7341f9d90502() 1238 auto mouseCallback = []() -> void {};
1239 std::vector<RectCallback> rectCallbackList {
1240 RectCallback(rectGetCallback, touchCallback, nullptr),
1241 RectCallback(rectGetCallback, nullptr, mouseCallback)
1242 };
1243
1244 /**
1245 * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::TOUCH
1246 * @tc.expected: rectCallbackList.size() is 1
1247 */
1248 eventManager->HandleOutOfRectCallback(point, rectCallbackList);
1249 EXPECT_EQ(rectCallbackList.size(), 1);
1250
1251 /**
1252 * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::MOUSE
1253 * @tc.expected: rectCallbackList is empty
1254 */
1255 point.SetSourceType(SourceType::MOUSE);
1256 eventManager->HandleOutOfRectCallback(point, rectCallbackList);
1257 EXPECT_TRUE(rectCallbackList.empty());
1258 }
1259
1260 /**
1261 * @tc.name: EventManagerTest068
1262 * @tc.desc: Test DispatchTouchEventToTouchTestResult
1263 * @tc.type: FUNC
1264 */
1265 HWTEST_F(EventManagerTestNg, EventManagerTest068, TestSize.Level1)
1266 {
1267 auto eventManager = AceType::MakeRefPtr<EventManager>();
1268 ASSERT_NE(eventManager, nullptr);
1269 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1270 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1271 ASSERT_NE(panHorizontal, nullptr);
1272 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1273 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
1274 int64_t deviceId = 20240711;
1275 TouchEvent event;
1276 event.type = TouchType::DOWN;
1277 event.deviceId = deviceId;
1278 event.sourceType = SourceType::TOUCH;
1279 panHorizontal->AttachFrameNode(pageNode);
1280
1281 TouchTestResult resultList;
1282 resultList.emplace_back(panHorizontal);
1283 eventManager->DispatchTouchEventToTouchTestResult(event, resultList, false);
1284 EXPECT_EQ(panHorizontal->deviceId_, deviceId);
1285 EXPECT_TRUE(panHorizontal->deviceType_ == SourceType::TOUCH);
1286 }
1287
1288 /**
1289 * @tc.name: EventManagerTest069
1290 * @tc.desc: Test PostEventDispatchTouchEvent
1291 * @tc.type: FUNC
1292 */
1293 HWTEST_F(EventManagerTestNg, EventManagerTest069, TestSize.Level2)
1294 {
1295 auto eventManager = AceType::MakeRefPtr<EventManager>();
1296 ASSERT_NE(eventManager, nullptr);
1297 auto rawHorizontal = AceType::MakeRefPtr<RawRecognizer>();
1298 ASSERT_NE(rawHorizontal, nullptr);
1299 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1300 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1301 ASSERT_NE(panHorizontal, nullptr);
1302 TouchEvent event;
1303 event.id = 1024;
1304 event.type = TouchType::DOWN;
1305 event.sourceType = SourceType::TOUCH;
1306 EXPECT_FALSE(eventManager->PostEventDispatchTouchEvent(event));
1307
__anon7341f9d90602() 1308 rawHorizontal->SetCatchEventCallback([]() {},
1309 static_cast<int32_t>(EventStage::CAPTURE), static_cast<int32_t>(EventType::TOUCH_DOWN));
1310 TouchTestResult resultList;
1311 resultList.emplace_back(panHorizontal);
1312 resultList.emplace_back(rawHorizontal);
1313 eventManager->postEventTouchTestResults_.emplace(event.id, resultList);
1314 EXPECT_TRUE(eventManager->PostEventDispatchTouchEvent(event));
1315 }
1316
1317 /**
1318 * @tc.name: EventManagerTest070
1319 * @tc.desc: Test MouseTest For API12.
1320 * @tc.type: FUNC
1321 */
1322 HWTEST_F(EventManagerTestNg, EventManagerTest070, TestSize.Level1)
1323 {
1324 /**
1325 * @tc.steps: step1. Create EventManager.
1326 * @tc.expected: eventManager is not null.
1327 */
1328 auto eventManager = AceType::MakeRefPtr<EventManager>();
1329 ASSERT_NE(eventManager, nullptr);
1330 int32_t settingApiVersion = 12;
1331 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion();
1332 AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion);
1333
1334 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1335 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
1336
1337 MouseEvent event;
1338 TouchRestrict touchRestrict;
1339 event.action = MouseAction::PULL_MOVE;
1340 eventManager->MouseTest(event, pageNode, touchRestrict);
1341 EXPECT_FALSE(touchRestrict.touchEvent.isMouseTouchTest);
1342
1343 event.action = MouseAction::MOVE;
1344 event.button = MouseButton::NONE_BUTTON;
1345 eventManager->MouseTest(event, pageNode, touchRestrict);
1346 EXPECT_FALSE(touchRestrict.touchEvent.isMouseTouchTest);
1347
1348 event.action = MouseAction::PRESS;
1349 event.button = MouseButton::LEFT_BUTTON;
1350 eventManager->MouseTest(event, pageNode, touchRestrict);
1351 EXPECT_TRUE(touchRestrict.touchEvent.isMouseTouchTest);
1352
1353 event.action = MouseAction::MOVE;
1354 event.button = MouseButton::RIGHT_BUTTON;
1355 eventManager->MouseTest(event, pageNode, touchRestrict);
1356
1357 event.action = MouseAction::WINDOW_ENTER;
1358 eventManager->MouseTest(event, pageNode, touchRestrict);
1359 EXPECT_TRUE(touchRestrict.touchEvent.isMouseTouchTest);
1360
1361 event.button = MouseButton::LEFT_BUTTON;
1362 eventManager->MouseTest(event, pageNode, touchRestrict);
1363 EXPECT_TRUE(touchRestrict.touchEvent.isMouseTouchTest);
1364 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion);
1365 }
1366
1367 /**
1368 * @tc.name: EventManagerTest071
1369 * @tc.desc: Test UpdateHoverNode
1370 * @tc.type: FUNC
1371 */
1372 HWTEST_F(EventManagerTestNg, EventManagerTest071, TestSize.Level1)
1373 {
1374 auto eventManager = AceType::MakeRefPtr<EventManager>();
1375 ASSERT_NE(eventManager, nullptr);
1376
1377 MouseEvent event;
1378 auto hoverEffectTarget = AceType::MakeRefPtr<HoverEffectTarget>(CTRLSHIFT, NODEID);
1379 std::list<RefPtr<TouchEventTarget>> testResult = { hoverEffectTarget };
1380 eventManager->UpdateHoverNode(event, testResult);
1381 EXPECT_TRUE(eventManager->currMouseTestResultsMap_[0].empty());
1382 }
1383
1384 /**
1385 * @tc.name: EventManagerTest073
1386 * @tc.desc: Test AddKeyboardShortcutNode
1387 * @tc.type: FUNC
1388 */
1389 HWTEST_F(EventManagerTestNg, EventManagerTest073, TestSize.Level2)
1390 {
1391 auto eventManager = AceType::MakeRefPtr<EventManager>();
1392 auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
1393 auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, NODEID, nullptr);
1394 frameNodeCtrl->SetActive(true);
1395 frameNodeCtrlShift->SetActive(true);
1396
1397 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
1398 eventManager->AddKeyboardShortcutNode(nullptr);
1399 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
1400 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1401 }
1402
1403 /**
1404 * @tc.name: EventManagerTest074
1405 * @tc.desc: Test DispatchKeyboardShortcut
1406 * @tc.type: FUNC
1407 */
1408 HWTEST_F(EventManagerTestNg, EventManagerTest074, TestSize.Level1)
1409 {
1410 auto eventManager = AceType::MakeRefPtr<EventManager>();
1411 KeyEvent event;
1412 auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
1413 auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NODEID, nullptr);
1414 auto frameNodeAlt = FrameNode::GetOrCreateFrameNode(ALT, NODEID, nullptr);
1415 auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, NODEID, nullptr);
1416 frameNodeCtrl->SetActive(true);
1417 frameNodeShift->SetActive(true);
1418 frameNodeAlt->SetActive(true);
1419 frameNodeCtrlShift->SetActive(true);
1420
1421 auto eventHubCtrl = frameNodeCtrl->GetOrCreateEventHub<NG::EventHub>();
1422 auto eventHubShift = frameNodeShift->GetOrCreateEventHub<NG::EventHub>();
1423 auto eventHubAlt = frameNodeAlt->GetOrCreateEventHub<NG::EventHub>();
1424 auto eventHubCtrlShift = frameNodeCtrlShift->GetOrCreateEventHub<NG::EventHub>();
1425
1426 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
1427 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
1428 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeAlt));
1429 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
1430 eventHubCtrl->SetKeyboardShortcut(CHARACTER_C, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE + NUM_ALT_VALUE), nullptr);
1431 event.code = KeyCode::KEY_C;
1432 event.action = KeyAction::DOWN;
1433 event.pressedCodes.emplace_back(KeyCode::KEY_CTRL_LEFT);
1434 event.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
1435 event.pressedCodes.emplace_back(KeyCode::KEY_ALT_LEFT);
1436 event.pressedCodes.emplace_back(KeyCode::KEY_C);
1437 eventManager->DispatchKeyboardShortcut(event);
1438 EXPECT_EQ(event.action, KeyAction::DOWN);
1439 }
1440
1441 /**
1442 * @tc.name: EventManagerTest075
1443 * @tc.desc: Test DispatchKeyboardShortcut
1444 * @tc.type: FUNC
1445 */
1446 HWTEST_F(EventManagerTestNg, EventManagerTest075, TestSize.Level2)
1447 {
1448 auto eventManager = AceType::MakeRefPtr<EventManager>();
1449 KeyEvent event;
1450 event.action = KeyAction::CLICK;
1451 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1452
1453 auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
1454 auto eventHubCtrl = frameNodeCtrl->GetOrCreateEventHub<NG::EventHub>();
1455 frameNodeCtrl->SetActive(true);
1456
1457 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
1458 uint8_t singleKeys = 0;
1459 eventHubCtrl->SetKeyboardShortcut(CTRL, singleKeys, nullptr);
1460 event.action = KeyAction::DOWN;
1461 event.code = KeyCode::KEY_ESCAPE;
1462 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1463
1464 eventHubCtrl->SetKeyboardShortcut(std::string(), (NUM_CTRL_VALUE + NUM_SHIFT_VALUE), nullptr);
1465 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1466
1467 eventHubCtrl->SetEnabled(false);
1468 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1469 }
1470
1471 /**
1472 * @tc.name: EventManagerTest076
1473 * @tc.desc: Test EventManager constructor fire callBack
1474 * @tc.type: FUNC
1475 */
1476 HWTEST_F(EventManagerTestNg, EventManagerTest076, TestSize.Level1)
1477 {
1478 auto eventManager = AceType::MakeRefPtr<EventManager>();
1479 ASSERT_NE(eventManager, nullptr);
1480 auto referee = eventManager->GetGestureReferee();
1481 ASSERT_NE(referee, nullptr);
1482 int32_t touchId = 10;
1483 EXPECT_NE(referee->queryStateFunc_, nullptr);
1484 referee->queryStateFunc_(touchId);
1485 auto gestureRefereeNg = eventManager->GetGestureRefereeNG(AceType::MakeRefPtr<ClickRecognizer>());
1486 ASSERT_NE(gestureRefereeNg, nullptr);
1487 EXPECT_NE(gestureRefereeNg->queryStateFunc_, nullptr);
1488 gestureRefereeNg->queryStateFunc_(touchId);
1489 }
1490
1491 /**
1492 * @tc.name: EventManagerTest077
1493 * @tc.desc: Test AddGestureSnapshot
1494 * @tc.type: FUNC
1495 */
1496 HWTEST_F(EventManagerTestNg, EventManagerTest077, TestSize.Level1)
1497 {
1498 auto eventManager = AceType::MakeRefPtr<EventManager>();
1499 ASSERT_NE(eventManager, nullptr);
1500 auto eventTree = eventManager->GetEventTreeRecord(EventTreeType::TOUCH);
1501 TouchEvent event;
1502 event.type = Ace::TouchType::DOWN;
1503 event.id = 1;
1504 eventTree.AddTouchPoint(event);
1505 eventManager->DumpEvent(EventTreeType::TOUCH);
1506
1507 int32_t finger = 1;
1508 int32_t depth = 0;
1509 int32_t nodeId = 16;
1510 eventManager->AddGestureSnapshot(finger, depth, nullptr, EventTreeType::TOUCH);
1511 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1512 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1513 eventManager->AddGestureSnapshot(finger, depth, recognizerGroup, EventTreeType::TOUCH);
1514 EXPECT_FALSE(eventTree.eventTreeList.empty());
1515 }
1516
1517 /**
1518 * @tc.name: EventManagerTest078
1519 * @tc.desc: Test SetHittedFrameNode
1520 * @tc.type: FUNC
1521 */
1522 HWTEST_F(EventManagerTestNg, EventManagerTest078, TestSize.Level1)
1523 {
1524 auto eventManager = AceType::MakeRefPtr<EventManager>();
1525 ASSERT_NE(eventManager, nullptr);
1526
1527 int32_t nodeId = 16;
1528 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1529 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1530
1531 std::list<RefPtr<NG::NGGestureRecognizer>> gestureRecognizers;
1532 eventManager->SetHittedFrameNode(gestureRecognizers);
1533 EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
1534
1535 gestureRecognizers.emplace_back(recognizerGroup);
1536 eventManager->SetHittedFrameNode(gestureRecognizers);
1537 EXPECT_FALSE(eventManager->hittedFrameNode_.empty());
1538 }
1539
1540 /**
1541 * @tc.name: EventManagerTest079
1542 * @tc.desc: Test CleanGestureEventHub
1543 * @tc.type: FUNC
1544 */
1545 HWTEST_F(EventManagerTestNg, EventManagerTest079, TestSize.Level1)
1546 {
1547 auto eventManager = AceType::MakeRefPtr<EventManager>();
1548 ASSERT_NE(eventManager, nullptr);
1549
1550 int32_t nodeId = 16;
1551 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1552 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1553
1554 std::list<RefPtr<NG::NGGestureRecognizer>> gestureRecognizers;
1555 gestureRecognizers.emplace_back(recognizerGroup);
1556 eventManager->SetHittedFrameNode(gestureRecognizers);
1557 EXPECT_FALSE(eventManager->hittedFrameNode_.empty());
1558 eventManager->CleanGestureEventHub();
1559 EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
1560 }
1561
1562 /**
1563 * @tc.name: EventManagerTest080
1564 * @tc.desc: Test SetResponseLinkRecognizers
1565 * @tc.type: FUNC
1566 */
1567 HWTEST_F(EventManagerTestNg, EventManagerTest080, TestSize.Level1)
1568 {
1569 auto eventManager = AceType::MakeRefPtr<EventManager>();
1570 ASSERT_NE(eventManager, nullptr);
1571
1572 int32_t nodeId = 16;
1573 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1574 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1575 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1576 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1577 auto targetLinkHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1578 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1579
1580 TouchTestResult resultList;
1581 ResponseLinkResult responseLinkRecognizers;
1582 resultList.emplace_back(recognizerGroup);
1583 resultList.emplace_back(panHorizontal);
1584 responseLinkRecognizers.emplace_back(targetLinkHorizontal);
1585 eventManager->SetResponseLinkRecognizers(resultList, responseLinkRecognizers);
1586 EXPECT_TRUE(responseLinkRecognizers.size() == 1);
1587 }
1588
1589 /**
1590 * @tc.name: EventManagerTest081
1591 * @tc.desc: Test FalsifyCancelEventAndDispatch
1592 * @tc.type: FUNC
1593 */
1594 HWTEST_F(EventManagerTestNg, EventManagerTest081, TestSize.Level1)
1595 {
1596 auto eventManager = AceType::MakeRefPtr<EventManager>();
1597 ASSERT_NE(eventManager, nullptr);
1598
1599 int32_t nodeId = 32;
1600 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1601 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1602 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1603 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1604 TouchTestResult resultList;
1605 resultList.emplace_back(recognizerGroup);
1606 resultList.emplace_back(panHorizontal);
1607 eventManager->axisTouchTestResults_.clear();
1608 eventManager->axisTouchTestResults_[0] = resultList;
1609 AxisEvent event;
1610 eventManager->FalsifyCancelEventAndDispatch(event);
1611 EXPECT_TRUE(eventManager->axisTouchTestResults_.empty());
1612 }
1613
1614 /**
1615 * @tc.name: EventManagerAccessibilityHoverTest001
1616 * @tc.desc: Test MouseTest (frameNode)
1617 * @tc.type: FUNC
1618 */
1619 HWTEST_F(EventManagerTestNg, EventManagerAccessibilityHoverTest001, TestSize.Level1)
1620 {
1621 /**
1622 * @tc.steps: step1. Create EventManager.
1623 * @tc.expected: eventManager is not null.
1624 */
1625 auto eventManager = AceType::MakeRefPtr<EventManager>();
1626 ASSERT_NE(eventManager, nullptr);
1627
1628 /**
1629 * @tc.steps: step2. Call MouseTest with MouseAction::WINDOW_LEAVE
1630 * @tc.expected: currHoverTestResults_ is empty
1631 */
1632 TouchEvent event;
1633 const int nodeId = 10008;
1634 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
1635 TouchRestrict touchRestrict;
1636
1637 event.type = TouchType::HOVER_EXIT;
1638 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(V2::LOCATION_BUTTON_ETS_TAG, nodeId);
1639 eventManager->curAccessibilityHoverResults_.push_back(hoverEventTarget);
1640 EXPECT_FALSE(eventManager->curAccessibilityHoverResults_.empty());
1641 eventManager->AccessibilityHoverTest(event, frameNode, touchRestrict);
1642 EXPECT_TRUE(eventManager->curAccessibilityHoverResults_.empty());
1643
1644 /**
1645 * @tc.steps: step3. Call MouseTest with MouseAction::WINDOW_ENTER
1646 * @tc.expected: lastHoverTestResults_ is empty
1647 */
1648 event.type = TouchType::HOVER_ENTER;
1649 eventManager->lastAccessibilityHoverResults_.push_back(hoverEventTarget);
1650 EXPECT_FALSE(eventManager->lastAccessibilityHoverResults_.empty());
1651 eventManager->AccessibilityHoverTest(event, frameNode, touchRestrict);
1652 EXPECT_TRUE(eventManager->lastAccessibilityHoverResults_.empty());
1653
1654 /**
1655 * @tc.steps: step4. Call MouseTest with MouseAction::HOVER
1656 * @tc.expected: lastHoverTestResults_ is empty and currHoverTestResults_ is empty
1657 */
1658 event.type = TouchType::HOVER_MOVE;
1659 eventManager->lastAccessibilityHoverResults_.push_back(hoverEventTarget);
1660 eventManager->AccessibilityHoverTest(event, frameNode, touchRestrict);
1661 EXPECT_TRUE(eventManager->lastAccessibilityHoverResults_.empty());
1662 EXPECT_TRUE(eventManager->curAccessibilityHoverResults_.empty());
1663
1664 /**
1665 * @tc.steps: step4. Call MouseTest with MouseAction::HOVER
1666 * @tc.expected: lastHoverTestResults_ is empty and currHoverTestResults_ is empty
1667 */
1668 event.type = TouchType::HOVER_CANCEL;
1669 eventManager->curAccessibilityHoverResults_.push_back(hoverEventTarget);
1670 eventManager->AccessibilityHoverTest(event, frameNode, touchRestrict);
1671 EXPECT_FALSE(eventManager->lastAccessibilityHoverResults_.empty());
1672 EXPECT_TRUE(eventManager->curAccessibilityHoverResults_.empty());
1673 }
1674
1675 /**
1676 * @tc.name: EventManagerTest082
1677 * @tc.desc: Test CheckDownEvent with FrameNode
1678 * @tc.type: FUNC
1679 */
1680 HWTEST_F(EventManagerTestNg, EventManagerTest082, TestSize.Level1)
1681 {
1682 auto eventManager = AceType::MakeRefPtr<EventManager>();
1683 bool result = true;
1684 ASSERT_NE(eventManager, nullptr);
1685 TouchEvent touchPoint;
1686 touchPoint.id = 1;
1687 touchPoint.type = TouchType::DOWN;
1688 eventManager->CheckDownEvent(touchPoint);
1689 eventManager->downFingerIds_[1] = 1;
1690 eventManager->downFingerIds_[2] = 2;
1691 eventManager->downFingerIds_[3] = 3;
1692 eventManager->CheckDownEvent(touchPoint);
1693 touchPoint.type = TouchType::UP;
1694 eventManager->CheckDownEvent(touchPoint);
1695 EXPECT_TRUE(result);
1696 }
1697
1698 /**
1699 * @tc.name: EventManagerTest083
1700 * @tc.desc: Test DispatchAccessibilityHoverEventNG with FrameNode
1701 * @tc.type: FUNC
1702 */
1703 HWTEST_F(EventManagerTestNg, EventManagerTest083, TestSize.Level1)
1704 {
1705 auto eventManager = AceType::MakeRefPtr<EventManager>();
1706 ASSERT_NE(eventManager, nullptr);
1707 bool result = true;
1708 TouchEvent event;
1709 const int nodeId = 10008;
1710 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(V2::LOCATION_BUTTON_ETS_TAG, nodeId);
1711 ASSERT_NE(hoverEventTarget, nullptr);
1712 eventManager->lastAccessibilityHoverResults_.push_back(hoverEventTarget);
1713 eventManager->DispatchAccessibilityHoverEventNG(event);
1714 eventManager->curAccessibilityHoverResults_.push_back(hoverEventTarget);
1715 eventManager->DispatchAccessibilityHoverEventNG(event);
1716 eventManager->lastAccessibilityHoverDispatchLength_ = 1;
1717 eventManager->DispatchAccessibilityHoverEventNG(event);
1718 eventManager->lastAccessibilityHoverDispatchLength_ = 10;
1719 eventManager->DispatchAccessibilityHoverEventNG(event);
1720 eventManager->curAccessibilityHoverResults_.clear();
1721 eventManager->lastAccessibilityHoverResults_.clear();
1722 eventManager->curAccessibilityHoverResults_.push_front(hoverEventTarget);
1723 eventManager->DispatchAccessibilityHoverEventNG(event);
1724 EXPECT_TRUE(result);
1725 }
1726
1727 /**
1728 * @tc.name: EventManagerTest084
1729 * @tc.desc: Test DispatchRotationEvent
1730 * @tc.type: FUNC
1731 */
1732 HWTEST_F(EventManagerTestNg, EventManagerTest084, TestSize.Level1)
1733 {
1734 auto eventManager = AceType::MakeRefPtr<EventManager>();
1735 ASSERT_NE(eventManager, nullptr);
1736 auto referee = eventManager->GetGestureReferee();
1737 ASSERT_NE(referee, nullptr);
1738 int32_t touchId = 10;
1739 RefPtr<GestureScope> scope = AceType::MakeRefPtr<GestureScope>(touchId);
1740 ASSERT_NE(scope, nullptr);
1741 referee->gestureScopes_.clear();
1742 referee->gestureScopes_.insert(std::make_pair(touchId, scope));
1743 auto gestureScope = referee->GetGestureScope();
1744 EXPECT_NE(referee->queryStateFunc_, nullptr);
1745 referee->queryStateFunc_(touchId);
1746 auto gestureRefereeNg = eventManager->GetGestureRefereeNG(AceType::MakeRefPtr<ClickRecognizer>());
1747 ASSERT_NE(gestureRefereeNg, nullptr);
1748 EXPECT_NE(gestureRefereeNg->queryStateFunc_, nullptr);
1749 gestureRefereeNg->queryStateFunc_(touchId);
1750 }
1751
1752 /**
1753 * @tc.name: EventManagerTest085
1754 * @tc.desc: Test RecordHitEmptyMessage
1755 * @tc.type: FUNC
1756 */
1757 HWTEST_F(EventManagerTestNg, EventManagerTest085, TestSize.Level1)
1758 {
1759 auto eventManager = AceType::MakeRefPtr<EventManager>();
1760 ASSERT_NE(eventManager, nullptr);
1761 TouchEvent touchPoint;
1762 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 1, nullptr);
1763 MockPipelineContext::SetUp();
1764 ASSERT_NE(MockPipelineContext::GetCurrentContext(), nullptr);
1765 MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrentContext();
1766 std::string resultInfo = "info";
1767 eventManager->RecordHitEmptyMessage(touchPoint, resultInfo, frameNode);
1768 MockPipelineContext::GetCurrentContext()->window_ = std::make_shared<MockWindow>();
1769 auto frontend = AceType::MakeRefPtr<MockFrontend>();
1770 EXPECT_CALL(*MockContainer::Current(), GetFrontend()).WillRepeatedly(Return(frontend));
1771 eventManager->RecordHitEmptyMessage(touchPoint, resultInfo, frameNode);
1772 EXPECT_CALL(*MockContainer::Current(), GetFrontend()).WillRepeatedly(Return(nullptr));
1773 MockContainer::Current()->pipelineContext_ = nullptr;
1774 MockPipelineContext::TearDown();
1775 EXPECT_EQ(touchPoint.isFalsified, false);
1776 }
1777
1778 /**
1779 * @tc.name: EventManagerTest086
1780 * @tc.desc: Test DispatchTouchEvent
1781 * @tc.type: FUNC
1782 */
1783 HWTEST_F(EventManagerTestNg, EventManagerTest086, TestSize.Level1)
1784 {
1785 auto eventManager = AceType::MakeRefPtr<EventManager>();
1786 ASSERT_NE(eventManager, nullptr);
1787 AxisEvent touchPoint;
1788 touchPoint.action = AxisAction::BEGIN;
1789 touchPoint.id = MOUSE_BASE_ID;
1790 TouchTestResult hitTestResult;
1791 hitTestResult.clear();
1792 eventManager->axisTouchTestResults_.clear();
1793 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1794 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1795 ASSERT_NE(panHorizontal, nullptr);
1796 auto panHorizontals = AceType::MakeRefPtr<PanRecognizer>(
1797 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1798 ASSERT_NE(panHorizontals, nullptr);
1799 hitTestResult.emplace_back(panHorizontals);
1800 hitTestResult.emplace_back(panHorizontal);
1801 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
1802 eventManager->DispatchTouchEvent(touchPoint);
1803 eventManager->refereeNG_ = nullptr;
1804 eventManager->DispatchTouchEvent(touchPoint);
1805 auto container = Container::Current();
1806 ASSERT_NE(container, nullptr);
1807 container->useNewPipeline_ = false;
1808 eventManager->DispatchTouchEvent(touchPoint);
1809 touchPoint.isRotationEvent = true;
1810 eventManager->DispatchTouchEvent(touchPoint);
1811 EXPECT_EQ(touchPoint.isRotationEvent, true);
1812 }
1813
1814 /**
1815 * @tc.name: EventManagerTest087
1816 * @tc.desc: Test DispatchKeyboardShortcut
1817 * @tc.type: FUNC
1818 */
1819 HWTEST_F(EventManagerTestNg, EventManagerTest087, TestSize.Level1)
1820 {
1821 auto eventManager = AceType::MakeRefPtr<EventManager>();
1822 ASSERT_NE(eventManager, nullptr);
1823 KeyEvent touchPoint;
1824 auto container = Container::GetContainer(eventManager->instanceId_);
1825 ASSERT_NE(container, nullptr);
1826 container->uIContentType_ = UIContentType::SECURITY_UI_EXTENSION;
1827 eventManager->DispatchKeyboardShortcut(touchPoint);
1828 EXPECT_EQ(eventManager->DispatchKeyboardShortcut(touchPoint), false);
1829 }
1830
1831 /**
1832 * @tc.name: EventManagerTest088
1833 * @tc.desc: Test TouchTest
1834 * @tc.type: FUNC
1835 */
1836 HWTEST_F(EventManagerTestNg, EventManagerTest088, TestSize.Level1)
1837 {
1838 auto eventManager = AceType::MakeRefPtr<EventManager>();
1839 ASSERT_NE(eventManager, nullptr);
1840 TouchEvent touchPoint;
1841 touchPoint.id = 1000;
1842 touchPoint.type = TouchType::DOWN;
1843 const int nodeId = 10003;
1844 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
1845 TouchRestrict touchRestrict;
1846 Offset offset;
1847 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(V2::LOCATION_BUTTON_ETS_TAG, nodeId);
1848 ASSERT_NE(hoverEventTarget, nullptr);
1849 eventManager->curAccessibilityHoverResults_.push_back(hoverEventTarget);
1850 TouchTestResult hitTestResult;
1851 hitTestResult.clear();
1852 eventManager->touchTestResults_.clear();
1853 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1854 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1855 ASSERT_NE(panHorizontal, nullptr);
1856 auto panHorizontals = AceType::MakeRefPtr<PanRecognizer>(
1857 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1858 ASSERT_NE(panHorizontals, nullptr);
1859 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
1860 panHorizontals->node_ = frameNode;
1861 hitTestResult.emplace_back(panHorizontals);
1862 hitTestResult.emplace_back(panHorizontal);
1863 eventManager->touchTestResults_[1000] = std::move(hitTestResult);
1864 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
1865 EXPECT_EQ(touchPoint.isFalsified, false);
1866 }
1867
1868 /**
1869 * @tc.name: EventManagerTest089
1870 * @tc.desc: Test MouseTest For API12.
1871 * @tc.type: FUNC
1872 */
1873 HWTEST_F(EventManagerTestNg, EventManagerTest089, TestSize.Level1)
1874 {
1875 /**
1876 * @tc.steps: step1. Create EventManager.
1877 * @tc.expected: eventManager is not null.
1878 */
1879 auto eventManager = AceType::MakeRefPtr<EventManager>();
1880 ASSERT_NE(eventManager, nullptr);
1881 int32_t settingApiVersion = 11;
1882 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion();
1883 AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion);
1884
1885 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1886 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
1887 const std::vector<MockMouseEvent> mockMouseEvents = {
1888 { MouseAction::NONE, MouseButton::NONE_BUTTON, false },
1889 { MouseAction::NONE, MouseButton::LEFT_BUTTON, true },
1890 { MouseAction::NONE, MouseButton::RIGHT_BUTTON, false },
1891 { MouseAction::NONE, MouseButton::MIDDLE_BUTTON, false },
1892 { MouseAction::NONE, MouseButton::BACK_BUTTON, false },
1893 { MouseAction::NONE, MouseButton::FORWARD_BUTTON, false },
1894 { MouseAction::NONE, MouseButton::SIDE_BUTTON, false },
1895 { MouseAction::NONE, MouseButton::EXTRA_BUTTON, false },
1896 { MouseAction::NONE, MouseButton::TASK_BUTTON, false },
1897 { MouseAction::PRESS, MouseButton::NONE_BUTTON, false },
1898 { MouseAction::PRESS, MouseButton::LEFT_BUTTON, true },
1899 { MouseAction::PRESS, MouseButton::RIGHT_BUTTON, false },
1900 { MouseAction::PRESS, MouseButton::MIDDLE_BUTTON, false },
1901 { MouseAction::PRESS, MouseButton::BACK_BUTTON, false },
1902 { MouseAction::PRESS, MouseButton::FORWARD_BUTTON, false },
1903 { MouseAction::PRESS, MouseButton::SIDE_BUTTON, false },
1904 { MouseAction::PRESS, MouseButton::EXTRA_BUTTON, false },
1905 { MouseAction::PRESS, MouseButton::TASK_BUTTON, false },
1906 { MouseAction::RELEASE, MouseButton::NONE_BUTTON, false },
1907 { MouseAction::RELEASE, MouseButton::LEFT_BUTTON, true },
1908 { MouseAction::RELEASE, MouseButton::RIGHT_BUTTON, false },
1909 { MouseAction::RELEASE, MouseButton::MIDDLE_BUTTON, false },
1910 { MouseAction::RELEASE, MouseButton::BACK_BUTTON, false },
1911 { MouseAction::RELEASE, MouseButton::FORWARD_BUTTON, false },
1912 { MouseAction::RELEASE, MouseButton::SIDE_BUTTON, false },
1913 { MouseAction::RELEASE, MouseButton::EXTRA_BUTTON, false },
1914 { MouseAction::RELEASE, MouseButton::TASK_BUTTON, false },
1915 { MouseAction::MOVE, MouseButton::NONE_BUTTON, false },
1916 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false },
1917 { MouseAction::MOVE, MouseButton::RIGHT_BUTTON, false },
1918 { MouseAction::MOVE, MouseButton::MIDDLE_BUTTON, false },
1919 { MouseAction::MOVE, MouseButton::BACK_BUTTON, false },
1920 { MouseAction::MOVE, MouseButton::FORWARD_BUTTON, false },
1921 { MouseAction::MOVE, MouseButton::SIDE_BUTTON, false },
1922 { MouseAction::MOVE, MouseButton::EXTRA_BUTTON, false },
1923 { MouseAction::MOVE, MouseButton::TASK_BUTTON, false },
1924 { MouseAction::WINDOW_ENTER, MouseButton::NONE_BUTTON, false },
1925 { MouseAction::WINDOW_ENTER, MouseButton::LEFT_BUTTON, true },
1926 { MouseAction::WINDOW_ENTER, MouseButton::RIGHT_BUTTON, false },
1927 { MouseAction::WINDOW_ENTER, MouseButton::MIDDLE_BUTTON, false },
1928 { MouseAction::WINDOW_ENTER, MouseButton::BACK_BUTTON, false },
1929 { MouseAction::WINDOW_ENTER, MouseButton::FORWARD_BUTTON, false },
1930 { MouseAction::WINDOW_ENTER, MouseButton::SIDE_BUTTON, false },
1931 { MouseAction::WINDOW_ENTER, MouseButton::EXTRA_BUTTON, false },
1932 { MouseAction::WINDOW_ENTER, MouseButton::TASK_BUTTON, false },
1933 { MouseAction::WINDOW_LEAVE, MouseButton::NONE_BUTTON, false },
1934 { MouseAction::WINDOW_LEAVE, MouseButton::LEFT_BUTTON, true },
1935 { MouseAction::WINDOW_LEAVE, MouseButton::RIGHT_BUTTON, false },
1936 { MouseAction::WINDOW_LEAVE, MouseButton::MIDDLE_BUTTON, false },
1937 { MouseAction::WINDOW_LEAVE, MouseButton::BACK_BUTTON, false },
1938 { MouseAction::WINDOW_LEAVE, MouseButton::FORWARD_BUTTON, false },
1939 { MouseAction::WINDOW_LEAVE, MouseButton::SIDE_BUTTON, false },
1940 { MouseAction::WINDOW_LEAVE, MouseButton::EXTRA_BUTTON, false },
1941 { MouseAction::WINDOW_LEAVE, MouseButton::TASK_BUTTON, false },
1942 { MouseAction::CANCEL, MouseButton::NONE_BUTTON, false },
1943 { MouseAction::CANCEL, MouseButton::LEFT_BUTTON, true },
1944 { MouseAction::CANCEL, MouseButton::RIGHT_BUTTON, false },
1945 { MouseAction::CANCEL, MouseButton::MIDDLE_BUTTON, false },
1946 { MouseAction::CANCEL, MouseButton::BACK_BUTTON, false },
1947 { MouseAction::CANCEL, MouseButton::FORWARD_BUTTON, false },
1948 { MouseAction::CANCEL, MouseButton::SIDE_BUTTON, false },
1949 { MouseAction::CANCEL, MouseButton::EXTRA_BUTTON, false },
1950 { MouseAction::CANCEL, MouseButton::TASK_BUTTON, false },
1951 };
1952
1953 /**
1954 * @tc.steps: step3. Inject mouseEvent
1955 * @tc.expected: pressMouseTestResults stop propagation no work for DispatchMouseEventNG result
1956 */
1957 for (auto mockMouseEvent : mockMouseEvents) {
1958 MouseEvent event;
1959 event.action = mockMouseEvent.action;
1960 event.button = mockMouseEvent.button;
1961 TouchRestrict touchRestrict;
1962 eventManager->MouseTest(event, pageNode, touchRestrict);
1963 EXPECT_EQ(touchRestrict.touchEvent.isMouseTouchTest, mockMouseEvent.expectedResult);
1964 }
1965 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion);
1966 /**
1967 * @tc.steps: step3. Inject mouseEvent
1968 * @tc.expected: pressMouseTestResults stop propagation no work for DispatchMouseEventNG result
1969 */
1970 for (auto mockMouseEvent : mockMouseEvents) {
1971 MouseEvent event;
1972 event.action = mockMouseEvent.action;
1973 event.button = mockMouseEvent.button;
1974 TouchRestrict touchRestrict;
1975 eventManager->MouseTest(event, pageNode, touchRestrict);
1976 EXPECT_EQ(touchRestrict.touchEvent.isMouseTouchTest, mockMouseEvent.expectedResult);
1977 }
1978 }
1979
1980
1981 #ifdef SUPPORT_DIGITAL_CROWN
1982 /**
1983 * @tc.name: EventManagerTest089
1984 * @tc.desc: Test OnCrownEvent
1985 * @tc.type: FUNC
1986 */
1987 HWTEST_F(EventManagerTestNg, EventManagerTest089, TestSize.Level1)
1988 {
1989 /**
1990 * @tc.steps: step1. Create EventManager.
1991 * @tc.expected: eventManager is not null.
1992 */
1993 auto eventManager = AceType::MakeRefPtr<EventManager>();
1994 ASSERT_NE(eventManager, nullptr);
1995
1996 /**
1997 * @tc.steps: step2. Call OnCrownEvent.
1998 * @tc.expected: ret is false.
1999 */
2000 CrownEvent event;
2001 bool ret = eventManager->OnCrownEvent(event);
2002 EXPECT_FALSE(ret);
2003
2004 /**
2005 * @tc.steps: step3. Call OnCrownEvent.
2006 * @tc.expected: ret is true.
2007 */
2008 MockPipelineContext::SetUp();
2009 ASSERT_NE(MockPipelineContext::GetCurrentContext(), nullptr);
2010 MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrentContext();
2011 ret = eventManager->OnCrownEvent(event);
2012 EXPECT_TRUE(ret);
2013
2014 /**
2015 * @tc.steps: step4. Call OnCrownEvent. pipelineContext is nullptr
2016 * @tc.expected: ret is false.
2017 */
2018 MockContainer::Current()->pipelineContext_ = nullptr;
2019 ret = eventManager->OnCrownEvent(event);
2020 EXPECT_FALSE(ret);
2021 MockPipelineContext::TearDown();
2022 }
2023 #endif
2024
2025 /**
2026 * @tc.name: CleanRecognizersForDragBeginTest001
2027 * @tc.desc: Test CleanRecognizersForDragBegin
2028 * @tc.type: FUNC
2029 */
2030 HWTEST_F(EventManagerTestNg, CleanRecognizersForDragBeginTest001, TestSize.Level1)
2031 {
2032 /**
2033 * @tc.steps: step1. Create EventManager.
2034 * @tc.expected: eventManager is not null.
2035 */
2036 auto eventManager = AceType::MakeRefPtr<EventManager>();
2037 ASSERT_NE(eventManager, nullptr);
2038 eventManager->downFingerIds_.clear();
2039 eventManager->touchTestResults_.clear();
2040
2041 /**
2042 * @tc.steps: step2. Call CleanRecognizersForDragBegin.
2043 * @tc.expected: downFingerIds_ erase id.
2044 */
2045 TouchEvent event;
2046 event.id = 100;
2047 event.type = TouchType::CANCEL;
2048 eventManager->downFingerIds_[event.id] = event.id;
2049 eventManager->CleanRecognizersForDragBegin(event);
2050 EXPECT_EQ(eventManager->downFingerIds_.size(), 0);
2051
2052 /**
2053 * @tc.steps: step3. Call CleanRecognizersForDragBegin.
2054 * @tc.expected: pan recognizer actionCancel called.
2055 */
2056 TouchTestResult resultList;
2057 auto panRecognizer = AceType::MakeRefPtr<PanRecognizer>(
2058 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
2059 ASSERT_NE(panRecognizer, nullptr);
2060 panRecognizer->refereeState_ = RefereeState::SUCCEED;
2061 panRecognizer->fingersId_.insert(event.id);
2062 panRecognizer->currentFingers_ = 1;
2063 bool unknownPropertyValue = false;
__anon7341f9d90702(GestureEvent& info) 2064 GestureEventFunc actionCancel = [&unknownPropertyValue](GestureEvent& info) { unknownPropertyValue = true; };
2065 panRecognizer->SetOnActionCancel(actionCancel);
2066 resultList.emplace_back(panRecognizer);
2067 eventManager->touchTestResults_.emplace(event.id, resultList);
2068 eventManager->downFingerIds_[event.id] = event.id;
2069 eventManager->CleanRecognizersForDragBegin(event);
2070 EXPECT_EQ(eventManager->downFingerIds_.size(), 0);
2071 EXPECT_TRUE(unknownPropertyValue);
2072 }
2073
2074 /**
2075 * @tc.name: DispatchTouchCancelToRecognizerTest
2076 * @tc.desc: Test DispatchTouchCancelToRecognizer
2077 * @tc.type: FUNC
2078 */
2079 HWTEST_F(EventManagerTestNg, DispatchTouchCancelToRecognizer, TestSize.Level1)
2080 {
2081 auto eventManager = AceType::MakeRefPtr<EventManager>();
2082 auto& touchTestResult = eventManager->touchTestResults_;
2083 const uint8_t targetCnt = 2; // defines 2 touch target;
2084 const uint8_t fingerCnt = 2; // defines 2 fingers;
2085 RefPtr<TouchEventActuator> targetRefs[targetCnt];
2086 using TouchRecoginerTarget = std::vector<std::pair<int32_t, TouchTestResult::iterator>>;
2087 TouchRecoginerTarget items[targetCnt];
2088 int32_t fingers[fingerCnt] = { 0, 1 };
2089 for (int32_t i = 0; i < targetCnt; ++i) {
2090 targetRefs[i] = AceType::MakeRefPtr<TouchEventActuator>();
2091 for (auto& finger : fingers) {
2092 touchTestResult[finger].emplace_front(targetRefs[i]);
2093 items[i].emplace_back(finger, touchTestResult[finger].begin());
2094 }
2095 }
2096 EXPECT_EQ(touchTestResult.size(), fingerCnt);
2097 EXPECT_EQ(touchTestResult[0].size(), targetCnt);
2098 EXPECT_EQ(touchTestResult[1].size(), targetCnt);
2099 eventManager->DispatchTouchCancelToRecognizer(AceType::RawPtr(targetRefs[0]), items[0]);
2100 EXPECT_EQ(touchTestResult.size(), fingerCnt);
2101 EXPECT_EQ(touchTestResult[1].size(), 1);
2102 eventManager->DispatchTouchCancelToRecognizer(AceType::RawPtr(targetRefs[1]), items[1]);
2103 EXPECT_EQ(touchTestResult.size(), 0);
2104 }
2105
2106 /**
2107 * @tc.name: DispatchTouchCancelToRecognizer_ItemsEmpty
2108 * @tc.desc: Test DispatchTouchCancelToRecognizer when items is empty.
2109 * @tc.type: FUNC
2110 */
2111 HWTEST_F(EventManagerTestNg, DispatchTouchCancelToRecognizer_ItemsEmpty, TestSize.Level1)
2112 {
2113 auto eventManager = AceType::MakeRefPtr<EventManager>();
2114 auto& touchTestResult = eventManager->touchTestResults_;
2115 RefPtr<TouchEventActuator> target = AceType::MakeRefPtr<TouchEventActuator>();
2116 using TouchRecognizerTarget = std::vector<std::pair<int32_t, TouchTestResult::iterator>>;
2117
2118 TouchTestResult resultList;
2119 resultList.push_back(target);
2120 touchTestResult[1] = resultList;
2121 TouchRecognizerTarget items;
2122
2123 eventManager->DispatchTouchCancelToRecognizer(AceType::RawPtr(target), items);
2124 EXPECT_EQ(touchTestResult.size(), 1);
2125 EXPECT_EQ(touchTestResult.count(1), 1);
2126 EXPECT_EQ(touchTestResult[1].size(), 1);
2127 }
2128
2129 /**
2130 * @tc.name: DispatchTouchEventTest001
2131 * @tc.desc: Test DispatchTouchEvent
2132 * @tc.type: FUNC
2133 */
2134 HWTEST_F(EventManagerTestNg, DispatchTouchEventTest001, TestSize.Level1)
2135 {
2136 /**
2137 * @tc.steps: step1. Create EventManager.
2138 * @tc.expected: eventManager is not null.
2139 */
2140 auto eventManager = AceType::MakeRefPtr<EventManager>();
2141 ASSERT_NE(eventManager, nullptr);
2142
2143 /**
2144 * @tc.steps: step2. Create TouchEvent and Call DispatchTouchEvent
2145 * @tc.expected: retFlag is false
2146 */
2147 TouchEvent event;
2148 event.type = TouchType::DOWN;
2149 event.sourceType = SourceType::TOUCH;
2150 eventManager->touchTestResults_.clear();
2151 TouchTestResult touchTestResult;
2152 auto firstTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
2153 auto secondTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
2154 touchTestResult.push_back(firstTarget);
2155 touchTestResult.push_back(secondTarget);
2156
2157 eventManager->touchTestResults_[event.id] = touchTestResult;
2158
2159 eventManager->DispatchTouchEvent(event, true);
2160 bool ret = eventManager->passThroughResult_;
2161
2162 event.type = TouchType::UP;
2163 eventManager->touchTestResults_.clear();
2164 eventManager->DispatchTouchEvent(event, true);
2165 EXPECT_NE(ret, !eventManager->touchTestResults_[event.id].empty());
2166 }
2167 } // namespace OHOS::Ace::NG