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/components_ng/pattern/node_container/node_container_pattern.h" 25 #include "core/pipeline_ng/pipeline_context.h" 26 #include "frameworks/core/accessibility/accessibility_constants.h" 27 #include "frameworks/core/accessibility/accessibility_manager_ng.h" 28 #include "frameworks/core/components_ng/event/touch_event.h" 29 #include "frameworks/core/components_ng/pattern/pattern.h" 30 #include "frameworks/core/components_ng/pattern/text/text_pattern.h" 31 #include "frameworks/core/event/mouse_event.h" 32 #include "frameworks/core/event/pointer_event.h" 33 34 #include "accessibility_session_adapter_test.h" 35 36 using namespace testing; 37 using namespace testing::ext; 38 39 namespace OHOS::Ace::NG { 40 namespace { 41 constexpr float TILT_X_VALUE = 400.0f; 42 constexpr float TILT_Y_VALUE = 400.0f; 43 const std::vector<TouchPoint> POINTERS = { { .tiltX = TILT_X_VALUE, .tiltY = TILT_Y_VALUE } }; 44 const float POINT_X = 1.0f; 45 const float POINT_Y = 1.0f; 46 const int32_t SOURCETYPE = 1; 47 const int32_t SOURCETYPETWO = 2; 48 const int32_t EVENTTYPE = 1; 49 const int64_t TIMEMS_INTERVAL_HOVER = 50; 50 const int64_t TIMEMS_DIFFERENT_HOVER_SOURCE = 200; 51 const int64_t TIMEMS = 500; 52 const int64_t LARGETIMEMS = 1500; 53 const int32_t NUMTWO = 2; 54 } // namespace 55 56 constexpr int ZERO_ANGLE = 0; 57 constexpr int QUARTER_ANGLE = 90; 58 constexpr int HALF_ANGLE = 180; 59 constexpr int THREE_QUARTER_ANGLE = 270; 60 constexpr int FULL_ANGLE = 360; 61 62 class MockFrameNode : public FrameNode { 63 public: GetTransformScale()64 VectorF GetTransformScale() 65 { 66 VectorF testScale {1.2f, 1.2f}; 67 return testScale; 68 } 69 }; 70 71 class AccessibilityManagerNgTestNg : public testing::Test { 72 public: SetUpTestCase()73 static void SetUpTestCase() {}; TearDownTestCase()74 static void TearDownTestCase() {}; 75 }; 76 77 /** 78 * @tc.name: accessibilityManagerNgTest001 79 * @tc.desc: 80 * @tc.type: FUNC 81 */ 82 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest001, TestSize.Level1) 83 { 84 AccessibilityManagerNG accessibilityManagerNg{}; 85 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true); 86 ASSERT_NE(frameNode, nullptr); 87 auto& hoverState = accessibilityManagerNg.hoverStateManager_.GetHoverState(frameNode->GetAccessibilityId()); 88 89 MouseEvent mouseEvent; 90 mouseEvent.button = MouseButton::LEFT_BUTTON; 91 mouseEvent.action = MouseAction::PRESS; 92 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 93 mouseEvent.sourceType = SourceType::NONE; 94 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 95 mouseEvent.sourceType = SourceType::MOUSE; 96 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 97 mouseEvent.action = MouseAction::WINDOW_ENTER; 98 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 99 mouseEvent.action = MouseAction::MOVE; 100 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 101 mouseEvent.action = MouseAction::WINDOW_LEAVE; 102 103 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 104 mouseEvent.action = MouseAction::PULL_UP; 105 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 106 hoverState.idle = false; 107 mouseEvent.sourceType = SourceType::MOUSE; 108 mouseEvent.action = MouseAction::MOVE; 109 110 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 111 hoverState.idle = true; 112 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 113 TimeStamp time; 114 hoverState.time = time; 115 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 116 117 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false); 118 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 119 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, mouseEvent); 120 EXPECT_EQ(hoverState.source, SourceType::MOUSE); 121 } 122 123 /** 124 * @tc.name: accessibilityManagerNgTest002 125 * @tc.desc: 126 * @tc.type: FUNC 127 */ 128 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest002, TestSize.Level1) 129 { 130 AccessibilityManagerNG accessibilityManagerNg{}; 131 auto frameNode = FrameNode::CreateFrameNode("main", NUMTWO, AceType::MakeRefPtr<Pattern>(), true); 132 ASSERT_NE(frameNode, nullptr); 133 auto& hoverState = accessibilityManagerNg.hoverStateManager_.GetHoverState(frameNode->GetAccessibilityId()); 134 135 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 136 137 TouchEvent touchEvent; 138 touchEvent.type = TouchType::DOWN; 139 TouchPoint pointOne; 140 touchEvent.pointers.push_back(pointOne); 141 TouchPoint pointTwo; 142 touchEvent.pointers.push_back(pointTwo); 143 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 144 touchEvent.type = TouchType::HOVER_ENTER; 145 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 146 touchEvent.type = TouchType::HOVER_MOVE; 147 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 148 touchEvent.type = TouchType::HOVER_EXIT; 149 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 150 touchEvent.type = TouchType::UNKNOWN; 151 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 152 touchEvent.sourceType = SourceType::TOUCH; 153 touchEvent.SetPointers(POINTERS); 154 touchEvent.pointers.push_back(pointOne); 155 touchEvent.pointers.push_back(pointTwo); 156 touchEvent.type = TouchType::HOVER_ENTER; 157 hoverState.source = SourceType::TOUCH; 158 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 159 touchEvent.SetPointers(POINTERS); 160 touchEvent.pointers.push_back(pointOne); 161 touchEvent.pointers.push_back(pointTwo); 162 hoverState.source = SourceType::NONE; 163 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 164 165 touchEvent.sourceType = SourceType::NONE; 166 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 167 168 touchEvent.type = TouchType::UNKNOWN; 169 touchEvent.x = 100; 170 touchEvent.y = 100; 171 hoverState.idle = false; 172 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 173 hoverState.idle = true; 174 touchEvent.sourceType = SourceType::TOUCH; 175 hoverState.source = SourceType::TOUCH; 176 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 177 178 touchEvent.sourceType = SourceType::NONE; 179 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 180 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 181 EXPECT_NE(frameNode, nullptr); 182 } 183 184 /** 185 * @tc.name: accessibilityManagerNgTest003 186 * @tc.desc: 187 * @tc.type: FUNC 188 */ 189 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest003, TestSize.Level1) 190 { 191 AccessibilityManagerNG accessibilityManagerNg{}; 192 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 193 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 194 195 ASSERT_NE(frameNode, nullptr); 196 auto& hoverState = accessibilityManagerNg.hoverStateManager_.GetHoverState(frameNode->GetAccessibilityId()); 197 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, SOURCETYPE, EVENTTYPE, TIMEMS); 198 199 hoverState.idle = false; 200 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 201 SOURCETYPETWO, EVENTTYPE, TIMEMS); 202 EXPECT_EQ(hoverState.idle, false); 203 WeakPtr<FrameNode> nodesHovering1; 204 WeakPtr<FrameNode> nodesHovering2; 205 hoverState.nodesHovering.push_back(nodesHovering1); 206 hoverState.nodesHovering.push_back(nodesHovering2); 207 hoverState.nodesHovering.push_back(frameNode); 208 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 209 SOURCETYPETWO, EVENTTYPE, TIMEMS); 210 EXPECT_NE(hoverState.nodesHovering.size(), 0); 211 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, -1, EVENTTYPE, TIMEMS); 212 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 99, EVENTTYPE, TIMEMS); 213 EXPECT_EQ(hoverState.idle, false); 214 215 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 216 hoverState.idle = false; 217 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 218 SOURCETYPETWO, EVENTTYPE, TIMEMS); 219 hoverState.idle = true; 220 hoverState.source = SourceType::NONE; 221 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 222 SOURCETYPETWO, EVENTTYPE, LARGETIMEMS); 223 hoverState.idle = true; 224 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 0, EVENTTYPE, TIMEMS); 225 226 int32_t eventTypeEnter = static_cast<int32_t>(AccessibilityHoverEventType::ENTER); 227 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 0, eventTypeEnter, TIMEMS); 228 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, SOURCETYPETWO, EVENTTYPE, TIMEMS); 229 EXPECT_EQ(AceApplicationInfo::GetInstance().IsAccessibilityEnabled(), true); 230 hoverState.idle = true; 231 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, SOURCETYPETWO, EVENTTYPE, TIMEMS); 232 EXPECT_EQ(AceApplicationInfo::GetInstance().IsAccessibilityEnabled(), true); 233 } 234 235 /** 236 * @tc.name: accessibilityManagerNgTest004 237 * @tc.desc: 238 * @tc.type: FUNC 239 */ 240 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest004, TestSize.Level1) 241 { 242 AccessibilityManagerNG accessibilityManagerNg{}; 243 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 244 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 245 ASSERT_NE(frameNode, nullptr); 246 247 int32_t x = 100; 248 int32_t y = 100; 249 NG::PointF hoverPoint(x, y); 250 std::string summary; 251 std::string detail; 252 DragPointerEvent pointerEvent; 253 254 TimeStamp time; 255 256 accessibilityManagerNg.HoverTestDebug(frameNode, hoverPoint, summary, detail); 257 accessibilityManagerNg.IgnoreCurrentHoveringNode(frameNode); 258 259 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>(); 260 eventHub->SetEnabled(false); 261 accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode, 262 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 263 eventHub->SetEnabled(true); 264 accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode, 265 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 266 PointF pointNode(hoverPoint); 267 auto result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, frameNode, hoverPoint, pointNode); 268 EXPECT_EQ(result, true); 269 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, nullptr, hoverPoint, pointNode); 270 EXPECT_EQ(result, false); 271 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(nullptr, frameNode, hoverPoint, pointNode); 272 EXPECT_EQ(result, false); 273 auto endNode = FrameNode::CreateFrameNode("main", NUMTWO, AceType::MakeRefPtr<Pattern>(), true); 274 ASSERT_NE(endNode, nullptr); 275 endNode->UpdateRecycleElmtId(NUMTWO); 276 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, endNode, hoverPoint, pointNode); 277 EXPECT_EQ(result, false); 278 279 endNode->SetParent(frameNode); 280 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, endNode, hoverPoint, pointNode); 281 EXPECT_EQ(result, true); 282 283 auto endNodeMock = MockFrameNode::CreateFrameNode("main", NUMTWO, AceType::MakeRefPtr<Pattern>(), true); 284 endNodeMock->SetParent(frameNode); 285 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, endNodeMock, hoverPoint, pointNode); 286 EXPECT_EQ(result, true); 287 } 288 289 /** 290 * @tc.name: accessibilityManagerNgTest005 291 * @tc.desc: 292 * @tc.type: FUNC 293 */ 294 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest005, TestSize.Level1) 295 { 296 AccessibilityManagerNG accessibilityManagerNg{}; 297 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 298 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 299 ASSERT_NE(frameNode, nullptr); 300 auto& hoverState = accessibilityManagerNg.hoverStateManager_.GetHoverState(frameNode->GetAccessibilityId()); 301 302 // for lastNodesHovering 303 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 304 hoverState.idle = true; 305 WeakPtr<FrameNode> nodesHovering1; 306 WeakPtr<FrameNode> nodesHovering2; 307 hoverState.nodesHovering.push_back(nodesHovering1); 308 hoverState.nodesHovering.push_back(nodesHovering2); 309 hoverState.nodesHovering.push_back(frameNode); 310 311 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 312 SOURCETYPETWO, EVENTTYPE, TIMEMS); 313 EXPECT_EQ(hoverState.nodesHovering.size(), 0); 314 315 // for first judge 316 TouchEvent touchEvent; 317 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false); 318 touchEvent.sourceType = SourceType::NONE; 319 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 320 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 321 touchEvent.sourceType = SourceType::MOUSE; 322 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 323 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 324 325 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 326 touchEvent.sourceType = SourceType::NONE; 327 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 328 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 329 touchEvent.sourceType = SourceType::MOUSE; 330 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 331 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 332 EXPECT_NE(frameNode, nullptr); 333 } 334 335 /** 336 * @tc.name: accessibilityManagerNgTest006 337 * @tc.desc: 338 * @tc.type: FUNC 339 */ 340 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest006, TestSize.Level1) 341 { 342 AccessibilityManagerNG accessibilityManagerNg{}; 343 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 344 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 345 ASSERT_NE(frameNode, nullptr); 346 auto& hoverState = accessibilityManagerNg.hoverStateManager_.GetHoverState(frameNode->GetAccessibilityId()); 347 348 // pointers.size 349 TouchEvent touchEvent; 350 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 351 352 hoverState.idle = true; 353 touchEvent.type = TouchType::HOVER_ENTER; 354 355 touchEvent.pointers.clear(); 356 357 touchEvent.sourceType = SourceType::NONE; 358 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 359 360 touchEvent.sourceType = SourceType::TOUCH; 361 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 362 363 touchEvent.SetPointers(POINTERS); 364 TouchPoint pointOne; 365 TouchPoint pointTwo; 366 touchEvent.pointers.push_back(pointOne); 367 touchEvent.pointers.push_back(pointTwo); 368 touchEvent.sourceType = SourceType::NONE; 369 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 370 371 touchEvent.sourceType = SourceType::TOUCH; 372 373 hoverState.source = SourceType::TOUCH; 374 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 375 EXPECT_EQ(hoverState.idle, true); 376 377 hoverState.source = SourceType::MOUSE; 378 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 379 EXPECT_EQ(hoverState.idle, false); 380 } 381 382 /** 383 * @tc.name: accessibilityManagerNgTest007 384 * @tc.desc: 385 * @tc.type: FUNC 386 */ 387 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest007, TestSize.Level1) 388 { 389 AccessibilityManagerNG accessibilityManagerNg{}; 390 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 391 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<MockAccessibilityTestPattern>()); 392 393 int32_t x = 100; 394 int32_t y = 100; 395 NG::PointF hoverPoint(x, y); 396 TimeStamp time; 397 accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode, 398 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 399 400 accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, nullptr, 401 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 402 403 EXPECT_NE(frameNode, nullptr); 404 } 405 406 /** 407 * @tc.name: accessibilityManagerNgTest008 408 * @tc.desc: 409 * @tc.type: FUNC 410 */ 411 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest008, TestSize.Level1) 412 { 413 AccessibilityManagerNG accessibilityManagerNg{}; 414 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 415 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 416 ASSERT_NE(frameNode, nullptr); 417 auto& hoverState = accessibilityManagerNg.hoverStateManager_.GetHoverState(frameNode->GetAccessibilityId()); 418 419 hoverState.idle = false; 420 hoverState.nodesHovering.push_back(frameNode); 421 422 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 423 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 424 SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER); 425 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 426 SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER); 427 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 428 SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER); 429 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 430 SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER); 431 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 432 SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER); 433 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 434 SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER); 435 436 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false); 437 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 438 SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER); 439 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 440 SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER); 441 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 442 SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER); 443 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 444 SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER); 445 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 446 SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER); 447 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 448 SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER); 449 450 EXPECT_NE(hoverState.nodesHovering.size(), 0); 451 } 452 453 /** 454 * @tc.name: accessibilityManagerNgTest009 455 * @tc.desc: 456 * @tc.type: FUNC 457 */ 458 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest009, TestSize.Level1) 459 { 460 AccessibilityManagerNG accessibilityManagerNg{}; 461 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 462 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 463 ASSERT_NE(frameNode, nullptr); 464 auto& hoverState = accessibilityManagerNg.hoverStateManager_.GetHoverState(frameNode->GetAccessibilityId()); 465 466 // hoverState source different and time is in MIN_SOURCE_CHANGE_GAP_MS 467 TouchEvent touchEvent; 468 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 469 470 hoverState.idle = false; 471 touchEvent.type = TouchType::HOVER_ENTER; 472 473 touchEvent.SetPointers(POINTERS); 474 475 touchEvent.sourceType = SourceType::TOUCH; 476 hoverState.source = SourceType::MOUSE; 477 TimeStamp time((std::chrono::milliseconds(TIMEMS_DIFFERENT_HOVER_SOURCE))); 478 touchEvent.time = time; 479 480 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 481 EXPECT_EQ(hoverState.idle, false); 482 483 hoverState.eventType = AccessibilityHoverEventType::MOVE; 484 auto ret = accessibilityManagerNg.IsEventTypeChangeDirectHandleHover( 485 AccessibilityHoverEventType::EXIT, 486 AccessibilityHoverEventType::MOVE); 487 EXPECT_TRUE(ret); 488 } 489 490 /** 491 * @tc.name: AccessibilityManagerNgTest010 492 * @tc.desc: NotifyHoverEventToNodeSession 493 * @tc.type: FUNC 494 */ 495 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest010, TestSize.Level1) 496 { 497 AccessibilityManagerNG accessibilityManagerNg{}; 498 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 499 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 500 ASSERT_NE(frameNode, nullptr); 501 int32_t x = 100; 502 int32_t y = 100; 503 NG::PointF hoverPoint(x, y); 504 TimeStamp time; 505 506 auto ret = accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode, 507 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 508 EXPECT_FALSE(ret); 509 510 ret = accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, nullptr, 511 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 512 EXPECT_FALSE(ret); 513 514 auto testNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 515 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<MockAccessibilityTestPattern>()); 516 auto pattern = testNode->GetPattern(); 517 ASSERT_NE(pattern, nullptr); 518 testNode->eventHub_ = pattern->CreateEventHub(); 519 auto eventHub = testNode->eventHub_; 520 ASSERT_NE(eventHub, nullptr); 521 eventHub->SetEnabledInternal(true); 522 ret = accessibilityManagerNg.NotifyHoverEventToNodeSession(testNode, testNode, 523 hoverPoint, SourceType::TOUCH, AccessibilityHoverEventType::ENTER, time); 524 EXPECT_TRUE(ret); 525 } 526 527 /** 528 * @tc.name: AccessibilityManagerNgTest011 529 * @tc.desc: HandleAccessibilityHoverTransparentCallback 530 * @tc.type: FUNC 531 */ 532 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest011, TestSize.Level1) 533 { 534 AccessibilityManagerNG accessibilityManagerNg{}; 535 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 536 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 537 ASSERT_NE(frameNode, nullptr); 538 539 AccessibilityManagerNG::HandleTransparentCallbackParam param = {0, 1}; 540 PointF point; 541 TouchEvent touchEvent; 542 543 auto ret = accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(true, 544 frameNode, 545 param, 546 point, 547 touchEvent); 548 EXPECT_FALSE(ret); 549 550 ret = accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(false, 551 frameNode, 552 param, 553 point, 554 touchEvent); 555 EXPECT_FALSE(ret); 556 557 param = {-1, -1}; 558 ret = accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(false, 559 frameNode, 560 param, 561 point, 562 touchEvent); 563 EXPECT_FALSE(ret); 564 565 ret = accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(false, 566 nullptr, 567 param, 568 point, 569 touchEvent); 570 EXPECT_FALSE(ret); 571 } 572 573 /** 574 * @tc.name: AccessibilityManagerNgTest012 575 * @tc.desc: ExecuteChildNodeHoverTransparentCallback 576 * @tc.type: FUNC 577 */ 578 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest012, TestSize.Level1) 579 { 580 AccessibilityManagerNG accessibilityManagerNg{}; 581 TouchEvent touchEvent; 582 583 PointF point; 584 auto ret = accessibilityManagerNg.ExecuteChildNodeHoverTransparentCallback(nullptr, point, touchEvent); 585 EXPECT_FALSE(ret); 586 587 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 588 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 589 ASSERT_NE(frameNode, nullptr); 590 ret = accessibilityManagerNg.ExecuteChildNodeHoverTransparentCallback(frameNode, point, touchEvent); 591 EXPECT_TRUE(ret); 592 } 593 594 /** 595 * @tc.name: AccessibilityRectTest001 596 * @tc.desc: AccessibilityRect 597 * @tc.type: FUNC 598 */ 599 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest001, TestSize.Level1) 600 { 601 AccessibilityRect rect1; 602 EXPECT_EQ(rect1.GetX(), 0); 603 EXPECT_EQ(rect1.GetY(), 0); 604 EXPECT_EQ(rect1.GetWidth(), 0); 605 EXPECT_EQ(rect1.GetHeight(), 0); 606 607 AccessibilityRect rect2(10, 20, 100, 200); 608 EXPECT_EQ(rect2.GetX(), 10); 609 EXPECT_EQ(rect2.GetY(), 20); 610 EXPECT_EQ(rect2.GetWidth(), 100); 611 EXPECT_EQ(rect2.GetHeight(), 200); 612 613 rect2.SetPosition(30, 40); 614 EXPECT_EQ(rect2.GetX(), 30); 615 EXPECT_EQ(rect2.GetY(), 40); 616 617 rect2.SetSize(50, 60); 618 EXPECT_EQ(rect2.GetWidth(), 50); 619 EXPECT_EQ(rect2.GetHeight(), 60); 620 } 621 622 /** 623 * @tc.name: AccessibilityRectTest002 624 * @tc.desc: AccessibilityRect 625 * @tc.type: FUNC 626 */ 627 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest002, TestSize.Level1) 628 { 629 // init x=0, y=0, width=100, height=200 630 AccessibilityRect rect(0, 0, 100, 200); 631 const float originalCenterX = 50; // 0 + 100/2 632 const float originalCenterY = 100; // 0 + 200/2 633 634 // rotate 90 635 rect.Rotate(QUARTER_ANGLE); 636 EXPECT_EQ(rect.GetWidth(), 200); 637 EXPECT_EQ(rect.GetHeight(), 100); 638 EXPECT_EQ(rect.GetX(), originalCenterX - 200/2); // 50 - 100 = -50 639 EXPECT_EQ(rect.GetY(), originalCenterY - 100/2); // 100 - 50 = 50 640 641 // rotate 180 642 rect.Rotate(HALF_ANGLE); 643 EXPECT_EQ(rect.GetWidth(), 200); 644 EXPECT_EQ(rect.GetHeight(), 100); 645 EXPECT_EQ(rect.GetX(), -50); 646 EXPECT_EQ(rect.GetY(), 50); 647 648 // rotate 270 649 rect.Rotate(THREE_QUARTER_ANGLE); 650 EXPECT_EQ(rect.GetWidth(), 100); 651 EXPECT_EQ(rect.GetHeight(), 200); 652 } 653 654 /** 655 * @tc.name: AccessibilityRectTest003 656 * @tc.desc: AccessibilityRect 657 * @tc.type: FUNC 658 */ 659 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest003, TestSize.Level1) 660 { 661 // rotate center (100, 100) 662 AccessibilityRect rect(0, 0, 100, 100); 663 // rotate 90 664 rect.Rotate(0, 0, QUARTER_ANGLE); 665 EXPECT_EQ(rect.GetWidth(), 100); 666 EXPECT_EQ(rect.GetHeight(), 100); 667 } 668 669 /** 670 * @tc.name: AccessibilityRectTest004 671 * @tc.desc: AccessibilityRect 672 * @tc.type: FUNC 673 */ 674 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest004, TestSize.Level1) 675 { 676 AccessibilityRect rect(0, 0, 100, 200); 677 678 // 450 ≡ 90 679 rect.Rotate(450); 680 EXPECT_EQ(rect.GetWidth(), 200); 681 682 // 720 ≡ 0 683 rect.Rotate(FULL_ANGLE * 2); 684 EXPECT_EQ(rect.GetWidth(), 200); 685 } 686 687 /** 688 * @tc.name: AccessibilityRectTest005 689 * @tc.desc: AccessibilityRect 690 * @tc.type: FUNC 691 */ 692 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest005, TestSize.Level1) 693 { 694 AccessibilityRect rect(10, 20, 30, 40); 695 rect.Rotate(ZERO_ANGLE); 696 EXPECT_EQ(rect.GetX(), 10); 697 EXPECT_EQ(rect.GetY(), 20); 698 EXPECT_EQ(rect.GetWidth(), 30); 699 EXPECT_EQ(rect.GetHeight(), 40); 700 701 rect.Rotate(FULL_ANGLE); 702 EXPECT_EQ(rect.GetWidth(), 30); 703 } 704 705 /** 706 * @tc.name: AccessibilityRectTest006 707 * @tc.desc: AccessibilityRect 708 * @tc.type: FUNC 709 */ 710 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest006, TestSize.Level1) 711 { 712 AccessibilityRect rect(10, 20, 100, 200); 713 RotateTransform transform(0, 50, 60, 30, 40); 714 715 // 2x, 3y 716 rect.ApplyTransformation(transform, 2.0f, 3.0f); 717 718 // x = (10 - 30)*2 + 50 = (-20)*2 +50 = 10 719 EXPECT_EQ(rect.GetX(), 10.0f); 720 // y = (20 -40)*3 +60 = (-20)*3 +60 = 0 721 EXPECT_EQ(rect.GetY(), 0); 722 // width = 100*2 = 200 723 EXPECT_EQ(rect.GetWidth(), 200); 724 // height = 200*3 = 600 725 EXPECT_EQ(rect.GetHeight(), 600); 726 } 727 728 /** 729 * @tc.name: IsHandlePipelineAccessibilityHoverEnter001 730 * @tc.desc: IsHandlePipelineAccessibilityHoverEnter 731 * @tc.type: FUNC 732 */ 733 HWTEST_F(AccessibilityManagerNgTestNg, IsHandlePipelineAccessibilityHoverEnter001, TestSize.Level1) 734 { 735 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 736 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 737 ASSERT_NE(frameNode, nullptr); 738 frameNode->context_ = nullptr; 739 740 AccessibilityManagerNG manager{}; 741 bool result = manager.IsHandlePipelineAccessibilityHoverEnter(frameNode); 742 EXPECT_FALSE(result); 743 } 744 745 /** 746 * @tc.name: IsHandlePipelineAccessibilityHoverEnter002 747 * @tc.desc: IsHandlePipelineAccessibilityHoverEnter 748 * @tc.type: FUNC 749 */ 750 HWTEST_F(AccessibilityManagerNgTestNg, IsHandlePipelineAccessibilityHoverEnter002, TestSize.Level1) 751 { 752 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 753 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 754 ASSERT_NE(frameNode, nullptr); 755 756 AccessibilityManagerNG manager; 757 bool result = manager.IsHandlePipelineAccessibilityHoverEnter(frameNode); 758 EXPECT_FALSE(result); 759 } 760 761 /** 762 * @tc.name: IsHandlePipelineAccessibilityHoverEnter003 763 * @tc.desc: IsHandlePipelineAccessibilityHoverEnter 764 * @tc.type: FUNC 765 */ 766 HWTEST_F(AccessibilityManagerNgTestNg, IsHandlePipelineAccessibilityHoverEnter003, TestSize.Level1) 767 { 768 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 769 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 770 ASSERT_NE(frameNode, nullptr); 771 auto pipe = MockPipelineContext::GetCurrent(); 772 frameNode->context_ = AceType::RawPtr(pipe); 773 AccessibilityManagerNG manager; 774 bool result = manager.IsHandlePipelineAccessibilityHoverEnter(frameNode); 775 EXPECT_FALSE(result); 776 } 777 778 /** 779 * @tc.name: AccessibilityHoverStateManager001 780 * @tc.desc: Test GetHoverState and ResetHoverState func 781 * @tc.type: FUNC 782 */ 783 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityHoverStateManager001, TestSize.Level1) 784 { 785 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 786 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 787 ASSERT_NE(frameNode, nullptr); 788 789 AccessibilityHoverStateManager manager; 790 auto& hoverState = manager.GetHoverState(frameNode->GetAccessibilityId()); 791 EXPECT_EQ(manager.hoverStateMap_.size(), 1); 792 793 hoverState.idle = false; 794 auto& hoverStateNew = manager.GetHoverState(frameNode->GetAccessibilityId()); 795 EXPECT_EQ(manager.hoverStateMap_.size(), 1); 796 EXPECT_FALSE(hoverStateNew.idle); 797 798 manager.ResetHoverState(hoverStateNew); 799 EXPECT_TRUE(hoverStateNew.idle); 800 } 801 802 /** 803 * @tc.name: HandlePipelineAccessibilityHoverEnter001 804 * @tc.desc: HandlePipelineAccessibilityHoverEnter 805 * @tc.type: FUNC 806 */ 807 HWTEST_F(AccessibilityManagerNgTestNg, HandlePipelineAccessibilityHoverEnter001, TestSize.Level1) { 808 AccessibilityManagerNG manager; 809 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 810 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 811 ASSERT_NE(frameNode, nullptr); 812 TouchEvent event; 813 int32_t eventType; 814 // Case 1: Test with AccessibilityHoverEventType::ENTER 815 eventType = static_cast<int32_t>(AccessibilityHoverEventType::ENTER); 816 manager.HandlePipelineAccessibilityHoverEnter(frameNode, event, eventType); 817 818 // Case 2: Test with AccessibilityHoverEventType::MOVE 819 eventType = static_cast<int32_t>(AccessibilityHoverEventType::MOVE); 820 manager.HandlePipelineAccessibilityHoverEnter(frameNode, event, eventType); 821 822 // Case 3: Test with AccessibilityHoverEventType::EXIT 823 eventType = static_cast<int32_t>(AccessibilityHoverEventType::EXIT); 824 manager.HandlePipelineAccessibilityHoverEnter(frameNode, event, eventType); 825 826 // Case 4: Test with an invalid event type (default case) 827 eventType = -1; // Invalid type 828 manager.HandlePipelineAccessibilityHoverEnter(frameNode, event, eventType); 829 } 830 831 /** 832 * @tc.name: HandleAccessibilityHoverEventBySurfaceId 833 * @tc.desc: HandleAccessibilityHoverEventBySurfaceId001 834 * @tc.type: FUNC 835 */ 836 HWTEST_F(AccessibilityManagerNgTestNg, HandleAccessibilityHoverEventBySurfaceId001, TestSize.Level1) 837 { 838 MockPipelineContext::SetUp(); 839 auto pipe = MockPipelineContext::GetCurrent(); 840 ASSERT_NE(pipe, nullptr); 841 842 auto exportNode = FrameNode::CreateFrameNode( 843 "exportNode", 844 ElementRegister::GetInstance()->MakeUniqueId(), 845 AceType::MakeRefPtr<TextPattern>()); 846 ASSERT_NE(exportNode, nullptr); 847 exportNode->context_ = AceType::RawPtr(pipe); 848 849 ElementRegister::GetInstance()->RegisterEmbedNode(1U, exportNode); 850 851 auto rootElement = pipe->GetRootElement(); 852 ASSERT_NE(rootElement, nullptr); 853 rootElement->AddChild(exportNode); 854 855 AccessibilityManagerNG manager; 856 std::stringstream ss; 857 ss << 1U; 858 PointF point(POINT_X, POINT_Y); 859 TimeStamp time((std::chrono::milliseconds(TIMEMS_DIFFERENT_HOVER_SOURCE))); 860 HandleHoverEventParam param { 861 .point = point, 862 .time = time, 863 .sourceType = SourceType::MOUSE, 864 .eventType = AccessibilityHoverEventType::ENTER 865 }; 866 auto ret = manager.HandleAccessibilityHoverEventBySurfaceId(ss.str(), param); 867 EXPECT_EQ(ret, HandleHoverRet::HOVER_FAIL); 868 869 MockPipelineContext::TearDown(); 870 } 871 872 /** 873 * @tc.name: HandleAccessibilityHoverEventInner001 874 * @tc.desc: HandleAccessibilityHoverEventInner 875 * @tc.type: FUNC 876 */ 877 HWTEST_F(AccessibilityManagerNgTestNg, HandleAccessibilityHoverEventInner001, TestSize.Level1) 878 { 879 MockPipelineContext::SetUp(); 880 auto pipe = MockPipelineContext::GetCurrent(); 881 ASSERT_NE(pipe, nullptr); 882 883 auto frameNode = FrameNode::CreateFrameNode( 884 "testNode", 885 ElementRegister::GetInstance()->MakeUniqueId(), 886 AceType::MakeRefPtr<TextPattern>()); 887 ASSERT_NE(frameNode, nullptr); 888 frameNode->context_ = AceType::RawPtr(pipe); 889 890 AccessibilityManagerNG manager; 891 auto& hoverState = manager.hoverStateManager_.GetHoverState(frameNode->GetAccessibilityId()); 892 TouchEvent touchEvent; 893 PointF point(10.0f, 20.0f); 894 TimeStamp baseTime((std::chrono::milliseconds(100))); 895 896 hoverState.idle = true; 897 HandleHoverEventParam param1 { 898 .point = point, 899 .time = baseTime, 900 .sourceType = SourceType::MOUSE, 901 .eventType = AccessibilityHoverEventType::ENTER 902 }; 903 auto ret = manager.HandleAccessibilityHoverEventInner(frameNode, param1, touchEvent); 904 EXPECT_TRUE(ret == HandleHoverRet::HOVER_FAIL); 905 906 hoverState.idle = false; 907 hoverState.time = baseTime; 908 hoverState.eventType = AccessibilityHoverEventType::MOVE; 909 HandleHoverEventParam param2 = param1; 910 param2.eventType = AccessibilityHoverEventType::MOVE; 911 param2.time = baseTime + std::chrono::milliseconds(5); 912 ret = manager.HandleAccessibilityHoverEventInner(frameNode, param2, touchEvent); 913 EXPECT_EQ(ret, HandleHoverRet::IN_TIME_LIMIT); 914 915 hoverState.idle = false; 916 hoverState.time = baseTime; 917 hoverState.eventType = AccessibilityHoverEventType::MOVE; 918 HandleHoverEventParam param3 = param1; 919 param3.eventType = AccessibilityHoverEventType::EXIT; 920 param3.time = baseTime + std::chrono::milliseconds(5); 921 ret = manager.HandleAccessibilityHoverEventInner(frameNode, param3, touchEvent); 922 EXPECT_TRUE(ret == HandleHoverRet::HOVER_FAIL); 923 MockPipelineContext::TearDown(); 924 } 925 926 /** 927 * @tc.name: HandleAccessibilityHoverEventInner002 928 * @tc.desc: HandleAccessibilityHoverEventInner 929 * @tc.type: FUNC 930 */ 931 HWTEST_F(AccessibilityManagerNgTestNg, HandleAccessibilityHoverEventInner002, TestSize.Level1) 932 { 933 // Step 1: Set up the mock pipeline context. 934 MockPipelineContext::SetUp(); 935 auto pipe = MockPipelineContext::GetCurrent(); 936 ASSERT_NE(pipe, nullptr); 937 // Step 2: Create a FrameNode and set its context. 938 auto frameNode = FrameNode::CreateFrameNode("testNode", ElementRegister::GetInstance()->MakeUniqueId(), 939 AceType::MakeRefPtr<TextPattern>()); 940 ASSERT_NE(frameNode, nullptr); 941 frameNode->context_ = AceType::RawPtr(pipe); 942 943 AccessibilityManagerNG manager; 944 // Step 3: Get the hover state for the frame node. 945 auto& hoverState = manager.hoverStateManager_.GetHoverState(frameNode->GetAccessibilityId()); 946 TouchEvent touchEvent; 947 PointF point(10.0f, 20.0f); 948 TimeStamp baseTime((std::chrono::milliseconds(100))); 949 // Step 4: Prepare a hover event param with idle state. 950 hoverState.idle = true; 951 HandleHoverEventParam param1 { 952 .point = point, 953 .time = baseTime, 954 .sourceType = SourceType::MOUSE, 955 .eventType = AccessibilityHoverEventType::ENTER 956 }; 957 // Step 5: Simulate previous event from TOUCH, current event from MOUSE, interval 2000ms. 958 hoverState.idle = false; 959 hoverState.source = SourceType::TOUCH; 960 hoverState.time = baseTime; 961 HandleHoverEventParam param5 = param1; 962 param5.sourceType = SourceType::MOUSE; 963 param5.eventType = AccessibilityHoverEventType::MOVE; 964 param5.time = baseTime + std::chrono::milliseconds(2000); 965 966 auto ret = manager.HandleAccessibilityHoverEventInner(frameNode, param5, touchEvent); 967 EXPECT_TRUE(ret == HandleHoverRet::HOVER_FAIL); 968 // Step 6: Previous event from MOUSE, current event ENTER, interval 50ms. 969 hoverState.idle = false; 970 hoverState.source = SourceType::MOUSE; 971 hoverState.time = baseTime; 972 HandleHoverEventParam param6 = param1; 973 param6.eventType = AccessibilityHoverEventType::ENTER; 974 param6.time = baseTime + std::chrono::milliseconds(50); 975 ret = manager.HandleAccessibilityHoverEventInner(frameNode, param6, touchEvent); 976 EXPECT_TRUE(ret == HandleHoverRet::HOVER_FAIL); 977 // Step 7: Pass nullptr as frameNode, expect HOVER_FAIL. 978 ret = manager.HandleAccessibilityHoverEventInner(nullptr, param1, touchEvent); 979 EXPECT_EQ(ret, HandleHoverRet::HOVER_FAIL); 980 // Step 8: Previous event from TOUCH, current event from MOUSE, interval 500ms. 981 hoverState.idle = false; 982 hoverState.source = SourceType::TOUCH; 983 hoverState.time = baseTime; 984 HandleHoverEventParam param4 = param1; 985 param4.sourceType = SourceType::MOUSE; 986 param4.eventType = AccessibilityHoverEventType::MOVE; 987 param4.time = baseTime + std::chrono::milliseconds(500); 988 ret = manager.HandleAccessibilityHoverEventInner(frameNode, param4, touchEvent); 989 EXPECT_EQ(ret, HandleHoverRet::IN_TIME_LIMIT); 990 MockPipelineContext::TearDown(); 991 } 992 } // namespace OHOS::Ace::NG