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
470 /**
471 * @tc.name: GetSetPressedKeyCodesTest001
472 * @tc.desc: Test GetPressedKeyCodes and SetPressedKeyCodes function.
473 * @tc.type: FUNC
474 */
475 HWTEST_F(EventManagerTestNg, GetSetPressedKeyCodesTest001, TestSize.Level1)
476 {
477 /**
478 * @tc.steps: step2. Call SetPressedKeyCodes GetPressedKeyCodes with event.
479 * @tc.expected: pressedKeyCodes size is 2.
480 */
481 BaseEventInfo event("test");
482 event.SetPressedKeyCodes({KeyCode::KEY_CTRL_LEFT, KeyCode::KEY_CTRL_RIGHT});
483 auto pressedKeyCodes = event.GetPressedKeyCodes();
484 EXPECT_EQ(pressedKeyCodes.size(), 2);
485 EXPECT_EQ(pressedKeyCodes[1], KeyCode::KEY_CTRL_RIGHT);
486 }
487
488 /**
489 * @tc.name: EventManagerTest045
490 * @tc.desc: Test PostEventFlushTouchEventEnd function.
491 * @tc.type: FUNC
492 */
493 HWTEST_F(EventManagerTestNg, EventManagerTest045, TestSize.Level1)
494 {
495 /**
496 * @tc.steps: step1. Create EventManager.
497 * @tc.expected: eventManager is not null.
498 */
499 auto eventManager = AceType::MakeRefPtr<EventManager>();
500 ASSERT_NE(eventManager, nullptr);
501
502 /**
503 * @tc.steps: step2. Call PostEventFlushTouchEventEnd with TouchType::DOWN.
504 * @tc.expected: ret is false.
505 */
506 TouchEvent event;
507 event.type = TouchType::DOWN;
508 event.id = 1;
509 TouchTestResult hitTestResult;
510 eventManager->PostEventFlushTouchEventEnd(event);
511
512 /**
513 * @tc.steps: step3. Create pan recognizers.
514 * @tc.expected: recognizers is not null and axis direction is correct.
515 */
516 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
517 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
518 ASSERT_NE(panHorizontal1, nullptr);
519 hitTestResult.emplace_back(panHorizontal1);
520 eventManager->postEventTouchTestResults_[1] = hitTestResult;
521
522 eventManager->PostEventFlushTouchEventEnd(event);
523 EXPECT_TRUE(panHorizontal1->isFlushTouchEventsEnd_);
524 }
525
526 /**
527 * @tc.name: EventManagerTest046
528 * @tc.desc: Test LogTouchTestResultRecognizers function.
529 * @tc.type: FUNC
530 */
531 HWTEST_F(EventManagerTestNg, EventManagerTest046, TestSize.Level1)
532 {
533 /**
534 * @tc.steps: step1. Create EventManager.
535 * @tc.expected: eventManager is not null.
536 */
537 auto eventManager = AceType::MakeRefPtr<EventManager>();
538 ASSERT_NE(eventManager, nullptr);
539
540 /**
541 * @tc.steps: step2. Call LogTouchTestResultRecognizers.
542 * @tc.expected: ret is false.
543 */
544 TouchEvent event;
545 event.type = TouchType::DOWN;
546 event.id = 1;
547 TouchTestResult hitTestResult;
548 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
549 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
550 ASSERT_NE(panHorizontal1, nullptr);
551 hitTestResult.emplace_back(panHorizontal1);
552 std::list<RefPtr<NGGestureRecognizer>> combined;
553 auto exclusiveRecognizer = AceType::MakeRefPtr<ExclusiveRecognizer>(std::move(combined));
554 auto exclusiveRecognizer1 = AceType::MakeRefPtr<ExclusiveRecognizer>(std::move(combined));
555 hitTestResult.emplace_back(exclusiveRecognizer);
556 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
557 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
558 exclusiveRecognizer1->node_ = pageNode;
559 hitTestResult.emplace_back(exclusiveRecognizer1);
560 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
561 hitTestResult.emplace_back(clickRecognizer);
562
563 eventManager->LogTouchTestResultRecognizers(hitTestResult, 1);
564 EXPECT_FALSE(panHorizontal1->isFlushTouchEventsEnd_);
565 }
566
567 /**
568 * @tc.name: EventManagerTest047
569 * @tc.desc: Test DispatchMouseHoverAnimation function.
570 * @tc.type: FUNC
571 */
572 HWTEST_F(EventManagerTestNg, EventManagerTest047, TestSize.Level1)
573 {
574 /**
575 * @tc.steps: step1. Create EventManager.
576 * @tc.expected: eventManager is not null.
577 */
578 auto eventManager = AceType::MakeRefPtr<EventManager>();
579 ASSERT_NE(eventManager, nullptr);
580
581 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
582 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
583 eventManager->mouseHoverNode_ = renderNode;
584
585 MouseEvent event;
586 event.action = MouseAction::PRESS;
587 eventManager->DispatchMouseHoverAnimation(event);
588
589 event.action = MouseAction::RELEASE;
590 eventManager->DispatchMouseHoverAnimation(event);
591
592 event.action = MouseAction::WINDOW_ENTER;
593 eventManager->DispatchMouseHoverAnimation(event);
594
595 event.action = MouseAction::WINDOW_LEAVE;
596
597 eventManager->DispatchMouseHoverAnimation(event);
598 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
599 EXPECT_EQ(hoverNodeCur, nullptr);
600 }
601
602 /**
603 * @tc.name: EventManagerTest048
604 * @tc.desc: Test GetTouchTestIds function.
605 * @tc.type: FUNC
606 */
607 HWTEST_F(EventManagerTestNg, EventManagerTest048, TestSize.Level1)
608 {
609 /**
610 * @tc.steps: step1. Create EventManager.
611 * @tc.expected: eventManager is not null.
612 */
613 auto eventManager = AceType::MakeRefPtr<EventManager>();
614 ASSERT_NE(eventManager, nullptr);
615
616 TouchEvent event;
617 event.type = TouchType::DOWN;
618 event.id = 1;
619 std::vector<std::string> touchTestIds = {"1", "2"};
620 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
621 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
622 ASSERT_NE(panHorizontal1, nullptr);
623 panHorizontal1->getEventTargetImpl_ = std::function<std::optional<EventTarget>()>{};
624
625 TouchTestResult hitTestResult;
626 hitTestResult.emplace_back(panHorizontal1);
627 eventManager->touchTestResults_.emplace(event.id, hitTestResult);
628 bool isMousePressAtSelectedNode = false;
629 eventManager->GetTouchTestIds(event, touchTestIds, isMousePressAtSelectedNode, 1);
630 EXPECT_FALSE(isMousePressAtSelectedNode);
631 }
632
633 /**
634 * @tc.name: EventManagerTest049
635 * @tc.desc: Test FlushTouchEventsBegin function.
636 * @tc.type: FUNC
637 */
638 HWTEST_F(EventManagerTestNg, EventManagerTest049, TestSize.Level1)
639 {
640 /**
641 * @tc.steps: step1. Create EventManager.
642 * @tc.expected: eventManager is not null.
643 */
644 auto eventManager = AceType::MakeRefPtr<EventManager>();
645 ASSERT_NE(eventManager, nullptr);
646
647 TouchEvent event;
648 event.type = TouchType::DOWN;
649 event.id = 1;
650 std::list<TouchEvent> touchEvents = {event};
651 TouchTestResult hitTestResult;
652 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
653 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
654 hitTestResult.emplace_back(panHorizontal1);
655 eventManager->touchTestResults_[2] = hitTestResult;
656 eventManager->FlushTouchEventsBegin(touchEvents);
657 EXPECT_TRUE(eventManager->touchTestResults_.count(2) == 1);
658 }
659
660 /**
661 * @tc.name: EventManagerTest050
662 * @tc.desc: Test CheckMouseTestResults function.
663 * @tc.type: FUNC
664 */
665 HWTEST_F(EventManagerTestNg, EventManagerTest050, TestSize.Level1)
666 {
667 /**
668 * @tc.steps: step1. Create EventManager.
669 * @tc.expected: eventManager is not null.
670 */
671 auto eventManager = AceType::MakeRefPtr<EventManager>();
672 ASSERT_NE(eventManager, nullptr);
673
674 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
675 std::list<RefPtr<MouseEventTarget>> mouseTestResult = {mouseEventTarget};
676 eventManager->currMouseTestResults_ = mouseTestResult;
677
678 bool isMousePressAtSelectedNode = false;
679 eventManager->CheckMouseTestResults(isMousePressAtSelectedNode, NODEID);
680 EXPECT_TRUE(isMousePressAtSelectedNode);
681 isMousePressAtSelectedNode = false;
682 eventManager->CheckMouseTestResults(isMousePressAtSelectedNode, NODEID + 1);
683 EXPECT_FALSE(isMousePressAtSelectedNode);
684 }
685
686 /**
687 * @tc.name: EventManagerTest051
688 * @tc.desc: Test MouseTest function.
689 * @tc.type: FUNC
690 */
691 HWTEST_F(EventManagerTestNg, EventManagerTest051, TestSize.Level1)
692 {
693 /**
694 * @tc.steps: step1. Create EventManager.
695 * @tc.expected: eventManager is not null.
696 */
697 auto eventManager = AceType::MakeRefPtr<EventManager>();
698 ASSERT_NE(eventManager, nullptr);
699
700 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
701 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
702
703 MouseEvent event;
704 event.action = MouseAction::WINDOW_LEAVE;
705 std::list<WeakPtr<RenderNode>> MouseHoverTestList;
706
707 eventManager->MouseTest(event, renderNode);
708
709 event.action = MouseAction::WINDOW_ENTER;
710 eventManager->MouseTest(event, renderNode);
711
712 event.action = MouseAction::NONE;
713 eventManager->MouseTest(event, renderNode);
714 EXPECT_TRUE(eventManager->mouseHoverTestResults_.empty());
715 }
716
717 /**
718 * @tc.name: EventManagerTest052
719 * @tc.desc: Test DispatchMouseEvent function.
720 * @tc.type: FUNC
721 */
722 HWTEST_F(EventManagerTestNg, EventManagerTest052, TestSize.Level1)
723 {
724 /**
725 * @tc.steps: step1. Create EventManager.
726 * @tc.expected: eventManager is not null.
727 */
728 auto eventManager = AceType::MakeRefPtr<EventManager>();
729 ASSERT_NE(eventManager, nullptr);
730
731 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
732 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
733 std::list<WeakPtr<RenderNode>> mouseHoverTestList = {renderNode};
734 MouseEvent event;
735 event.action = MouseAction::WINDOW_LEAVE;
736 EXPECT_FALSE(eventManager->DispatchMouseEvent(event));
737
738 eventManager->mouseHoverTestResults_ = mouseHoverTestList;
739 event.action = MouseAction::MOVE;
740 EXPECT_TRUE(eventManager->DispatchMouseEvent(event));
741 }
742
743 /**
744 * @tc.name: EventManagerTest053
745 * @tc.desc: Test LogPrintMouseTest function.
746 * @tc.type: FUNC
747 */
748 HWTEST_F(EventManagerTestNg, EventManagerTest053, TestSize.Level1)
749 {
750 /**
751 * @tc.steps: step1. Create EventManager.
752 * @tc.expected: eventManager is not null.
753 */
754 auto eventManager = AceType::MakeRefPtr<EventManager>();
755 ASSERT_NE(eventManager, nullptr);
756 SystemProperties::debugEnabled_ = true;
757
758 eventManager->LogPrintMouseTest();
759 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
760 std::list<RefPtr<MouseEventTarget>> MouseTestResult = {mouseEventTarget};
761 eventManager->currMouseTestResults_ = MouseTestResult;
762
763 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(MOUSE, NODEID);
764 std::list<RefPtr<HoverEventTarget>> HoverTestResult = {hoverEventTarget};
765 eventManager->lastHoverTestResults_ = HoverTestResult;
766 eventManager->currHoverTestResults_ = HoverTestResult;
767 eventManager->LogPrintMouseTest();
768 }
769
770 /**
771 * @tc.name: EventManagerTest054
772 * @tc.desc: Test UpdateHoverNode function.
773 * @tc.type: FUNC
774 */
775 HWTEST_F(EventManagerTestNg, EventManagerTest054, TestSize.Level1)
776 {
777 /**
778 * @tc.steps: step1. Create EventManager.
779 * @tc.expected: eventManager is not null.
780 */
781 auto eventManager = AceType::MakeRefPtr<EventManager>();
782 ASSERT_NE(eventManager, nullptr);
783
784 MouseEvent event;
785 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
786 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(MOUSE, NODEID);
787 std::list<RefPtr<TouchEventTarget>> testResult = {AceType::MakeRefPtr<MockTouchEventTarget>(),
788 mouseEventTarget, hoverEventTarget};
789 eventManager->UpdateHoverNode(event, testResult);
790 EXPECT_FALSE((eventManager->currMouseTestResults_).empty());
791 }
792
793 /**
794 * @tc.name: EventManagerTest055
795 * @tc.desc: Test DispatchKeyboardShortcut function.
796 * @tc.type: FUNC
797 */
798 HWTEST_F(EventManagerTestNg, EventManagerTest055, TestSize.Level1)
799 {
800 /**
801 * @tc.steps: step1. Create EventManager.
802 * @tc.expected: eventManager is not null.
803 */
804 auto eventManager = AceType::MakeRefPtr<EventManager>();
805 ASSERT_NE(eventManager, nullptr);
806
807 KeyEvent event;
808 event.action = KeyAction::UP;
809 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
810
811 event.action = KeyAction::DOWN;
812 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
813 frameNode->isActive_ = false;
814
815 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
816 auto frameNode3 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
817 auto eventHub = AceType::MakeRefPtr<EventHub>();
818 frameNode3->eventHub_ = eventHub;
819 eventHub->enabled_ = false;
820
821 std::list<WeakPtr<NG::FrameNode>> keyboardShortcutNode = {nullptr, frameNode, frameNode2, frameNode3};
822 eventManager->keyboardShortcutNode_ = keyboardShortcutNode;
823 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
824 }
825
826 /**
827 * @tc.name: EventManagerTest056
828 * @tc.desc: Test DelKeyboardShortcutNode function.
829 * @tc.type: FUNC
830 */
831 HWTEST_F(EventManagerTestNg, EventManagerTest056, TestSize.Level1)
832 {
833 /**
834 * @tc.steps: step1. Create EventManager.
835 * @tc.expected: eventManager is not null.
836 */
837 auto eventManager = AceType::MakeRefPtr<EventManager>();
838 ASSERT_NE(eventManager, nullptr);
839 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
840 std::list<WeakPtr<NG::FrameNode>> keyboardShortcutNode = {nullptr, frameNode};
841 eventManager->keyboardShortcutNode_ = keyboardShortcutNode;
842
843 eventManager->DelKeyboardShortcutNode(2);
844 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
845 }
846
847 /**
848 * @tc.name: EventManagerTest057
849 * @tc.desc: Test AddGestureSnapshot function.
850 * @tc.type: FUNC
851 */
852 HWTEST_F(EventManagerTestNg, EventManagerTest057, TestSize.Level1)
853 {
854 /**
855 * @tc.steps: step1. Create EventManager.
856 * @tc.expected: eventManager is not null.
857 */
858 auto eventManager = AceType::MakeRefPtr<EventManager>();
859 ASSERT_NE(eventManager, nullptr);
860 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
861 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
862 eventManager->AddGestureSnapshot(1, 1, panHorizontal1, EventTreeType::TOUCH);
863
864 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
865 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
866 mouseEventTarget->node_ = frameNode;
867 eventManager->AddGestureSnapshot(1, 1, mouseEventTarget, EventTreeType::TOUCH);
868
869 eventManager->AddGestureSnapshot(1, 1, nullptr, EventTreeType::TOUCH);
870 EXPECT_TRUE(eventManager->eventTree_.eventTreeList.empty());
871 }
872
873 /**
874 * @tc.name: EventManagerTest058
875 * @tc.desc: Test SetHittedFrameNode function.
876 * @tc.type: FUNC
877 */
878 HWTEST_F(EventManagerTestNg, EventManagerTest058, TestSize.Level1)
879 {
880 /**
881 * @tc.steps: step1. Create EventManager.
882 * @tc.expected: eventManager is not null.
883 */
884 auto eventManager = AceType::MakeRefPtr<EventManager>();
885 ASSERT_NE(eventManager, nullptr);
886
887 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
888 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
889 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
890 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
891 std::list<RefPtr<NG::NGGestureRecognizer>> touchTestResults;
892 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
893 panHorizontal1->node_ = frameNode;
894 touchTestResults.emplace_back(panHorizontal1);
895 touchTestResults.emplace_back(panHorizontal2);
896 eventManager->SetHittedFrameNode(touchTestResults);
897 EXPECT_TRUE(eventManager->eventTree_.eventTreeList.empty());
898 }
899
900 /**
901 * @tc.name: EventManagerTest059
902 * @tc.desc: Test CleanGestureEventHub function.
903 * @tc.type: FUNC
904 */
905 HWTEST_F(EventManagerTestNg, EventManagerTest059, TestSize.Level1)
906 {
907 /**
908 * @tc.steps: step1. Create EventManager.
909 * @tc.expected: eventManager is not null.
910 */
911 auto eventManager = AceType::MakeRefPtr<EventManager>();
912 ASSERT_NE(eventManager, nullptr);
913 std::set<WeakPtr<FrameNode>> hittedFrameNode;
914 eventManager->hittedFrameNode_ = hittedFrameNode;
915 eventManager->CleanGestureEventHub();
916 EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
917
918 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
919 auto frameNode2 = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
920 auto eventHub = AceType::MakeRefPtr<EventHub>();
921 frameNode2->eventHub_ = eventHub;
922 hittedFrameNode.insert(frameNode);
923 hittedFrameNode.insert(frameNode2);
924 hittedFrameNode.insert(nullptr);
925 eventManager->hittedFrameNode_ = hittedFrameNode;
926 eventManager->CleanGestureEventHub();
927 EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
928 }
929
930 /**
931 * @tc.name: EventManagerTest060
932 * @tc.desc: Test CheckAndLogLastReceivedEventInfo function.
933 * @tc.type: FUNC
934 */
935 HWTEST_F(EventManagerTestNg, EventManagerTest060, TestSize.Level1)
936 {
937 /**
938 * @tc.steps: step1. Create EventManager.
939 * @tc.expected: eventManager is not null.
940 */
941 auto eventManager = AceType::MakeRefPtr<EventManager>();
942 ASSERT_NE(eventManager, nullptr);
943 int eventId = 1;
944 bool logImmediately = true;
945
946 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
947 EXPECT_TRUE(eventManager->lastReceivedEvent_.eventId == -1);
948
949 logImmediately = false;
950 eventManager->lastReceivedEvent_.lastLogTimeStamp = 0;
951 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
952 EXPECT_TRUE(eventManager->lastReceivedEvent_.eventId == 1);
953
954 auto currentTime = GetSysTimestamp();
955 auto lastLogTimeStamp = currentTime - 1000 * 1000000 - 1000;
956 eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp;
957 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
958 EXPECT_TRUE(eventManager->lastReceivedEvent_.lastLogTimeStamp > currentTime);
959
960 eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000;
961 eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately);
962 EXPECT_TRUE(eventManager->lastReceivedEvent_.lastLogTimeStamp == lastLogTimeStamp + 20000);
963 }
964
965 /**
966 * @tc.name: EventManagerTest061
967 * @tc.desc: Test CheckAndLogLastConsumedEventInfo function.
968 * @tc.type: FUNC
969 */
970 HWTEST_F(EventManagerTestNg, EventManagerTest061, TestSize.Level1)
971 {
972 /**
973 * @tc.steps: step1. Create EventManager.
974 * @tc.expected: eventManager is not null.
975 */
976 auto eventManager = AceType::MakeRefPtr<EventManager>();
977 ASSERT_NE(eventManager, nullptr);
978 int eventId = 1;
979 bool logImmediately = true;
980
981 eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
982
983 logImmediately = false;
984 eventManager->lastConsumedEvent_.lastLogTimeStamp = 0;
985 eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
986 EXPECT_TRUE(eventManager->lastConsumedEvent_.eventId == 1);
987
988 auto currentTime = GetSysTimestamp();
989 auto lastLogTimeStamp = currentTime - 1000 * 1000000 - 1000;
990 eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp;
991 eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
992 EXPECT_TRUE(eventManager->lastConsumedEvent_.lastLogTimeStamp > currentTime);
993
994 eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000;
995 eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000;
996 eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately);
997 EXPECT_TRUE(eventManager->lastConsumedEvent_.lastLogTimeStamp == lastLogTimeStamp + 20000);
998 }
999
1000 /**
1001 * @tc.name: EventManagerTest062
1002 * @tc.desc: Test SetResponseLinkRecognizers function.
1003 * @tc.type: FUNC
1004 */
1005 HWTEST_F(EventManagerTestNg, EventManagerTest062, TestSize.Level1)
1006 {
1007 /**
1008 * @tc.steps: step1. Create EventManager.
1009 * @tc.expected: eventManager is not null.
1010 */
1011 auto eventManager = AceType::MakeRefPtr<EventManager>();
1012 ASSERT_NE(eventManager, nullptr);
1013
1014 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
1015 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1016 std::list<RefPtr<TouchEventTarget>> result;
1017 ResponseLinkResult responseLinkRecognizers;
1018 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
1019 panHorizontal1->node_ = frameNode;
1020 result.emplace_back(panHorizontal1);
1021 result.emplace_back(nullptr);
1022 responseLinkRecognizers.emplace_back(panHorizontal1);
1023
1024 eventManager->SetResponseLinkRecognizers(result, responseLinkRecognizers);
1025 EXPECT_TRUE(responseLinkRecognizers.size() == 1);
1026 }
1027
1028 /**
1029 * @tc.name: EventManagerTest063
1030 * @tc.desc: Test touchtest
1031 * @tc.type: FUNC
1032 */
1033 HWTEST_F(EventManagerTestNg, EventManagerTest063, TestSize.Level1)
1034 {
1035 /**
1036 * @tc.steps: step1. Create EventManager.
1037 * @tc.expected: eventManager is not null.
1038 */
1039 auto eventManager = AceType::MakeRefPtr<EventManager>();
1040 ASSERT_NE(eventManager, nullptr);
1041
1042 /**
1043 * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id].
1044 * @tc.expected: touchTestResults_ has the touchPoint.id of instance.
1045 */
1046 TouchEvent touchPoint;
1047 touchPoint.id = 1;
1048 touchPoint.type = TouchType::DOWN;
1049 touchPoint.sourceType = SourceType::TOUCH;
1050 auto currentTime = GetSysTimestamp();
1051 auto lastTime = currentTime - 1000 * 1000000 - 1000;
1052 TimeStamp lastTimeStamp((std::chrono::milliseconds(lastTime)));
1053 TimeStamp currentTimeStamp((std::chrono::milliseconds(currentTime)));
1054 eventManager->lastEventTime_ = lastTimeStamp;
1055 touchPoint.time = currentTimeStamp;
1056 const int nodeId = 1;
1057 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, nodeId, nullptr);
1058 TouchRestrict touchRestrict;
1059 Offset offset;
1060 auto clickRecognizer = AceType::MakeRefPtr<ClickRecognizer>();
1061 ASSERT_NE(clickRecognizer, nullptr);
1062 clickRecognizer->OnRejected();
1063 auto gestureRefereeNg = eventManager->GetGestureRefereeNG(clickRecognizer);
1064 ASSERT_NE(gestureRefereeNg, nullptr);
1065 gestureRefereeNg->CheckSourceTypeChange(SourceType::NONE, true);
1066 TouchTestResult resultList = { clickRecognizer };
1067 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
1068 EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
1069 }
1070
1071 /**
1072 * @tc.name: EventManagerTest064
1073 * @tc.desc: Test LogTouchTestResultRecognizers
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(EventManagerTestNg, EventManagerTest064, TestSize.Level1)
1077 {
1078 /**
1079 * @tc.steps: step1. Create EventManager.
1080 * @tc.expected: eventManager is not null.
1081 */
1082 auto eventManager = AceType::MakeRefPtr<EventManager>();
1083 ASSERT_NE(eventManager, nullptr);
1084
1085 /**
1086 * @tc.steps: step2. Call LogTouchTestResultRecognizers.
1087 * @tc.expected: ret is false.
1088 */
1089 TouchEvent event;
1090 event.type = TouchType::DOWN;
1091 event.id = 1;
1092 TouchTestResult resultList;
1093 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1094 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1095 ASSERT_NE(panHorizontal, nullptr);
1096 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1097 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
1098 panHorizontal->AttachFrameNode(pageNode);
1099 resultList.emplace_back(panHorizontal);
1100 eventManager->LogTouchTestResultRecognizers(resultList, 1);
1101 EXPECT_FALSE(panHorizontal->isFlushTouchEventsEnd_);
1102 }
1103
1104 /**
1105 * @tc.name: EventManagerTest065
1106 * @tc.desc: Test HandleGlobalEventNG whith mouse
1107 * @tc.type: FUNC
1108 */
1109 HWTEST_F(EventManagerTestNg, EventManagerTest065, TestSize.Level1)
1110 {
1111 /**
1112 * @tc.steps: step1. Create EventManager.
1113 * @tc.expected: eventManager is not null.
1114 */
1115 auto eventManager = AceType::MakeRefPtr<EventManager>();
1116 ASSERT_NE(eventManager, nullptr);
1117
1118 /**
1119 * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id].
1120 * @tc.expected: touchTestResults_ has the touchPoint.id of instance.
1121 */
1122 TouchEvent touchPoint;
1123 touchPoint.id = 1000;
1124 touchPoint.type = TouchType::DOWN;
1125 touchPoint.sourceType = SourceType::MOUSE;
1126
1127 const int nodeId = 10003;
1128 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
1129 TouchRestrict touchRestrict;
1130 Offset offset;
1131
1132 auto eventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE_EVENT, nodeId);
1133 eventManager->currMouseTestResults_.emplace_back(eventTarget);
1134
1135 /**
1136 * @tc.steps: step3. Create FrameNode and Call HandleGlobalEventNG.
1137 * @tc.expected: currMouseTestResults_.size is equal to 1.
1138 */
1139 auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode);
1140 NG::OffsetF rootOffset;
1141 eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset);
1142 EXPECT_EQ(eventManager->currMouseTestResults_.size(), 1);
1143 }
1144
1145 /**
1146 * @tc.name: EventManagerTest066
1147 * @tc.desc: Test GetTouchTestIds function.
1148 * @tc.type: FUNC
1149 */
1150 HWTEST_F(EventManagerTestNg, EventManagerTest066, TestSize.Level1)
1151 {
1152 /**
1153 * @tc.steps: step1. Create EventManager.
1154 * @tc.expected: eventManager is not null.
1155 */
1156 auto eventManager = AceType::MakeRefPtr<EventManager>();
1157 ASSERT_NE(eventManager, nullptr);
1158
1159 TouchEvent event;
1160 event.type = TouchType::DOWN;
1161 event.id = 1;
1162 std::vector<std::string> touchTestIds;
1163 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1164 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1165 ASSERT_NE(panHorizontal, nullptr);
__anonbe46c4770202() 1166 panHorizontal->SetGetEventTargetImpl([]() -> std::optional<EventTarget> {
1167 struct EventTarget eventTarget = {
1168 .id = "eventTargetCallback",
1169 .type = "eventTargetType"
1170 };
1171 std::optional<EventTarget> eventTargetCallback = eventTarget;
1172 return eventTargetCallback;
1173 });
1174
1175 TouchTestResult hitTestResult;
1176 hitTestResult.emplace_back(panHorizontal);
1177 eventManager->touchTestResults_.insert({event.id, hitTestResult});
1178 bool isMousePressAtSelectedNode = false;
1179 eventManager->GetTouchTestIds(event, touchTestIds, isMousePressAtSelectedNode, 1);
1180 EXPECT_FALSE(isMousePressAtSelectedNode);
1181 EXPECT_FALSE(touchTestIds.empty());
1182 }
1183
1184 /**
1185 * @tc.name: EventManagerTest067
1186 * @tc.desc: Test HandleOutOfRectCallback
1187 * @tc.type: FUNC
1188 */
1189 HWTEST_F(EventManagerTestNg, EventManagerTest067, TestSize.Level2)
1190 {
1191 /**
1192 * @tc.steps: step1. Create EventManager.
1193 * @tc.expected: eventManager is not null.
1194 */
1195 auto eventManager = AceType::MakeRefPtr<EventManager>();
1196 ASSERT_NE(eventManager, nullptr);
1197
1198 /**
1199 * @tc.steps: step2. Create rectCallbackList
1200 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
1201 */
1202 Point point(10, 20);
1203 point.SetSourceType(SourceType::TOUCH);
1204
__anonbe46c4770302(std::vector<Rect>& rectList) 1205 auto rectGetCallback = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect()); };
1206
__anonbe46c4770402() 1207 auto touchCallback = []() -> void {};
__anonbe46c4770502() 1208 auto mouseCallback = []() -> void {};
1209 std::vector<RectCallback> rectCallbackList {
1210 RectCallback(rectGetCallback, touchCallback, nullptr),
1211 RectCallback(rectGetCallback, nullptr, mouseCallback)
1212 };
1213
1214 /**
1215 * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::TOUCH
1216 * @tc.expected: rectCallbackList.size() is 1
1217 */
1218 eventManager->HandleOutOfRectCallback(point, rectCallbackList);
1219 EXPECT_EQ(rectCallbackList.size(), 1);
1220
1221 /**
1222 * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::MOUSE
1223 * @tc.expected: rectCallbackList is empty
1224 */
1225 point.SetSourceType(SourceType::MOUSE);
1226 eventManager->HandleOutOfRectCallback(point, rectCallbackList);
1227 EXPECT_TRUE(rectCallbackList.empty());
1228 }
1229
1230 /**
1231 * @tc.name: EventManagerTest068
1232 * @tc.desc: Test DispatchTouchEventToTouchTestResult
1233 * @tc.type: FUNC
1234 */
1235 HWTEST_F(EventManagerTestNg, EventManagerTest068, TestSize.Level1)
1236 {
1237 auto eventManager = AceType::MakeRefPtr<EventManager>();
1238 ASSERT_NE(eventManager, nullptr);
1239 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1240 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1241 ASSERT_NE(panHorizontal, nullptr);
1242 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1243 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
1244 int64_t deviceId = 20240711;
1245 TouchEvent event;
1246 event.type = TouchType::DOWN;
1247 event.deviceId = deviceId;
1248 event.sourceType = SourceType::TOUCH;
1249 panHorizontal->AttachFrameNode(pageNode);
1250
1251 TouchTestResult resultList;
1252 resultList.emplace_back(panHorizontal);
1253 eventManager->DispatchTouchEventToTouchTestResult(event, resultList, false);
1254 EXPECT_EQ(panHorizontal->deviceId_, deviceId);
1255 EXPECT_TRUE(panHorizontal->deviceType_ == SourceType::TOUCH);
1256 }
1257
1258 /**
1259 * @tc.name: EventManagerTest069
1260 * @tc.desc: Test PostEventDispatchTouchEvent
1261 * @tc.type: FUNC
1262 */
1263 HWTEST_F(EventManagerTestNg, EventManagerTest069, TestSize.Level2)
1264 {
1265 auto eventManager = AceType::MakeRefPtr<EventManager>();
1266 ASSERT_NE(eventManager, nullptr);
1267 auto rawHorizontal = AceType::MakeRefPtr<RawRecognizer>();
1268 ASSERT_NE(rawHorizontal, nullptr);
1269 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1270 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1271 ASSERT_NE(panHorizontal, nullptr);
1272 TouchEvent event;
1273 event.id = 1024;
1274 event.type = TouchType::DOWN;
1275 event.sourceType = SourceType::TOUCH;
1276 EXPECT_FALSE(eventManager->PostEventDispatchTouchEvent(event));
1277
__anonbe46c4770602() 1278 rawHorizontal->SetCatchEventCallback([]() {},
1279 static_cast<int32_t>(EventStage::CAPTURE), static_cast<int32_t>(EventType::TOUCH_DOWN));
1280 TouchTestResult resultList;
1281 resultList.emplace_back(panHorizontal);
1282 resultList.emplace_back(rawHorizontal);
1283 eventManager->postEventTouchTestResults_.emplace(event.id, resultList);
1284 EXPECT_TRUE(eventManager->PostEventDispatchTouchEvent(event));
1285 }
1286
1287 /**
1288 * @tc.name: EventManagerTest070
1289 * @tc.desc: Test MouseTest For API12.
1290 * @tc.type: FUNC
1291 */
1292 HWTEST_F(EventManagerTestNg, EventManagerTest070, TestSize.Level1)
1293 {
1294 /**
1295 * @tc.steps: step1. Create EventManager.
1296 * @tc.expected: eventManager is not null.
1297 */
1298 auto eventManager = AceType::MakeRefPtr<EventManager>();
1299 ASSERT_NE(eventManager, nullptr);
1300 int32_t settingApiVersion = 12;
1301 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion();
1302 AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion);
1303
1304 auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
1305 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
1306
1307 MouseEvent event;
1308 event.action = MouseAction::MOVE;
1309 event.button = MouseButton::RIGHT_BUTTON;
1310 TouchRestrict touchRestrict;
1311 eventManager->MouseTest(event, pageNode, touchRestrict);
1312
1313 event.action = MouseAction::WINDOW_ENTER;
1314 eventManager->MouseTest(event, pageNode, touchRestrict);
1315 EXPECT_TRUE(touchRestrict.touchEvent.isMouseTouchTest);
1316 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion);
1317 }
1318
1319 /**
1320 * @tc.name: EventManagerTest071
1321 * @tc.desc: Test UpdateHoverNode
1322 * @tc.type: FUNC
1323 */
1324 HWTEST_F(EventManagerTestNg, EventManagerTest071, TestSize.Level1)
1325 {
1326 auto eventManager = AceType::MakeRefPtr<EventManager>();
1327 ASSERT_NE(eventManager, nullptr);
1328
1329 MouseEvent event;
1330 auto hoverEffectTarget = AceType::MakeRefPtr<HoverEffectTarget>(CTRLSHIFT, NODEID);
1331 std::list<RefPtr<TouchEventTarget>> testResult = { hoverEffectTarget };
1332 eventManager->UpdateHoverNode(event, testResult);
1333 EXPECT_TRUE(eventManager->currMouseTestResults_.empty());
1334 }
1335
1336 /**
1337 * @tc.name: EventManagerTest073
1338 * @tc.desc: Test AddKeyboardShortcutNode
1339 * @tc.type: FUNC
1340 */
1341 HWTEST_F(EventManagerTestNg, EventManagerTest073, TestSize.Level2)
1342 {
1343 auto eventManager = AceType::MakeRefPtr<EventManager>();
1344 auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
1345 auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, NODEID, nullptr);
1346 frameNodeCtrl->SetActive(true);
1347 frameNodeCtrlShift->SetActive(true);
1348
1349 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
1350 eventManager->AddKeyboardShortcutNode(nullptr);
1351 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
1352 EXPECT_EQ(eventManager->keyboardShortcutNode_.size(), 1);
1353 }
1354
1355 /**
1356 * @tc.name: EventManagerTest074
1357 * @tc.desc: Test DispatchKeyboardShortcut
1358 * @tc.type: FUNC
1359 */
1360 HWTEST_F(EventManagerTestNg, EventManagerTest074, TestSize.Level1)
1361 {
1362 auto eventManager = AceType::MakeRefPtr<EventManager>();
1363 KeyEvent event;
1364 auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
1365 auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NODEID, nullptr);
1366 auto frameNodeAlt = FrameNode::GetOrCreateFrameNode(ALT, NODEID, nullptr);
1367 auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, NODEID, nullptr);
1368 frameNodeCtrl->SetActive(true);
1369 frameNodeShift->SetActive(true);
1370 frameNodeAlt->SetActive(true);
1371 frameNodeCtrlShift->SetActive(true);
1372
1373 auto eventHubCtrl = frameNodeCtrl->GetEventHub<NG::EventHub>();
1374 auto eventHubShift = frameNodeShift->GetEventHub<NG::EventHub>();
1375 auto eventHubAlt = frameNodeAlt->GetEventHub<NG::EventHub>();
1376 auto eventHubCtrlShift = frameNodeCtrlShift->GetEventHub<NG::EventHub>();
1377
1378 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
1379 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
1380 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeAlt));
1381 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
1382 eventHubCtrl->SetKeyboardShortcut(CHARACTER_C, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE + NUM_ALT_VALUE), nullptr);
1383 event.code = KeyCode::KEY_C;
1384 event.action = KeyAction::DOWN;
1385 event.pressedCodes.emplace_back(KeyCode::KEY_CTRL_LEFT);
1386 event.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
1387 event.pressedCodes.emplace_back(KeyCode::KEY_ALT_LEFT);
1388 event.pressedCodes.emplace_back(KeyCode::KEY_C);
1389 eventManager->DispatchKeyboardShortcut(event);
1390 EXPECT_EQ(event.action, KeyAction::DOWN);
1391 }
1392
1393 /**
1394 * @tc.name: EventManagerTest075
1395 * @tc.desc: Test DispatchKeyboardShortcut
1396 * @tc.type: FUNC
1397 */
1398 HWTEST_F(EventManagerTestNg, EventManagerTest075, TestSize.Level2)
1399 {
1400 auto eventManager = AceType::MakeRefPtr<EventManager>();
1401 KeyEvent event;
1402 event.action = KeyAction::CLICK;
1403 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1404
1405 auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
1406 auto eventHubCtrl = frameNodeCtrl->GetEventHub<NG::EventHub>();
1407 frameNodeCtrl->SetActive(true);
1408
1409 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
1410 uint8_t singleKeys = 0;
1411 eventHubCtrl->SetKeyboardShortcut(CTRL, singleKeys, nullptr);
1412 event.action = KeyAction::DOWN;
1413 event.code = KeyCode::KEY_ESCAPE;
1414 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1415
1416 eventHubCtrl->SetKeyboardShortcut(std::string(), (NUM_CTRL_VALUE + NUM_SHIFT_VALUE), nullptr);
1417 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1418
1419 eventHubCtrl->SetEnabled(false);
1420 EXPECT_FALSE(eventManager->DispatchKeyboardShortcut(event));
1421 }
1422
1423 /**
1424 * @tc.name: EventManagerTest076
1425 * @tc.desc: Test EventManager constructor fire callBack
1426 * @tc.type: FUNC
1427 */
1428 HWTEST_F(EventManagerTestNg, EventManagerTest076, TestSize.Level1)
1429 {
1430 auto eventManager = AceType::MakeRefPtr<EventManager>();
1431 ASSERT_NE(eventManager, nullptr);
1432 auto referee = eventManager->GetGestureReferee();
1433 ASSERT_NE(referee, nullptr);
1434 int32_t touchId = 10;
1435 EXPECT_NE(referee->queryStateFunc_, nullptr);
1436 referee->queryStateFunc_(touchId);
1437 auto gestureRefereeNg = eventManager->GetGestureRefereeNG(AceType::MakeRefPtr<ClickRecognizer>());
1438 ASSERT_NE(gestureRefereeNg, nullptr);
1439 EXPECT_NE(gestureRefereeNg->queryStateFunc_, nullptr);
1440 gestureRefereeNg->queryStateFunc_(touchId);
1441 }
1442
1443 /**
1444 * @tc.name: EventManagerTest077
1445 * @tc.desc: Test AddGestureSnapshot
1446 * @tc.type: FUNC
1447 */
1448 HWTEST_F(EventManagerTestNg, EventManagerTest077, TestSize.Level1)
1449 {
1450 auto eventManager = AceType::MakeRefPtr<EventManager>();
1451 ASSERT_NE(eventManager, nullptr);
1452 auto eventTree = eventManager->GetEventTreeRecord(EventTreeType::TOUCH);
1453 TouchEvent event;
1454 event.type = Ace::TouchType::DOWN;
1455 event.id = 1;
1456 eventTree.AddTouchPoint(event);
1457 eventManager->DumpEvent(EventTreeType::TOUCH);
1458
1459 int32_t finger = 1;
1460 int32_t depth = 0;
1461 int32_t nodeId = 16;
1462 eventManager->AddGestureSnapshot(finger, depth, nullptr, EventTreeType::TOUCH);
1463 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1464 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1465 eventManager->AddGestureSnapshot(finger, depth, recognizerGroup, EventTreeType::TOUCH);
1466 EXPECT_FALSE(eventTree.eventTreeList.empty());
1467 }
1468
1469 /**
1470 * @tc.name: EventManagerTest078
1471 * @tc.desc: Test SetHittedFrameNode
1472 * @tc.type: FUNC
1473 */
1474 HWTEST_F(EventManagerTestNg, EventManagerTest078, TestSize.Level1)
1475 {
1476 auto eventManager = AceType::MakeRefPtr<EventManager>();
1477 ASSERT_NE(eventManager, nullptr);
1478
1479 int32_t nodeId = 16;
1480 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1481 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1482
1483 std::list<RefPtr<NG::NGGestureRecognizer>> gestureRecognizers;
1484 eventManager->SetHittedFrameNode(gestureRecognizers);
1485 EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
1486
1487 gestureRecognizers.emplace_back(recognizerGroup);
1488 eventManager->SetHittedFrameNode(gestureRecognizers);
1489 EXPECT_FALSE(eventManager->hittedFrameNode_.empty());
1490 }
1491
1492 /**
1493 * @tc.name: EventManagerTest079
1494 * @tc.desc: Test CleanGestureEventHub
1495 * @tc.type: FUNC
1496 */
1497 HWTEST_F(EventManagerTestNg, EventManagerTest079, TestSize.Level1)
1498 {
1499 auto eventManager = AceType::MakeRefPtr<EventManager>();
1500 ASSERT_NE(eventManager, nullptr);
1501
1502 int32_t nodeId = 16;
1503 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1504 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1505
1506 std::list<RefPtr<NG::NGGestureRecognizer>> gestureRecognizers;
1507 gestureRecognizers.emplace_back(recognizerGroup);
1508 eventManager->SetHittedFrameNode(gestureRecognizers);
1509 EXPECT_FALSE(eventManager->hittedFrameNode_.empty());
1510 eventManager->CleanGestureEventHub();
1511 EXPECT_TRUE(eventManager->hittedFrameNode_.empty());
1512 }
1513
1514 /**
1515 * @tc.name: EventManagerTest080
1516 * @tc.desc: Test SetResponseLinkRecognizers
1517 * @tc.type: FUNC
1518 */
1519 HWTEST_F(EventManagerTestNg, EventManagerTest080, TestSize.Level1)
1520 {
1521 auto eventManager = AceType::MakeRefPtr<EventManager>();
1522 ASSERT_NE(eventManager, nullptr);
1523
1524 int32_t nodeId = 16;
1525 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1526 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1527 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1528 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1529 auto targetLinkHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1530 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1531
1532 TouchTestResult resultList;
1533 ResponseLinkResult responseLinkRecognizers;
1534 resultList.emplace_back(recognizerGroup);
1535 resultList.emplace_back(panHorizontal);
1536 responseLinkRecognizers.emplace_back(targetLinkHorizontal);
1537 eventManager->SetResponseLinkRecognizers(resultList, responseLinkRecognizers);
1538 EXPECT_TRUE(responseLinkRecognizers.size() == 1);
1539 }
1540
1541 /**
1542 * @tc.name: EventManagerTest081
1543 * @tc.desc: Test FalsifyCancelEventAndDispatch
1544 * @tc.type: FUNC
1545 */
1546 HWTEST_F(EventManagerTestNg, EventManagerTest081, TestSize.Level1)
1547 {
1548 auto eventManager = AceType::MakeRefPtr<EventManager>();
1549 ASSERT_NE(eventManager, nullptr);
1550
1551 int32_t nodeId = 32;
1552 auto parentNode = CreateFrameNodeGroup(nodeId, 3);
1553 auto recognizerGroup = CreateRecognizerGroup(parentNode);
1554 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1555 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1556 TouchTestResult resultList;
1557 resultList.emplace_back(recognizerGroup);
1558 resultList.emplace_back(panHorizontal);
1559 eventManager->axisTouchTestResults_.clear();
1560 eventManager->axisTouchTestResults_[0] = resultList;
1561 AxisEvent event;
1562 eventManager->FalsifyCancelEventAndDispatch(event);
1563 EXPECT_TRUE(eventManager->axisTouchTestResults_.empty());
1564 }
1565
1566 /**
1567 * @tc.name: EventManagerAccessibilityHoverTest001
1568 * @tc.desc: Test MouseTest (frameNode)
1569 * @tc.type: FUNC
1570 */
1571 HWTEST_F(EventManagerTestNg, EventManagerAccessibilityHoverTest001, TestSize.Level1)
1572 {
1573 /**
1574 * @tc.steps: step1. Create EventManager.
1575 * @tc.expected: eventManager is not null.
1576 */
1577 auto eventManager = AceType::MakeRefPtr<EventManager>();
1578 ASSERT_NE(eventManager, nullptr);
1579
1580 /**
1581 * @tc.steps: step2. Call MouseTest with MouseAction::WINDOW_LEAVE
1582 * @tc.expected: currHoverTestResults_ is empty
1583 */
1584 TouchEvent event;
1585 const int nodeId = 10008;
1586 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
1587 TouchRestrict touchRestrict;
1588
1589 event.type = TouchType::HOVER_EXIT;
1590 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(V2::LOCATION_BUTTON_ETS_TAG, nodeId);
1591 eventManager->curAccessibilityHoverResults_.push_back(hoverEventTarget);
1592 EXPECT_FALSE(eventManager->curAccessibilityHoverResults_.empty());
1593 eventManager->AccessibilityHoverTest(event, frameNode, touchRestrict);
1594 EXPECT_TRUE(eventManager->curAccessibilityHoverResults_.empty());
1595
1596 /**
1597 * @tc.steps: step3. Call MouseTest with MouseAction::WINDOW_ENTER
1598 * @tc.expected: lastHoverTestResults_ is empty
1599 */
1600 event.type = TouchType::HOVER_ENTER;
1601 eventManager->lastAccessibilityHoverResults_.push_back(hoverEventTarget);
1602 EXPECT_FALSE(eventManager->lastAccessibilityHoverResults_.empty());
1603 eventManager->AccessibilityHoverTest(event, frameNode, touchRestrict);
1604 EXPECT_TRUE(eventManager->lastAccessibilityHoverResults_.empty());
1605
1606 /**
1607 * @tc.steps: step4. Call MouseTest with MouseAction::HOVER
1608 * @tc.expected: lastHoverTestResults_ is empty and currHoverTestResults_ is empty
1609 */
1610 event.type = TouchType::HOVER_MOVE;
1611 eventManager->lastAccessibilityHoverResults_.push_back(hoverEventTarget);
1612 eventManager->AccessibilityHoverTest(event, frameNode, touchRestrict);
1613 EXPECT_TRUE(eventManager->lastAccessibilityHoverResults_.empty());
1614 EXPECT_TRUE(eventManager->curAccessibilityHoverResults_.empty());
1615 }
1616
1617 /**
1618 * @tc.name: EventManagerTest082
1619 * @tc.desc: Test CheckDownEvent with FrameNode
1620 * @tc.type: FUNC
1621 */
1622 HWTEST_F(EventManagerTestNg, EventManagerTest082, TestSize.Level1)
1623 {
1624 auto eventManager = AceType::MakeRefPtr<EventManager>();
1625 bool result = true;
1626 ASSERT_NE(eventManager, nullptr);
1627 TouchEvent touchPoint;
1628 touchPoint.id = 1;
1629 touchPoint.type = TouchType::DOWN;
1630 eventManager->CheckDownEvent(touchPoint);
1631 eventManager->downFingerIds_[1] = 1;
1632 eventManager->downFingerIds_[2] = 2;
1633 eventManager->downFingerIds_[3] = 3;
1634 eventManager->CheckDownEvent(touchPoint);
1635 touchPoint.type = TouchType::UP;
1636 eventManager->CheckDownEvent(touchPoint);
1637 EXPECT_TRUE(result);
1638 }
1639
1640 /**
1641 * @tc.name: EventManagerTest083
1642 * @tc.desc: Test DispatchAccessibilityHoverEventNG with FrameNode
1643 * @tc.type: FUNC
1644 */
1645 HWTEST_F(EventManagerTestNg, EventManagerTest083, TestSize.Level1)
1646 {
1647 auto eventManager = AceType::MakeRefPtr<EventManager>();
1648 ASSERT_NE(eventManager, nullptr);
1649 bool result = true;
1650 TouchEvent event;
1651 const int nodeId = 10008;
1652 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(V2::LOCATION_BUTTON_ETS_TAG, nodeId);
1653 ASSERT_NE(hoverEventTarget, nullptr);
1654 eventManager->lastAccessibilityHoverResults_.push_back(hoverEventTarget);
1655 eventManager->DispatchAccessibilityHoverEventNG(event);
1656 eventManager->curAccessibilityHoverResults_.push_back(hoverEventTarget);
1657 eventManager->DispatchAccessibilityHoverEventNG(event);
1658 eventManager->lastAccessibilityHoverDispatchLength_ = 1;
1659 eventManager->DispatchAccessibilityHoverEventNG(event);
1660 eventManager->lastAccessibilityHoverDispatchLength_ = 10;
1661 eventManager->DispatchAccessibilityHoverEventNG(event);
1662 eventManager->curAccessibilityHoverResults_.clear();
1663 eventManager->lastAccessibilityHoverResults_.clear();
1664 eventManager->curAccessibilityHoverResults_.push_front(hoverEventTarget);
1665 eventManager->DispatchAccessibilityHoverEventNG(event);
1666 EXPECT_TRUE(result);
1667 }
1668
1669 /**
1670 * @tc.name: EventManagerTest084
1671 * @tc.desc: Test DispatchRotationEvent
1672 * @tc.type: FUNC
1673 */
1674 HWTEST_F(EventManagerTestNg, EventManagerTest084, TestSize.Level1)
1675 {
1676 auto eventManager = AceType::MakeRefPtr<EventManager>();
1677 ASSERT_NE(eventManager, nullptr);
1678 auto referee = eventManager->GetGestureReferee();
1679 ASSERT_NE(referee, nullptr);
1680 int32_t touchId = 10;
1681 RefPtr<GestureScope> scope = AceType::MakeRefPtr<GestureScope>(touchId);
1682 ASSERT_NE(scope, nullptr);
1683 referee->gestureScopes_.clear();
1684 referee->gestureScopes_.insert(std::make_pair(touchId, scope));
1685 auto gestureScope = referee->GetGestureScope();
1686 EXPECT_NE(referee->queryStateFunc_, nullptr);
1687 referee->queryStateFunc_(touchId);
1688 auto gestureRefereeNg = eventManager->GetGestureRefereeNG(AceType::MakeRefPtr<ClickRecognizer>());
1689 ASSERT_NE(gestureRefereeNg, nullptr);
1690 EXPECT_NE(gestureRefereeNg->queryStateFunc_, nullptr);
1691 gestureRefereeNg->queryStateFunc_(touchId);
1692 }
1693
1694 /**
1695 * @tc.name: EventManagerTest085
1696 * @tc.desc: Test RecordHitEmptyMessage
1697 * @tc.type: FUNC
1698 */
1699 HWTEST_F(EventManagerTestNg, EventManagerTest085, TestSize.Level1)
1700 {
1701 auto eventManager = AceType::MakeRefPtr<EventManager>();
1702 ASSERT_NE(eventManager, nullptr);
1703 TouchEvent touchPoint;
1704 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 1, nullptr);
1705 MockPipelineContext::SetUp();
1706 ASSERT_NE(MockPipelineContext::GetCurrentContext(), nullptr);
1707 MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrentContext();
1708 std::string resultInfo = "info";
1709 eventManager->RecordHitEmptyMessage(touchPoint, resultInfo, frameNode);
1710 MockPipelineContext::GetCurrentContext()->window_ = std::make_shared<MockWindow>();
1711 auto frontend = AceType::MakeRefPtr<MockFrontend>();
1712 EXPECT_CALL(*MockContainer::Current(), GetFrontend()).WillRepeatedly(Return(frontend));
1713 eventManager->RecordHitEmptyMessage(touchPoint, resultInfo, frameNode);
1714 EXPECT_CALL(*MockContainer::Current(), GetFrontend()).WillRepeatedly(Return(nullptr));
1715 MockContainer::Current()->pipelineContext_ = nullptr;
1716 MockPipelineContext::TearDown();
1717 EXPECT_EQ(touchPoint.isFalsified, false);
1718 }
1719
1720 /**
1721 * @tc.name: EventManagerTest086
1722 * @tc.desc: Test DispatchTouchEvent
1723 * @tc.type: FUNC
1724 */
1725 HWTEST_F(EventManagerTestNg, EventManagerTest086, TestSize.Level1)
1726 {
1727 auto eventManager = AceType::MakeRefPtr<EventManager>();
1728 ASSERT_NE(eventManager, nullptr);
1729 AxisEvent touchPoint;
1730 touchPoint.action = AxisAction::BEGIN;
1731 touchPoint.id = MOUSE_BASE_ID;
1732 TouchTestResult hitTestResult;
1733 hitTestResult.clear();
1734 eventManager->axisTouchTestResults_.clear();
1735 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1736 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1737 ASSERT_NE(panHorizontal, nullptr);
1738 auto panHorizontals = AceType::MakeRefPtr<PanRecognizer>(
1739 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1740 ASSERT_NE(panHorizontals, nullptr);
1741 hitTestResult.emplace_back(panHorizontals);
1742 hitTestResult.emplace_back(panHorizontal);
1743 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
1744 eventManager->DispatchTouchEvent(touchPoint);
1745 eventManager->refereeNG_ = nullptr;
1746 eventManager->DispatchTouchEvent(touchPoint);
1747 auto container = Container::Current();
1748 ASSERT_NE(container, nullptr);
1749 container->useNewPipeline_ = false;
1750 eventManager->DispatchTouchEvent(touchPoint);
1751 touchPoint.isRotationEvent = true;
1752 eventManager->DispatchTouchEvent(touchPoint);
1753 EXPECT_EQ(touchPoint.isRotationEvent, true);
1754 }
1755
1756 /**
1757 * @tc.name: EventManagerTest087
1758 * @tc.desc: Test DispatchKeyboardShortcut
1759 * @tc.type: FUNC
1760 */
1761 HWTEST_F(EventManagerTestNg, EventManagerTest087, TestSize.Level1)
1762 {
1763 auto eventManager = AceType::MakeRefPtr<EventManager>();
1764 ASSERT_NE(eventManager, nullptr);
1765 KeyEvent touchPoint;
1766 auto container = Container::GetContainer(eventManager->instanceId_);
1767 ASSERT_NE(container, nullptr);
1768 container->uIContentType_ = UIContentType::SECURITY_UI_EXTENSION;
1769 eventManager->DispatchKeyboardShortcut(touchPoint);
1770 EXPECT_EQ(eventManager->DispatchKeyboardShortcut(touchPoint), false);
1771 }
1772
1773 /**
1774 * @tc.name: EventManagerTest088
1775 * @tc.desc: Test TouchTest
1776 * @tc.type: FUNC
1777 */
1778 HWTEST_F(EventManagerTestNg, EventManagerTest088, TestSize.Level1)
1779 {
1780 auto eventManager = AceType::MakeRefPtr<EventManager>();
1781 ASSERT_NE(eventManager, nullptr);
1782 TouchEvent touchPoint;
1783 touchPoint.id = 1000;
1784 touchPoint.type = TouchType::DOWN;
1785 const int nodeId = 10003;
1786 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
1787 TouchRestrict touchRestrict;
1788 Offset offset;
1789 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(V2::LOCATION_BUTTON_ETS_TAG, nodeId);
1790 ASSERT_NE(hoverEventTarget, nullptr);
1791 eventManager->curAccessibilityHoverResults_.push_back(hoverEventTarget);
1792 TouchTestResult hitTestResult;
1793 hitTestResult.clear();
1794 eventManager->touchTestResults_.clear();
1795 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1796 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1797 ASSERT_NE(panHorizontal, nullptr);
1798 auto panHorizontals = AceType::MakeRefPtr<PanRecognizer>(
1799 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1800 ASSERT_NE(panHorizontals, nullptr);
1801 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
1802 panHorizontals->node_ = frameNode;
1803 hitTestResult.emplace_back(panHorizontals);
1804 hitTestResult.emplace_back(panHorizontal);
1805 eventManager->touchTestResults_[1000] = std::move(hitTestResult);
1806 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
1807 EXPECT_EQ(touchPoint.isFalsified, false);
1808 }
1809
1810 #ifdef SUPPORT_DIGITAL_CROWN
1811 /**
1812 * @tc.name: EventManagerTest089
1813 * @tc.desc: Test OnCrownEvent
1814 * @tc.type: FUNC
1815 */
1816 HWTEST_F(EventManagerTestNg, EventManagerTest089, TestSize.Level1)
1817 {
1818 /**
1819 * @tc.steps: step1. Create EventManager.
1820 * @tc.expected: eventManager is not null.
1821 */
1822 auto eventManager = AceType::MakeRefPtr<EventManager>();
1823 ASSERT_NE(eventManager, nullptr);
1824
1825 /**
1826 * @tc.steps: step2. Call OnCrownEvent.
1827 * @tc.expected: ret is false.
1828 */
1829 CrownEvent event;
1830 bool ret = eventManager->OnCrownEvent(event);
1831 EXPECT_FALSE(ret);
1832
1833 /**
1834 * @tc.steps: step3. Call OnCrownEvent.
1835 * @tc.expected: ret is true.
1836 */
1837 MockPipelineContext::SetUp();
1838 ASSERT_NE(MockPipelineContext::GetCurrentContext(), nullptr);
1839 MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrentContext();
1840 ret = eventManager->OnCrownEvent(event);
1841 EXPECT_TRUE(ret);
1842
1843 /**
1844 * @tc.steps: step4. Call OnCrownEvent. pipelineContext is nullptr
1845 * @tc.expected: ret is false.
1846 */
1847 MockContainer::Current()->pipelineContext_ = nullptr;
1848 ret = eventManager->OnCrownEvent(event);
1849 EXPECT_FALSE(ret);
1850 MockPipelineContext::TearDown();
1851 }
1852 #endif
1853
1854 /**
1855 * @tc.name: CleanRecognizersForDragBeginTest001
1856 * @tc.desc: Test CleanRecognizersForDragBegin
1857 * @tc.type: FUNC
1858 */
1859 HWTEST_F(EventManagerTestNg, CleanRecognizersForDragBeginTest001, TestSize.Level1)
1860 {
1861 /**
1862 * @tc.steps: step1. Create EventManager.
1863 * @tc.expected: eventManager is not null.
1864 */
1865 auto eventManager = AceType::MakeRefPtr<EventManager>();
1866 ASSERT_NE(eventManager, nullptr);
1867 eventManager->downFingerIds_.clear();
1868 eventManager->touchTestResults_.clear();
1869
1870 /**
1871 * @tc.steps: step2. Call CleanRecognizersForDragBegin.
1872 * @tc.expected: downFingerIds_ erase id.
1873 */
1874 TouchEvent event;
1875 event.id = 100;
1876 event.type = TouchType::CANCEL;
1877 eventManager->downFingerIds_[event.id] = event.id;
1878 eventManager->CleanRecognizersForDragBegin(event);
1879 EXPECT_EQ(eventManager->downFingerIds_.size(), 0);
1880
1881 /**
1882 * @tc.steps: step3. Call CleanRecognizersForDragBegin.
1883 * @tc.expected: pan recognizer actionCancel called.
1884 */
1885 TouchTestResult resultList;
1886 auto panRecognizer = AceType::MakeRefPtr<PanRecognizer>(
1887 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1888 ASSERT_NE(panRecognizer, nullptr);
1889 panRecognizer->refereeState_ = RefereeState::SUCCEED;
1890 panRecognizer->fingersId_.insert(event.id);
1891 panRecognizer->currentFingers_ = 1;
1892 bool unknownPropertyValue = false;
__anonbe46c4770702(GestureEvent& info) 1893 GestureEventFunc actionCancel = [&unknownPropertyValue](GestureEvent& info) { unknownPropertyValue = true; };
1894 panRecognizer->SetOnActionCancel(actionCancel);
1895 resultList.emplace_back(panRecognizer);
1896 eventManager->touchTestResults_.emplace(event.id, resultList);
1897 eventManager->downFingerIds_[event.id] = event.id;
1898 eventManager->CleanRecognizersForDragBegin(event);
1899 EXPECT_EQ(eventManager->downFingerIds_.size(), 0);
1900 EXPECT_TRUE(unknownPropertyValue);
1901 }
1902
1903 /**
1904 * @tc.name: DispatchTouchCancelToRecognizerTest
1905 * @tc.desc: Test DispatchTouchCancelToRecognizer
1906 * @tc.type: FUNC
1907 */
1908 HWTEST_F(EventManagerTestNg, DispatchTouchCancelToRecognizer, TestSize.Level1)
1909 {
1910 auto eventManager = AceType::MakeRefPtr<EventManager>();
1911 auto& touchTestResult = eventManager->touchTestResults_;
1912 const uint8_t targetCnt = 2; // defines 2 touch target;
1913 const uint8_t fingerCnt = 2; // defines 2 fingers;
1914 RefPtr<TouchEventActuator> targetRefs[targetCnt];
1915 using TouchRecoginerTarget = std::vector<std::pair<int32_t, TouchTestResult::iterator>>;
1916 TouchRecoginerTarget items[targetCnt];
1917 int32_t fingers[fingerCnt] = { 0, 1 };
1918 for (int32_t i = 0; i < targetCnt; ++i) {
1919 targetRefs[i] = AceType::MakeRefPtr<TouchEventActuator>();
1920 for (auto& finger : fingers) {
1921 touchTestResult[finger].emplace_front(targetRefs[i]);
1922 items[i].emplace_back(finger, touchTestResult[finger].begin());
1923 }
1924 }
1925 EXPECT_EQ(touchTestResult.size(), fingerCnt);
1926 EXPECT_EQ(touchTestResult[0].size(), targetCnt);
1927 EXPECT_EQ(touchTestResult[1].size(), targetCnt);
1928 eventManager->DispatchTouchCancelToRecognizer(AceType::RawPtr(targetRefs[0]), items[0]);
1929 EXPECT_EQ(touchTestResult.size(), fingerCnt);
1930 EXPECT_EQ(touchTestResult[1].size(), 1);
1931 eventManager->DispatchTouchCancelToRecognizer(AceType::RawPtr(targetRefs[1]), items[1]);
1932 EXPECT_EQ(touchTestResult.size(), 0);
1933 }
1934 } // namespace OHOS::Ace::NG