1 /*
2 * Copyright (c) 2022-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 <cstddef>
17
18 #include "gtest/gtest.h"
19
20 #define private public
21 #include "core/components_ng/base/frame_node.h"
22 #include "core/components_ng/event/event_hub.h"
23 #include "core/components_ng/pattern/pattern.h"
24 #include "core/components_v2/inspector/inspector_constants.h"
25 #include "core/event/mouse_event.h"
26 #include "test/mock/core/pipeline/mock_pipeline_context.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS::Ace::NG {
32 namespace {
33 constexpr uint32_t INPUT_EVENTS_SIZE = 1;
34 constexpr uint32_t INPUT_EVENTS_SIZE_2 = 2;
35 constexpr uint32_t INPUT_EVENTS_SIZE_0 = 0;
36 constexpr uint32_t MOUSE_RESULT_SIZE = 10;
37 constexpr uint32_t AXIS_RESULT_SIZE = 1;
38 const HoverEffectType HOVER_EFFECT_TYPE = HoverEffectType::BOARD;
39 constexpr float WIDTH = 400.0f;
40 constexpr float HEIGHT = 400.0f;
41 const OffsetF COORDINATE_OFFSET(WIDTH, HEIGHT);
42 constexpr bool HOVER_VALUE = true;
43 const std::string RESULT_SUCCESS_ONE = "sucess1";
44 const std::string RESULT_SUCCESS_TWO = "sucess2";
45 bool accessibilityHover = false;
46 } // namespace
47
48 class InputEventHubTestNg : public testing::Test {
49 public:
50 static void SetUpTestSuite();
51 static void TearDownTestSuite();
52 void SetUp() override;
53 void TearDown() override;
54 };
55
SetUpTestSuite()56 void InputEventHubTestNg::SetUpTestSuite()
57 {
58 GTEST_LOG_(INFO) << "InputEventHubTestNg SetUpTestCase";
59 }
60
TearDownTestSuite()61 void InputEventHubTestNg::TearDownTestSuite()
62 {
63 GTEST_LOG_(INFO) << "InputEventHubTestNg TearDownTestCase";
64 }
65
SetUp()66 void InputEventHubTestNg::SetUp()
67 {
68 MockPipelineContext::SetUp();
69 }
70
TearDown()71 void InputEventHubTestNg::TearDown()
72 {
73 MockPipelineContext::TearDown();
74 }
75 /**
76 * @tc.name: InputEventHubCreateTest001
77 * @tc.desc: Create InputEventHub
78 * @tc.type: FUNC
79 */
80 HWTEST_F(InputEventHubTestNg, InputEventHubCreateTest001, TestSize.Level1)
81 {
82 /**
83 * @tc.steps: step1. Create InputEventHub.
84 */
85 auto eventHub = AceType::MakeRefPtr<EventHub>();
86 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
87 EXPECT_NE(inputEventHub, nullptr);
88 }
89
90 /**
91 * @tc.name: InputEventHubMouseEventTest002
92 * @tc.desc: Create InputEventHub and set, add and remove mouse event.
93 * @tc.type: FUNC
94 */
95 HWTEST_F(InputEventHubTestNg, InputEventHubMouseEventTest002, TestSize.Level1)
96 {
97 /**
98 * @tc.steps: step1. Create InputEventHub.
99 */
100 auto eventHub = AceType::MakeRefPtr<EventHub>();
101 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
102 eventHub->AttachHost(frameNode);
103 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
104 EXPECT_NE(inputEventHub, nullptr);
105 EXPECT_TRUE(
106 inputEventHub->GetFrameNode() != nullptr && inputEventHub->GetFrameNode()->GetTag() == V2::TEXT_ETS_TAG);
107
108 /**
109 * @tc.steps: step2. Create mouse event and set it to inputEventHub.
110 * @tc.expected: mouseEventActuator_ will be initialized.
111 */
__anonc455dc410202(MouseInfo& info) 112 const OnMouseEventFunc onMouse = [](MouseInfo& info) {};
113 OnMouseEventFunc onMouse1 = onMouse;
114 inputEventHub->SetMouseEvent(std::move(onMouse1));
115 EXPECT_NE(inputEventHub->mouseEventActuator_, nullptr);
116
117 /**
118 * @tc.steps: step3. Make mouseEventActuator_ as nullptr, and create input event and add it to inputEventHub.
119 * @tc.expected: mouseEventActuator_ will be initialized and the list of inputEvents size is 1.
120 */
121 inputEventHub->mouseEventActuator_ = nullptr;
122 OnMouseEventFunc onMouse2 = onMouse;
123 auto inputEvent = AceType::MakeRefPtr<InputEvent>(std::move(onMouse2));
124 inputEventHub->AddOnMouseEvent(inputEvent);
125 EXPECT_EQ(inputEventHub->mouseEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE);
126
127 /**
128 * @tc.steps: step4. Remove OnMouseEvent.
129 * @tc.expected: inputEvent will be remove from the list of inputEvents and the size will be 0. If
130 * mouseEventActuator_ is nullptr, the function will return directly.
131 */
132 inputEventHub->RemoveOnMouseEvent(inputEvent);
133 EXPECT_EQ(inputEventHub->mouseEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE_0);
134 inputEventHub->mouseEventActuator_ = nullptr;
135 inputEventHub->RemoveOnMouseEvent(inputEvent);
136 }
137
138 /**
139 * @tc.name: InputEventHubHoverEventTest003
140 * @tc.desc: Create InputEventHub and invoke hover related functions.
141 * @tc.type: FUNC
142 */
143 HWTEST_F(InputEventHubTestNg, InputEventHubHoverEventTest003, TestSize.Level1)
144 {
145 /**
146 * @tc.steps: step1. Create InputEventHub.
147 */
148 auto eventHub = AceType::MakeRefPtr<EventHub>();
149 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
150 eventHub->AttachHost(frameNode);
151 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
152 EXPECT_NE(inputEventHub, nullptr);
153
154 /**
155 * @tc.steps: step2. Set hover animation.
156 * @tc.expected: mouseEventActuator_ will be initialized and get the hoverEffect which will be assigned the correct
157 * value.
158 */
159 inputEventHub->SetHoverEffect(HOVER_EFFECT_TYPE);
160 EXPECT_NE(inputEventHub->hoverEffectActuator_, nullptr);
161 EXPECT_EQ(inputEventHub->GetHoverEffect(), HOVER_EFFECT_TYPE);
162
163 /**
164 * @tc.steps: step3. Set HoverEvent.
165 * @tc.expected: hoverEventActuator_ will be initialized.
166 */
__anonc455dc410302(bool, HoverInfo) 167 OnHoverFunc onHover = [](bool, HoverInfo) {};
168 inputEventHub->SetHoverEvent(std::move(onHover));
169 EXPECT_NE(inputEventHub->hoverEventActuator_, nullptr);
170
171 /**
172 * @tc.steps: step4. Add OnHoverEvent.
173 * @tc.expected: hoverEventActuator_ will be initialized and and the list of inputEvents size is 1.
174 */
175 inputEventHub->hoverEventActuator_ = nullptr;
__anonc455dc410402(MouseInfo& info) 176 OnMouseEventFunc onHover2 = [](MouseInfo& info) {};
177 auto onHoverEvent = AceType::MakeRefPtr<InputEvent>(std::move(onHover2));
178 inputEventHub->AddOnHoverEvent(onHoverEvent);
179 EXPECT_NE(inputEventHub->hoverEventActuator_, nullptr);
180 EXPECT_EQ(inputEventHub->hoverEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE);
181
182 /**
183 * @tc.steps: step5. Remove OnHoverEvent.
184 * @tc.expected: onHoverEvent will be remove from the list of inputEvents and the size will be 0. If
185 * hoverEventActuator_ is nullptr, the function will return directly.
186 */
187 inputEventHub->RemoveOnHoverEvent(onHoverEvent);
188 EXPECT_EQ(inputEventHub->hoverEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE_0);
189 inputEventHub->hoverEventActuator_ = nullptr;
190 inputEventHub->RemoveOnHoverEvent(onHoverEvent);
191 }
192
193 /**
194 * @tc.name: InputEventHubAxisEventTest004
195 * @tc.desc: Create InputEventHub and invoke Axis related functions.
196 * @tc.type: FUNC
197 */
198 HWTEST_F(InputEventHubTestNg, InputEventHubAxisEventTest004, TestSize.Level1)
199 {
200 /**
201 * @tc.steps: step1. Create InputEventHub.
202 */
203 auto eventHub = AceType::MakeRefPtr<EventHub>();
204 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
205 eventHub->AttachHost(frameNode);
206 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
207 EXPECT_NE(inputEventHub, nullptr);
208
209 /**
210 * @tc.steps: step2. Add OnAxisEvent.
211 * @tc.expected: axisEventActuator_ will be initialized, and the list of inputEvents and the size will be 1.
212 */
__anonc455dc410502(MouseInfo& info) 213 OnMouseEventFunc onAxis = [](MouseInfo& info) {};
214 auto onAxisEvent = AceType::MakeRefPtr<InputEvent>(std::move(onAxis));
215 inputEventHub->AddOnAxisEvent(onAxisEvent);
216 EXPECT_NE(inputEventHub->axisEventActuator_, nullptr);
217 EXPECT_EQ(inputEventHub->axisEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE);
218
219 /**
220 * @tc.steps: step3. Remove OnAxisEvent.
221 * @tc.expected: onAxisEvent will be remove from the list of inputEvents and the size will be 0. If
222 * axisEventActuator_ is nullptr, the function will return directly.
223 */
224 inputEventHub->RemoveOnAxisEvent(onAxisEvent);
225 EXPECT_EQ(inputEventHub->axisEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE_0);
226 inputEventHub->axisEventActuator_ = nullptr;
227 inputEventHub->RemoveOnAxisEvent(onAxisEvent);
228 }
229
230 /**
231 * @tc.name: InputEventHubProcessMouseTest005
232 * @tc.desc: Create InputEventHub and invoke ProcessMouseTestHit functions.
233 * @tc.type: FUNC
234 */
235 HWTEST_F(InputEventHubTestNg, InputEventHubProcessMouseTest005, TestSize.Level1)
236 {
237 /**
238 * @tc.steps: step1. Create InputEventHub.
239 */
240 auto eventHub = AceType::MakeRefPtr<EventHub>();
241 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
242 eventHub->AttachHost(frameNode);
243 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
244 EXPECT_NE(inputEventHub, nullptr);
245
246 /**
247 * @tc.steps: step2. Invoke ProcessMouseTestHit when eventHub is nullptr.
248 * @tc.expected: ProcessMouseTestHit return false.
249 */
250 TouchTestResult mouseResult;
251 auto inputEventHub2 = AceType::MakeRefPtr<InputEventHub>(nullptr);
252 EXPECT_FALSE(inputEventHub2->ProcessMouseTestHit(COORDINATE_OFFSET, mouseResult));
253
254 /**
255 * @tc.steps: step3. Initialize mouseEventActuator_ and mouseEventActuator_, their inputEvents_ is empty and
256 * userCallback_ is nullptr and userJSFrameNodeCallback_ is nullptr too.
257 * @tc.expected: OnCollectMouseEvent will return directly, and ProcessMouseTestHit return false.
258 */
259 inputEventHub->mouseEventActuator_ =
260 AceType::MakeRefPtr<InputEventActuator>(AceType::WeakClaim(AceType::RawPtr(inputEventHub)));
261 inputEventHub->hoverEffectActuator_ =
262 AceType::MakeRefPtr<InputEventActuator>(AceType::WeakClaim(AceType::RawPtr(inputEventHub)));
263 EXPECT_FALSE(inputEventHub->ProcessMouseTestHit(COORDINATE_OFFSET, mouseResult));
264
265 /**
266 * @tc.steps: step4. Create mouse event and initialize userJSFrameNodeCallback_ .
267 * @tc.expected: userJSFrameNodeCallback_ will be initialized and ProcessMouseTestHit return false.
268 */
__anonc455dc410602(MouseInfo& info) 269 const OnMouseEventFunc onMouse = [](MouseInfo& info) {};
270 OnMouseEventFunc onMouse1 = onMouse;
271 inputEventHub->SetJSFrameNodeOnMouseEvent(std::move(onMouse1));
272 EXPECT_FALSE(inputEventHub->ProcessMouseTestHit(COORDINATE_OFFSET, mouseResult));
273
274 /**
275 * @tc.steps: step5. Invoke ProcessMouseTestHit when hoverNode is nullptr and the hover effect is UNKNOWN or not.
276 * @tc.expected: OnCollectMouseEvent will return directly, and ProcessMouseTestHit return false.
277 */
278 EXPECT_FALSE(inputEventHub->ProcessMouseTestHit(COORDINATE_OFFSET, mouseResult));
279 inputEventHub->SetHoverEffect(HOVER_EFFECT_TYPE);
280 EXPECT_FALSE(inputEventHub->ProcessMouseTestHit(COORDINATE_OFFSET, mouseResult));
281
282 /**
283 * @tc.steps: step6. Set MouseEvent and mouseEventActuator_ and userCallback_ will be initialized.
284 */
285 OnMouseEventFunc onMouse2 = onMouse;
286 inputEventHub->SetMouseEvent(std::move(onMouse2));
287 EXPECT_NE(inputEventHub->mouseEventActuator_->userCallback_, nullptr);
288
289 /**
290 * @tc.steps: step7. Set HoverEvent and hoverEventActuator_ and userCallback_ will be initialized.
291 */
__anonc455dc410702(bool, HoverInfo) 292 const OnHoverFunc onHover = [](bool, HoverInfo) {};
293 OnHoverFunc onHover1 = onHover;
294 inputEventHub->SetHoverEvent(std::move(onHover1));
295 EXPECT_NE(inputEventHub->hoverEventActuator_->userCallback_, nullptr);
296
297 /**
298 * @tc.steps: step8. Add OnMouseEvent and inputEvents_ will not be empty.
299 */
300 OnMouseEventFunc onMouse3 = onMouse;
301 auto inputEvent = AceType::MakeRefPtr<InputEvent>(std::move(onMouse3));
302 inputEventHub->AddOnMouseEvent(inputEvent);
303 inputEventHub->AddOnMouseEvent(nullptr);
304 EXPECT_EQ(inputEventHub->mouseEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE_2);
305
306 /**
307 * @tc.steps: step9. Set HoverEvent and inputEvents_ will not be empty.
308 */
309 OnHoverFunc onHover2 = onHover;
310 auto onHoverEvent = AceType::MakeRefPtr<InputEvent>(std::move(onHover2));
311 inputEventHub->AddOnHoverEvent(onHoverEvent);
312 inputEventHub->AddOnHoverEvent(nullptr);
313 EXPECT_EQ(inputEventHub->hoverEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE_2);
314
315 /**
316 * @tc.steps: step10. Invoke ProcessMouseTestHit when inputEvents_ is not empty and userCallback_ has already been
317 * initialized.
318 * @tc.expected: ProcessMouseTestHit return false, mouse and hover result size has been increased one.
319 */
320 EXPECT_FALSE(inputEventHub->ProcessMouseTestHit(COORDINATE_OFFSET, mouseResult));
321 EXPECT_EQ(inputEventHub->mouseEventActuator_->mouseEventTarget_->GetCoordinateOffset(),
322 Offset(COORDINATE_OFFSET.GetX(), COORDINATE_OFFSET.GetY()));
323 EXPECT_EQ(inputEventHub->hoverEventActuator_->hoverEventTarget_->GetCoordinateOffset(),
324 Offset(COORDINATE_OFFSET.GetX(), COORDINATE_OFFSET.GetY()));
325 EXPECT_EQ(inputEventHub->hoverEffectActuator_->hoverEffectTarget_->GetCoordinateOffset(),
326 Offset(COORDINATE_OFFSET.GetX(), COORDINATE_OFFSET.GetY()));
327 EXPECT_EQ(mouseResult.size(), MOUSE_RESULT_SIZE);
328
329 /**
330 * @tc.steps: step11. Handle mouse and hover event when the events and userCallback is nullptr or not.
331 */
332 MouseEvent mouseEvent;
333 mouseEvent.action = MouseAction::MOVE;
334 EXPECT_FALSE(inputEventHub->hoverEventActuator_->hoverEventTarget_->HandleHoverEvent(HOVER_VALUE));
335 inputEventHub->mouseEventActuator_->mouseEventTarget_->HandleMouseEvent(mouseEvent);
336 inputEventHub->mouseEventActuator_->userCallback_ = nullptr;
337 inputEventHub->hoverEventActuator_->userCallback_ = nullptr;
338 EXPECT_FALSE(inputEventHub->hoverEventActuator_->hoverEventTarget_->HandleHoverEvent(HOVER_VALUE));
339 inputEventHub->mouseEventActuator_->mouseEventTarget_->HandleMouseEvent(mouseEvent);
340 }
341
342 /**
343 * @tc.name: InputEventHubProcessAxisTestHitTest006
344 * @tc.desc: Create InputEventHub and invoke ProcessAxisTestHit functions.
345 * @tc.type: FUNC
346 */
347 HWTEST_F(InputEventHubTestNg, InputEventHubProcessAxisTestHitTest006, TestSize.Level1)
348 {
349 /**
350 * @tc.steps: step1. Create InputEventHub.
351 */
352 auto eventHub = AceType::MakeRefPtr<EventHub>();
353 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
354 eventHub->AttachHost(frameNode);
355 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
356 EXPECT_NE(inputEventHub, nullptr);
357
358 /**
359 * @tc.steps: step2. Invoke ProcessAxisTestHit when eventHub is nullptr.
360 * @tc.expected: ProcessMouseTestHit return false.
361 */
362 AxisTestResult onAxisResult;
363 auto inputEventHub2 = AceType::MakeRefPtr<InputEventHub>(nullptr);
364 EXPECT_FALSE(inputEventHub2->ProcessAxisTestHit(COORDINATE_OFFSET, onAxisResult));
365
366 /**
367 * @tc.steps: step3. Initialize axisEventActuator_ and its inputEvents_ is empty and userCallback_ is nullptr.
368 * @tc.expected: OnCollectAxisEvent will return directly, and ProcessAxisTestHit return false.
369 */
370 inputEventHub->axisEventActuator_ =
371 AceType::MakeRefPtr<InputEventActuator>(AceType::WeakClaim(AceType::RawPtr(inputEventHub)));
372 EXPECT_FALSE(inputEventHub2->ProcessAxisTestHit(COORDINATE_OFFSET, onAxisResult));
373
374 /**
375 * @tc.steps: step4. Initialize userCallback_.
376 */
__anonc455dc410802(MouseInfo& info) 377 OnMouseEventFunc onAxis = [](MouseInfo& info) {};
378 auto onAxisEvent = AceType::MakeRefPtr<InputEvent>(std::move(onAxis));
379 inputEventHub->axisEventActuator_->userCallback_ = onAxisEvent;
380
381 /**
382 * @tc.steps: step5. Add OnAxisEvent.
383 * @tc.expected: axisEventActuator_ will be initialized, and the list of inputEvents and the size will be 1.
384 */
385 inputEventHub->AddOnAxisEvent(onAxisEvent);
386 EXPECT_EQ(inputEventHub->axisEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE);
387
388 /**
389 * @tc.steps: step6. Invoke ProcessAxisTestHit when inputEvents_ is not empty and userCallback_ has already been
390 * initialized.
391 * @tc.expected: ProcessAxisTestHit return false, axis result size has been increased one.
392 */
393 EXPECT_FALSE(inputEventHub->ProcessAxisTestHit(COORDINATE_OFFSET, onAxisResult));
394 EXPECT_EQ(inputEventHub->axisEventActuator_->axisEventTarget_->coordinateOffset_, COORDINATE_OFFSET);
395 EXPECT_EQ(onAxisResult.size(), AXIS_RESULT_SIZE);
396 }
397
398 /**
399 * @tc.name: InputEventHubBindContextMenuTest007
400 * @tc.desc: Create InputEventHub and invoke BindContextMenu functions.
401 * @tc.type: FUNC
402 */
403 HWTEST_F(InputEventHubTestNg, InputEventHubBindContextMenuTest007, TestSize.Level1)
404 {
405 /**
406 * @tc.steps: step1. Create InputEventHub.
407 */
408 auto eventHub = AceType::MakeRefPtr<EventHub>();
409 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
410 eventHub->AttachHost(frameNode);
411 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
412 EXPECT_NE(inputEventHub, nullptr);
413
414 /**
415 * @tc.steps: step2. Invoke BindContextMenu when showMenu_ is nullptr or not.
416 * @tc.expected: mouseEventActuator_ is not nullptr.
417 */
__anonc455dc410902(MouseInfo& info) 418 const OnMouseEventFunc onMouse = [](MouseInfo& info) {};
419 OnMouseEventFunc onMouse1 = onMouse;
420 OnMouseEventFunc onMouse2 = onMouse;
421 inputEventHub->BindContextMenu(std::move(onMouse1));
422 inputEventHub->BindContextMenu(std::move(onMouse2));
423 EXPECT_NE(inputEventHub->mouseEventActuator_, nullptr);
424 }
425
426 /**
427 * @tc.name: InputEventHubProcessMouseTest008
428 * @tc.desc: Create InputEventHub and invoke ProcessMouseTestHit functions.
429 * @tc.type: FUNC
430 */
431 HWTEST_F(InputEventHubTestNg, InputEventHubProcessMouseTest008, TestSize.Level1)
432 {
433 /**
434 * @tc.steps: step1. Create InputEventHub.
435 */
436 auto eventHub = AceType::MakeRefPtr<EventHub>();
437 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
438 eventHub->AttachHost(frameNode);
439 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
440 EXPECT_NE(inputEventHub, nullptr);
441 TouchTestResult mouseResult;
442
443 /**
444 * @tc.steps: step2. Set HoverEvent and hoverEventActuator_ and userCallback_ will be initialized.
445 */
__anonc455dc410a02(bool, AccessibilityHoverInfo) 446 const OnAccessibilityHoverFunc onHover = [](bool, AccessibilityHoverInfo) { accessibilityHover = true; };
447 OnAccessibilityHoverFunc onHover1 = onHover;
448 inputEventHub->SetAccessibilityHoverEvent(std::move(onHover1));
449 EXPECT_NE(inputEventHub->accessibilityHoverEventActuator_->userCallback_, nullptr);
450
451 /**
452 * @tc.steps: step3. Invoke ProcessMouseTestHit when the userCallback_ has already been
453 * initialized.
454 * @tc.expected: ProcessMouseTestHit return false, mouse and hover result size has been increased one.
455 */
456 EXPECT_FALSE(inputEventHub->ProcessMouseTestHit(COORDINATE_OFFSET, mouseResult));
457 EXPECT_EQ(inputEventHub->accessibilityHoverEventActuator_->accessibilityHoverEventTarget_->GetCoordinateOffset(),
458 Offset(COORDINATE_OFFSET.GetX(), COORDINATE_OFFSET.GetY()));
459 EXPECT_EQ(mouseResult.size(), INPUT_EVENTS_SIZE);
460
461 /**
462 * @tc.steps: step11. Handle mouse and hover event when the events and userCallback is nullptr or not.
463 */
464 TouchEvent event;
465 inputEventHub->accessibilityHoverEventActuator_->accessibilityHoverEventTarget_->HandleAccessibilityHoverEvent(
466 HOVER_VALUE, event);
467 EXPECT_EQ(accessibilityHover, true);
468 }
469
470 /**
471 * @tc.name: DisableMouseEvent001
472 * @tc.desc: Test disable mouse event.
473 * @tc.type: FUNC
474 */
475 HWTEST_F(InputEventHubTestNg, DisableMouseEvent001, TestSize.Level1)
476 {
477 /**
478 * @tc.steps: step1. Create InputEventHub.
479 */
480 auto eventHub = AceType::MakeRefPtr<EventHub>();
481 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
482 eventHub->AttachHost(frameNode);
483 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
484 EXPECT_NE(inputEventHub, nullptr);
485
486 /**
487 * @tc.steps: step2. Initialize mouseEventActuator_, and set callback
488 * @tc.expected: callback is right.
489 */
490 inputEventHub->mouseEventActuator_ =
491 AceType::MakeRefPtr<InputEventActuator>(AceType::WeakClaim(AceType::RawPtr(inputEventHub)));
492 std::string result;
__anonc455dc410b02(MouseInfo& info) 493 OnMouseEventFunc onMouse = [&result](MouseInfo& info) { result = RESULT_SUCCESS_ONE; };
494 inputEventHub->SetMouseEvent(std::move(onMouse));
495 EXPECT_NE(inputEventHub->mouseEventActuator_->userCallback_, nullptr);
496
497 MouseInfo press;
498 press.SetButton(MouseButton::LEFT_BUTTON);
499 press.SetAction(MouseAction::PRESS);
500 inputEventHub->mouseEventActuator_->userCallback_->onMouseCallback_(press);
501 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
502
503 /**
504 * @tc.steps: step3. Clear the callback.
505 * @tc.expected: callback is null.
506 */
507 inputEventHub->ClearUserOnMouse();
508 EXPECT_EQ(inputEventHub->mouseEventActuator_->userCallback_, nullptr);
509
510 /**
511 * @tc.steps: step4. Set the callback again.
512 * @tc.expected: callback is right.
513 */
__anonc455dc410c02(MouseInfo& info) 514 OnMouseEventFunc onMouse2 = [&result](MouseInfo& info) { result = RESULT_SUCCESS_TWO; };
515 inputEventHub->SetMouseEvent(std::move(onMouse2));
516 EXPECT_NE(inputEventHub->mouseEventActuator_->userCallback_, nullptr);
517
518 MouseInfo release;
519 release.SetButton(MouseButton::LEFT_BUTTON);
520 release.SetAction(MouseAction::RELEASE);
521 inputEventHub->mouseEventActuator_->userCallback_->onMouseCallback_(release);
522 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
523 }
524
525 /**
526 * @tc.name: DisableAxisEvent001
527 * @tc.desc: Test disable Axis event.
528 * @tc.type: FUNC
529 */
530 HWTEST_F(InputEventHubTestNg, DisableAxisEvent001, TestSize.Level1)
531 {
532 /**
533 * @tc.steps: step1. Create InputEventHub.
534 */
535 auto eventHub = AceType::MakeRefPtr<EventHub>();
536 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
537 eventHub->AttachHost(frameNode);
538 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
539 EXPECT_NE(inputEventHub, nullptr);
540
541 /**
542 * @tc.steps: step2. Initialize axisEventActuator_, and set callback
543 * @tc.expected: callback is right.
544 */
545 inputEventHub->axisEventActuator_ =
546 AceType::MakeRefPtr<InputEventActuator>(AceType::WeakClaim(AceType::RawPtr(inputEventHub)));
547 std::string result;
__anonc455dc410d02(AxisInfo& info) 548 OnAxisEventFunc onAxis = [&result](AxisInfo& info) { result = RESULT_SUCCESS_ONE; };
549 inputEventHub->SetAxisEvent(std::move(onAxis));
550 EXPECT_NE(inputEventHub->axisEventActuator_->userCallback_, nullptr);
551
552 AxisInfo axis;
553 inputEventHub->axisEventActuator_->userCallback_->onAxisCallback_(axis);
554 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
555
556 /**
557 * @tc.steps: step3. Clear the callback.
558 * @tc.expected: callback is null.
559 */
560 inputEventHub->ClearUserOnAxisEvent();
561 EXPECT_EQ(inputEventHub->axisEventActuator_->userCallback_, nullptr);
562
563 /**
564 * @tc.steps: step4. Set the callback again.
565 * @tc.expected: callback is right.
566 */
__anonc455dc410e02(AxisInfo& info) 567 OnAxisEventFunc onAxis2 = [&result](AxisInfo& info) { result = RESULT_SUCCESS_TWO; };
568 inputEventHub->SetAxisEvent(std::move(onAxis2));
569 EXPECT_NE(inputEventHub->axisEventActuator_->userCallback_, nullptr);
570
571 AxisInfo axis2;
572 inputEventHub->axisEventActuator_->userCallback_->onAxisCallback_(axis2);
573 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
574 }
575
576 /**
577 * @tc.name: DisableHoverEvent001
578 * @tc.desc: Test disable hover event.
579 * @tc.type: FUNC
580 */
581 HWTEST_F(InputEventHubTestNg, DisableHoverEvent001, TestSize.Level1)
582 {
583 /**
584 * @tc.steps: step1. Create InputEventHub.
585 */
586 auto eventHub = AceType::MakeRefPtr<EventHub>();
587 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
588 eventHub->AttachHost(frameNode);
589 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
590 EXPECT_NE(inputEventHub, nullptr);
591
592 /**
593 * @tc.steps: step2. Initialize hoverEventActuator_, and set callback
594 * @tc.expected: callback is right.
595 */
596 inputEventHub->hoverEventActuator_ =
597 AceType::MakeRefPtr<InputEventActuator>(AceType::WeakClaim(AceType::RawPtr(inputEventHub)));
598 std::string result;
__anonc455dc410f02(bool, HoverInfo) 599 OnHoverFunc onHover = [&result](bool, HoverInfo) { result = RESULT_SUCCESS_ONE; };
600 inputEventHub->SetHoverEvent(std::move(onHover));
601 EXPECT_NE(inputEventHub->hoverEventActuator_->userCallback_, nullptr);
602
603 HoverInfo hover;
604 inputEventHub->hoverEventActuator_->userCallback_->onHoverEventCallback_(true, hover);
605 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
606
607 /**
608 * @tc.steps: step3. Clear the callback.
609 * @tc.expected: callback is null.
610 */
611 inputEventHub->ClearUserOnHover();
612 EXPECT_EQ(inputEventHub->hoverEventActuator_->userCallback_, nullptr);
613
614 /**
615 * @tc.steps: step4. Set the callback again.
616 * @tc.expected: callback is right.
617 */
__anonc455dc411002(bool, HoverInfo) 618 OnHoverFunc onHover2 = [&result](bool, HoverInfo) { result = RESULT_SUCCESS_TWO; };
619 inputEventHub->SetHoverEvent(std::move(onHover2));
620 EXPECT_NE(inputEventHub->hoverEventActuator_->userCallback_, nullptr);
621
622 HoverInfo hover2;
623 inputEventHub->hoverEventActuator_->userCallback_->onHoverEventCallback_(true, hover2);
624 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
625 }
626
627 /**
628 * @tc.name: InputEventHubGetHoverEffectStr001
629 * @tc.desc: Create InputEventHub and invoke GetHoverEffectStr function.
630 * @tc.type: FUNC
631 */
632 HWTEST_F(InputEventHubTestNg, InputEventHubGetHoverEffectStr001, TestSize.Level1)
633 {
634 /**
635 * @tc.steps: step1. Create InputEventHub.
636 */
637 auto eventHub = AceType::MakeRefPtr<EventHub>();
638 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
639 eventHub->AttachHost(frameNode);
640 auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
641 EXPECT_NE(inputEventHub, nullptr);
642 inputEventHub->hoverEffectType_ = HoverEffectType::AUTO;
643
644 /**
645 * @tc.steps: step2. Invoke BindContextMenu when showMenu_ is nullptr or not.
646 * @tc.expected: mouseEventActuator_ is not nullptr.
647 */
648 for (int i = 0; i <= 1; i++) {
649 for (int j = 0; j <= 1; j++) {
650 EXPECT_EQ(inputEventHub->GetHoverEffectStr(), i==0&&j==0?"HoverEffect.Auto":(i==0&&j==1?"HoverEffect.Scale":
651 (i==1&&j==0?"HoverEffect.Highlight":"HoverEffect.None")));
652 if (i == 1) {
653 inputEventHub->hoverEffectType_ = HoverEffectType::NONE;
654 continue;
655 }
656 inputEventHub->hoverEffectType_ = HoverEffectType::SCALE;
657 }
658 inputEventHub->hoverEffectType_ = HoverEffectType::BOARD;
659 }
660 inputEventHub->hoverEffectType_ = HoverEffectType::OPACITY;
661 EXPECT_EQ(inputEventHub->GetHoverEffectStr(), "HoverEffect.Auto");
662 }
663 } // namespace OHOS::Ace::NG
664