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 constexpr int ZERO_ANGLE = 0; 56 constexpr int QUARTER_ANGLE = 90; 57 constexpr int HALF_ANGLE = 180; 58 constexpr int THREE_QUARTER_ANGLE = 270; 59 constexpr int FULL_ANGLE = 360; 60 61 class AccessibilityManagerNgTestNg : public testing::Test { 62 public: SetUpTestCase()63 static void SetUpTestCase() {}; TearDownTestCase()64 static void TearDownTestCase() {}; 65 }; 66 67 /** 68 * @tc.name: accessibilityManagerNgTest001 69 * @tc.desc: 70 * @tc.type: FUNC 71 */ 72 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest001, TestSize.Level1) 73 { 74 AccessibilityManagerNG accessibilityManagerNg{}; 75 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true); 76 ASSERT_NE(frameNode, nullptr); 77 78 MouseEvent mouseEvent; 79 mouseEvent.button = MouseButton::LEFT_BUTTON; 80 mouseEvent.action = MouseAction::PRESS; 81 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 82 mouseEvent.sourceType = SourceType::NONE; 83 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 84 mouseEvent.sourceType = SourceType::MOUSE; 85 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 86 mouseEvent.action = MouseAction::WINDOW_ENTER; 87 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 88 mouseEvent.action = MouseAction::MOVE; 89 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 90 mouseEvent.action = MouseAction::WINDOW_LEAVE; 91 92 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 93 mouseEvent.action = MouseAction::PULL_UP; 94 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 95 EXPECT_EQ(mouseEvent.action, MouseAction::PULL_UP); 96 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 97 accessibilityManagerNg.hoverState_.idle = false; 98 mouseEvent.sourceType = SourceType::MOUSE; 99 mouseEvent.action = MouseAction::MOVE; 100 101 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 102 accessibilityManagerNg.hoverState_.idle = true; 103 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 104 TimeStamp time; 105 accessibilityManagerNg.hoverState_.time = time; 106 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 107 108 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false); 109 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, mouseEvent); 110 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, mouseEvent); 111 EXPECT_EQ(accessibilityManagerNg.hoverState_.source, SourceType::MOUSE); 112 } 113 114 /** 115 * @tc.name: accessibilityManagerNgTest002 116 * @tc.desc: 117 * @tc.type: FUNC 118 */ 119 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest002, TestSize.Level1) 120 { 121 AccessibilityManagerNG accessibilityManagerNg{}; 122 auto frameNode = FrameNode::CreateFrameNode("main", NUMTWO, AceType::MakeRefPtr<Pattern>(), true); 123 ASSERT_NE(frameNode, nullptr); 124 125 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 126 127 TouchEvent touchEvent; 128 touchEvent.type = TouchType::DOWN; 129 TouchPoint pointOne; 130 touchEvent.pointers.push_back(pointOne); 131 TouchPoint pointTwo; 132 touchEvent.pointers.push_back(pointTwo); 133 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 134 touchEvent.type = TouchType::HOVER_ENTER; 135 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 136 touchEvent.type = TouchType::HOVER_MOVE; 137 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 138 touchEvent.type = TouchType::HOVER_EXIT; 139 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 140 EXPECT_EQ(touchEvent.type, TouchType::HOVER_EXIT); 141 touchEvent.type = TouchType::UNKNOWN; 142 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 143 touchEvent.sourceType = SourceType::TOUCH; 144 touchEvent.SetPointers(POINTERS); 145 touchEvent.pointers.push_back(pointOne); 146 touchEvent.pointers.push_back(pointTwo); 147 touchEvent.type = TouchType::HOVER_ENTER; 148 accessibilityManagerNg.hoverState_.source = SourceType::TOUCH; 149 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 150 touchEvent.SetPointers(POINTERS); 151 touchEvent.pointers.push_back(pointOne); 152 touchEvent.pointers.push_back(pointTwo); 153 accessibilityManagerNg.hoverState_.source = SourceType::NONE; 154 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 155 156 touchEvent.sourceType = SourceType::NONE; 157 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 158 159 touchEvent.type = TouchType::UNKNOWN; 160 touchEvent.x = 100; 161 touchEvent.y = 100; 162 accessibilityManagerNg.hoverState_.idle = false; 163 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 164 accessibilityManagerNg.hoverState_.idle = true; 165 touchEvent.sourceType = SourceType::TOUCH; 166 accessibilityManagerNg.hoverState_.source = SourceType::TOUCH; 167 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 168 EXPECT_EQ(touchEvent.type, TouchType::UNKNOWN); 169 170 touchEvent.sourceType = SourceType::NONE; 171 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 172 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 173 EXPECT_NE(frameNode, nullptr); 174 } 175 176 /** 177 * @tc.name: accessibilityManagerNgTest003 178 * @tc.desc: 179 * @tc.type: FUNC 180 */ 181 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest003, TestSize.Level1) 182 { 183 AccessibilityManagerNG accessibilityManagerNg{}; 184 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 185 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 186 187 ASSERT_NE(frameNode, nullptr); 188 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, SOURCETYPE, EVENTTYPE, TIMEMS); 189 190 accessibilityManagerNg.hoverState_.idle = false; 191 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 192 SOURCETYPETWO, EVENTTYPE, TIMEMS); 193 EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, false); 194 WeakPtr<FrameNode> nodesHovering1; 195 WeakPtr<FrameNode> nodesHovering2; 196 accessibilityManagerNg.hoverState_.nodesHovering.push_back(nodesHovering1); 197 accessibilityManagerNg.hoverState_.nodesHovering.push_back(nodesHovering2); 198 accessibilityManagerNg.hoverState_.nodesHovering.push_back(frameNode); 199 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 200 SOURCETYPETWO, EVENTTYPE, TIMEMS); 201 EXPECT_NE(accessibilityManagerNg.hoverState_.nodesHovering.size(), 0); 202 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, -1, EVENTTYPE, TIMEMS); 203 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 99, EVENTTYPE, TIMEMS); 204 EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, false); 205 206 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 207 accessibilityManagerNg.hoverState_.idle = false; 208 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 209 SOURCETYPETWO, EVENTTYPE, TIMEMS); 210 accessibilityManagerNg.hoverState_.idle = true; 211 accessibilityManagerNg.hoverState_.source = SourceType::NONE; 212 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 213 SOURCETYPETWO, EVENTTYPE, LARGETIMEMS); 214 accessibilityManagerNg.hoverState_.idle = true; 215 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 0, EVENTTYPE, TIMEMS); 216 217 int32_t eventTypeEnter = static_cast<int32_t>(AccessibilityHoverEventType::ENTER); 218 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 0, eventTypeEnter, TIMEMS); 219 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, SOURCETYPETWO, EVENTTYPE, TIMEMS); 220 EXPECT_EQ(AceApplicationInfo::GetInstance().IsAccessibilityEnabled(), true); 221 accessibilityManagerNg.hoverState_.idle = true; 222 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, SOURCETYPETWO, EVENTTYPE, TIMEMS); 223 EXPECT_EQ(AceApplicationInfo::GetInstance().IsAccessibilityEnabled(), true); 224 } 225 226 /** 227 * @tc.name: accessibilityManagerNgTest004 228 * @tc.desc: 229 * @tc.type: FUNC 230 */ 231 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest004, TestSize.Level1) 232 { 233 AccessibilityManagerNG accessibilityManagerNg{}; 234 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 235 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 236 ASSERT_NE(frameNode, nullptr); 237 238 int32_t x = 100; 239 int32_t y = 100; 240 NG::PointF hoverPoint(x, y); 241 std::string summary; 242 std::string detail; 243 DragPointerEvent pointerEvent; 244 245 TimeStamp time; 246 247 accessibilityManagerNg.HoverTestDebug(frameNode, hoverPoint, summary, detail); 248 auto result = accessibilityManagerNg.DeliverAccessibilityHoverEvent(frameNode, hoverPoint); 249 EXPECT_EQ(result, false); 250 accessibilityManagerNg.IgnoreCurrentHoveringNode(frameNode); 251 252 auto eventHub = frameNode->GetEventHub<EventHub>(); 253 eventHub->SetEnabled(false); 254 accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode, 255 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 256 eventHub->SetEnabled(true); 257 accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode, 258 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 259 PointF pointNode(hoverPoint); 260 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, frameNode, hoverPoint, pointNode); 261 EXPECT_EQ(result, true); 262 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, nullptr, hoverPoint, pointNode); 263 EXPECT_EQ(result, false); 264 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(nullptr, frameNode, hoverPoint, pointNode); 265 EXPECT_EQ(result, false); 266 auto endNode = FrameNode::CreateFrameNode("main", NUMTWO, AceType::MakeRefPtr<Pattern>(), true); 267 ASSERT_NE(endNode, nullptr); 268 endNode->UpdateRecycleElmtId(NUMTWO); 269 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, endNode, hoverPoint, pointNode); 270 EXPECT_EQ(result, true); 271 272 endNode->SetParent(frameNode); 273 result = accessibilityManagerNg.ConvertPointFromAncestorToNode(frameNode, endNode, hoverPoint, pointNode); 274 EXPECT_EQ(result, true); 275 } 276 277 /** 278 * @tc.name: accessibilityManagerNgTest005 279 * @tc.desc: 280 * @tc.type: FUNC 281 */ 282 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest005, TestSize.Level1) 283 { 284 AccessibilityManagerNG accessibilityManagerNg{}; 285 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 286 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 287 ASSERT_NE(frameNode, nullptr); 288 289 // for lastNodesHovering 290 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 291 accessibilityManagerNg.hoverState_.idle = true; 292 WeakPtr<FrameNode> nodesHovering1; 293 WeakPtr<FrameNode> nodesHovering2; 294 accessibilityManagerNg.hoverState_.nodesHovering.push_back(nodesHovering1); 295 accessibilityManagerNg.hoverState_.nodesHovering.push_back(nodesHovering2); 296 accessibilityManagerNg.hoverState_.nodesHovering.push_back(frameNode); 297 298 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 299 SOURCETYPETWO, EVENTTYPE, TIMEMS); 300 EXPECT_EQ(accessibilityManagerNg.hoverState_.nodesHovering.size(), 0); 301 302 // for first judge 303 TouchEvent touchEvent; 304 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false); 305 touchEvent.sourceType = SourceType::NONE; 306 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 307 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 308 touchEvent.sourceType = SourceType::MOUSE; 309 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 310 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 311 312 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 313 touchEvent.sourceType = SourceType::NONE; 314 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 315 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 316 touchEvent.sourceType = SourceType::MOUSE; 317 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, touchEvent); 318 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 319 EXPECT_NE(frameNode, nullptr); 320 } 321 322 /** 323 * @tc.name: accessibilityManagerNgTest006 324 * @tc.desc: 325 * @tc.type: FUNC 326 */ 327 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest006, TestSize.Level1) 328 { 329 AccessibilityManagerNG accessibilityManagerNg{}; 330 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 331 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 332 ASSERT_NE(frameNode, nullptr); 333 334 // pointers.size 335 TouchEvent touchEvent; 336 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 337 338 accessibilityManagerNg.hoverState_.idle = true; 339 touchEvent.type = TouchType::HOVER_ENTER; 340 341 touchEvent.pointers.clear(); 342 343 touchEvent.sourceType = SourceType::NONE; 344 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 345 346 touchEvent.sourceType = SourceType::TOUCH; 347 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 348 349 touchEvent.SetPointers(POINTERS); 350 TouchPoint pointOne; 351 TouchPoint pointTwo; 352 touchEvent.pointers.push_back(pointOne); 353 touchEvent.pointers.push_back(pointTwo); 354 touchEvent.sourceType = SourceType::NONE; 355 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 356 357 touchEvent.sourceType = SourceType::TOUCH; 358 359 accessibilityManagerNg.hoverState_.source = SourceType::TOUCH; 360 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 361 EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, true); 362 363 accessibilityManagerNg.hoverState_.source = SourceType::MOUSE; 364 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 365 EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, false); 366 } 367 368 /** 369 * @tc.name: accessibilityManagerNgTest007 370 * @tc.desc: 371 * @tc.type: FUNC 372 */ 373 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest007, TestSize.Level1) 374 { 375 AccessibilityManagerNG accessibilityManagerNg{}; 376 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 377 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<MockAccessibilityTestPattern>()); 378 379 int32_t x = 100; 380 int32_t y = 100; 381 NG::PointF hoverPoint(x, y); 382 TimeStamp time; 383 accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, frameNode, 384 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 385 386 accessibilityManagerNg.NotifyHoverEventToNodeSession(frameNode, nullptr, 387 hoverPoint, SourceType::MOUSE, AccessibilityHoverEventType::ENTER, time); 388 389 EXPECT_NE(frameNode, nullptr); 390 } 391 392 /** 393 * @tc.name: accessibilityManagerNgTest008 394 * @tc.desc: 395 * @tc.type: FUNC 396 */ 397 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest008, TestSize.Level1) 398 { 399 AccessibilityManagerNG accessibilityManagerNg{}; 400 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 401 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 402 ASSERT_NE(frameNode, nullptr); 403 404 accessibilityManagerNg.hoverState_.idle = false; 405 accessibilityManagerNg.hoverState_.nodesHovering.push_back(frameNode); 406 407 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 408 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 409 SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER); 410 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 411 SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER); 412 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 413 SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER); 414 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 415 SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER); 416 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 417 SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER); 418 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 419 SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER); 420 421 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false); 422 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 423 SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER); 424 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 425 SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER); 426 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, POINT_X, POINT_Y, 427 SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER); 428 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 429 SOURCETYPETWO, EVENTTYPE, TIMEMS_INTERVAL_HOVER); 430 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 431 SOURCETYPETWO, -1, TIMEMS_INTERVAL_HOVER); 432 accessibilityManagerNg.HandleAccessibilityHoverEvent(nullptr, POINT_X, POINT_Y, 433 SOURCETYPETWO, 99, TIMEMS_INTERVAL_HOVER); 434 435 EXPECT_NE(accessibilityManagerNg.hoverState_.nodesHovering.size(), 0); 436 } 437 438 /** 439 * @tc.name: accessibilityManagerNgTest009 440 * @tc.desc: 441 * @tc.type: FUNC 442 */ 443 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityManagerNgTest009, TestSize.Level1) 444 { 445 AccessibilityManagerNG accessibilityManagerNg{}; 446 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 447 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 448 ASSERT_NE(frameNode, nullptr); 449 450 // hoverState source different and time is in MIN_SOURCE_CHANGE_GAP_MS 451 TouchEvent touchEvent; 452 AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true); 453 454 accessibilityManagerNg.hoverState_.idle = false; 455 touchEvent.type = TouchType::HOVER_ENTER; 456 457 touchEvent.SetPointers(POINTERS); 458 459 touchEvent.sourceType = SourceType::TOUCH; 460 accessibilityManagerNg.hoverState_.source = SourceType::MOUSE; 461 TimeStamp time((std::chrono::milliseconds(TIMEMS_DIFFERENT_HOVER_SOURCE))); 462 touchEvent.time = time; 463 464 accessibilityManagerNg.HandleAccessibilityHoverEvent(frameNode, touchEvent); 465 EXPECT_EQ(accessibilityManagerNg.hoverState_.idle, false); 466 467 accessibilityManagerNg.hoverState_.eventType = AccessibilityHoverEventType::MOVE; 468 auto ret = accessibilityManagerNg.IsEventTypeChangeDirectHandleHover( 469 AccessibilityHoverEventType::EXIT); 470 EXPECT_TRUE(ret); 471 } 472 473 /** 474 * @tc.name: AccessibilityRectTest001 475 * @tc.desc: AccessibilityRect 476 * @tc.type: FUNC 477 */ 478 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest001, TestSize.Level1) 479 { 480 AccessibilityRect rect1; 481 EXPECT_EQ(rect1.GetX(), 0); 482 EXPECT_EQ(rect1.GetY(), 0); 483 EXPECT_EQ(rect1.GetWidth(), 0); 484 EXPECT_EQ(rect1.GetHeight(), 0); 485 486 AccessibilityRect rect2(10, 20, 100, 200); 487 EXPECT_EQ(rect2.GetX(), 10); 488 EXPECT_EQ(rect2.GetY(), 20); 489 EXPECT_EQ(rect2.GetWidth(), 100); 490 EXPECT_EQ(rect2.GetHeight(), 200); 491 492 rect2.SetPosition(30, 40); 493 EXPECT_EQ(rect2.GetX(), 30); 494 EXPECT_EQ(rect2.GetY(), 40); 495 496 rect2.SetSize(50, 60); 497 EXPECT_EQ(rect2.GetWidth(), 50); 498 EXPECT_EQ(rect2.GetHeight(), 60); 499 } 500 501 /** 502 * @tc.name: AccessibilityRectTest002 503 * @tc.desc: AccessibilityRect 504 * @tc.type: FUNC 505 */ 506 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest002, TestSize.Level1) 507 { 508 // init x=0, y=0, width=100, height=200 509 AccessibilityRect rect(0, 0, 100, 200); 510 const float originalCenterX = 50; // 0 + 100/2 511 const float originalCenterY = 100; // 0 + 200/2 512 513 // rotate 90 514 rect.Rotate(QUARTER_ANGLE); 515 EXPECT_EQ(rect.GetWidth(), 200); 516 EXPECT_EQ(rect.GetHeight(), 100); 517 EXPECT_EQ(rect.GetX(), originalCenterX - 200/2); // 50 - 100 = -50 518 EXPECT_EQ(rect.GetY(), originalCenterY - 100/2); // 100 - 50 = 50 519 520 // rotate 180 521 rect.Rotate(HALF_ANGLE); 522 EXPECT_EQ(rect.GetWidth(), 200); 523 EXPECT_EQ(rect.GetHeight(), 100); 524 EXPECT_EQ(rect.GetX(), -50); 525 EXPECT_EQ(rect.GetY(), 50); 526 527 // rotate 270 528 rect.Rotate(THREE_QUARTER_ANGLE); 529 EXPECT_EQ(rect.GetWidth(), 100); 530 EXPECT_EQ(rect.GetHeight(), 200); 531 } 532 533 /** 534 * @tc.name: AccessibilityRectTest003 535 * @tc.desc: AccessibilityRect 536 * @tc.type: FUNC 537 */ 538 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest003, TestSize.Level1) 539 { 540 // rotate center (100, 100) 541 AccessibilityRect rect(0, 0, 100, 100); 542 // rotate 90 543 rect.Rotate(0, 0, QUARTER_ANGLE); 544 EXPECT_EQ(rect.GetWidth(), 100); 545 EXPECT_EQ(rect.GetHeight(), 100); 546 } 547 548 /** 549 * @tc.name: AccessibilityRectTest004 550 * @tc.desc: AccessibilityRect 551 * @tc.type: FUNC 552 */ 553 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest004, TestSize.Level1) 554 { 555 AccessibilityRect rect(0, 0, 100, 200); 556 557 // 450 ≡ 90 558 rect.Rotate(450); 559 EXPECT_EQ(rect.GetWidth(), 200); 560 561 // 720 ≡ 0 562 rect.Rotate(FULL_ANGLE * 2); 563 EXPECT_EQ(rect.GetWidth(), 200); 564 } 565 566 /** 567 * @tc.name: AccessibilityRectTest005 568 * @tc.desc: AccessibilityRect 569 * @tc.type: FUNC 570 */ 571 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest005, TestSize.Level1) 572 { 573 AccessibilityRect rect(10, 20, 30, 40); 574 rect.Rotate(ZERO_ANGLE); 575 EXPECT_EQ(rect.GetX(), 10); 576 EXPECT_EQ(rect.GetY(), 20); 577 EXPECT_EQ(rect.GetWidth(), 30); 578 EXPECT_EQ(rect.GetHeight(), 40); 579 580 rect.Rotate(FULL_ANGLE); 581 EXPECT_EQ(rect.GetWidth(), 30); 582 } 583 584 /** 585 * @tc.name: AccessibilityRectTest006 586 * @tc.desc: AccessibilityRect 587 * @tc.type: FUNC 588 */ 589 HWTEST_F(AccessibilityManagerNgTestNg, AccessibilityRectTest006, TestSize.Level1) 590 { 591 AccessibilityRect rect(10, 20, 100, 200); 592 RotateTransform transform(0, 50, 60, 30, 40); 593 594 // 2x, 3y 595 rect.ApplyTransformation(transform, 2.0f, 3.0f); 596 597 // x = (10 - 30)*2 + 50 = (-20)*2 +50 = 10 598 EXPECT_EQ(rect.GetX(), 10.0f); 599 // y = (20 -40)*3 +60 = (-20)*3 +60 = 0 600 EXPECT_EQ(rect.GetY(), 0); 601 // width = 100*2 = 200 602 EXPECT_EQ(rect.GetWidth(), 200); 603 // height = 200*3 = 600 604 EXPECT_EQ(rect.GetHeight(), 600); 605 } 606 607 HWTEST_F(AccessibilityManagerNgTestNg, IsHandlePipelineAccessibilityHoverEnter001, TestSize.Level1) 608 { 609 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 610 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 611 ASSERT_NE(frameNode, nullptr); 612 frameNode->context_ = nullptr; 613 614 AccessibilityManagerNG manager{}; 615 bool result = manager.IsHandlePipelineAccessibilityHoverEnter(frameNode); 616 EXPECT_FALSE(result); 617 } 618 619 HWTEST_F(AccessibilityManagerNgTestNg, IsHandlePipelineAccessibilityHoverEnter002, TestSize.Level1) 620 { 621 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 622 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 623 ASSERT_NE(frameNode, nullptr); 624 625 AccessibilityManagerNG manager; 626 bool result = manager.IsHandlePipelineAccessibilityHoverEnter(frameNode); 627 EXPECT_FALSE(result); 628 } 629 630 HWTEST_F(AccessibilityManagerNgTestNg, IsHandlePipelineAccessibilityHoverEnter003, TestSize.Level1) 631 { 632 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 633 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 634 ASSERT_NE(frameNode, nullptr); 635 auto pipe = MockPipelineContext::GetCurrent(); 636 frameNode->context_ = AceType::RawPtr(pipe); 637 AccessibilityManagerNG manager; 638 bool result = manager.IsHandlePipelineAccessibilityHoverEnter(frameNode); 639 EXPECT_FALSE(result); 640 } 641 642 HWTEST_F(AccessibilityManagerNgTestNg, HandlePipelineAccessibilityHoverEnter001, TestSize.Level1) { 643 AccessibilityManagerNG manager; 644 auto frameNode = FrameNode::CreateFrameNode(V2::TEXT_ETS_TAG, 645 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<TextPattern>()); 646 ASSERT_NE(frameNode, nullptr); 647 TouchEvent event; 648 int32_t eventType; 649 // Case 1: Test with AccessibilityHoverEventType::ENTER 650 eventType = static_cast<int32_t>(AccessibilityHoverEventType::ENTER); 651 manager.HandlePipelineAccessibilityHoverEnter(frameNode, event, eventType); 652 653 // Case 2: Test with AccessibilityHoverEventType::MOVE 654 eventType = static_cast<int32_t>(AccessibilityHoverEventType::MOVE); 655 manager.HandlePipelineAccessibilityHoverEnter(frameNode, event, eventType); 656 657 // Case 3: Test with AccessibilityHoverEventType::EXIT 658 eventType = static_cast<int32_t>(AccessibilityHoverEventType::EXIT); 659 manager.HandlePipelineAccessibilityHoverEnter(frameNode, event, eventType); 660 661 // Case 4: Test with an invalid event type (default case) 662 eventType = -1; // Invalid type 663 manager.HandlePipelineAccessibilityHoverEnter(frameNode, event, eventType); 664 } 665 } // namespace OHOS::Ace::NG