1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <list>
17 #include <string>
18 #include <utility>
19 #include <vector>
20
21 #include "gtest/gtest.h"
22
23 #define private public
24 #define protected public
25 #include "mock_touch_event_target.h"
26 #include "test/mock/base/mock_task_executor.h"
27 #include "test/mock/core/common/mock_container.h"
28
29 #include "base/geometry/ng/offset_t.h"
30 #include "base/geometry/offset.h"
31 #include "base/geometry/point.h"
32 #include "base/geometry/rect.h"
33 #include "base/log/log_wrapper.h"
34 #include "base/memory/ace_type.h"
35 #include "base/memory/referenced.h"
36 #include "core/common/ace_engine.h"
37 #include "core/components/ability_component/ability_component.h"
38 #include "core/components/ability_component/render_ability_component.h"
39 #include "core/components/box/render_box.h"
40 #include "core/components/common/layout/constants.h"
41 #include "core/components_ng/base/frame_node.h"
42 #include "core/components_ng/event/focus_hub.h"
43 #include "core/components_ng/gestures/recognizers/gesture_recognizer.h"
44 #include "core/components_ng/gestures/recognizers/swipe_recognizer.h"
45 #include "core/components_ng/manager/select_overlay/select_overlay_manager.h"
46 #include "core/components_ng/pattern/button/button_event_hub.h"
47 #include "core/components_v2/inspector/inspector_constants.h"
48 #include "core/event/ace_events.h"
49 #include "core/event/axis_event.h"
50 #include "core/event/key_event.h"
51 #include "core/event/mouse_event.h"
52 #include "core/event/touch_event.h"
53 #include "core/pipeline/base/element_register.h"
54 #include "core/pipeline/pipeline_context.h"
55 #include "core/pipeline_ng/pipeline_context.h"
56 #include "frameworks/core/animation/animatable_properties.h"
57 #include "frameworks/core/common/event_manager.h"
58 #include "frameworks/core/common/font_manager.h"
59 #include "frameworks/core/common/manager_interface.h"
60
61 using namespace testing;
62 using namespace testing::ext;
63 namespace OHOS::Ace::NG {
64 namespace {
65 const std::string CTRL = "Ctrl";
66 const std::string SHIFT = "shift";
67 const std::string ALT = "alt";
68 const std::string CTRLSHIFT = "Ctrl + shift";
69 const std::string MOUSE = "mouse";
70 const std::string MOUSE_EVENT = "mouse_event";
71 const std::string MOUSE_EVENT_2 = "mouse_event_2";
72
73 const std::string CHARACTER_C = "C";
74 const std::string CHARACTER_A = "A";
75 const std::string CHARACTER_V = "V";
76 const std::string CHARACTER_Z = "Z";
77 const std::string CHARACTER_EIGHT = "8";
78 const std::string CHARACTER_X = "X";
79
80 const std::string SHORT_CUT_VALUE_X = "X";
81 const std::string SHORT_CUT_VALUE_Y = "Y";
82 const std::string SHORT_CUT_VALUE_Z = "Z";
83 const std::string SHORT_CUT_VALUE_A = "A";
84 const std::string SHORT_CUT_VALUE_C = "C";
85 const std::string SHORT_CUT_VALUE_V = "V";
86
87 constexpr int32_t NUM_CTRL_VALUE = 1;
88 constexpr int32_t NUM_SHIFT_VALUE = 2;
89 constexpr int32_t NUM_ALT_VALUE = 4;
90
91 constexpr int32_t NODEID = 1;
92 constexpr int32_t NODEID_2 = 2;
93 constexpr int32_t NODEID_3 = 3;
94
95 enum class CtrlKeysBit {
96 CTRL = 1,
97 SHIFT = 2,
98 ALT = 4,
99 };
100
101 RefPtr<MockTaskExecutor> MOCK_TASK_EXECUTOR;
102 const int32_t CONTAINER_INSTANCE_ID = 777;
103 } // namespace
104
105 class EventManagerTestNg : public testing::Test {
106 public:
107 static void SetUpTestSuite();
108 static void TearDownTestSuite();
109 };
110
SetUpTestSuite()111 void EventManagerTestNg::SetUpTestSuite()
112 {
113 MockContainer::SetUp();
114 MockContainer::Current()->pipelineContext_ = nullptr;
115 MOCK_TASK_EXECUTOR = AceType::MakeRefPtr<MockTaskExecutor>();
116 }
117
TearDownTestSuite()118 void EventManagerTestNg::TearDownTestSuite()
119 {
120 MockContainer::TearDown();
121 }
122
123 /**
124 * @tc.name: EventManagerTest001
125 * @tc.desc: Test OnDragStart
126 * @tc.type: FUNC
127 */
128 HWTEST_F(EventManagerTestNg, EventManagerTest001, TestSize.Level1)
129 {
130 auto eventManager = AceType::MakeRefPtr<EventManager>();
131
132 bool isCtrlC = eventManager->IsSystemKeyboardShortcut(CHARACTER_C, NUM_CTRL_VALUE);
133 bool isCtrlA = eventManager->IsSystemKeyboardShortcut(CHARACTER_A, NUM_CTRL_VALUE);
134 bool isCtrlV = eventManager->IsSystemKeyboardShortcut(CHARACTER_V, NUM_CTRL_VALUE);
135 bool isCtrl8 = eventManager->IsSystemKeyboardShortcut(CHARACTER_EIGHT, NUM_CTRL_VALUE);
136 bool isCtrlX = eventManager->IsSystemKeyboardShortcut(CHARACTER_X, NUM_CTRL_VALUE);
137 bool isShiftC = eventManager->IsSystemKeyboardShortcut(CHARACTER_C, NUM_SHIFT_VALUE);
138 bool isShiftA = eventManager->IsSystemKeyboardShortcut(CHARACTER_A, NUM_SHIFT_VALUE);
139 bool isShiftV = eventManager->IsSystemKeyboardShortcut(CHARACTER_V, NUM_SHIFT_VALUE);
140 bool isShift8 = eventManager->IsSystemKeyboardShortcut(CHARACTER_EIGHT, NUM_SHIFT_VALUE);
141 bool isShiftX = eventManager->IsSystemKeyboardShortcut(CHARACTER_X, NUM_SHIFT_VALUE);
142 bool isAltC = eventManager->IsSystemKeyboardShortcut(CHARACTER_C, NUM_ALT_VALUE);
143 bool isAltA = eventManager->IsSystemKeyboardShortcut(CHARACTER_A, NUM_ALT_VALUE);
144 bool isAltV = eventManager->IsSystemKeyboardShortcut(CHARACTER_V, NUM_ALT_VALUE);
145 bool isAlt8 = eventManager->IsSystemKeyboardShortcut(CHARACTER_EIGHT, NUM_ALT_VALUE);
146 bool isAltX = eventManager->IsSystemKeyboardShortcut(CHARACTER_X, NUM_ALT_VALUE);
147 bool isCtrlShiftC = eventManager->IsSystemKeyboardShortcut(CHARACTER_C, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
148 bool isCtrlShiftA = eventManager->IsSystemKeyboardShortcut(CHARACTER_A, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
149 bool isCtrlShiftV = eventManager->IsSystemKeyboardShortcut(CHARACTER_V, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
150 bool isCtrlShift8 = eventManager->IsSystemKeyboardShortcut(CHARACTER_EIGHT, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
151 bool isCtrlShiftX = eventManager->IsSystemKeyboardShortcut(CHARACTER_X, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
152
153 EXPECT_TRUE(isCtrlC);
154 EXPECT_TRUE(isCtrlA);
155 EXPECT_TRUE(isCtrlV);
156 EXPECT_FALSE(isCtrl8);
157 EXPECT_TRUE(isCtrlX);
158 EXPECT_FALSE(isShiftC);
159 EXPECT_FALSE(isShiftA);
160 EXPECT_FALSE(isShiftV);
161 EXPECT_FALSE(isShift8);
162 EXPECT_FALSE(isShiftX);
163 EXPECT_FALSE(isAltC);
164 EXPECT_FALSE(isAltA);
165 EXPECT_FALSE(isAltV);
166 EXPECT_FALSE(isAlt8);
167 EXPECT_FALSE(isAltX);
168 EXPECT_FALSE(isCtrlShiftC);
169 EXPECT_FALSE(isCtrlShiftA);
170 EXPECT_FALSE(isCtrlShiftV);
171 EXPECT_FALSE(isCtrlShift8);
172 EXPECT_FALSE(isCtrlShiftX);
173 }
174
175 /**
176 * @tc.name: EventManagerTest002
177 * @tc.desc: Test OnDragStart
178 * @tc.type: FUNC
179 */
180 HWTEST_F(EventManagerTestNg, EventManagerTest002, TestSize.Level1)
181 {
182 auto eventManager = AceType::MakeRefPtr<EventManager>();
183 KeyEvent event;
184 auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
185 auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NODEID, nullptr);
186 auto frameNodeAlt = FrameNode::GetOrCreateFrameNode(ALT, NODEID, nullptr);
187 auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, NODEID, nullptr);
188 frameNodeCtrl->SetActive(true);
189 frameNodeShift->SetActive(true);
190 frameNodeAlt->SetActive(true);
191 frameNodeCtrlShift->SetActive(true);
192
193 auto eventHubCtrl = frameNodeCtrl->GetEventHub<NG::EventHub>();
194 auto eventHubShift = frameNodeShift->GetEventHub<NG::EventHub>();
195 auto eventHubAlt = frameNodeAlt->GetEventHub<NG::EventHub>();
196 auto eventHubCtrlShift = frameNodeCtrlShift->GetEventHub<NG::EventHub>();
197
198 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
199 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
200 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeAlt));
201 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
__anon093f950f0202() 202 eventHubCtrl->SetKeyboardShortcut(CHARACTER_C, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE + NUM_ALT_VALUE), []() {});
203 event.code = KeyCode::KEY_C;
204 event.action = KeyAction::DOWN;
205 event.pressedCodes.emplace_back(KeyCode::KEY_CTRL_LEFT);
206 event.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
207 event.pressedCodes.emplace_back(KeyCode::KEY_ALT_LEFT);
208 event.pressedCodes.emplace_back(KeyCode::KEY_C);
209 eventManager->DispatchKeyboardShortcut(event);
210 EXPECT_EQ(event.action, KeyAction::DOWN);
__anon093f950f0302() 211 eventHubShift->SetKeyboardShortcut(CHARACTER_A, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE), []() {});
212 event.code = KeyCode::KEY_A;
213 event.action = KeyAction::DOWN;
214 event.pressedCodes.emplace_back(KeyCode::KEY_CTRL_LEFT);
215 event.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
216 event.pressedCodes.emplace_back(KeyCode::KEY_A);
217 eventManager->DispatchKeyboardShortcut(event);
218 EXPECT_EQ(event.action, KeyAction::DOWN);
__anon093f950f0402() 219 eventHubAlt->SetKeyboardShortcut(CHARACTER_A, (NUM_CTRL_VALUE + NUM_ALT_VALUE), []() {});
220 event.code = KeyCode::KEY_V;
221 event.action = KeyAction::DOWN;
222 event.pressedCodes.emplace_back(KeyCode::KEY_CTRL_LEFT);
223 event.pressedCodes.emplace_back(KeyCode::KEY_V);
224 eventManager->DispatchKeyboardShortcut(event);
225 EXPECT_EQ(event.action, KeyAction::DOWN);
226 }
227
228 /**
229 * @tc.name: EventManagerTest003
230 * @tc.desc: Test OnDragStart
231 * @tc.type: FUNC
232 */
233 HWTEST_F(EventManagerTestNg, EventManagerTest003, TestSize.Level1)
234 {
235 auto eventManager = AceType::MakeRefPtr<EventManager>();
236
237 auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, NUM_CTRL_VALUE, nullptr);
238 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
239 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
240 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrl));
241 auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NUM_SHIFT_VALUE, nullptr);
242 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
243 auto frameNodeAlt = FrameNode::GetOrCreateFrameNode(ALT, NUM_ALT_VALUE, nullptr);
244 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeAlt));
245 auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRLSHIFT, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE), nullptr);
246 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeCtrlShift));
247
248 auto eventHubCtrl = frameNodeCtrl->GetEventHub<NG::EventHub>();
249 auto eventHubShift = frameNodeShift->GetEventHub<NG::EventHub>();
250 auto eventHubAlt = frameNodeAlt->GetEventHub<NG::EventHub>();
251 auto eventHubCtrlShift = frameNodeCtrlShift->GetEventHub<NG::EventHub>();
252
__anon093f950f0502() 253 eventHubCtrl->SetKeyboardShortcut(CHARACTER_C, NUM_CTRL_VALUE, []() {});
__anon093f950f0602() 254 eventHubShift->SetKeyboardShortcut(CHARACTER_A, NUM_SHIFT_VALUE, []() {});
__anon093f950f0702() 255 eventHubAlt->SetKeyboardShortcut(CHARACTER_V, NUM_ALT_VALUE, []() {});
__anon093f950f0802() 256 eventHubCtrlShift->SetKeyboardShortcut(CHARACTER_Z, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE), []() {});
257
258 bool isShortcutNodeCtrlC = eventManager->IsSameKeyboardShortcutNode(CHARACTER_C, NUM_CTRL_VALUE);
259 EXPECT_TRUE(isShortcutNodeCtrlC);
260 bool isShortcutNodeCtrlEIGHT = eventManager->IsSameKeyboardShortcutNode(CHARACTER_EIGHT, NUM_CTRL_VALUE);
261 EXPECT_FALSE(isShortcutNodeCtrlEIGHT);
262 bool isShortcutNodeShiftC = eventManager->IsSameKeyboardShortcutNode(CHARACTER_C, NUM_SHIFT_VALUE);
263 EXPECT_FALSE(isShortcutNodeShiftC);
264 bool isShortcutNodeShiftEight = eventManager->IsSameKeyboardShortcutNode(CHARACTER_EIGHT, NUM_SHIFT_VALUE);
265 EXPECT_FALSE(isShortcutNodeShiftEight);
266 bool isShortcutNodeAltC = eventManager->IsSameKeyboardShortcutNode(CHARACTER_C, NUM_ALT_VALUE);
267 EXPECT_FALSE(isShortcutNodeAltC);
268 bool isShortcutNodeAltEight = eventManager->IsSameKeyboardShortcutNode(CHARACTER_EIGHT, NUM_ALT_VALUE);
269 EXPECT_FALSE(isShortcutNodeAltEight);
270 bool isShortcutComposeC = eventManager->IsSameKeyboardShortcutNode(CHARACTER_C, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
271 EXPECT_FALSE(isShortcutComposeC);
272 bool isShortcutComposeEight =
273 eventManager->IsSameKeyboardShortcutNode(CHARACTER_EIGHT, (NUM_CTRL_VALUE + NUM_SHIFT_VALUE));
274 EXPECT_FALSE(isShortcutComposeEight);
275 }
276
277 /**
278 * @tc.name: EventManagerTest004
279 * @tc.desc: Test OnDragStart
280 * @tc.type: FUNC
281 */
282 HWTEST_F(EventManagerTestNg, EventManagerTest004, TestSize.Level1)
283 {
284 auto eventManager = AceType::MakeRefPtr<EventManager>();
285 ASSERT_NE(eventManager, nullptr);
286
287 auto frameNodeone = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
288
289 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeone));
290 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeone));
291 ASSERT_NE(frameNodeone, nullptr);
292
293 auto frameNodetwo = FrameNode::GetOrCreateFrameNode(SHIFT, NODEID, nullptr);
294 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodetwo));
295 ASSERT_NE(frameNodetwo, nullptr);
296 }
297
298 /**
299 * @tc.name: EventManagerTest005
300 * @tc.desc: Test OnDragStart
301 * @tc.type: FUNC
302 */
303 HWTEST_F(EventManagerTestNg, EventManagerTest005, TestSize.Level1)
304 {
305 auto eventManager = AceType::MakeRefPtr<EventManager>();
306 ASSERT_NE(eventManager, nullptr);
307
308 auto frameNodeone = FrameNode::GetOrCreateFrameNode(CTRL, NODEID, nullptr);
309 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeone));
310
311 eventManager->DelKeyboardShortcutNode(frameNodeone->GetId());
312 ASSERT_NE(frameNodeone, nullptr);
313
314 auto frameNodetwo = FrameNode::GetOrCreateFrameNode(SHIFT, NODEID, nullptr);
315 eventManager->DelKeyboardShortcutNode(frameNodetwo->GetId());
316 ASSERT_NE(frameNodetwo, nullptr);
317 }
318
319 /**
320 * @tc.name: EventManagerTest006
321 * @tc.desc: Test GetKeyboardShortcutKeys
322 * @tc.type: FUNC
323 */
324 HWTEST_F(EventManagerTestNg, EventManagerTest006, TestSize.Level1)
325 {
326 /**
327 * @tc.steps: step1. Create EventManager.
328 * @tc.expected: eventManager is not null.
329 */
330 auto eventManager = AceType::MakeRefPtr<EventManager>();
331 ASSERT_NE(eventManager, nullptr);
332
333 /**
334 * @tc.steps: step2. Call GetKeyboardShortcutKeys with keys.size() > KEYS_MAX_VALUE.
335 * @tc.expected: Value of ret is 0.
336 */
337 std::vector<ModifierKey> keys { ModifierKey::ALT, ModifierKey::CTRL, ModifierKey::SHIFT, ModifierKey::SHIFT };
338 auto ret = eventManager->GetKeyboardShortcutKeys(keys);
339 ASSERT_EQ(ret, 0);
340
341 /**
342 * @tc.steps: step3. Call GetKeyboardShortcutKeys with keys CTRL SHIFT ALT.
343 * @tc.expected: Value of ret is CTRL | SHIFT | ALT.
344 */
345 keys.pop_back();
346 ret = eventManager->GetKeyboardShortcutKeys(keys);
347 uint8_t target = static_cast<uint8_t>(CtrlKeysBit::CTRL) | static_cast<uint8_t>(CtrlKeysBit::SHIFT) |
348 static_cast<uint8_t>(CtrlKeysBit::ALT);
349 ASSERT_EQ(ret, target);
350
351 /**
352 * @tc.steps: step4. Call GetKeyboardShortcutKeys with keys CTRL CTRL.
353 * @tc.expected: Value of ret is 0.
354 */
355 keys = std::vector<ModifierKey>({ ModifierKey::CTRL, ModifierKey::CTRL });
356 ret = eventManager->GetKeyboardShortcutKeys(keys);
357 ASSERT_EQ(ret, 0);
358
359 /**
360 * @tc.steps: step5. Call GetKeyboardShortcutKeys with keys SHIFT SHIFT.
361 * @tc.expected: Value of ret is 0.
362 */
363 keys = std::vector<ModifierKey>({ ModifierKey::SHIFT, ModifierKey::SHIFT });
364 ret = eventManager->GetKeyboardShortcutKeys(keys);
365 ASSERT_EQ(ret, 0);
366
367 /**
368 * @tc.steps: step6. Call GetKeyboardShortcutKeys with keys SHIFT SHIFT.
369 * @tc.expected: Value of ret is 0.
370 */
371 keys = std::vector<ModifierKey>({ ModifierKey::ALT, ModifierKey::ALT });
372 ret = eventManager->GetKeyboardShortcutKeys(keys);
373 ASSERT_EQ(ret, 0);
374 }
375
376 /**
377 * @tc.name: EventManagerTest007
378 * @tc.desc: Test IsSystemKeyboardShortcut
379 * @tc.type: FUNC
380 */
381 HWTEST_F(EventManagerTestNg, EventManagerTest007, TestSize.Level1)
382 {
383 /**
384 * @tc.steps: step1. Create EventManager.
385 * @tc.expected: eventManager is not null.
386 */
387 auto eventManager = AceType::MakeRefPtr<EventManager>();
388 ASSERT_NE(eventManager, nullptr);
389
390 /**
391 * @tc.steps: step2. Call IsSystemKeyboardShortcut with CTRL C.
392 * @tc.expected: retFlag is true.
393 */
394 std::string value = SHORT_CUT_VALUE_C;
395 uint8_t keys = static_cast<uint8_t>(CtrlKeysBit::CTRL);
396 auto retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
397 ASSERT_TRUE(retFlag);
398
399 /**
400 * @tc.steps: step2. Call IsSystemKeyboardShortcut with CTRL A.
401 * @tc.expected: retFlag is true.
402 */
403 value = SHORT_CUT_VALUE_A;
404 retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
405 ASSERT_TRUE(retFlag);
406
407 /**
408 * @tc.steps: step3. Call IsSystemKeyboardShortcut with CTRL V.
409 * @tc.expected: retFlag is true.
410 */
411 value = SHORT_CUT_VALUE_V;
412 retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
413 ASSERT_TRUE(retFlag);
414
415 /**
416 * @tc.steps: step4. Call IsSystemKeyboardShortcut with CTRL X.
417 * @tc.expected: retFlag is true.
418 */
419 value = SHORT_CUT_VALUE_X;
420 retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
421 ASSERT_TRUE(retFlag);
422
423 /**
424 * @tc.steps: step5. Call IsSystemKeyboardShortcut with CTRL Y.
425 * @tc.expected: retFlag is true.
426 */
427 value = SHORT_CUT_VALUE_Y;
428 retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
429 ASSERT_TRUE(retFlag);
430
431 /**
432 * @tc.steps: step6. Call IsSystemKeyboardShortcut with CTRL Z.
433 * @tc.expected: retFlag is true.
434 */
435 value = SHORT_CUT_VALUE_Z;
436 retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
437 ASSERT_TRUE(retFlag);
438
439 /**
440 * @tc.steps: step6. Call IsSystemKeyboardShortcut with CTRL SHIFT Z.
441 * @tc.expected: retFlag is true.
442 */
443 value = SHORT_CUT_VALUE_Z;
444 keys = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::SHIFT);
445 retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
446 ASSERT_TRUE(retFlag);
447
448 /**
449 * @tc.steps: step6. Call IsSystemKeyboardShortcut with CTRL SHIFT A.
450 * @tc.expected: retFlag is false.
451 */
452 value = SHORT_CUT_VALUE_A;
453 keys = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::SHIFT);
454 retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
455 ASSERT_FALSE(retFlag);
456 }
457
458 /**
459 * @tc.name: EventManagerTest008
460 * @tc.desc: Test IsSystemKeyboardShortcut
461 * @tc.type: FUNC
462 */
463 HWTEST_F(EventManagerTestNg, EventManagerTest008, TestSize.Level1)
464 {
465 /**
466 * @tc.steps: step1. Create EventManager.
467 * @tc.expected: eventManager is not null.
468 */
469 auto eventManager = AceType::MakeRefPtr<EventManager>();
470 ASSERT_NE(eventManager, nullptr);
471
472 /**
473 * @tc.steps: step2. Call IsSameKeyboardShortcutNode with CTRL C.
474 * @tc.expected: retFlag is true.
475 */
476 std::string value = SHORT_CUT_VALUE_A;
477 uint8_t keys = static_cast<uint8_t>(CtrlKeysBit::CTRL);
478 auto retFlag = eventManager->IsSystemKeyboardShortcut(value, keys);
479 ASSERT_TRUE(retFlag);
480 retFlag = eventManager->IsSameKeyboardShortcutNode(value, keys);
481 ASSERT_TRUE(retFlag);
482
483 /**
484 * @tc.steps: step2. Call IsSystemKeyboardShortcut with SHIFT A.
485 * @tc.expected: retFlag is true.
486 */
487 auto frameNode = FrameNode::GetOrCreateFrameNode(CTRL, NUM_CTRL_VALUE, nullptr);
488 frameNode->eventHub_ = nullptr;
489 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNode));
490
491 auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NUM_SHIFT_VALUE, nullptr);
__anon093f950f0902() 492 frameNodeShift->eventHub_->SetKeyboardShortcut(SHORT_CUT_VALUE_A, static_cast<int>(CtrlKeysBit::SHIFT), []() {});
493 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
494
495 value = SHORT_CUT_VALUE_A;
496 keys = static_cast<uint8_t>(CtrlKeysBit::SHIFT);
497 retFlag = eventManager->IsSameKeyboardShortcutNode(value, keys);
498 ASSERT_TRUE(retFlag);
499
500 /**
501 * @tc.steps: step3. Call IsSystemKeyboardShortcut with SHIFT X while shortcut in frameNode is SHIFT A.
502 * @tc.expected: retFlag is true.
503 */
504 value = SHORT_CUT_VALUE_X;
505 keys = static_cast<uint8_t>(CtrlKeysBit::SHIFT);
506 retFlag = eventManager->IsSameKeyboardShortcutNode(value, keys);
507 ASSERT_FALSE(retFlag);
508 }
509
510 /**
511 * @tc.name: EventManagerTest009
512 * @tc.desc: Test ClearResults
513 * @tc.type: FUNC
514 */
515 HWTEST_F(EventManagerTestNg, EventManagerTest009, TestSize.Level1)
516 {
517 /**
518 * @tc.steps: step1. Create EventManager.
519 * @tc.expected: eventManager is not null.
520 */
521 auto eventManager = AceType::MakeRefPtr<EventManager>();
522 ASSERT_NE(eventManager, nullptr);
523
524 /**
525 * @tc.steps: step2. Add KeyboardShortcutNode
526 * @tc.expected: keyboardShortcutNode_.size() > 0.
527 */
528 auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, NUM_SHIFT_VALUE, nullptr);
__anon093f950f0a02() 529 frameNodeShift->eventHub_->SetKeyboardShortcut(SHORT_CUT_VALUE_A, static_cast<int>(CtrlKeysBit::SHIFT), []() {});
530 eventManager->AddKeyboardShortcutNode(WeakPtr<NG::FrameNode>(frameNodeShift));
531 ASSERT_GT(eventManager->keyboardShortcutNode_.size(), 0);
532
533 /**
534 * @tc.steps: step3. Call ClearResults
535 * @tc.expected: keyboardShortcutNode_.size() = 0.
536 */
537 eventManager->ClearResults();
538 ASSERT_EQ(eventManager->keyboardShortcutNode_.size(), 0);
539 }
540
541 /**
542 * @tc.name: EventManagerTest010
543 * @tc.desc: Test TouchTest with FrameNode
544 * @tc.type: FUNC
545 */
546 HWTEST_F(EventManagerTestNg, EventManagerTest010, TestSize.Level1)
547 {
548 /**
549 * @tc.steps: step1. Create EventManager.
550 * @tc.expected: eventManager is not null.
551 */
552 auto eventManager = AceType::MakeRefPtr<EventManager>();
553 ASSERT_NE(eventManager, nullptr);
554
555 /**
556 * @tc.steps: step2. Create FrameNode and Call TouchTest with needAppend false
557 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
558 */
559 TouchEvent touchPoint;
560 touchPoint.id = 0;
561 touchPoint.type = TouchType::DOWN;
562
563 const int nodeId = 10001;
564 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
565 TouchRestrict touchRestrict;
566 Offset offset;
567 EXPECT_EQ(eventManager->touchTestResults_.count(touchPoint.id), 0);
568 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, false);
569 EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
570
571 /**
572 * @tc.steps: step2. Create FrameNode and Call TouchTest with needAppend true
573 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
574 */
575 eventManager->touchTestResults_.erase(touchPoint.id);
576 EXPECT_EQ(eventManager->touchTestResults_.count(touchPoint.id), 0);
577 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
578 EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
579
580 /**
581 * @tc.steps: step3. Create GestureScope.
582 * @tc.expected: GestureScope is not null.
583 */
584 size_t touchId = 100;
585 RefPtr<GestureScope> scope = AceType::MakeRefPtr<GestureScope>(touchId);
586 ASSERT_NE(scope, nullptr);
587 eventManager->refereeNG_->gestureScopes_.insert(std::make_pair(touchId, scope));
588 ASSERT_TRUE(eventManager->refereeNG_->QueryAllDone(touchId));
589 }
590
591 /**
592 * @tc.name: EventManagerTest011
593 * @tc.desc: Test TouchTest with FrameNode
594 * @tc.type: FUNC
595 */
596 HWTEST_F(EventManagerTestNg, EventManagerTest011, TestSize.Level1)
597 {
598 /**
599 * @tc.steps: step1. Create EventManager.
600 * @tc.expected: eventManager is not null.
601 */
602 auto eventManager = AceType::MakeRefPtr<EventManager>();
603 ASSERT_NE(eventManager, nullptr);
604
605 /**
606 * @tc.steps: step2. Create FrameNode and Call TouchTest
607 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
608 */
609 AxisEvent axisEvent;
610 axisEvent.sourceType = SourceType::TOUCH;
611
612 const int nodeId = 10002;
613 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
614 TouchRestrict touchRestrict;
615
616 EXPECT_EQ(eventManager->axisTouchTestResults_.count(axisEvent.id), 0);
617 eventManager->TouchTest(axisEvent, frameNode, touchRestrict);
618 EXPECT_GT(eventManager->axisTouchTestResults_.count(axisEvent.id), 0);
619 }
620
621 /**
622 * @tc.name: EventManagerTest012
623 * @tc.desc: Test HandleGlobalEventNG
624 * @tc.type: FUNC
625 */
626 HWTEST_F(EventManagerTestNg, EventManagerTest012, TestSize.Level1)
627 {
628 /**
629 * @tc.steps: step1. Create EventManager.
630 * @tc.expected: eventManager is not null.
631 */
632 auto eventManager = AceType::MakeRefPtr<EventManager>();
633 ASSERT_NE(eventManager, nullptr);
634
635 /**
636 * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id]
637 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
638 */
639 TouchEvent touchPoint;
640 touchPoint.type = TouchType::DOWN;
641
642 const int nodeId = 10003;
643 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
644 TouchRestrict touchRestrict;
645 Offset offset;
646
647 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
648 EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
649
650 /**
651 * @tc.steps: step3. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id]
652 * @tc.expected: selectOverlayManager->touchTestResults_ is empty for do not have specific event
653 */
654 auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode);
655 NG::OffsetF rootOffset;
656 eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset);
657 EXPECT_EQ(selectOverlayManager->touchTestResults_.size(), 0);
658 }
659
660 /**
661 * @tc.name: EventManagerTest013
662 * @tc.desc: Test HandleOutOfRectCallback
663 * @tc.type: FUNC
664 */
665 HWTEST_F(EventManagerTestNg, EventManagerTest013, 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 /**
675 * @tc.steps: step2. Create rectCallbackList
676 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
677 */
678 Point point(10, 20);
679 point.SetSourceType(SourceType::TOUCH);
680
__anon093f950f0b02(std::vector<Rect>& rectList) 681 auto rectGetCallback1 = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect()); };
__anon093f950f0c02(std::vector<Rect>& rectList) 682 auto rectGetCallback2 = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect(0, 0, 100, 100)); };
683
__anon093f950f0d02() 684 auto touchCallback = []() -> void {};
__anon093f950f0e02() 685 auto mouseCallback = []() -> void {};
686 std::vector<RectCallback> rectCallbackList { RectCallback(rectGetCallback1, touchCallback, mouseCallback),
687 RectCallback(rectGetCallback2, touchCallback, mouseCallback) };
688
689 /**
690 * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::TOUCH
691 * @tc.expected: rectCallbackList.size() is 1
692 */
693 eventManager->HandleOutOfRectCallback(point, rectCallbackList);
694 EXPECT_EQ(rectCallbackList.size(), 1);
695
696 /**
697 * @tc.steps: step4. Call HandleOutOfRectCallback with SourceType::MOUSE
698 * @tc.expected: rectCallbackList.size() is 0
699 */
700 point.SetSourceType(SourceType::MOUSE);
701 rectCallbackList = vector<RectCallback>({ RectCallback(rectGetCallback1, touchCallback, mouseCallback) });
702 eventManager->HandleOutOfRectCallback(point, rectCallbackList);
703 EXPECT_TRUE(rectCallbackList.empty());
704 }
705
706 /**
707 * @tc.name: EventManagerTest014
708 * @tc.desc: Test DispatchTouchEvent
709 * @tc.type: FUNC
710 */
711 HWTEST_F(EventManagerTestNg, EventManagerTest014, TestSize.Level1)
712 {
713 /**
714 * @tc.steps: step1. Create EventManager.
715 * @tc.expected: eventManager is not null.
716 */
717 auto eventManager = AceType::MakeRefPtr<EventManager>();
718 ASSERT_NE(eventManager, nullptr);
719
720 /**
721 * @tc.steps: step2. Create TouchEvent and Call DispatchTouchEvent
722 * @tc.expected: retFlag is false
723 */
724 AxisEvent event;
725 event.action = AxisAction::BEGIN;
726
727 auto retFlag = eventManager->DispatchTouchEvent(event);
728 EXPECT_FALSE(retFlag);
729
730 /**
731 * @tc.steps: step3. Create FrameNode and Call TouchTest to add axisTouchTestResults_
732 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
733 */
734 event.action = AxisAction::END;
735
736 const int nodeId = 10004;
737 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
738 TouchRestrict touchRestrict;
739
740 eventManager->TouchTest(event, frameNode, touchRestrict);
741 EXPECT_GT(eventManager->axisTouchTestResults_.count(event.id), 0);
742
743 /**
744 * @tc.steps: step4. Call DispatchTouchEvent
745 * @tc.expected: touchTestResults_ has the touchPoint.id of instance
746 */
747 retFlag = eventManager->DispatchTouchEvent(event);
748 EXPECT_TRUE(retFlag);
749
750 /**
751 * @tc.steps: step5. Create AxisEvent and Call DispatchTouchEvent
752 * @tc.expected: retFlag is false
753 */
754 event.action = AxisAction::BEGIN;
755 Container::SetCurrentUsePartialUpdate(true);
756 AceForwardCompatibility::isNewPipeline_ = true;
757 eventManager->DispatchTouchEvent(event);
758 auto container = Container::Current();
759 container->useNewPipeline_ = true;
760 ASSERT_NE(container, nullptr);
761 retFlag = Container::IsCurrentUseNewPipeline();
762 EXPECT_TRUE(retFlag);
763 }
764
765 /**
766 * @tc.name: EventManagerTest015
767 * @tc.desc: Test DispatchTabIndexEventNG
768 * @tc.type: FUNC
769 */
770 HWTEST_F(EventManagerTestNg, EventManagerTest015, TestSize.Level1)
771 {
772 /**
773 * @tc.steps: step1. Create EventManager.
774 * @tc.expected: eventManager is not null.
775 */
776 auto eventManager = AceType::MakeRefPtr<EventManager>();
777 ASSERT_NE(eventManager, nullptr);
778
779 /**
780 * @tc.steps: step2. Create frameNodes
781 * @tc.expected: retFlag is false
782 */
783 const int mainNodeId = 10006;
784 auto mainNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, mainNodeId, nullptr);
785
786 /**
787 * @tc.steps: step3. Call DispatchTabIndexEventNG
788 * @tc.expected: retFlag is false
789 */
790 KeyEvent event;
791 auto retFlag = eventManager->DispatchTabIndexEventNG(event, mainNode);
792 ASSERT_FALSE(retFlag);
793 }
794
795 /**
796 * @tc.name: EventManagerTest016
797 * @tc.desc: Test DispatchKeyEventNG
798 * @tc.type: FUNC
799 */
800 HWTEST_F(EventManagerTestNg, EventManagerTest016, TestSize.Level1)
801 {
802 /**
803 * @tc.steps: step1. Create EventManager.
804 * @tc.expected: eventManager is not null.
805 */
806 auto eventManager = AceType::MakeRefPtr<EventManager>();
807 ASSERT_NE(eventManager, nullptr);
808
809 /**
810 * @tc.steps: step2. Create frameNodes
811 * @tc.expected: retFlag is false
812 */
813 const int focusNodeId = 10007;
814 auto focusNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, focusNodeId, nullptr);
815 focusNode->eventHub_ = AceType::MakeRefPtr<ButtonEventHub>();
816 focusNode->eventHub_->GetOrCreateFocusHub(FocusType::NODE);
817 ASSERT_NE(focusNode->GetFocusHub(), nullptr);
818
819 /**
820 * @tc.steps: step3. Call DispatchKeyEventNG
821 * @tc.expected: retFlag is false
822 */
823 KeyEvent event;
824 auto retFlag = eventManager->DispatchKeyEventNG(event, focusNode);
825 ASSERT_FALSE(retFlag);
826 }
827
828 /**
829 * @tc.name: EventManagerTest017
830 * @tc.desc: Test MouseTest (frameNode)
831 * @tc.type: FUNC
832 */
833 HWTEST_F(EventManagerTestNg, EventManagerTest017, TestSize.Level1)
834 {
835 /**
836 * @tc.steps: step1. Create EventManager.
837 * @tc.expected: eventManager is not null.
838 */
839 auto eventManager = AceType::MakeRefPtr<EventManager>();
840 ASSERT_NE(eventManager, nullptr);
841
842 /**
843 * @tc.steps: step2. Call MouseTest with MouseAction::WINDOW_LEAVE
844 * @tc.expected: currHoverTestResults_ is empty
845 */
846 MouseEvent event;
847 const int nodeId = 10008;
848 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
849 TouchRestrict touchRestrict;
850
851 event.action = MouseAction::WINDOW_LEAVE;
852 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(V2::LOCATION_BUTTON_ETS_TAG, nodeId);
853 eventManager->currHoverTestResults_.push_back(hoverEventTarget);
854 ASSERT_FALSE(eventManager->currHoverTestResults_.empty());
855 eventManager->MouseTest(event, frameNode, touchRestrict);
856 ASSERT_TRUE(eventManager->currHoverTestResults_.empty());
857
858 /**
859 * @tc.steps: step3. Call MouseTest with MouseAction::WINDOW_ENTER
860 * @tc.expected: lastHoverTestResults_ is empty
861 */
862 event.action = MouseAction::WINDOW_ENTER;
863 eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
864 ASSERT_FALSE(eventManager->lastHoverTestResults_.empty());
865 eventManager->MouseTest(event, frameNode, touchRestrict);
866 ASSERT_TRUE(eventManager->lastHoverTestResults_.empty());
867
868 /**
869 * @tc.steps: step4. Call MouseTest with MouseAction::HOVER
870 * @tc.expected: lastHoverTestResults_ is empty and currHoverTestResults_ is empty
871 */
872 event.action = MouseAction::HOVER;
873 eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
874 eventManager->MouseTest(event, frameNode, touchRestrict);
875 ASSERT_TRUE(eventManager->lastHoverTestResults_.empty());
876 ASSERT_TRUE(eventManager->currHoverTestResults_.empty());
877 }
878
879 /**
880 * @tc.name: EventManagerTest018
881 * @tc.desc: Test DispatchMouseEventNG
882 * @tc.type: FUNC
883 */
884 HWTEST_F(EventManagerTestNg, EventManagerTest018, TestSize.Level1)
885 {
886 /**
887 * @tc.steps: step1. Create EventManager.
888 * @tc.expected: eventManager is not null.
889 */
890 auto eventManager = AceType::MakeRefPtr<EventManager>();
891 ASSERT_NE(eventManager, nullptr);
892
893 /**
894 * @tc.steps: step2. Call DispatchMouseEventNG
895 * @tc.expected: currHoverTestResults_ is empty
896 */
897 MouseEvent event;
898 event.action = MouseAction::PRESS;
899 event.button = MouseButton::LEFT_BUTTON;
900 event.pullAction = MouseAction::MOVE;
901
902 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID);
903 eventManager->pressMouseTestResults_.push_back(mouseEventTarget);
904 eventManager->currMouseTestResults_.push_back(mouseEventTarget);
905
906 auto retFlag = eventManager->DispatchMouseEventNG(event);
907 ASSERT_FALSE(retFlag);
908
909 /**
910 * @tc.steps: step2. Call DispatchMouseEventNG
911 * @tc.expected: currHoverTestResults_ is empty
912 */
913 event.action = MouseAction::RELEASE;
914 event.button = MouseButton::LEFT_BUTTON;
915 event.pullAction = MouseAction::MOVE;
916 retFlag = eventManager->DispatchMouseEventNG(event);
917 ASSERT_FALSE(retFlag);
918
919 /**
920 * @tc.steps: step3. Call DispatchMouseEventNG
921 * @tc.expected: currHoverTestResults_ is empty
922 */
923 event.action = MouseAction::MOVE;
924 event.button = MouseButton::LEFT_BUTTON;
925 event.pullAction = MouseAction::PULL_UP;
926 retFlag = eventManager->DispatchMouseEventNG(event);
927 ASSERT_FALSE(retFlag);
928
929 /**
930 * @tc.steps: step4. Call DispatchMouseEventNG
931 * @tc.expected: currHoverTestResults_ not empty
932 */
933 event.action = MouseAction::MOVE;
934 event.button = MouseButton::LEFT_BUTTON;
935 event.pullAction = MouseAction::PULL_UP;
936
937 auto mouseTestResult = AceType::MakeRefPtr<MouseEventTarget>(CTRL, NODEID);
938 eventManager->currMouseTestResults_.push_back(mouseTestResult);
939
940 retFlag = eventManager->DispatchMouseEventNG(event);
941 ASSERT_FALSE(retFlag);
942 }
943
944 /**
945 * @tc.name: EventManagerTest019
946 * @tc.desc: Test DispatchMouseHoverEventNG
947 * @tc.type: FUNC
948 */
949 HWTEST_F(EventManagerTestNg, EventManagerTest019, TestSize.Level1)
950 {
951 /**
952 * @tc.steps: step1. Create EventManager.
953 * @tc.expected: eventManager is not null.
954 */
955 auto eventManager = AceType::MakeRefPtr<EventManager>();
956 ASSERT_NE(eventManager, nullptr);
957
958 /**
959 * @tc.steps: step2. Call DispatchMouseHoverEventNG with lastHoverTestResults != currHoverTestResults
960 * @tc.expected: retFlag is true
961 */
962 MouseEvent event;
963 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(MOUSE, NODEID);
964 auto hoverEventTarget2 = AceType::MakeRefPtr<HoverEventTarget>(MOUSE_EVENT, NODEID_2);
965 auto hoverEventTarget3 = AceType::MakeRefPtr<HoverEventTarget>(MOUSE_EVENT_2, NODEID_3);
966 eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
967 eventManager->currHoverTestResults_.push_back(hoverEventTarget2);
968 eventManager->currHoverTestResults_.push_back(hoverEventTarget3);
969 eventManager->currHoverTestResults_.push_back(hoverEventTarget);
970 eventManager->lastHoverDispatchLength_++;
971
972 auto retFlag = eventManager->DispatchMouseHoverEventNG(event);
973 ASSERT_TRUE(retFlag);
974
975 /**
976 * @tc.steps: step2. Call DispatchMouseHoverEventNG with lastHoverTestResults == currHoverTestResults
977 * @tc.expected: retFlag is true
978 */
979 eventManager->lastHoverTestResults_.clear();
980 eventManager->lastHoverTestResults_.push_back(hoverEventTarget);
981 eventManager->currHoverTestResults_.clear();
982 eventManager->currHoverTestResults_.push_back(hoverEventTarget);
983
984 retFlag = eventManager->DispatchMouseHoverEventNG(event);
985 ASSERT_TRUE(retFlag);
986 }
987
988 /**
989 * @tc.name: EventManagerTest020
990 * @tc.desc: Test DispatchAxisEventNG
991 * @tc.type: FUNC
992 */
993 HWTEST_F(EventManagerTestNg, EventManagerTest020, TestSize.Level1)
994 {
995 /**
996 * @tc.steps: step1. Create EventManager.
997 * @tc.expected: eventManager is not null.
998 */
999 auto eventManager = AceType::MakeRefPtr<EventManager>();
1000 ASSERT_NE(eventManager, nullptr);
1001
1002 /**
1003 * @tc.steps: step2. Call DispatchAxisEventNG with horizontalAxis verticalAxis pinchAxisScale = 0
1004 * @tc.expected: retFlag is false
1005 */
1006 AxisEvent event;
1007 event.horizontalAxis = 0;
1008 event.verticalAxis = 0;
1009 event.pinchAxisScale = 0;
1010 auto retFlag = eventManager->DispatchAxisEventNG(event);
1011 ASSERT_FALSE(retFlag);
1012
1013 /**
1014 * @tc.steps: step3. Call DispatchAxisEventNG with axisTestResults_ empty
1015 * @tc.expected: retFlag is false
1016 */
1017 event.horizontalAxis = 1;
1018 retFlag = eventManager->DispatchAxisEventNG(event);
1019 ASSERT_TRUE(retFlag);
1020
1021 /**
1022 * @tc.steps: step4. Call DispatchAxisEventNG with axisTestResults_ not empty
1023 * @tc.expected: retFlag is false
1024 */
1025 auto axisEventTarget = AceType::MakeRefPtr<AxisEventTarget>();
__anon093f950f0f02(AxisInfo&) 1026 auto onAxisCallback = [](AxisInfo&) -> void {};
1027 axisEventTarget->SetOnAxisCallback(onAxisCallback);
1028
1029 eventManager->axisTestResults_.push_back(axisEventTarget);
1030 retFlag = eventManager->DispatchAxisEventNG(event);
1031 ASSERT_TRUE(retFlag);
1032 }
1033
1034 /**
1035 * @tc.name: EventManagerTest021
1036 * @tc.desc: Test DispatchAxisEventNG
1037 * @tc.type: FUNC
1038 */
1039 HWTEST_F(EventManagerTestNg, EventManagerTest021, TestSize.Level1)
1040 {
1041 /**
1042 * @tc.steps: step1. Create EventManager.
1043 * @tc.expected: eventManager is not null.
1044 */
1045 auto eventManager = AceType::MakeRefPtr<EventManager>();
1046 ASSERT_NE(eventManager, nullptr);
1047
1048 /**
1049 * @tc.steps: step2. AddKeyboardShortcutNode to eventManager
1050 */
1051 const int nodeIdCtrlShift = 10010;
1052 auto frameNodeCtrlShift = FrameNode::GetOrCreateFrameNode(CTRL, nodeIdCtrlShift, nullptr);
1053 frameNodeCtrlShift->SetActive(true);
1054 frameNodeCtrlShift->eventHub_->SetEnabled(true);
1055 const uint8_t ctrlShift = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::SHIFT);
__anon093f950f1002() 1056 frameNodeCtrlShift->eventHub_->SetKeyboardShortcut(CHARACTER_A, ctrlShift, []() {});
1057 eventManager->AddKeyboardShortcutNode(frameNodeCtrlShift);
1058
1059 const int nodeIdCtrlAlt = 10011;
1060 auto frameNodeCtrlAlt = FrameNode::GetOrCreateFrameNode(CTRL, nodeIdCtrlAlt, nullptr);
1061 frameNodeCtrlAlt->SetActive(true);
1062 frameNodeCtrlAlt->eventHub_->SetEnabled(true);
1063 const uint8_t ctrlAlt = static_cast<uint8_t>(CtrlKeysBit::CTRL) + static_cast<uint8_t>(CtrlKeysBit::ALT);
__anon093f950f1102() 1064 frameNodeCtrlAlt->eventHub_->SetKeyboardShortcut(CHARACTER_A, ctrlAlt, []() {});
1065 eventManager->AddKeyboardShortcutNode(frameNodeCtrlAlt);
1066
1067 const int nodeIdAltShift = 10012;
1068 auto frameNodeAltShift = FrameNode::GetOrCreateFrameNode(ALT, nodeIdAltShift, nullptr);
1069 frameNodeAltShift->SetActive(true);
1070 frameNodeAltShift->eventHub_->SetEnabled(true);
1071 const uint8_t altShift = static_cast<uint8_t>(CtrlKeysBit::SHIFT) + static_cast<uint8_t>(CtrlKeysBit::ALT);
__anon093f950f1202() 1072 frameNodeAltShift->eventHub_->SetKeyboardShortcut(CHARACTER_A, altShift, []() {});
1073 eventManager->AddKeyboardShortcutNode(frameNodeAltShift);
1074
1075 /**
1076 * @tc.steps: step3. call DispatchKeyboardShortcut
1077 * @tc.expected: AddKeyboardShortcutDoubleKeys calls.
1078 */
1079 KeyEvent event;
1080 event.action = KeyAction::DOWN;
1081 eventManager->DispatchKeyboardShortcut(event);
1082 ASSERT_EQ(frameNodeCtrlShift->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, ctrlShift);
1083 ASSERT_EQ(frameNodeCtrlAlt->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, ctrlAlt);
1084 ASSERT_EQ(frameNodeAltShift->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, altShift);
1085 }
1086
1087 /**
1088 * @tc.name: EventManagerTest022
1089 * @tc.desc: Test DispatchAxisEventNG
1090 * @tc.type: FUNC
1091 */
1092 HWTEST_F(EventManagerTestNg, EventManagerTest022, TestSize.Level1)
1093 {
1094 /**
1095 * @tc.steps: step1. Create EventManager.
1096 * @tc.expected: eventManager is not null.
1097 */
1098 auto eventManager = AceType::MakeRefPtr<EventManager>();
1099 ASSERT_NE(eventManager, nullptr);
1100
1101 /**
1102 * @tc.steps: step2. AddKeyboardShortcutNode to eventManager
1103 */
1104 const int nodeIdCtrl = 10013;
1105 auto frameNodeCtrl = FrameNode::GetOrCreateFrameNode(CTRL, nodeIdCtrl, nullptr);
1106 frameNodeCtrl->SetActive(true);
1107 frameNodeCtrl->eventHub_->SetEnabled(true);
1108 const uint8_t ctrl = static_cast<uint8_t>(CtrlKeysBit::CTRL);
__anon093f950f1302() 1109 frameNodeCtrl->eventHub_->SetKeyboardShortcut(CHARACTER_A, ctrl, []() {});
1110 eventManager->AddKeyboardShortcutNode(frameNodeCtrl);
1111
1112 const int nodeIdAlt = 10014;
1113 auto frameNodeAlt = FrameNode::GetOrCreateFrameNode(ALT, nodeIdAlt, nullptr);
1114 frameNodeAlt->SetActive(true);
1115 frameNodeAlt->eventHub_->SetEnabled(true);
1116 const uint8_t alt = static_cast<uint8_t>(CtrlKeysBit::ALT);
__anon093f950f1402() 1117 frameNodeAlt->eventHub_->SetKeyboardShortcut(CHARACTER_A, alt, []() {});
1118 eventManager->AddKeyboardShortcutNode(frameNodeAlt);
1119
1120 const int nodeIdShift = 10015;
1121 auto frameNodeShift = FrameNode::GetOrCreateFrameNode(SHIFT, nodeIdShift, nullptr);
1122 frameNodeShift->SetActive(true);
1123 frameNodeShift->eventHub_->SetEnabled(true);
1124 const uint8_t shift = static_cast<uint8_t>(CtrlKeysBit::SHIFT);
__anon093f950f1502() 1125 frameNodeShift->eventHub_->SetKeyboardShortcut(CHARACTER_A, shift, []() {});
1126 eventManager->AddKeyboardShortcutNode(frameNodeShift);
1127
1128 /**
1129 * @tc.steps: step3. call DispatchKeyboardShortcut
1130 * @tc.expected: AddKeyboardShortcutSingleKey is called.
1131 */
1132 KeyEvent event;
1133 event.action = KeyAction::DOWN;
1134 eventManager->DispatchKeyboardShortcut(event);
1135 ASSERT_EQ(frameNodeCtrl->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, ctrl);
1136 ASSERT_EQ(frameNodeAlt->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, alt);
1137 ASSERT_EQ(frameNodeShift->GetEventHub<NG::EventHub>()->GetKeyboardShortcut().back().keys, shift);
1138 }
1139
1140 /**
1141 * @tc.name: EventManagerTest023
1142 * @tc.desc: Test DispatchTouchEvent
1143 * @tc.type: FUNC
1144 */
1145 HWTEST_F(EventManagerTestNg, EventManagerTest023, TestSize.Level1)
1146 {
1147 /**
1148 * @tc.steps: step1. Create EventManager.
1149 * @tc.expected: eventManager is not null.
1150 */
1151 auto eventManager = AceType::MakeRefPtr<EventManager>();
1152 ASSERT_NE(eventManager, nullptr);
1153 AceEngine& aceEngine = AceEngine::Get();
1154 aceEngine.AddContainer(CONTAINER_INSTANCE_ID, MockContainer::container_);
1155 /**
1156 * @tc.steps: step2. Call DispatchTouchEvent with TouchType::DOWN and
1157 touchTestResults_ empty;
1158 * @tc.expected: ret is false
1159 */
1160 TouchEvent event;
1161 event.type = TouchType::DOWN;
1162 auto ret = eventManager->DispatchTouchEvent(event);
1163 EXPECT_FALSE(ret);
1164
1165 /**
1166 * @tc.steps: step3. Call DispatchTouchEvent with TouchType::DOWN and
1167 touchTestResults_ has element;
1168 * @tc.expected: ret is true
1169 */
1170 TouchTestResult touchTestResults;
1171 auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
1172 touchTestResults.push_back(eventTarget);
1173 eventManager->touchTestResults_.emplace(event.id, touchTestResults);
1174 ret = eventManager->DispatchTouchEvent(event);
1175 EXPECT_TRUE(ret);
1176
1177 /**
1178 * @tc.steps: step4. Call DispatchTouchEvent with TouchType::UP and
1179 touchTestResults_ has element;
1180 * @tc.expected: ret is true
1181 */
1182 event.type = TouchType::UP;
1183 ret = eventManager->DispatchTouchEvent(event);
1184 EXPECT_TRUE(ret);
1185 }
1186
1187 /**
1188 * @tc.name: EventManagerTest024
1189 * @tc.desc: Test DispatchTouchEvent
1190 * @tc.type: FUNC
1191 */
1192 HWTEST_F(EventManagerTestNg, EventManagerTest024, TestSize.Level1)
1193 {
1194 /**
1195 * @tc.steps: step1. Create EventManager.
1196 * @tc.expected: eventManager is not null.
1197 */
1198 auto eventManager = AceType::MakeRefPtr<EventManager>();
1199 ASSERT_NE(eventManager, nullptr);
1200
1201 auto currentHoverNodeId = ElementRegister::GetInstance()->MakeUniqueId();
1202 auto currentHoverNode = FrameNode::GetOrCreateFrameNode(CTRL, currentHoverNodeId, nullptr);
1203 eventManager->currHoverNode_ = currentHoverNode;
1204 auto lastHoverNodeId = ElementRegister::GetInstance()->MakeUniqueId();
1205 auto lastHoverNode = FrameNode::GetOrCreateFrameNode(SHIFT, lastHoverNodeId, nullptr);
1206 eventManager->lastHoverNode_ = lastHoverNode;
1207
1208 /**
1209 * @tc.steps: step2. Call DispatchMouseHoverAnimationNG with MouseAction::PRESS;
1210 * @tc.expected: ret is false
1211 */
1212 MouseEvent event;
1213 event.button = MouseButton::NONE_BUTTON;
1214 event.action = MouseAction::PRESS;
1215 eventManager->DispatchMouseHoverAnimationNG(event);
1216 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1217
1218 /**
1219 * @tc.steps: step3. Call DispatchMouseHoverAnimationNG with MouseAction::RELEASE;
1220 * @tc.expected: ret is false
1221 */
1222 event.action = MouseAction::RELEASE;
1223 eventManager->DispatchMouseHoverAnimationNG(event);
1224 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1225
1226 /**
1227 * @tc.steps: step4. Call DispatchMouseHoverAnimationNG with MouseAction::MOVE;
1228 * @tc.expected: ret is false
1229 */
1230 event.action = MouseAction::MOVE;
1231 eventManager->DispatchMouseHoverAnimationNG(event);
1232 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1233
1234 /**
1235 * @tc.steps: step5. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_ENTER;
1236 * @tc.expected: ret is false
1237 */
1238 event.action = MouseAction::WINDOW_ENTER;
1239 eventManager->DispatchMouseHoverAnimationNG(event);
1240 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1241
1242 /**
1243 * @tc.steps: step6. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_LEAVE;
1244 * @tc.expected: ret is false
1245 */
1246 event.action = MouseAction::WINDOW_LEAVE;
1247 eventManager->DispatchMouseHoverAnimationNG(event);
1248 EXPECT_NE(eventManager->currHoverNode_.Upgrade(), nullptr);
1249 }
1250
1251 /**
1252 * @tc.name: EventManagerTest025
1253 * @tc.desc: Test FlushTouchEventsBegin
1254 * @tc.type: FUNC
1255 */
1256 HWTEST_F(EventManagerTestNg, EventManagerTest025, TestSize.Level1)
1257 {
1258 /**
1259 * @tc.steps: step1. Create EventManager.
1260 * @tc.expected: eventManager is not null.
1261 */
1262 auto eventManager = AceType::MakeRefPtr<EventManager>();
1263 ASSERT_NE(eventManager, nullptr);
1264
1265 auto resultId = ElementRegister::GetInstance()->MakeUniqueId();
1266 TouchTestResult touchTestResults;
1267 touchTestResults.push_back(AceType::MakeRefPtr<MockTouchEventTarget>());
1268 eventManager->touchTestResults_.emplace(resultId, touchTestResults);
1269
1270 TouchEvent event { .id = resultId };
1271 std::list<TouchEvent> touchEvents { event };
1272 eventManager->FlushTouchEventsBegin(touchEvents);
1273 EXPECT_NE(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end());
1274 }
1275
1276 /**
1277 * @tc.name: EventManagerTest026
1278 * @tc.desc: Test FlushTouchEventsBegin
1279 * @tc.type: FUNC
1280 */
1281 HWTEST_F(EventManagerTestNg, EventManagerTest026, TestSize.Level1)
1282 {
1283 /**
1284 * @tc.steps: step1. Create EventManager.
1285 * @tc.expected: eventManager is not null.
1286 */
1287 auto eventManager = AceType::MakeRefPtr<EventManager>();
1288 ASSERT_NE(eventManager, nullptr);
1289
1290 auto resultId = ElementRegister::GetInstance()->MakeUniqueId();
1291 TouchTestResult touchTestResults;
1292 touchTestResults.push_back(AceType::MakeRefPtr<MockTouchEventTarget>());
1293 eventManager->touchTestResults_.emplace(resultId, touchTestResults);
1294
1295 TouchEvent event { .id = resultId };
1296 std::list<TouchEvent> touchEvents { event };
1297 eventManager->FlushTouchEventsEnd(touchEvents);
1298 EXPECT_NE(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end());
1299 }
1300
1301 /**
1302 * @tc.name: EventManagerTest027
1303 * @tc.desc: Test FlushTouchEventsBegin
1304 * @tc.type: FUNC
1305 */
1306 HWTEST_F(EventManagerTestNg, EventManagerTest027, TestSize.Level1)
1307 {
1308 /**
1309 * @tc.steps: step1. Create EventManager.
1310 * @tc.expected: eventManager is not null.
1311 */
1312 auto eventManager = AceType::MakeRefPtr<EventManager>();
1313 ASSERT_NE(eventManager, nullptr);
1314
1315 AxisEvent axisEvent { .x = 1, .y = 2, .sourceType = SourceType::TOUCH };
1316 auto nodeId = ElementRegister::GetInstance()->MakeUniqueId();
1317 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
1318 eventManager->AxisTest(axisEvent, frameNode);
1319 EXPECT_NE(frameNode, nullptr);
1320 }
1321
1322 /**
1323 * @tc.name: EventManagerTest028
1324 * @tc.desc: Test DispatchTouchEvent:hoverNodeCur and hoverNodePre both null
1325 * @tc.type: FUNC
1326 */
1327 HWTEST_F(EventManagerTestNg, EventManagerTest028, TestSize.Level1)
1328 {
1329 /**
1330 * @tc.steps: step1. Create EventManager.
1331 * @tc.expected: eventManager is not null.
1332 */
1333 auto eventManager = AceType::MakeRefPtr<EventManager>();
1334 ASSERT_NE(eventManager, nullptr);
1335
1336 eventManager->currHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr);
1337 eventManager->lastHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr);
1338
1339 /**
1340 * @tc.steps: step2. Call DispatchMouseHoverAnimationNG with MouseAction::PRESS;
1341 * @tc.expected: ret is false
1342 */
1343 MouseEvent event;
1344 event.button = MouseButton::NONE_BUTTON;
1345 event.action = MouseAction::PRESS;
1346 eventManager->DispatchMouseHoverAnimationNG(event);
1347 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1348
1349 /**
1350 * @tc.steps: step3. Call DispatchMouseHoverAnimationNG with MouseAction::RELEASE;
1351 * @tc.expected: ret is false
1352 */
1353 event.action = MouseAction::RELEASE;
1354 eventManager->DispatchMouseHoverAnimationNG(event);
1355 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1356
1357 /**
1358 * @tc.steps: step4. Call DispatchMouseHoverAnimationNG with MouseAction::MOVE;
1359 * @tc.expected: ret is false
1360 */
1361 event.action = MouseAction::MOVE;
1362 eventManager->DispatchMouseHoverAnimationNG(event);
1363 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1364
1365 /**
1366 * @tc.steps: step5. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_ENTER;
1367 * @tc.expected: ret is false
1368 */
1369 event.action = MouseAction::WINDOW_ENTER;
1370 eventManager->DispatchMouseHoverAnimationNG(event);
1371 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1372
1373 /**
1374 * @tc.steps: step6. Call DispatchMouseHoverAnimationNG with MouseAction::WINDOW_LEAVE;
1375 * @tc.expected: ret is false
1376 */
1377 event.action = MouseAction::WINDOW_LEAVE;
1378 eventManager->DispatchMouseHoverAnimationNG(event);
1379 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1380
1381 /**
1382 * @tc.steps: step6. Call DispatchMouseHoverAnimationNG with MouseAction::HOVER;
1383 * @tc.expected: ret is false
1384 */
1385 event.action = MouseAction::HOVER;
1386 eventManager->DispatchMouseHoverAnimationNG(event);
1387 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr);
1388 }
1389
1390 /**
1391 * @tc.name: EventManagerTest029
1392 * @tc.desc: Test TouchTest
1393 * @tc.type: FUNC
1394 */
1395 HWTEST_F(EventManagerTestNg, EventManagerTest029, TestSize.Level1)
1396 {
1397 /**
1398 * @tc.steps: step1. Create EventManager.
1399 * @tc.expected: eventManager is not null.
1400 */
1401 auto eventManager = AceType::MakeRefPtr<EventManager>();
1402 ASSERT_NE(eventManager, nullptr);
1403
1404 TouchEvent touchPoint;
1405 touchPoint.id = 100;
1406 touchPoint.type = TouchType::DOWN;
1407
1408 TouchRestrict touchRestrict;
1409 Offset offset;
1410
1411 /**
1412 * @tc.steps: step1. Create renderNode.
1413 * @tc.expected: renderNode is not null.
1414 */
1415 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
1416 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
1417
1418 /**
1419 * @tc.steps: step2. Call TouchTest with MouseAction::PRESS;
1420 * @tc.expected: ret is false
1421 */
1422 eventManager->TouchTest(touchPoint, renderNode, touchRestrict, offset, 0, true);
1423 auto findIt = eventManager->touchTestResults_.find(touchPoint.id);
1424 EXPECT_EQ(findIt, eventManager->touchTestResults_.end());
1425 }
1426
1427 /**
1428 * @tc.name: EventManagerTest032
1429 * @tc.desc: Test DispatchAxisEvent
1430 * @tc.type: FUNC
1431 */
1432 HWTEST_F(EventManagerTestNg, EventManagerTest032, TestSize.Level1)
1433 {
1434 /**
1435 * @tc.steps: step1. Create EventManager.
1436 * @tc.expected: eventManager is not null.
1437 */
1438 auto eventManager = AceType::MakeRefPtr<EventManager>();
1439 ASSERT_NE(eventManager, nullptr);
1440
1441 AxisEvent axisEvent;
1442 axisEvent.horizontalAxis = 0;
1443 axisEvent.verticalAxis = 0;
1444 axisEvent.pinchAxisScale = 1.0f;
1445
1446 /**
1447 * @tc.steps: step2. Call AxisTest with SourceType::TOUCH.
1448 * @tc.expected: eventManager->axisNode_.Upgrade() is not null.
1449 */
1450 bool retFlag = eventManager->DispatchAxisEvent(axisEvent);
1451 ASSERT_TRUE(retFlag);
1452 }
1453
1454 /**
1455 * @tc.name: EventManagerTest033
1456 * @tc.desc: Test DumpEvent
1457 * @tc.type: FUNC
1458 */
1459 HWTEST_F(EventManagerTestNg, EventManagerTest033, TestSize.Level1)
1460 {
1461 /**
1462 * @tc.steps: step1. Create EventManager.
1463 * @tc.expected: eventManager is not null.
1464 */
1465 auto eventManager = AceType::MakeRefPtr<EventManager>();
1466 ASSERT_NE(eventManager, nullptr);
1467
1468 /**
1469 * @tc.steps: step2. Call DumpEvent.
1470 * @tc.expected: eventManager->axisNode_.Upgrade() is not null.
1471 */
1472 eventManager->DumpEvent();
1473 std::list<std::pair<int32_t, std::string>> dumpList;
1474 eventManager->eventTree_.Dump(dumpList, 0);
1475 ASSERT_TRUE(dumpList.empty());
1476 }
1477
1478 /**
1479 * @tc.name: EventManagerTest034
1480 * @tc.desc: Test DispatchMouseEvent
1481 * @tc.type: FUNC
1482 */
1483 HWTEST_F(EventManagerTestNg, EventManagerTest034, TestSize.Level1)
1484 {
1485 /**
1486 * @tc.steps: step1. Create EventManager.
1487 * @tc.expected: eventManager is not null.
1488 */
1489 auto eventManager = AceType::MakeRefPtr<EventManager>();
1490 ASSERT_NE(eventManager, nullptr);
1491
1492 /**
1493 * @tc.steps: step2. Call DispatchMouseEvent.
1494 * @tc.expected: retFlag is false.
1495 */
1496 MouseEvent event;
1497 event.action = MouseAction::PRESS;
1498 bool retFlag = eventManager->DispatchMouseEvent(event);
1499 ASSERT_TRUE(retFlag);
1500 }
1501
1502 /**
1503 * @tc.name: EventManagerTest0351
1504 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::PRESS branches
1505 * @tc.type: FUNC
1506 */
1507 HWTEST_F(EventManagerTestNg, EventManagerTest0351, TestSize.Level1)
1508 {
1509 /**
1510 * @tc.steps: step1. Create EventManager.
1511 * @tc.expected: eventManager is not null.
1512 */
1513 auto eventManager = AceType::MakeRefPtr<EventManager>();
1514 ASSERT_NE(eventManager, nullptr);
1515
1516 /**
1517 * @tc.steps: step2. Call DispatchMouseEvent.
1518 * @tc.expected: hoverNodeCur is not null.
1519 */
1520 MouseEvent event;
1521 event.action = MouseAction::PRESS;
1522 eventManager->DispatchMouseHoverAnimation(event);
1523 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1524 EXPECT_EQ(hoverNodeCur, nullptr);
1525 }
1526
1527 /**
1528 * @tc.name: EventManagerTest0352
1529 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::RELEASE branches
1530 * @tc.type: FUNC
1531 */
1532 HWTEST_F(EventManagerTestNg, EventManagerTest0352, TestSize.Level1)
1533 {
1534 /**
1535 * @tc.steps: step1. Create EventManager.
1536 * @tc.expected: eventManager is not null.
1537 */
1538 auto eventManager = AceType::MakeRefPtr<EventManager>();
1539 ASSERT_NE(eventManager, nullptr);
1540
1541 /**
1542 * @tc.steps: step2. Call DispatchMouseEvent.
1543 * @tc.expected: hoverNodeCur is not null.
1544 */
1545 MouseEvent event;
1546 event.action = MouseAction::RELEASE;
1547 eventManager->DispatchMouseHoverAnimation(event);
1548 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1549 EXPECT_EQ(hoverNodeCur, nullptr);
1550 }
1551
1552 /**
1553 * @tc.name: EventManagerTest0353
1554 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::WINDOW_ENTER branches
1555 * @tc.type: FUNC
1556 */
1557 HWTEST_F(EventManagerTestNg, EventManagerTest0353, TestSize.Level1)
1558 {
1559 /**
1560 * @tc.steps: step1. Create EventManager.
1561 * @tc.expected: eventManager is not null.
1562 */
1563 auto eventManager = AceType::MakeRefPtr<EventManager>();
1564 ASSERT_NE(eventManager, nullptr);
1565
1566 /**
1567 * @tc.steps: step2. Call DispatchMouseEvent.
1568 * @tc.expected: hoverNodeCur is not null.
1569 */
1570 MouseEvent event;
1571 event.action = MouseAction::WINDOW_ENTER;
1572 eventManager->DispatchMouseHoverAnimation(event);
1573 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1574 EXPECT_EQ(hoverNodeCur, nullptr);
1575 }
1576
1577 /**
1578 * @tc.name: EventManagerTest0354
1579 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::WINDOW_LEAVE branches
1580 * @tc.type: FUNC
1581 */
1582 HWTEST_F(EventManagerTestNg, EventManagerTest0354, TestSize.Level1)
1583 {
1584 /**
1585 * @tc.steps: step1. Create EventManager.
1586 * @tc.expected: eventManager is not null.
1587 */
1588 auto eventManager = AceType::MakeRefPtr<EventManager>();
1589 ASSERT_NE(eventManager, nullptr);
1590
1591 /**
1592 * @tc.steps: step2. Call DispatchMouseEvent.
1593 * @tc.expected: hoverNodeCur is not null.
1594 */
1595 MouseEvent event;
1596 event.action = MouseAction::WINDOW_LEAVE;
1597 eventManager->DispatchMouseHoverAnimation(event);
1598 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1599 EXPECT_EQ(hoverNodeCur, nullptr);
1600 }
1601
1602 /**
1603 * @tc.name: EventManagerTest0355
1604 * @tc.desc: Test DispatchMouseHoverAnimation in MouseButton::NONE_BUTTON and MouseAction::MOVE branches
1605 * @tc.type: FUNC
1606 */
1607 HWTEST_F(EventManagerTestNg, EventManagerTest0355, TestSize.Level1)
1608 {
1609 /**
1610 * @tc.steps: step1. Create EventManager.
1611 * @tc.expected: eventManager is not null.
1612 */
1613 auto eventManager = AceType::MakeRefPtr<EventManager>();
1614 ASSERT_NE(eventManager, nullptr);
1615
1616 /**
1617 * @tc.steps: step2. Call DispatchMouseEvent.
1618 * @tc.expected: hoverNodeCur is not null.
1619 */
1620 MouseEvent event;
1621 event.button = MouseButton::NONE_BUTTON;
1622 event.action = MouseAction::MOVE;
1623 eventManager->DispatchMouseHoverAnimation(event);
1624 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1625 EXPECT_EQ(hoverNodeCur, nullptr);
1626 }
1627
1628 /**
1629 * @tc.name: EventManagerTest0356
1630 * @tc.desc: Test DispatchMouseHoverAnimation in MouseAction::MOVE branches
1631 * @tc.type: FUNC
1632 */
1633 HWTEST_F(EventManagerTestNg, EventManagerTest0356, TestSize.Level1)
1634 {
1635 /**
1636 * @tc.steps: step1. Create EventManager.
1637 * @tc.expected: eventManager is not null.
1638 */
1639 auto eventManager = AceType::MakeRefPtr<EventManager>();
1640 ASSERT_NE(eventManager, nullptr);
1641
1642 /**
1643 * @tc.steps: step2. Call DispatchMouseEvent.
1644 * @tc.expected: hoverNodeCur is not null.
1645 */
1646 MouseEvent event;
1647 event.action = MouseAction::MOVE;
1648 eventManager->DispatchMouseHoverAnimation(event);
1649 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1650 EXPECT_EQ(hoverNodeCur, nullptr);
1651 }
1652
1653 /**
1654 * @tc.name: EventManagerTest0357
1655 * @tc.desc: Test DispatchMouseHoverAnimation in MouseButton::NONE_BUTTON branches
1656 * @tc.type: FUNC
1657 */
1658 HWTEST_F(EventManagerTestNg, EventManagerTest0357, TestSize.Level1)
1659 {
1660 /**
1661 * @tc.steps: step1. Create EventManager.
1662 * @tc.expected: eventManager is not null.
1663 */
1664 auto eventManager = AceType::MakeRefPtr<EventManager>();
1665 ASSERT_NE(eventManager, nullptr);
1666
1667 /**
1668 * @tc.steps: step2. Call DispatchMouseEvent.
1669 * @tc.expected: hoverNodeCur is not null.
1670 */
1671 MouseEvent event;
1672 event.button = MouseButton::NONE_BUTTON;
1673 eventManager->DispatchMouseHoverAnimation(event);
1674 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
1675 EXPECT_EQ(hoverNodeCur, nullptr);
1676 }
1677
1678 /**
1679 * @tc.name: EventManagerTest036
1680 * @tc.desc: Test DispatchMouseHoverEvent
1681 * @tc.type: FUNC
1682 */
1683 HWTEST_F(EventManagerTestNg, EventManagerTest036, TestSize.Level1)
1684 {
1685 /**
1686 * @tc.steps: step1. Create EventManager.
1687 * @tc.expected: eventManager is not null.
1688 */
1689 auto eventManager = AceType::MakeRefPtr<EventManager>();
1690 ASSERT_NE(eventManager, nullptr);
1691
1692 /**
1693 * @tc.steps: step2. Call DispatchMouseHoverEvent.
1694 * @tc.expected: retFlag is true.
1695 */
1696 MouseEvent event;
1697 bool retFlag = eventManager->DispatchMouseHoverEvent(event);
1698 ASSERT_TRUE(retFlag);
1699 }
1700
1701 /**
1702 * @tc.name: PanRecognizerAxisDirection001
1703 * @tc.desc: Test GetAxisDirection() of PanRecognizer.
1704 * @tc.type: FUNC
1705 */
1706 HWTEST_F(EventManagerTestNg, PanRecognizerAxisDirection001, TestSize.Level1)
1707 {
1708 /**
1709 * @tc.steps: step1. Create pan recognizers.
1710 * @tc.expected: recognizers is not null and axis direction is correct.
1711 */
1712 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>(
1713 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1714 ASSERT_NE(panHorizontal, nullptr);
1715 EXPECT_EQ(panHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1716
1717 auto panVertical = AceType::MakeRefPtr<PanRecognizer>(
1718 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1719 ASSERT_NE(panVertical, nullptr);
1720 EXPECT_EQ(panVertical->GetAxisDirection(), Axis::VERTICAL);
1721
1722 auto panLeft = AceType::MakeRefPtr<PanRecognizer>(
1723 DEFAULT_PAN_FINGER, PanDirection { PanDirection::LEFT }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1724 ASSERT_NE(panLeft, nullptr);
1725 EXPECT_EQ(panLeft->GetAxisDirection(), Axis::HORIZONTAL);
1726
1727 auto panRight = AceType::MakeRefPtr<PanRecognizer>(
1728 DEFAULT_PAN_FINGER, PanDirection { PanDirection::RIGHT }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1729 ASSERT_NE(panRight, nullptr);
1730 EXPECT_EQ(panRight->GetAxisDirection(), Axis::HORIZONTAL);
1731
1732 auto panUp = AceType::MakeRefPtr<PanRecognizer>(
1733 DEFAULT_PAN_FINGER, PanDirection { PanDirection::UP }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1734 ASSERT_NE(panUp, nullptr);
1735 EXPECT_EQ(panUp->GetAxisDirection(), Axis::VERTICAL);
1736
1737 auto panDown = AceType::MakeRefPtr<PanRecognizer>(
1738 DEFAULT_PAN_FINGER, PanDirection { PanDirection::DOWN }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1739 ASSERT_NE(panDown, nullptr);
1740 EXPECT_EQ(panDown->GetAxisDirection(), Axis::VERTICAL);
1741
1742 auto panFree = AceType::MakeRefPtr<PanRecognizer>(
1743 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1744 ASSERT_NE(panFree, nullptr);
1745 EXPECT_EQ(panFree->GetAxisDirection(), Axis::FREE);
1746 }
1747
1748 /**
1749 * @tc.name: SwipeRecognizerAxisDirection001
1750 * @tc.desc: Test GetAxisDirection() of SwipeRecognizer.
1751 * @tc.type: FUNC
1752 */
1753 HWTEST_F(EventManagerTestNg, SwipeRecognizerAxisDirection001, TestSize.Level1)
1754 {
1755 /**
1756 * @tc.steps: step1. Create swipe recognizers.
1757 * @tc.expected: recognizers is not null and axis direction is correct.
1758 */
1759 auto swipeHorizontal = AceType::MakeRefPtr<SwipeRecognizer>(1, SwipeDirection { SwipeDirection::HORIZONTAL }, 0.0);
1760 ASSERT_NE(swipeHorizontal, nullptr);
1761 EXPECT_EQ(swipeHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1762
1763 auto swipeVertical = AceType::MakeRefPtr<SwipeRecognizer>(1, SwipeDirection { SwipeDirection::VERTICAL }, 0.0);
1764 ASSERT_NE(swipeVertical, nullptr);
1765 EXPECT_EQ(swipeVertical->GetAxisDirection(), Axis::VERTICAL);
1766
1767 auto swipeFree = AceType::MakeRefPtr<SwipeRecognizer>(1, SwipeDirection { SwipeDirection::ALL }, 0.0);
1768 ASSERT_NE(swipeFree, nullptr);
1769 EXPECT_EQ(swipeFree->GetAxisDirection(), Axis::FREE);
1770 }
1771
1772 /**
1773 * @tc.name: ExclusiveRecognizerAxisDirection001
1774 * @tc.desc: Test GetAxisDirection() of ExclusiveRecognizer.
1775 * @tc.type: FUNC
1776 */
1777 HWTEST_F(EventManagerTestNg, ExclusiveRecognizerAxisDirection001, TestSize.Level1)
1778 {
1779 /**
1780 * @tc.steps: step1. Create pan recognizers.
1781 * @tc.expected: recognizers is not null and axis direction is correct.
1782 */
1783 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
1784 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1785 ASSERT_NE(panHorizontal1, nullptr);
1786 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
1787 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1788 ASSERT_NE(panHorizontal2, nullptr);
1789
1790 auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
1791 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1792 ASSERT_NE(panVertical1, nullptr);
1793 auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
1794 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1795 ASSERT_NE(panVertical2, nullptr);
1796
1797 auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
1798 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1799 ASSERT_NE(panFree1, nullptr);
1800 auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
1801 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1802 ASSERT_NE(panFree2, nullptr);
1803
1804 /**
1805 * @tc.steps: step2. Create exclusive recognizers.
1806 * @tc.expected: recognizers is not null and axis direction is correct.
1807 */
1808 std::vector<RefPtr<NGGestureRecognizer>> recognizers;
1809 recognizers.clear();
1810 recognizers.emplace_back(panHorizontal1);
1811 recognizers.emplace_back(panHorizontal2);
1812 auto exclusiveDoubleHorizontal = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1813 ASSERT_NE(exclusiveDoubleHorizontal, nullptr);
1814 EXPECT_EQ(exclusiveDoubleHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1815
1816 recognizers.clear();
1817 recognizers.emplace_back(panVertical1);
1818 recognizers.emplace_back(panVertical2);
1819 auto exclusiveDoubleVertical = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1820 ASSERT_NE(exclusiveDoubleVertical, nullptr);
1821 EXPECT_EQ(exclusiveDoubleVertical->GetAxisDirection(), Axis::VERTICAL);
1822
1823 recognizers.clear();
1824 recognizers.emplace_back(panFree1);
1825 recognizers.emplace_back(panFree2);
1826 auto exclusiveDoubleFree = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1827 ASSERT_NE(exclusiveDoubleFree, nullptr);
1828 EXPECT_EQ(exclusiveDoubleFree->GetAxisDirection(), Axis::FREE);
1829
1830 recognizers.clear();
1831 recognizers.emplace_back(panHorizontal1);
1832 recognizers.emplace_back(panVertical1);
1833 auto exclusiveHorizontalVertical = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1834 ASSERT_NE(exclusiveHorizontalVertical, nullptr);
1835 EXPECT_EQ(exclusiveHorizontalVertical->GetAxisDirection(), Axis::FREE);
1836
1837 recognizers.clear();
1838 recognizers.emplace_back(panHorizontal1);
1839 recognizers.emplace_back(panFree1);
1840 auto exclusiveHorizontalFree = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1841 ASSERT_NE(exclusiveHorizontalFree, nullptr);
1842 EXPECT_EQ(exclusiveHorizontalFree->GetAxisDirection(), Axis::FREE);
1843
1844 recognizers.clear();
1845 recognizers.emplace_back(panVertical1);
1846 recognizers.emplace_back(panFree1);
1847 auto exclusiveVerticalFree = AceType::MakeRefPtr<ExclusiveRecognizer>(recognizers);
1848 ASSERT_NE(exclusiveVerticalFree, nullptr);
1849 EXPECT_EQ(exclusiveVerticalFree->GetAxisDirection(), Axis::FREE);
1850 }
1851
1852 /**
1853 * @tc.name: ParallelRecognizerAxisDirection001
1854 * @tc.desc: Test GetAxisDirection() of ParallelRecognizer.
1855 * @tc.type: FUNC
1856 */
1857 HWTEST_F(EventManagerTestNg, ParallelRecognizerAxisDirection001, TestSize.Level1)
1858 {
1859 /**
1860 * @tc.steps: step1. Create pan recognizers.
1861 * @tc.expected: recognizers is not null and axis direction is correct.
1862 */
1863 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
1864 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1865 ASSERT_NE(panHorizontal1, nullptr);
1866 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
1867 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1868 ASSERT_NE(panHorizontal2, nullptr);
1869
1870 auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
1871 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1872 ASSERT_NE(panVertical1, nullptr);
1873 auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
1874 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1875 ASSERT_NE(panVertical2, nullptr);
1876
1877 auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
1878 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1879 ASSERT_NE(panFree1, nullptr);
1880 auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
1881 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1882 ASSERT_NE(panFree2, nullptr);
1883
1884 /**
1885 * @tc.steps: step2. Create parallel recognizers.
1886 * @tc.expected: recognizers is not null and axis direction is correct.
1887 */
1888 std::vector<RefPtr<NGGestureRecognizer>> recognizers;
1889 recognizers.clear();
1890 recognizers.emplace_back(panHorizontal1);
1891 recognizers.emplace_back(panHorizontal2);
1892 auto parallelDoubleHorizontal = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1893 ASSERT_NE(parallelDoubleHorizontal, nullptr);
1894 EXPECT_EQ(parallelDoubleHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1895
1896 recognizers.clear();
1897 recognizers.emplace_back(panVertical1);
1898 recognizers.emplace_back(panVertical2);
1899 auto parallelDoubleVertical = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1900 ASSERT_NE(parallelDoubleVertical, nullptr);
1901 EXPECT_EQ(parallelDoubleVertical->GetAxisDirection(), Axis::VERTICAL);
1902
1903 recognizers.clear();
1904 recognizers.emplace_back(panFree1);
1905 recognizers.emplace_back(panFree2);
1906 auto parallelDoubleFree = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1907 ASSERT_NE(parallelDoubleFree, nullptr);
1908 EXPECT_EQ(parallelDoubleFree->GetAxisDirection(), Axis::FREE);
1909
1910 recognizers.clear();
1911 recognizers.emplace_back(panHorizontal1);
1912 recognizers.emplace_back(panVertical1);
1913 auto parallelHorizontalVertical = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1914 ASSERT_NE(parallelHorizontalVertical, nullptr);
1915 EXPECT_EQ(parallelHorizontalVertical->GetAxisDirection(), Axis::FREE);
1916
1917 recognizers.clear();
1918 recognizers.emplace_back(panHorizontal1);
1919 recognizers.emplace_back(panFree1);
1920 auto parallelHorizontalFree = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1921 ASSERT_NE(parallelHorizontalFree, nullptr);
1922 EXPECT_EQ(parallelHorizontalFree->GetAxisDirection(), Axis::FREE);
1923
1924 recognizers.clear();
1925 recognizers.emplace_back(panVertical1);
1926 recognizers.emplace_back(panFree1);
1927 auto parallelVerticalFree = AceType::MakeRefPtr<ParallelRecognizer>(recognizers);
1928 ASSERT_NE(parallelVerticalFree, nullptr);
1929 EXPECT_EQ(parallelVerticalFree->GetAxisDirection(), Axis::FREE);
1930 }
1931
1932 /**
1933 * @tc.name: SequenceRecognizerAxisDirection001
1934 * @tc.desc: Test GetAxisDirection() of SequenceRecognizer.
1935 * @tc.type: FUNC
1936 */
1937 HWTEST_F(EventManagerTestNg, SequenceRecognizerAxisDirection001, TestSize.Level1)
1938 {
1939 /**
1940 * @tc.steps: step1. Create pan recognizers.
1941 * @tc.expected: recognizers is not null and axis direction is correct.
1942 */
1943 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
1944 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1945 ASSERT_NE(panHorizontal1, nullptr);
1946 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
1947 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1948 ASSERT_NE(panHorizontal2, nullptr);
1949
1950 auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
1951 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1952 ASSERT_NE(panVertical1, nullptr);
1953 auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
1954 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1955 ASSERT_NE(panVertical2, nullptr);
1956
1957 auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
1958 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1959 ASSERT_NE(panFree1, nullptr);
1960 auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
1961 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
1962 ASSERT_NE(panFree2, nullptr);
1963
1964 /**
1965 * @tc.steps: step2. Create sequence recognizers.
1966 * @tc.expected: recognizers is not null and axis direction is correct.
1967 */
1968 std::vector<RefPtr<NGGestureRecognizer>> recognizers;
1969 recognizers.clear();
1970 recognizers.emplace_back(panHorizontal1);
1971 recognizers.emplace_back(panHorizontal2);
1972 auto sequenceDoubleHorizontal = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1973 ASSERT_NE(sequenceDoubleHorizontal, nullptr);
1974 EXPECT_EQ(sequenceDoubleHorizontal->GetAxisDirection(), Axis::HORIZONTAL);
1975
1976 recognizers.clear();
1977 recognizers.emplace_back(panVertical1);
1978 recognizers.emplace_back(panVertical2);
1979 auto sequenceDoubleVertical = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1980 ASSERT_NE(sequenceDoubleVertical, nullptr);
1981 EXPECT_EQ(sequenceDoubleVertical->GetAxisDirection(), Axis::VERTICAL);
1982
1983 recognizers.clear();
1984 recognizers.emplace_back(panFree1);
1985 recognizers.emplace_back(panFree2);
1986 auto sequenceDoubleFree = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1987 ASSERT_NE(sequenceDoubleFree, nullptr);
1988 EXPECT_EQ(sequenceDoubleFree->GetAxisDirection(), Axis::FREE);
1989
1990 recognizers.clear();
1991 recognizers.emplace_back(panHorizontal1);
1992 recognizers.emplace_back(panVertical1);
1993 auto sequenceHorizontalVertical = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
1994 ASSERT_NE(sequenceHorizontalVertical, nullptr);
1995 EXPECT_EQ(sequenceHorizontalVertical->GetAxisDirection(), Axis::FREE);
1996
1997 recognizers.clear();
1998 recognizers.emplace_back(panHorizontal1);
1999 recognizers.emplace_back(panFree1);
2000 auto sequenceHorizontalFree = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
2001 ASSERT_NE(sequenceHorizontalFree, nullptr);
2002 EXPECT_EQ(sequenceHorizontalFree->GetAxisDirection(), Axis::FREE);
2003
2004 recognizers.clear();
2005 recognizers.emplace_back(panVertical1);
2006 recognizers.emplace_back(panFree1);
2007 auto sequenceVerticalFree = AceType::MakeRefPtr<SequencedRecognizer>(recognizers);
2008 ASSERT_NE(sequenceVerticalFree, nullptr);
2009 EXPECT_EQ(sequenceVerticalFree->GetAxisDirection(), Axis::FREE);
2010 }
2011
2012 /**
2013 * @tc.name: HasDifferentDirectionGesture001
2014 * @tc.desc: Test HasDifferentDirectionGesture() of EventManager.
2015 * @tc.type: FUNC
2016 */
2017 HWTEST_F(EventManagerTestNg, HasDifferentDirectionGesture001, TestSize.Level1)
2018 {
2019 /**
2020 * @tc.steps: step1. Create pan recognizers.
2021 * @tc.expected: recognizers is not null and axis direction is correct.
2022 */
2023 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>(
2024 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
2025 ASSERT_NE(panHorizontal1, nullptr);
2026 auto panHorizontal2 = AceType::MakeRefPtr<PanRecognizer>(
2027 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
2028 ASSERT_NE(panHorizontal2, nullptr);
2029
2030 auto panVertical1 = AceType::MakeRefPtr<PanRecognizer>(
2031 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
2032 ASSERT_NE(panVertical1, nullptr);
2033 auto panVertical2 = AceType::MakeRefPtr<PanRecognizer>(
2034 DEFAULT_PAN_FINGER, PanDirection { PanDirection::VERTICAL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
2035 ASSERT_NE(panVertical2, nullptr);
2036
2037 auto panFree1 = AceType::MakeRefPtr<PanRecognizer>(
2038 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
2039 ASSERT_NE(panFree1, nullptr);
2040 auto panFree2 = AceType::MakeRefPtr<PanRecognizer>(
2041 DEFAULT_PAN_FINGER, PanDirection { PanDirection::ALL }, DEFAULT_PAN_DISTANCE.ConvertToPx());
2042 ASSERT_NE(panFree2, nullptr);
2043
2044 /**
2045 * @tc.steps: step2. Create EventManager.
2046 * @tc.expected: eventManager is not null.
2047 */
2048 auto eventManager = AceType::MakeRefPtr<EventManager>();
2049 ASSERT_NE(eventManager, nullptr);
2050 TouchTestResult hitTestResult;
2051
2052 /**
2053 * @tc.steps: step3. Add 2 horizontal recognizer to axisTouchTestResults_
2054 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is false.
2055 */
2056 hitTestResult.clear();
2057 eventManager->axisTouchTestResults_.clear();
2058 hitTestResult.emplace_back(panHorizontal1);
2059 hitTestResult.emplace_back(panHorizontal2);
2060 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
2061 EXPECT_FALSE(eventManager->HasDifferentDirectionGesture());
2062
2063 /**
2064 * @tc.steps: step4. Add 2 vertical recognizer to axisTouchTestResults_
2065 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is false.
2066 */
2067 hitTestResult.clear();
2068 eventManager->axisTouchTestResults_.clear();
2069 hitTestResult.emplace_back(panVertical1);
2070 hitTestResult.emplace_back(panVertical2);
2071 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
2072 EXPECT_FALSE(eventManager->HasDifferentDirectionGesture());
2073
2074 /**
2075 * @tc.steps: step5. Add horizontal and vertical recognizer to axisTouchTestResults_
2076 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
2077 */
2078 hitTestResult.clear();
2079 eventManager->axisTouchTestResults_.clear();
2080 hitTestResult.emplace_back(panHorizontal1);
2081 hitTestResult.emplace_back(panVertical1);
2082 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
2083 EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
2084
2085 /**
2086 * @tc.steps: step6. Add horizontal and free recognizer to axisTouchTestResults_
2087 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
2088 */
2089 hitTestResult.clear();
2090 eventManager->axisTouchTestResults_.clear();
2091 hitTestResult.emplace_back(panHorizontal1);
2092 hitTestResult.emplace_back(panFree1);
2093 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
2094 EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
2095
2096 /**
2097 * @tc.steps: step6. Add vertical and free recognizer to axisTouchTestResults_
2098 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
2099 */
2100 hitTestResult.clear();
2101 eventManager->axisTouchTestResults_.clear();
2102 hitTestResult.emplace_back(panVertical1);
2103 hitTestResult.emplace_back(panFree1);
2104 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
2105 EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
2106
2107 /**
2108 * @tc.steps: step6. Add free and free recognizer to axisTouchTestResults_
2109 * @tc.expected: axisTouchTestResults_->HasDifferentDirectionGesture() is true.
2110 */
2111 hitTestResult.clear();
2112 eventManager->axisTouchTestResults_.clear();
2113 hitTestResult.emplace_back(panFree1);
2114 hitTestResult.emplace_back(panFree2);
2115 eventManager->axisTouchTestResults_[MOUSE_BASE_ID] = std::move(hitTestResult);
2116 EXPECT_TRUE(eventManager->HasDifferentDirectionGesture());
2117 }
2118
2119 /**
2120 * @tc.name: EventManagerTest038
2121 * @tc.desc: Test DispatchRotationEvent
2122 * @tc.type: FUNC
2123 */
2124 HWTEST_F(EventManagerTestNg, EventManagerTest038, TestSize.Level1)
2125 {
2126 /**
2127 * @tc.steps: step1. Create EventManager.
2128 * @tc.expected: eventManager is not null.
2129 */
2130 auto eventManager = AceType::MakeRefPtr<EventManager>();
2131 ASSERT_NE(eventManager, nullptr);
2132
2133 /**
2134 * @tc.steps: step2. Call DispatchRotationEvent.
2135 * @tc.expected: ret is false.
2136 */
2137 RotationEvent event;
2138 event.value = 0.1;
2139 auto animatablePoperties = AceType::MakeRefPtr<OHOS::Ace::AnimatableProperties>();
2140 auto renderNode = AceType::DynamicCast<RenderNode>(animatablePoperties);
2141 const RefPtr<RenderNode> requestNode = nullptr;
2142 auto ret = eventManager->DispatchRotationEvent(event, renderNode, requestNode);
2143 EXPECT_FALSE(ret);
2144 }
2145
2146 /**
2147 * @tc.name: EventManagerTest039
2148 * @tc.desc: Test PostEventDispatchTouchEvent
2149 * @tc.type: FUNC
2150 */
2151 HWTEST_F(EventManagerTestNg, EventManagerTest039, TestSize.Level1)
2152 {
2153 /**
2154 * @tc.steps: step1. Create EventManager.
2155 * @tc.expected: eventManager is not null.
2156 */
2157 auto eventManager = AceType::MakeRefPtr<EventManager>();
2158 ASSERT_NE(eventManager, nullptr);
2159 AceEngine& aceEngine = AceEngine::Get();
2160 aceEngine.AddContainer(CONTAINER_INSTANCE_ID, MockContainer::container_);
2161
2162 /**
2163 * @tc.steps: step2. Call PostEventDispatchTouchEvent with event.
2164 * @tc.expected: ret is true
2165 */
2166 TouchEvent event;
2167 event.type = TouchType::DOWN;
2168 TouchTestResult touchTestResults;
2169 auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
2170 touchTestResults.push_back(eventTarget);
2171 eventManager->postEventTouchTestResults_.emplace(event.id, touchTestResults);
2172 auto ret = eventManager->PostEventDispatchTouchEvent(event);
2173 EXPECT_TRUE(ret);
2174
2175 /**
2176 * @tc.steps: step3. Call PostEventDispatchTouchEvent event.
2177 * @tc.expected: ret is true
2178 */
2179 event.type = TouchType::UP;
2180 touchTestResults.push_back(eventTarget);
2181 eventManager->postEventTouchTestResults_.emplace(event.id, touchTestResults);
2182 ret = eventManager->PostEventDispatchTouchEvent(event);
2183 EXPECT_TRUE(ret);
2184
2185 /**
2186 * @tc.steps: step4. Call PostEventDispatchTouchEvent event.
2187 * @tc.expected: ret is true
2188 */
2189 event.type = TouchType::CANCEL;
2190 touchTestResults.push_back(eventTarget);
2191 eventManager->postEventTouchTestResults_.emplace(event.id, touchTestResults);
2192 ret = eventManager->PostEventDispatchTouchEvent(event);
2193 EXPECT_TRUE(ret);
2194 }
2195
2196 /**
2197 * @tc.name: EventManagerTest040
2198 * @tc.desc: Test DispatchMouseEvent
2199 * @tc.type: FUNC
2200 */
2201 HWTEST_F(EventManagerTestNg, EventManagerTest040, TestSize.Level1)
2202 {
2203 /**
2204 * @tc.steps: step1. Create EventManager.
2205 * @tc.expected: eventManager is not null.
2206 */
2207 auto eventManager = AceType::MakeRefPtr<EventManager>();
2208 ASSERT_NE(eventManager, nullptr);
2209
2210 /**
2211 * @tc.steps: step2. Call DispatchMouseEvent.
2212 * @tc.expected: retFlag is true.
2213 */
2214 MouseEvent event;
2215 event.action = MouseAction::MOVE;
2216 bool retFlag = eventManager->DispatchMouseEvent(event);
2217 ASSERT_TRUE(retFlag);
2218 }
2219
2220 /**
2221 * @tc.name: EventManagerTest041
2222 * @tc.desc: Test HandleGlobalEventNG
2223 * @tc.type: FUNC
2224 */
2225 HWTEST_F(EventManagerTestNg, EventManagerTest041, TestSize.Level1)
2226 {
2227 /**
2228 * @tc.steps: step1. Create EventManager.
2229 * @tc.expected: eventManager is not null.
2230 */
2231 auto eventManager = AceType::MakeRefPtr<EventManager>();
2232 ASSERT_NE(eventManager, nullptr);
2233
2234 /**
2235 * @tc.steps: step2. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id].
2236 * @tc.expected: touchTestResults_ has the touchPoint.id of instance.
2237 */
2238 TouchEvent touchPoint;
2239 touchPoint.id = 1000;
2240 touchPoint.type = TouchType::DOWN;
2241
2242 const int nodeId = 10003;
2243 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr);
2244 TouchRestrict touchRestrict;
2245 Offset offset;
2246
2247 eventManager->TouchTest(touchPoint, frameNode, touchRestrict, offset, 0, true);
2248 EXPECT_GT(eventManager->touchTestResults_.count(touchPoint.id), 0);
2249 TouchTestResult touchTestResults;
2250 auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
2251 touchTestResults.push_back(eventTarget);
2252 eventManager->touchTestResults_.emplace(touchPoint.id, touchTestResults);
2253
2254 /**
2255 * @tc.steps: step3. Create FrameNode and Call HandleGlobalEventNG.
2256 * @tc.expected: touchTestResults_.size() is equal to 1.
2257 */
2258 auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode);
2259 NG::OffsetF rootOffset;
2260 eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset);
2261 EXPECT_EQ(eventManager->touchTestResults_.size(), 1);
2262 }
2263
2264 /**
2265 * @tc.name: EventManagerTest042
2266 * @tc.desc: Test DispatchMouseHoverAnimation in MouseButton::NONE_BUTTON branches
2267 * @tc.type: FUNC
2268 */
2269 HWTEST_F(EventManagerTestNg, EventManagerTest042, TestSize.Level1)
2270 {
2271 /**
2272 * @tc.steps: step1. Create EventManager.
2273 * @tc.expected: eventManager is not null.
2274 */
2275 auto eventManager = AceType::MakeRefPtr<EventManager>();
2276 ASSERT_NE(eventManager, nullptr);
2277
2278 /**
2279 * @tc.steps: step2. Call DispatchMouseHoverAnimation with event.
2280 * @tc.expected: hoverNodeCur is null.
2281 */
2282 MouseEvent event;
2283 event.button = MouseButton::NONE_BUTTON;
2284 eventManager->DispatchMouseHoverAnimation(event);
2285 auto hoverNodeCur = eventManager->mouseHoverNode_.Upgrade();
2286 EXPECT_EQ(hoverNodeCur, nullptr);
2287 }
2288
2289 /**
2290 * @tc.name: EventManagerTest043
2291 * @tc.desc: Test DispatchTouchEvent
2292 * @tc.type: FUNC
2293 */
2294 HWTEST_F(EventManagerTestNg, EventManagerTest043, TestSize.Level1)
2295 {
2296 /**
2297 * @tc.steps: step1. Create EventManager.
2298 * @tc.expected: eventManager is not null.
2299 */
2300 auto eventManager = AceType::MakeRefPtr<EventManager>();
2301 ASSERT_NE(eventManager, nullptr);
2302 AceEngine& aceEngine = AceEngine::Get();
2303 aceEngine.AddContainer(CONTAINER_INSTANCE_ID, MockContainer::container_);
2304
2305 /**
2306 * @tc.steps: step2. Call DispatchTouchEvent with TouchType::DOWN.
2307 * @tc.expected: ret is false.
2308 */
2309 TouchEvent event;
2310 event.type = TouchType::DOWN;
2311 auto ret = eventManager->DispatchTouchEvent(event);
2312 EXPECT_FALSE(ret);
2313
2314 /**
2315 * @tc.steps: step3. Call DispatchTouchEvent with TouchType::DOWN and
2316 touchTestResults_ has element;
2317 * @tc.expected: ret is true
2318 */
2319 TouchTestResult touchTestResults;
2320 auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>();
2321 touchTestResults.push_back(eventTarget);
2322 eventManager->touchTestResults_.emplace(event.id, touchTestResults);
2323 ret = eventManager->DispatchTouchEvent(event);
2324 EXPECT_TRUE(ret);
2325
2326 /**
2327 * @tc.steps: step4. Call DispatchTouchEvent with TouchType::PULL_MOVE and
2328 touchTestResults_ has element;
2329 * @tc.expected: ret is true
2330 */
2331 event.type = TouchType::PULL_MOVE;
2332 ret = eventManager->DispatchTouchEvent(event);
2333 EXPECT_TRUE(ret);
2334
2335 /**
2336 * @tc.steps: step5. Call DispatchTouchEvent with TouchType::PULL_MOVE and
2337 touchTestResults_ has element;
2338 * @tc.expected: ret is false.
2339 */
2340 event.pullType = TouchType::PULL_MOVE;
2341 ret = eventManager->DispatchTouchEvent(event);
2342 EXPECT_FALSE(ret);
2343 }
2344 } // namespace OHOS::Ace::NG
2345