1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <iostream>
17 #include <chrono>
18 #include "gtest/gtest.h"
19 
20 #define private public
21 #define protected public
22 #include "test/mock/core/pipeline/mock_pipeline_context.h"
23 
24 #include "core/pipeline_ng/pipeline_context.h"
25 #include "frameworks/core/accessibility/accessibility_constants.h"
26 #include "frameworks/core/accessibility/accessibility_manager_ng.h"
27 #include "frameworks/core/components_ng/event/touch_event.h"
28 #include "frameworks/core/components_ng/pattern/pattern.h"
29 #include "frameworks/core/components_ng/pattern/text/text_pattern.h"
30 #include "frameworks/core/event/mouse_event.h"
31 #include "frameworks/core/event/pointer_event.h"
32 
33 #include "accessibility_session_adapter_test.h"
34 
35 using namespace testing;
36 using namespace testing::ext;
37 
38 namespace OHOS::Ace::NG {
39 namespace {
40     constexpr float TILT_X_VALUE = 400.0f;
41     constexpr float TILT_Y_VALUE = 400.0f;
42     const std::vector<TouchPoint> POINTERS = { { .tiltX = TILT_X_VALUE, .tiltY = TILT_Y_VALUE } };
43     const float POINT_X = 1.0f;
44     const float POINT_Y = 1.0f;
45     const int32_t SOURCETYPE = 1;
46     const int32_t SOURCETYPETWO = 2;
47     const int32_t EVENTTYPE = 1;
48     const int64_t TIMEMS_INTERVAL_HOVER = 50;
49     const int64_t TIMEMS_DIFFERENT_HOVER_SOURCE = 200;
50     const int64_t TIMEMS = 500;
51     const int64_t LARGETIMEMS = 1500;
52     const int32_t NUMTWO = 2;
53 } // namespace
54 
55 class AccessibilityManagerNgTestNg : public testing::Test {
56 public:
SetUpTestCase()57     static void SetUpTestCase() {};
TearDownTestCase()58     static void TearDownTestCase() {};
59 };
60 
61 /**
62  * @tc.name: accessibilityManagerNgTest001
63  * @tc.desc:
64  * @tc.type: FUNC
65  */
66 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest001, TestSize.Level1)
67 {
68     AccessibilityManagerNG accessibilityManagerNg{};
69     auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
70     ASSERT_NE(frameNode, nullptr);
71 
72     MouseEvent mouseEvent;
73     mouseEvent.button = MouseButton::LEFT_BUTTON;
74     mouseEvent.action = MouseAction::PRESS;
75     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
76     mouseEvent.sourceType = SourceType::NONE;
77     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
78     mouseEvent.sourceType = SourceType::MOUSE;
79     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
80     mouseEvent.action = MouseAction::WINDOW_ENTER;
81     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
82     mouseEvent.action = MouseAction::MOVE;
83     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
84     mouseEvent.action = MouseAction::WINDOW_LEAVE;
85 
86     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
87     mouseEvent.action = MouseAction::PULL_UP;
88     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
89     EXPECT_EQ(mouseEvent.action, MouseAction::PULL_UP);
90     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
91     accessibilityManagerNg.hoverState_.idle = false;
92     mouseEvent.sourceType = SourceType::MOUSE;
93     mouseEvent.action = MouseAction::MOVE;
94 
95     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
96     accessibilityManagerNg.hoverState_.idle = true;
97     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
98     TimeStamp time;
99     accessibilityManagerNg.hoverState_.time = time;
100     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
101 
102     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false);
103     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent);
104     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, mouseEvent);
105     EXPECT_EQ(accessibilityManagerNg.hoverState_.source, SourceType::MOUSE);
106 }
107 
108 /**
109  * @tc.name: accessibilityManagerNgTest002
110  * @tc.desc:
111  * @tc.type: FUNC
112  */
113 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest002, TestSize.Level1)
114 {
115     AccessibilityManagerNG accessibilityManagerNg{};
116     auto frameNode = FrameNode::CreateFrameNode("main", NUMTWO, AceType::MakeRefPtr<Pattern>(), true);
117     ASSERT_NE(frameNode, nullptr);
118 
119     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
120 
121     TouchEvent touchEvent;
122     touchEvent.type = TouchType::DOWN;
123     TouchPoint pointOne;
124     touchEvent.pointers.push_back(pointOne);
125     TouchPoint pointTwo;
126     touchEvent.pointers.push_back(pointTwo);
127     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
128     touchEvent.type = TouchType::HOVER_ENTER;
129     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
130     touchEvent.type = TouchType::HOVER_MOVE;
131     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
132     touchEvent.type = TouchType::HOVER_EXIT;
133     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
134     EXPECT_EQ(touchEvent.type, TouchType::HOVER_EXIT);
135     touchEvent.type = TouchType::UNKNOWN;
136     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
137     touchEvent.sourceType = SourceType::TOUCH;
138     touchEvent.SetPointers(POINTERS);
139     touchEvent.pointers.push_back(pointOne);
140     touchEvent.pointers.push_back(pointTwo);
141     touchEvent.type = TouchType::HOVER_ENTER;
142     accessibilityManagerNg.hoverState_.source = SourceType::TOUCH;
143     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
144     touchEvent.SetPointers(POINTERS);
145     touchEvent.pointers.push_back(pointOne);
146     touchEvent.pointers.push_back(pointTwo);
147     accessibilityManagerNg.hoverState_.source = SourceType::NONE;
148     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
149 
150     touchEvent.sourceType = SourceType::NONE;
151     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
152 
153     touchEvent.type = TouchType::UNKNOWN;
154     touchEvent.x = 100;
155     touchEvent.y = 100;
156     accessibilityManagerNg.hoverState_.idle = false;
157     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
158     accessibilityManagerNg.hoverState_.idle = true;
159     touchEvent.sourceType = SourceType::TOUCH;
160     accessibilityManagerNg.hoverState_.source = SourceType::TOUCH;
161     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
162     EXPECT_EQ(touchEvent.type, TouchType::UNKNOWN);
163 
164     touchEvent.sourceType = SourceType::NONE;
165     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
166     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent);
167     EXPECT_NE(frameNode, nullptr);
168 }
169 
170 /**
171  * @tc.name: accessibilityManagerNgTest003
172  * @tc.desc:
173  * @tc.type: FUNC
174  */
175 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest003, TestSize.Level1)
176 {
177     AccessibilityManagerNG accessibilityManagerNg{};
178     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG,
179         ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
180 
181     ASSERT_NE(frameNode, nullptr);
182     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, SOURCETYPE, EVENTTYPE, TIMEMS);
183 
184     accessibilityManagerNg.hoverState_.idle = false;
185     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
186         SOURCETYPETWO, EVENTTYPE, TIMEMS);
187     EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, false);
188     WeakPtr<FrameNode> nodesHovering1;
189     WeakPtr<FrameNode> nodesHovering2;
190     accessibilityManagerNg.hoverState_.nodesHovering.push_back(nodesHovering1);
191     accessibilityManagerNg.hoverState_.nodesHovering.push_back(nodesHovering2);
192     accessibilityManagerNg.hoverState_.nodesHovering.push_back(frameNode);
193     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
194         SOURCETYPETWO, EVENTTYPE, TIMEMS);
195     EXPECT_NE(accessibilityManagerNg.hoverState_.nodesHovering.size(), 0);
196     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, -1, EVENTTYPE, TIMEMS);
197     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 99, EVENTTYPE, TIMEMS);
198     EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, false);
199 
200     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
201     accessibilityManagerNg.hoverState_.idle = false;
202     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
203         SOURCETYPETWO, EVENTTYPE, TIMEMS);
204     accessibilityManagerNg.hoverState_.idle = true;
205     accessibilityManagerNg.hoverState_.source = SourceType::NONE;
206     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
207         SOURCETYPETWO, EVENTTYPE, LARGETIMEMS);
208     accessibilityManagerNg.hoverState_.idle = true;
209     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 0, EVENTTYPE, TIMEMS);
210 
211     int32_t eventTypeEnter = static_cast<int32_t>(AccessibilityHoverEventType::ENTER);
212     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 0, eventTypeEnter, TIMEMS);
213     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, SOURCETYPETWO, EVENTTYPE, TIMEMS);
214     EXPECT_EQ(AceApplicationInfo::GetInstance().IsAccessibilityEnabled(), true);
215     accessibilityManagerNg.hoverState_.idle = true;
216     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, SOURCETYPETWO, EVENTTYPE, TIMEMS);
217     EXPECT_EQ(AceApplicationInfo::GetInstance().IsAccessibilityEnabled(), true);
218 }
219 
220 /**
221  * @tc.name: accessibilityManagerNgTest004
222  * @tc.desc:
223  * @tc.type: FUNC
224  */
225 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest004, TestSize.Level1)
226 {
227     AccessibilityManagerNG accessibilityManagerNg{};
228     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG,
229         ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
230     ASSERT_NE(frameNode, nullptr);
231 
232     int32_t x = 100;
233     int32_t y = 100;
234     NG::PointF hoverPoint(x, y);
235     std::string summary;
236     std::string detail;
237     PointerEvent pointerEvent;
238 
239     TimeStamp time;
240 
241     accessibilityManagerNg.HoverTestDebug(frameNode, hoverPoint, summary, detail);
242     auto result = accessibilityManagerNg.DeliverAccessibilityHoverEvent(frameNode, hoverPoint);
243     EXPECT_EQ(result, false);
244     accessibilityManagerNg.IgnoreCurrentHoveringNode(frameNode);
245 
246     auto eventHub = frameNode->GetEventHub<EventHub>();
247     eventHub->SetEnabled(false);
248     accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode,
249         hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time);
250     eventHub->SetEnabled(true);
251     accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode,
252         hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time);
253     PointF pointNode(hoverPoint);
254     result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, frameNode, hoverPoint, pointNode);
255     EXPECT_EQ(result, true);
256     result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, nullptr, hoverPoint, pointNode);
257     EXPECT_EQ(result, false);
258     result = accessibilityManagerNg.ConvertPointFromAncestorToNode(nullptr, frameNode, hoverPoint, pointNode);
259     EXPECT_EQ(result, false);
260     auto endNode = FrameNode::CreateFrameNode("main", NUMTWO, AceType::MakeRefPtr<Pattern>(), true);
261     ASSERT_NE(endNode, nullptr);
262     endNode->UpdateRecycleElmtId(NUMTWO);
263     result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, endNode, hoverPoint, pointNode);
264     EXPECT_EQ(result, true);
265 
266     endNode->SetParent(frameNode);
267     result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, endNode, hoverPoint, pointNode);
268     EXPECT_EQ(result, true);
269 }
270 
271 /**
272  * @tc.name: accessibilityManagerNgTest005
273  * @tc.desc:
274  * @tc.type: FUNC
275  */
276 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest005, TestSize.Level1)
277 {
278     AccessibilityManagerNG accessibilityManagerNg{};
279     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG,
280         ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
281     ASSERT_NE(frameNode, nullptr);
282 
283     // for lastNodesHovering
284     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
285     accessibilityManagerNg.hoverState_.idle = true;
286     WeakPtr<FrameNode> nodesHovering1;
287     WeakPtr<FrameNode> nodesHovering2;
288     accessibilityManagerNg.hoverState_.nodesHovering.push_back(nodesHovering1);
289     accessibilityManagerNg.hoverState_.nodesHovering.push_back(nodesHovering2);
290     accessibilityManagerNg.hoverState_.nodesHovering.push_back(frameNode);
291 
292     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
293         SOURCETYPETWO, EVENTTYPE, TIMEMS);
294     EXPECT_EQ(accessibilityManagerNg.hoverState_.nodesHovering.size(), 0);
295 
296     // for first judge
297     TouchEvent touchEvent;
298     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false);
299     touchEvent.sourceType = SourceType::NONE;
300     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent);
301     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
302     touchEvent.sourceType = SourceType::MOUSE;
303     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent);
304     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
305 
306     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
307     touchEvent.sourceType = SourceType::NONE;
308     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent);
309     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
310     touchEvent.sourceType = SourceType::MOUSE;
311     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent);
312     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
313     EXPECT_NE(frameNode, nullptr);
314 }
315 
316 /**
317  * @tc.name: accessibilityManagerNgTest006
318  * @tc.desc:
319  * @tc.type: FUNC
320  */
321 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest006, TestSize.Level1)
322 {
323     AccessibilityManagerNG accessibilityManagerNg{};
324     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG,
325         ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
326     ASSERT_NE(frameNode, nullptr);
327 
328     // pointers.size
329     TouchEvent touchEvent;
330     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
331 
332     accessibilityManagerNg.hoverState_.idle = true;
333     touchEvent.type = TouchType::HOVER_ENTER;
334 
335     touchEvent.pointers.clear();
336 
337     touchEvent.sourceType = SourceType::NONE;
338     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
339 
340     touchEvent.sourceType = SourceType::TOUCH;
341     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
342 
343     touchEvent.SetPointers(POINTERS);
344     TouchPoint pointOne;
345     TouchPoint pointTwo;
346     touchEvent.pointers.push_back(pointOne);
347     touchEvent.pointers.push_back(pointTwo);
348     touchEvent.sourceType = SourceType::NONE;
349     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
350 
351     touchEvent.sourceType = SourceType::TOUCH;
352 
353     accessibilityManagerNg.hoverState_.source = SourceType::TOUCH;
354     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
355     EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, true);
356 
357     accessibilityManagerNg.hoverState_.source = SourceType::MOUSE;
358     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
359     EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, false);
360 }
361 
362 /**
363  * @tc.name: accessibilityManagerNgTest007
364  * @tc.desc:
365  * @tc.type: FUNC
366  */
367 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest007, TestSize.Level1)
368 {
369     AccessibilityManagerNG accessibilityManagerNg{};
370     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG,
371         ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<MockAccessibilityTestPattern>());
372 
373     int32_t x = 100;
374     int32_t y = 100;
375     NG::PointF hoverPoint(x, y);
376     TimeStamp time;
377     accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode,
378         hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time);
379 
380     accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, nullptr,
381         hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time);
382 
383     EXPECT_NE(frameNode, nullptr);
384 }
385 
386 /**
387  * @tc.name: accessibilityManagerNgTest008
388  * @tc.desc:
389  * @tc.type: FUNC
390  */
391 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest008, TestSize.Level1)
392 {
393     AccessibilityManagerNG accessibilityManagerNg{};
394     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG,
395         ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
396     ASSERT_NE(frameNode, nullptr);
397 
398     accessibilityManagerNg.hoverState_.idle = false;
399     accessibilityManagerNg.hoverState_.nodesHovering.push_back(frameNode);
400 
401     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
402     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
403         SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER);
404     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
405         SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER);
406     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
407         SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER);
408     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y,
409         SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER);
410     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y,
411         SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER);
412     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y,
413         SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER);
414 
415     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false);
416     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
417         SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER);
418     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
419         SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER);
420     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y,
421         SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER);
422     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y,
423         SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER);
424     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y,
425         SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER);
426     accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y,
427         SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER);
428 
429     EXPECT_NE(accessibilityManagerNg.hoverState_.nodesHovering.size(), 0);
430 }
431 
432 /**
433  * @tc.name: accessibilityManagerNgTest009
434  * @tc.desc:
435  * @tc.type: FUNC
436  */
437 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest009, TestSize.Level1)
438 {
439     AccessibilityManagerNG accessibilityManagerNg{};
440     auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG,
441         ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>());
442     ASSERT_NE(frameNode, nullptr);
443 
444     // hoverState source different and time is in MIN_SOURCE_CHANGE_GAP_MS
445     TouchEvent touchEvent;
446     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
447 
448     accessibilityManagerNg.hoverState_.idle = false;
449     touchEvent.type = TouchType::HOVER_ENTER;
450 
451     touchEvent.SetPointers(POINTERS);
452 
453     touchEvent.sourceType = SourceType::TOUCH;
454     accessibilityManagerNg.hoverState_.source = SourceType::MOUSE;
455     TimeStamp time((std::chrono::milliseconds(TIMEMS_DIFFERENT_HOVER_SOURCE)));
456     touchEvent.time = time;
457 
458     accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent);
459     EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, false);
460 }
461 } // namespace OHOS::Ace::NG