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      */
__anon767b40390202(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      */
__anon767b40390302(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;
__anon767b40390402(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      */
__anon767b40390502(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      */
__anon767b40390602(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      */
__anon767b40390702(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     const MouseEvent mouseEvent = { .action = MouseAction::MOVE };
333     EXPECT_FALSE(inputEventHub->hoverEventActuator_->hoverEventTarget_->HandleHoverEvent(HOVER_VALUE));
334     inputEventHub->mouseEventActuator_->mouseEventTarget_->HandleMouseEvent(mouseEvent);
335     inputEventHub->mouseEventActuator_->userCallback_ = nullptr;
336     inputEventHub->hoverEventActuator_->userCallback_ = nullptr;
337     EXPECT_FALSE(inputEventHub->hoverEventActuator_->hoverEventTarget_->HandleHoverEvent(HOVER_VALUE));
338     inputEventHub->mouseEventActuator_->mouseEventTarget_->HandleMouseEvent(mouseEvent);
339 }
340 
341 /**
342  * @tc.name: InputEventHubProcessAxisTestHitTest006
343  * @tc.desc: Create InputEventHub and invoke ProcessAxisTestHit functions.
344  * @tc.type: FUNC
345  */
346 HWTEST_F(InputEventHubTestNg, InputEventHubProcessAxisTestHitTest006, TestSize.Level1)
347 {
348     /**
349      * @tc.steps: step1. Create InputEventHub.
350      */
351     auto eventHub = AceType::MakeRefPtr<EventHub>();
352     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
353     eventHub->AttachHost(frameNode);
354     auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
355     EXPECT_NE(inputEventHub, nullptr);
356 
357     /**
358      * @tc.steps: step2. Invoke ProcessAxisTestHit when eventHub is nullptr.
359      * @tc.expected: ProcessMouseTestHit return false.
360      */
361     AxisTestResult onAxisResult;
362     auto inputEventHub2 = AceType::MakeRefPtr<InputEventHub>(nullptr);
363     EXPECT_FALSE(inputEventHub2->ProcessAxisTestHit(COORDINATE_OFFSET, onAxisResult));
364 
365     /**
366      * @tc.steps: step3. Initialize axisEventActuator_ and its inputEvents_ is empty and userCallback_ is nullptr.
367      * @tc.expected: OnCollectAxisEvent will return directly, and ProcessAxisTestHit return false.
368      */
369     inputEventHub->axisEventActuator_ =
370         AceType::MakeRefPtr<InputEventActuator>(AceType::WeakClaim(AceType::RawPtr(inputEventHub)));
371     EXPECT_FALSE(inputEventHub2->ProcessAxisTestHit(COORDINATE_OFFSET, onAxisResult));
372 
373     /**
374      * @tc.steps: step4. Initialize userCallback_.
375      */
__anon767b40390802(MouseInfo& info) 376     OnMouseEventFunc onAxis = [](MouseInfo& info) {};
377     auto onAxisEvent = AceType::MakeRefPtr<InputEvent>(std::move(onAxis));
378     inputEventHub->axisEventActuator_->userCallback_ = onAxisEvent;
379 
380     /**
381      * @tc.steps: step5. Add OnAxisEvent.
382      * @tc.expected: axisEventActuator_ will be initialized, and the list of inputEvents and the size will be 1.
383      */
384     inputEventHub->AddOnAxisEvent(onAxisEvent);
385     EXPECT_EQ(inputEventHub->axisEventActuator_->inputEvents_.size(), INPUT_EVENTS_SIZE);
386 
387     /**
388      * @tc.steps: step6. Invoke ProcessAxisTestHit when inputEvents_ is not empty and userCallback_ has already been
389      * initialized.
390      * @tc.expected: ProcessAxisTestHit return false, axis result size has been increased one.
391      */
392     EXPECT_FALSE(inputEventHub->ProcessAxisTestHit(COORDINATE_OFFSET, onAxisResult));
393     EXPECT_EQ(inputEventHub->axisEventActuator_->axisEventTarget_->coordinateOffset_, COORDINATE_OFFSET);
394     EXPECT_EQ(onAxisResult.size(), AXIS_RESULT_SIZE);
395 }
396 
397 /**
398  * @tc.name: InputEventHubBindContextMenuTest007
399  * @tc.desc: Create InputEventHub and invoke BindContextMenu functions.
400  * @tc.type: FUNC
401  */
402 HWTEST_F(InputEventHubTestNg, InputEventHubBindContextMenuTest007, TestSize.Level1)
403 {
404     /**
405      * @tc.steps: step1. Create InputEventHub.
406      */
407     auto eventHub = AceType::MakeRefPtr<EventHub>();
408     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
409     eventHub->AttachHost(frameNode);
410     auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
411     EXPECT_NE(inputEventHub, nullptr);
412 
413     /**
414      * @tc.steps: step2. Invoke BindContextMenu when showMenu_ is nullptr or not.
415      * @tc.expected: mouseEventActuator_ is not nullptr.
416      */
__anon767b40390902(MouseInfo& info) 417     const OnMouseEventFunc onMouse = [](MouseInfo& info) {};
418     OnMouseEventFunc onMouse1 = onMouse;
419     OnMouseEventFunc onMouse2 = onMouse;
420     inputEventHub->BindContextMenu(std::move(onMouse1));
421     inputEventHub->BindContextMenu(std::move(onMouse2));
422     EXPECT_NE(inputEventHub->mouseEventActuator_, nullptr);
423 }
424 
425 /**
426  * @tc.name: InputEventHubProcessMouseTest008
427  * @tc.desc: Create InputEventHub and invoke ProcessMouseTestHit functions.
428  * @tc.type: FUNC
429  */
430 HWTEST_F(InputEventHubTestNg, InputEventHubProcessMouseTest008, TestSize.Level1)
431 {
432     /**
433      * @tc.steps: step1. Create InputEventHub.
434      */
435     auto eventHub = AceType::MakeRefPtr<EventHub>();
436     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
437     eventHub->AttachHost(frameNode);
438     auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
439     EXPECT_NE(inputEventHub, nullptr);
440     TouchTestResult mouseResult;
441 
442     /**
443      * @tc.steps: step2. Set HoverEvent and hoverEventActuator_ and userCallback_ will be initialized.
444      */
__anon767b40390a02(bool, AccessibilityHoverInfo) 445     const OnAccessibilityHoverFunc onHover = [](bool, AccessibilityHoverInfo) { accessibilityHover = true; };
446     OnAccessibilityHoverFunc onHover1 = onHover;
447     inputEventHub->SetAccessibilityHoverEvent(std::move(onHover1));
448     EXPECT_NE(inputEventHub->accessibilityHoverEventActuator_->userCallback_, nullptr);
449 
450     /**
451      * @tc.steps: step3. Invoke ProcessMouseTestHit when the userCallback_ has already been
452      * initialized.
453      * @tc.expected: ProcessMouseTestHit return false, mouse and hover result size has been increased one.
454      */
455     EXPECT_FALSE(inputEventHub->ProcessMouseTestHit(COORDINATE_OFFSET, mouseResult));
456     EXPECT_EQ(inputEventHub->accessibilityHoverEventActuator_->accessibilityHoverEventTarget_->GetCoordinateOffset(),
457         Offset(COORDINATE_OFFSET.GetX(), COORDINATE_OFFSET.GetY()));
458     EXPECT_EQ(mouseResult.size(), INPUT_EVENTS_SIZE);
459 
460     /**
461      * @tc.steps: step11. Handle mouse and hover event when the events and userCallback is nullptr or not.
462      */
463     TouchEvent event;
464     inputEventHub->accessibilityHoverEventActuator_->accessibilityHoverEventTarget_->HandleAccessibilityHoverEvent(
465         HOVER_VALUE, event);
466     EXPECT_EQ(accessibilityHover, true);
467 }
468 
469 /**
470  * @tc.name: DisableMouseEvent001
471  * @tc.desc: Test disable mouse event.
472  * @tc.type: FUNC
473  */
474 HWTEST_F(InputEventHubTestNg, DisableMouseEvent001, TestSize.Level1)
475 {
476     /**
477      * @tc.steps: step1. Create InputEventHub.
478      */
479     auto eventHub = AceType::MakeRefPtr<EventHub>();
480     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
481     eventHub->AttachHost(frameNode);
482     auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
483     EXPECT_NE(inputEventHub, nullptr);
484 
485     /**
486      * @tc.steps: step2. Initialize mouseEventActuator_, and set callback
487      * @tc.expected: callback is right.
488      */
489     inputEventHub->mouseEventActuator_ =
490         AceType::MakeRefPtr<InputEventActuator>(AceType::WeakClaim(AceType::RawPtr(inputEventHub)));
491     std::string result;
__anon767b40390b02(MouseInfo& info) 492     OnMouseEventFunc onMouse = [&result](MouseInfo& info) { result = RESULT_SUCCESS_ONE; };
493     inputEventHub->SetMouseEvent(std::move(onMouse));
494     EXPECT_NE(inputEventHub->mouseEventActuator_->userCallback_, nullptr);
495 
496     MouseInfo press;
497     press.SetButton(MouseButton::LEFT_BUTTON);
498     press.SetAction(MouseAction::PRESS);
499     inputEventHub->mouseEventActuator_->userCallback_->onMouseCallback_(press);
500     EXPECT_EQ(result, RESULT_SUCCESS_ONE);
501 
502     /**
503      * @tc.steps: step3. Clear the callback.
504      * @tc.expected: callback is null.
505      */
506     inputEventHub->ClearUserOnMouse();
507     EXPECT_EQ(inputEventHub->mouseEventActuator_->userCallback_, nullptr);
508 
509     /**
510      * @tc.steps: step4. Set the callback again.
511      * @tc.expected: callback is right.
512      */
__anon767b40390c02(MouseInfo& info) 513     OnMouseEventFunc onMouse2 = [&result](MouseInfo& info) { result = RESULT_SUCCESS_TWO; };
514     inputEventHub->SetMouseEvent(std::move(onMouse2));
515     EXPECT_NE(inputEventHub->mouseEventActuator_->userCallback_, nullptr);
516 
517     MouseInfo release;
518     release.SetButton(MouseButton::LEFT_BUTTON);
519     release.SetAction(MouseAction::RELEASE);
520     inputEventHub->mouseEventActuator_->userCallback_->onMouseCallback_(release);
521     EXPECT_EQ(result, RESULT_SUCCESS_TWO);
522 }
523 
524 /**
525  * @tc.name: DisableHoverEvent001
526  * @tc.desc: Test disable hover event.
527  * @tc.type: FUNC
528  */
529 HWTEST_F(InputEventHubTestNg, DisableHoverEvent001, TestSize.Level1)
530 {
531     /**
532      * @tc.steps: step1. Create InputEventHub.
533      */
534     auto eventHub = AceType::MakeRefPtr<EventHub>();
535     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
536     eventHub->AttachHost(frameNode);
537     auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
538     EXPECT_NE(inputEventHub, nullptr);
539 
540     /**
541      * @tc.steps: step2. Initialize hoverEventActuator_, and set callback
542      * @tc.expected: callback is right.
543      */
544     inputEventHub->hoverEventActuator_ =
545         AceType::MakeRefPtr<InputEventActuator>(AceType::WeakClaim(AceType::RawPtr(inputEventHub)));
546     std::string result;
__anon767b40390d02(bool, HoverInfo) 547     OnHoverFunc onHover = [&result](bool, HoverInfo) { result = RESULT_SUCCESS_ONE; };
548     inputEventHub->SetHoverEvent(std::move(onHover));
549     EXPECT_NE(inputEventHub->hoverEventActuator_->userCallback_, nullptr);
550 
551     HoverInfo hover;
552     inputEventHub->hoverEventActuator_->userCallback_->onHoverEventCallback_(true, hover);
553     EXPECT_EQ(result, RESULT_SUCCESS_ONE);
554 
555     /**
556      * @tc.steps: step3. Clear the callback.
557      * @tc.expected: callback is null.
558      */
559     inputEventHub->ClearUserOnHover();
560     EXPECT_EQ(inputEventHub->hoverEventActuator_->userCallback_, nullptr);
561 
562     /**
563      * @tc.steps: step4. Set the callback again.
564      * @tc.expected: callback is right.
565      */
__anon767b40390e02(bool, HoverInfo) 566     OnHoverFunc onHover2 = [&result](bool, HoverInfo) { result = RESULT_SUCCESS_TWO; };
567     inputEventHub->SetHoverEvent(std::move(onHover2));
568     EXPECT_NE(inputEventHub->hoverEventActuator_->userCallback_, nullptr);
569 
570     HoverInfo hover2;
571     inputEventHub->hoverEventActuator_->userCallback_->onHoverEventCallback_(true, hover2);
572     EXPECT_EQ(result, RESULT_SUCCESS_TWO);
573 }
574 
575 /**
576  * @tc.name: InputEventHubGetHoverEffectStr001
577  * @tc.desc: Create InputEventHub and invoke GetHoverEffectStr function.
578  * @tc.type: FUNC
579  */
580 HWTEST_F(InputEventHubTestNg, InputEventHubGetHoverEffectStr001, TestSize.Level1)
581 {
582     /**
583      * @tc.steps: step1. Create InputEventHub.
584      */
585     auto eventHub = AceType::MakeRefPtr<EventHub>();
586     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
587     eventHub->AttachHost(frameNode);
588     auto inputEventHub = AceType::MakeRefPtr<InputEventHub>(AceType::WeakClaim(AceType::RawPtr(eventHub)));
589     EXPECT_NE(inputEventHub, nullptr);
590     inputEventHub->hoverEffectType_ = HoverEffectType::AUTO;
591 
592     /**
593      * @tc.steps: step2. Invoke BindContextMenu when showMenu_ is nullptr or not.
594      * @tc.expected: mouseEventActuator_ is not nullptr.
595      */
596     for (int i = 0; i <= 1; i++) {
597         for (int j = 0; j <= 1; j++) {
598             EXPECT_EQ(inputEventHub->GetHoverEffectStr(), i==0&&j==0?"HoverEffect.Auto":(i==0&&j==1?"HoverEffect.Scale":
599                 (i==1&&j==0?"HoverEffect.Highlight":"HoverEffect.None")));
600             if (i == 1) {
601                 inputEventHub->hoverEffectType_ = HoverEffectType::NONE;
602                 continue;
603             }
604             inputEventHub->hoverEffectType_ = HoverEffectType::SCALE;
605         }
606         inputEventHub->hoverEffectType_ = HoverEffectType::BOARD;
607     }
608     inputEventHub->hoverEffectType_ = HoverEffectType::OPACITY;
609     EXPECT_EQ(inputEventHub->GetHoverEffectStr(), "HoverEffect.Auto");
610 }
611 } // namespace OHOS::Ace::NG
612