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 #include "gtest/gtest.h" 16 #include "test/unittest/core/event/event_manager_test_ng.h" 17 #include "test/mock/core/pipeline/mock_pipeline_context.h" 18 #include "test/mock/core/render/mock_render_context.h" 19 #include "test/mock/core/common/mock_window.h" 20 #include "test/mock/core/common/mock_frontend.h" 21 22 using namespace testing; 23 using namespace testing::ext; 24 namespace OHOS::Ace::NG { 25 26 class MouseEventTargetTest : public MouseEventTarget { 27 DECLARE_ACE_TYPE(MouseEventTargetTest, MouseEventTarget); 28 29 public: MouseEventTargetTest(const std::string & nodeName,int32_t nodeId,bool setStopPropagation=false,int32_t expectedResult=0)30 MouseEventTargetTest( 31 const std::string& nodeName, int32_t nodeId, bool setStopPropagation = false, int32_t expectedResult = 0) 32 : MouseEventTarget(nodeName, nodeId), expectedResult_(expectedResult) 33 { 34 SetCallback([setStopPropagation, this](MouseInfo& info) { 35 info.SetStopPropagation(setStopPropagation); 36 callbackInvokeCount_++; 37 }); 38 } 39 GetCallbackInvokeCount() const40 int32_t GetCallbackInvokeCount() const 41 { 42 return callbackInvokeCount_; 43 } 44 ResetCallbackInvokeCount()45 void ResetCallbackInvokeCount() 46 { 47 callbackInvokeCount_ = 0; 48 } 49 GetExpectedResult() const50 int32_t GetExpectedResult() const 51 { 52 return expectedResult_; 53 } 54 55 private: 56 int32_t callbackInvokeCount_ = 0; 57 int32_t expectedResult_ = 0; 58 }; 59 60 class EventManagerDispatchMouseEventNGTest : public EventManagerTestNg { 61 public: SetUpTestSuite()62 static void SetUpTestSuite() 63 { 64 EventManagerTestNg::SetUpTestSuite(); 65 } TearDownTestSuite()66 static void TearDownTestSuite() 67 { 68 EventManagerTestNg::TearDownTestSuite(); 69 } 70 }; 71 struct MockMouseEvent { 72 MouseAction action; 73 MouseButton button; 74 bool expectedResult; 75 }; 76 77 class APIVersionGuard final { 78 public: APIVersionGuard(int32_t apiVersion)79 explicit APIVersionGuard(int32_t apiVersion) 80 { 81 backupApiVersion_ = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 82 AceApplicationInfo::GetInstance().SetApiTargetVersion(apiVersion); 83 } 84 ~APIVersionGuard()85 ~APIVersionGuard() 86 { 87 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion_); 88 } 89 90 private: 91 int32_t backupApiVersion_ = 0; 92 }; 93 /** 94 * @tc.name: MouseEventTest001 95 * @tc.desc: Test DispatchMouseEventNG 96 * @tc.type: FUNC 97 */ 98 HWTEST_F(EventManagerTestNg, MouseEventTest001, TestSize.Level1) 99 { 100 /** 101 * @tc.steps: step1. Create EventManager. 102 * @tc.expected: eventManager is not null. 103 */ 104 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 105 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 106 auto eventManager = AceType::MakeRefPtr<EventManager>(); 107 ASSERT_NE(eventManager, nullptr); 108 109 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); 110 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].push_back(mouseEventTarget); 111 eventManager->currMouseTestResults_.push_back(mouseEventTarget); 112 __anone3a363090202(MouseInfo& info) 113 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(false); }; 114 mouseEventTarget->SetCallback(onMouse); 115 116 /** 117 * @tc.steps: step2. Call DispatchMouseEventNG. 118 * @tc.expected: retFlag is FALSE. 119 */ 120 MouseEvent event; 121 event.action = MouseAction::PRESS; 122 bool retFlag = eventManager->DispatchMouseEventNG(event); 123 EXPECT_FALSE(retFlag); 124 125 event.action = MouseAction::RELEASE; 126 retFlag = eventManager->DispatchMouseEventNG(event); 127 EXPECT_FALSE(retFlag); 128 129 event.action = MouseAction::MOVE; 130 retFlag = eventManager->DispatchMouseEventNG(event); 131 EXPECT_FALSE(retFlag); 132 133 event.action = MouseAction::WINDOW_ENTER; 134 retFlag = eventManager->DispatchMouseEventNG(event); 135 EXPECT_FALSE(retFlag); 136 137 event.action = MouseAction::WINDOW_LEAVE; 138 retFlag = eventManager->DispatchMouseEventNG(event); 139 EXPECT_FALSE(retFlag); 140 141 event.action = MouseAction::WINDOW_LEAVE; 142 retFlag = eventManager->DispatchMouseEventNG(event); 143 EXPECT_FALSE(retFlag); 144 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 145 } 146 147 /** 148 * @tc.name: MouseEventTest002 149 * @tc.desc: Test DispatchMouseEventNG 150 * @tc.type: FUNC 151 */ 152 HWTEST_F(EventManagerTestNg, MouseEventTest002, TestSize.Level1) 153 { 154 /** 155 * @tc.steps: step1. Create EventManager. 156 * @tc.expected: eventManager is not null. 157 */ 158 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 159 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 160 auto eventManager = AceType::MakeRefPtr<EventManager>(); 161 ASSERT_NE(eventManager, nullptr); 162 163 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); 164 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].push_back(mouseEventTarget); 165 eventManager->currMouseTestResults_.push_back(mouseEventTarget); 166 __anone3a363090302(MouseInfo& info) 167 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(true); }; 168 mouseEventTarget->SetCallback(onMouse); 169 170 /** 171 * @tc.steps: step2. Call DispatchMouseEventNG. 172 * @tc.expected: retFlag is TRUE. 173 */ 174 MouseEvent event; 175 event.action = MouseAction::PRESS; 176 bool retFlag = eventManager->DispatchMouseEventNG(event); 177 EXPECT_TRUE(retFlag); 178 179 event.action = MouseAction::RELEASE; 180 retFlag = eventManager->DispatchMouseEventNG(event); 181 EXPECT_TRUE(retFlag); 182 183 event.action = MouseAction::MOVE; 184 retFlag = eventManager->DispatchMouseEventNG(event); 185 EXPECT_TRUE(retFlag); 186 187 event.action = MouseAction::WINDOW_ENTER; 188 retFlag = eventManager->DispatchMouseEventNG(event); 189 EXPECT_TRUE(retFlag); 190 191 event.action = MouseAction::WINDOW_LEAVE; 192 retFlag = eventManager->DispatchMouseEventNG(event); 193 EXPECT_TRUE(retFlag); 194 195 event.action = MouseAction::WINDOW_LEAVE; 196 retFlag = eventManager->DispatchMouseEventNG(event); 197 EXPECT_TRUE(retFlag); 198 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 199 } 200 201 /** 202 * @tc.name: MouseEventTest003 203 * @tc.desc: Test DispatchMouseEventNG 204 * @tc.type: FUNC 205 */ 206 HWTEST_F(EventManagerTestNg, MouseEventTest003, TestSize.Level1) 207 { 208 /** 209 * @tc.steps: step1. Create EventManager. 210 * @tc.expected: eventManager is not null. 211 */ 212 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 213 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 214 auto eventManager = AceType::MakeRefPtr<EventManager>(); 215 ASSERT_NE(eventManager, nullptr); 216 217 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); 218 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].push_back(mouseEventTarget); 219 eventManager->currMouseTestResults_.push_back(mouseEventTarget); 220 __anone3a363090402(MouseInfo& info) 221 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(false); }; 222 mouseEventTarget->SetCallback(onMouse); 223 224 /** 225 * @tc.steps: step2. Call DispatchMouseEventNG. 226 * @tc.expected: retFlag is FALSE. 227 */ 228 MouseEvent event; 229 event.action = MouseAction::PRESS; 230 event.button = MouseButton::NONE_BUTTON; 231 bool retFlag = eventManager->DispatchMouseEventNG(event); 232 EXPECT_FALSE(retFlag); 233 234 event.action = MouseAction::PRESS; 235 event.button = MouseButton::NONE_BUTTON; 236 retFlag = eventManager->DispatchMouseEventNG(event); 237 EXPECT_FALSE(retFlag); 238 239 event.action = MouseAction::RELEASE; 240 event.button = MouseButton::NONE_BUTTON; 241 retFlag = eventManager->DispatchMouseEventNG(event); 242 EXPECT_FALSE(retFlag); 243 244 event.action = MouseAction::MOVE; 245 event.button = MouseButton::NONE_BUTTON; 246 retFlag = eventManager->DispatchMouseEventNG(event); 247 EXPECT_FALSE(retFlag); 248 249 event.action = MouseAction::WINDOW_ENTER; 250 event.button = MouseButton::NONE_BUTTON; 251 retFlag = eventManager->DispatchMouseEventNG(event); 252 EXPECT_FALSE(retFlag); 253 254 event.action = MouseAction::WINDOW_LEAVE; 255 event.button = MouseButton::NONE_BUTTON; 256 retFlag = eventManager->DispatchMouseEventNG(event); 257 EXPECT_FALSE(retFlag); 258 259 event.action = MouseAction::WINDOW_LEAVE; 260 event.button = MouseButton::NONE_BUTTON; 261 retFlag = eventManager->DispatchMouseEventNG(event); 262 EXPECT_FALSE(retFlag); 263 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 264 } 265 266 /** 267 * @tc.name: MouseEventTest004 268 * @tc.desc: Test DispatchMouseEventNG function 269 * @tc.type: FUNC 270 */ 271 HWTEST_F(EventManagerTestNg, MouseEventTest004, TestSize.Level1) 272 { 273 /** 274 * @tc.steps: step1. Create EventManager. 275 * @tc.expected: eventManager is not null. 276 */ 277 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 278 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 279 auto eventManager = AceType::MakeRefPtr<EventManager>(); 280 ASSERT_NE(eventManager, nullptr); 281 282 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); 283 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].push_back(mouseEventTarget); 284 eventManager->currMouseTestResults_.push_back(mouseEventTarget); 285 __anone3a363090502(MouseInfo& info) 286 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(true); }; 287 mouseEventTarget->SetCallback(onMouse); 288 289 /** 290 * @tc.steps: step2. Call DispatchMouseEventNG. 291 * @tc.expected: retFlag is false. 292 */ 293 MouseEvent event; 294 event.action = MouseAction::HOVER; 295 event.button = MouseButton::LEFT_BUTTON; 296 bool retFlag = eventManager->DispatchMouseEventNG(event); 297 EXPECT_FALSE(retFlag); 298 299 event.action = MouseAction::HOVER_ENTER; 300 event.button = MouseButton::RIGHT_BUTTON; 301 retFlag = eventManager->DispatchMouseEventNG(event); 302 EXPECT_FALSE(retFlag); 303 304 event.action = MouseAction::HOVER_MOVE; 305 event.button = MouseButton::MIDDLE_BUTTON; 306 retFlag = eventManager->DispatchMouseEventNG(event); 307 EXPECT_FALSE(retFlag); 308 309 event.action = MouseAction::HOVER_EXIT; 310 event.button = MouseButton::BACK_BUTTON; 311 retFlag = eventManager->DispatchMouseEventNG(event); 312 EXPECT_FALSE(retFlag); 313 314 event.action = MouseAction::PULL_DOWN; 315 event.button = MouseButton::FORWARD_BUTTON; 316 retFlag = eventManager->DispatchMouseEventNG(event); 317 EXPECT_FALSE(retFlag); 318 319 event.action = MouseAction::PULL_MOVE; 320 event.button = MouseButton::SIDE_BUTTON; 321 retFlag = eventManager->DispatchMouseEventNG(event); 322 EXPECT_FALSE(retFlag); 323 324 event.action = MouseAction::PULL_UP; 325 event.button = MouseButton::EXTRA_BUTTON; 326 retFlag = eventManager->DispatchMouseEventNG(event); 327 EXPECT_FALSE(retFlag); 328 329 event.action = MouseAction::CANCEL; 330 event.button = MouseButton::EXTRA_BUTTON; 331 retFlag = eventManager->DispatchMouseEventNG(event); 332 EXPECT_TRUE(retFlag); 333 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 334 } 335 336 /** 337 * @tc.name: MouseEventTest005 338 * @tc.desc: Test DispatchMouseEventNG function 339 * @tc.type: FUNC 340 */ 341 HWTEST_F(EventManagerTestNg, MouseEventTest005, TestSize.Level1) 342 { 343 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 344 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 345 auto eventManager = AceType::MakeRefPtr<EventManager>(); 346 ASSERT_NE(eventManager, nullptr); 347 348 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); __anone3a363090602(MouseInfo& info) 349 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(true); }; 350 mouseEventTarget->SetCallback(onMouse); 351 eventManager->currMouseTestResults_.emplace_back(mouseEventTarget); 352 auto mouseEventTarget2 = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID_2); __anone3a363090702(MouseInfo& info) 353 const OnMouseEventFunc onMouse2 = [](MouseInfo& info) { info.SetStopPropagation(false); }; 354 mouseEventTarget2->SetCallback(onMouse2); 355 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(mouseEventTarget2); 356 357 MouseEvent event; 358 event.action = MouseAction::PULL_DOWN; 359 event.button = MouseButton::FORWARD_BUTTON; 360 bool retFlag = eventManager->DispatchMouseEventNG(event); 361 EXPECT_FALSE(retFlag); 362 event.action = MouseAction::PRESS; 363 event.button = MouseButton::LEFT_BUTTON; 364 retFlag = eventManager->DispatchMouseEventNG(event); 365 EXPECT_TRUE(retFlag); 366 event.action = MouseAction::HOVER; 367 event.button = MouseButton::LEFT_BUTTON; 368 retFlag = eventManager->DispatchMouseEventNG(event); 369 EXPECT_FALSE(retFlag); 370 event.action = MouseAction::HOVER_ENTER; 371 event.button = MouseButton::RIGHT_BUTTON; 372 retFlag = eventManager->DispatchMouseEventNG(event); 373 EXPECT_FALSE(retFlag); 374 event.action = MouseAction::HOVER_MOVE; 375 event.button = MouseButton::MIDDLE_BUTTON; 376 retFlag = eventManager->DispatchMouseEventNG(event); 377 EXPECT_FALSE(retFlag); 378 event.action = MouseAction::HOVER_EXIT; 379 event.button = MouseButton::BACK_BUTTON; 380 retFlag = eventManager->DispatchMouseEventNG(event); 381 EXPECT_FALSE(retFlag); 382 event.action = MouseAction::PULL_UP; 383 event.button = MouseButton::EXTRA_BUTTON; 384 retFlag = eventManager->DispatchMouseEventNG(event); 385 EXPECT_FALSE(retFlag); 386 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 387 } 388 389 /** 390 * @tc.name: MouseEventTest006 391 * @tc.desc: Test DispatchMouseEventNG function. 392 * @tc.type: FUNC 393 */ 394 HWTEST_F(EventManagerTestNg, MouseEventTest006, TestSize.Level1) 395 { 396 /** 397 * @tc.steps: step1. Create EventManager. 398 * @tc.expected: eventManager is not null. 399 */ 400 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 401 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 402 auto eventManager = AceType::MakeRefPtr<EventManager>(); 403 ASSERT_NE(eventManager, nullptr); 404 405 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); 406 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].push_back(mouseEventTarget); __anone3a363090802(MouseInfo& info) 407 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(true); }; 408 mouseEventTarget->SetCallback(onMouse); 409 eventManager->currMouseTestResults_.push_back(mouseEventTarget); 410 411 /** 412 * @tc.steps: step2. Call DispatchMouseEventNG. 413 * @tc.expected: retFlag is FALSE. 414 */ 415 MouseEvent event; 416 event.action = MouseAction::MOVE; 417 event.button = MouseButton::LEFT_BUTTON; 418 bool result = eventManager->DispatchMouseEventNG(event); 419 EXPECT_FALSE(result); 420 421 event.action = MouseAction::PRESS; 422 event.button = MouseButton::LEFT_BUTTON; 423 result = eventManager->DispatchMouseEventNG(event); 424 EXPECT_FALSE(result); 425 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 426 } 427 428 /** 429 * @tc.name: MouseEventTest007 430 * @tc.desc: Test DispatchMouseEventNG function 431 * @tc.type: FUNC 432 */ 433 HWTEST_F(EventManagerTestNg, MouseEventTest007, TestSize.Level1) 434 { 435 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 436 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 437 auto eventManager = AceType::MakeRefPtr<EventManager>(); 438 ASSERT_NE(eventManager, nullptr); 439 440 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); __anone3a363090902(MouseInfo& info) 441 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(true); }; 442 mouseEventTarget->SetCallback(onMouse); 443 eventManager->currMouseTestResults_.emplace_back(mouseEventTarget); 444 auto mouseEventTarget2 = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID_2); __anone3a363090a02(MouseInfo& info) 445 const OnMouseEventFunc onMouse2 = [](MouseInfo& info) { info.SetStopPropagation(false); }; 446 mouseEventTarget2->SetCallback(onMouse2); 447 eventManager->pressMouseTestResultsMap_[MouseButton::RIGHT_BUTTON].emplace_back(mouseEventTarget2); 448 449 MouseEvent event; 450 event.action = MouseAction::RELEASE; 451 event.button = MouseButton::MIDDLE_BUTTON; 452 bool result = eventManager->DispatchMouseEventNG(event); 453 EXPECT_TRUE(result); 454 event.action = MouseAction::RELEASE; 455 event.button = MouseButton::BACK_BUTTON; 456 result = eventManager->DispatchMouseEventNG(event); 457 EXPECT_TRUE(result); 458 event.action = MouseAction::MOVE; 459 event.button = MouseButton::FORWARD_BUTTON; 460 result = eventManager->DispatchMouseEventNG(event); 461 EXPECT_TRUE(result); 462 event.action = MouseAction::WINDOW_ENTER; 463 event.button = MouseButton::SIDE_BUTTON; 464 result = eventManager->DispatchMouseEventNG(event); 465 EXPECT_TRUE(result); 466 event.action = MouseAction::WINDOW_LEAVE; 467 event.button = MouseButton::EXTRA_BUTTON; 468 result = eventManager->DispatchMouseEventNG(event); 469 EXPECT_TRUE(result); 470 event.action = MouseAction::PRESS; 471 event.button = MouseButton::LEFT_BUTTON; 472 result = eventManager->DispatchMouseEventNG(event); 473 EXPECT_TRUE(result); 474 event.action = MouseAction::RELEASE; 475 event.button = MouseButton::LEFT_BUTTON; 476 result = eventManager->DispatchMouseEventNG(event); 477 EXPECT_FALSE(result); 478 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 479 } 480 481 /** 482 * @tc.name: MouseEventTest008 483 * @tc.desc: Test DispatchMouseEventNG function 484 * @tc.type: FUNC 485 */ 486 HWTEST_F(EventManagerTestNg, MouseEventTest008, TestSize.Level1) 487 { 488 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 489 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 490 auto eventManager = AceType::MakeRefPtr<EventManager>(); 491 ASSERT_NE(eventManager, nullptr); 492 493 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); __anone3a363090b02(MouseInfo& info) 494 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(true); }; 495 mouseEventTarget->SetCallback(onMouse); 496 eventManager->currMouseTestResults_.emplace_back(mouseEventTarget); 497 auto mouseEventTarget2 = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID_2); __anone3a363090c02(MouseInfo& info) 498 const OnMouseEventFunc onMouse2 = [](MouseInfo& info) { info.SetStopPropagation(false); }; 499 mouseEventTarget2->SetCallback(onMouse2); 500 eventManager->pressMouseTestResultsMap_[MouseButton::MIDDLE_BUTTON].emplace_back(mouseEventTarget2); 501 502 MouseEvent event; 503 event.action = MouseAction::MOVE; 504 event.button = MouseButton::BACK_BUTTON; 505 bool result = eventManager->DispatchMouseEventNG(event); 506 EXPECT_TRUE(result); 507 event.action = MouseAction::WINDOW_ENTER; 508 event.button = MouseButton::SIDE_BUTTON; 509 result = eventManager->DispatchMouseEventNG(event); 510 EXPECT_TRUE(result); 511 event.action = MouseAction::PRESS; 512 event.button = MouseButton::LEFT_BUTTON; 513 result = eventManager->DispatchMouseEventNG(event); 514 EXPECT_TRUE(result); 515 event.action = MouseAction::RELEASE; 516 event.button = MouseButton::LEFT_BUTTON; 517 result = eventManager->DispatchMouseEventNG(event); 518 EXPECT_FALSE(result); 519 event.action = MouseAction::RELEASE; 520 event.button = MouseButton::RIGHT_BUTTON; 521 result = eventManager->DispatchMouseEventNG(event); 522 EXPECT_TRUE(result); 523 event.action = MouseAction::RELEASE; 524 event.button = MouseButton::MIDDLE_BUTTON; 525 result = eventManager->DispatchMouseEventNG(event); 526 EXPECT_TRUE(result); 527 event.action = MouseAction::RELEASE; 528 event.button = MouseButton::BACK_BUTTON; 529 result = eventManager->DispatchMouseEventNG(event); 530 EXPECT_TRUE(result); 531 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 532 } 533 534 /** 535 * @tc.name: MouseEventTest009 536 * @tc.desc: Test DispatchMouseEventNG function 537 * @tc.type: FUNC 538 */ 539 HWTEST_F(EventManagerTestNg, MouseEventTest009, TestSize.Level1) 540 { 541 /** 542 * @tc.steps: step1. Create EventManager. 543 * @tc.expected: eventManager is not null. 544 */ 545 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 546 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 547 auto eventManager = AceType::MakeRefPtr<EventManager>(); 548 ASSERT_NE(eventManager, nullptr); 549 550 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); __anone3a363090d02(MouseInfo& info) 551 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(false); }; 552 mouseEventTarget->SetCallback(onMouse); 553 eventManager->currMouseTestResults_.emplace_back(mouseEventTarget); 554 555 auto mouseEventTarget2 = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID_2); __anone3a363090e02(MouseInfo& info) 556 const OnMouseEventFunc onMouse2 = [](MouseInfo& info) { info.SetStopPropagation(true); }; 557 mouseEventTarget2->SetCallback(onMouse2); 558 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(mouseEventTarget2); 559 560 /** 561 * @tc.steps: step2. Call DispatchMouseEventNG. 562 * @tc.expected: retFlag is FALSE. 563 */ 564 MouseEvent event; 565 event.action = MouseAction::PRESS; 566 event.button = MouseButton::LEFT_BUTTON; 567 568 bool result = eventManager->DispatchMouseEventNG(event); 569 EXPECT_FALSE(result); 570 571 event.action = MouseAction::RELEASE; 572 event.button = MouseButton::LEFT_BUTTON; 573 result = eventManager->DispatchMouseEventNG(event); 574 EXPECT_FALSE(result); 575 576 event.action = MouseAction::RELEASE; 577 event.button = MouseButton::RIGHT_BUTTON; 578 result = eventManager->DispatchMouseEventNG(event); 579 EXPECT_FALSE(result); 580 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 581 } 582 583 /** 584 * @tc.name: MouseEventTest010 585 * @tc.desc: Test DispatchMouseEventNG function 586 * @tc.type: FUNC 587 */ 588 HWTEST_F(EventManagerTestNg, MouseEventTest010, TestSize.Level1) 589 { 590 /** 591 * @tc.steps: step1. Create EventManager. 592 * @tc.expected: eventManager is not null. 593 */ 594 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 595 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 596 auto eventManager = AceType::MakeRefPtr<EventManager>(); 597 ASSERT_NE(eventManager, nullptr); 598 599 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); 600 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].push_back(mouseEventTarget); 601 eventManager->currMouseTestResults_.push_back(mouseEventTarget); 602 __anone3a363090f02(MouseInfo& info) 603 const OnMouseEventFunc onMousePress = [](MouseInfo& info) -> bool { 604 info.SetStopPropagation(false); 605 return false; 606 }; __anone3a363091002(MouseInfo& info) 607 const OnMouseEventFunc onMouseRelease = [](MouseInfo& info) -> bool { return false; }; 608 mouseEventTarget->SetCallback(onMousePress); 609 610 /** 611 * @tc.steps: step2. Call DispatchMouseEventNG. 612 * @tc.expected: retFlag is FALSE. 613 */ 614 MouseEvent pressEvent; 615 pressEvent.action = MouseAction::PRESS; 616 pressEvent.button = MouseButton::LEFT_BUTTON; 617 bool result = eventManager->DispatchMouseEventNG(pressEvent); 618 EXPECT_FALSE(result); 619 620 MouseEvent releaseEvent; 621 releaseEvent.action = MouseAction::RELEASE; 622 releaseEvent.button = MouseButton::LEFT_BUTTON; 623 result = eventManager->DispatchMouseEventNG(releaseEvent); 624 EXPECT_FALSE(result); 625 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 626 } 627 628 /** 629 * @tc.name: MouseEventTest011 630 * @tc.desc: Test DispatchMouseEventNG function 631 * @tc.type: FUNC 632 */ 633 HWTEST_F(EventManagerTestNg, MouseEventTest011, TestSize.Level1) 634 { 635 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 636 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 637 auto eventManager = AceType::MakeRefPtr<EventManager>(); 638 ASSERT_NE(eventManager, nullptr); 639 640 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); __anone3a363091102(MouseInfo& info) 641 const OnMouseEventFunc onMouse = [](MouseInfo& info) { info.SetStopPropagation(false); }; 642 mouseEventTarget->SetCallback(onMouse); 643 eventManager->currMouseTestResults_.emplace_back(mouseEventTarget); 644 645 /** 646 * @tc.steps: step2. Call DispatchMouseEventNG. 647 * @tc.expected: retFlag is FALSE. 648 */ 649 MouseEvent event; 650 event.action = MouseAction::PRESS; 651 event.button = MouseButton::RIGHT_BUTTON; 652 653 bool result = eventManager->DispatchMouseEventNG(event); 654 EXPECT_FALSE(result); 655 656 event.action = MouseAction::RELEASE; 657 result = eventManager->DispatchMouseEventNG(event); 658 EXPECT_FALSE(result); 659 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 660 } 661 662 /** 663 * @tc.name: MouseEventTest012 664 * @tc.desc: Test DispatchMouseEventNG function 665 * @tc.type: FUNC 666 */ 667 HWTEST_F(EventManagerTestNg, MouseEventTest012, TestSize.Level1) 668 { 669 /** 670 * @tc.steps: step1. Create EventManager. 671 * @tc.expected: eventManager is not null. 672 */ 673 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 674 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 675 auto eventManager = AceType::MakeRefPtr<EventManager>(); 676 ASSERT_NE(eventManager, nullptr); 677 678 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); __anone3a363091202(MouseInfo& info) 679 const OnMouseEventFunc onMouse = [](MouseInfo& info) {}; 680 mouseEventTarget->SetCallback(onMouse); 681 eventManager->currMouseTestResults_.emplace_back(mouseEventTarget); 682 683 /** 684 * @tc.steps: step2. Call DispatchMouseEventNG. 685 * @tc.expected: retFlag is FALSE. 686 */ 687 MouseEvent event; 688 event.action = MouseAction::MOVE; 689 event.button = MouseButton::NONE_BUTTON; 690 bool retFlag = eventManager->DispatchMouseEventNG(event); 691 EXPECT_FALSE(retFlag); 692 693 event.action = MouseAction::PRESS; 694 event.button = MouseButton::NONE_BUTTON; 695 retFlag = eventManager->DispatchMouseEventNG(event); 696 EXPECT_FALSE(retFlag); 697 698 event.action = MouseAction::PRESS; 699 event.button = MouseButton::LEFT_BUTTON; 700 retFlag = eventManager->DispatchMouseEventNG(event); 701 EXPECT_FALSE(retFlag); 702 703 event.action = MouseAction::WINDOW_ENTER; 704 event.button = MouseButton::RIGHT_BUTTON; 705 retFlag = eventManager->DispatchMouseEventNG(event); 706 EXPECT_FALSE(retFlag); 707 708 event.action = MouseAction::MOVE; 709 event.button = MouseButton::MIDDLE_BUTTON; 710 retFlag = eventManager->DispatchMouseEventNG(event); 711 EXPECT_FALSE(retFlag); 712 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 713 } 714 715 /** 716 * @tc.name: MouseEventTest013 717 * @tc.desc: Test DispatchMouseEventNG function 718 * @tc.type: FUNC 719 */ 720 HWTEST_F(EventManagerTestNg, MouseEventTest013, TestSize.Level1) 721 { 722 /** 723 * @tc.steps: step1. Create EventManager. 724 * @tc.expected: eventManager is not null. 725 */ 726 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 727 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 728 auto eventManager = AceType::MakeRefPtr<EventManager>(); 729 ASSERT_NE(eventManager, nullptr); 730 731 /** 732 * @tc.steps: step2. Call DispatchMouseEventNG. 733 * @tc.expected: retFlag is FALSE. 734 */ 735 MouseEvent event; 736 event.action = MouseAction::NONE; 737 event.button = MouseButton::NONE_BUTTON; 738 bool retFlag = eventManager->DispatchMouseEventNG(event); 739 EXPECT_FALSE(retFlag); 740 741 event.action = MouseAction::PRESS; 742 event.button = MouseButton::LEFT_BUTTON; 743 retFlag = eventManager->DispatchMouseEventNG(event); 744 EXPECT_FALSE(retFlag); 745 746 event.action = MouseAction::RELEASE; 747 event.button = MouseButton::RIGHT_BUTTON; 748 retFlag = eventManager->DispatchMouseEventNG(event); 749 EXPECT_FALSE(retFlag); 750 751 event.action = MouseAction::MOVE; 752 event.button = MouseButton::MIDDLE_BUTTON; 753 retFlag = eventManager->DispatchMouseEventNG(event); 754 EXPECT_FALSE(retFlag); 755 756 event.action = MouseAction::WINDOW_ENTER; 757 event.button = MouseButton::BACK_BUTTON; 758 retFlag = eventManager->DispatchMouseEventNG(event); 759 EXPECT_FALSE(retFlag); 760 761 event.action = MouseAction::WINDOW_LEAVE; 762 event.button = MouseButton::FORWARD_BUTTON; 763 retFlag = eventManager->DispatchMouseEventNG(event); 764 EXPECT_FALSE(retFlag); 765 766 event.action = MouseAction::PRESS; 767 event.button = MouseButton::SIDE_BUTTON; 768 retFlag = eventManager->DispatchMouseEventNG(event); 769 EXPECT_FALSE(retFlag); 770 771 event.action = MouseAction::RELEASE; 772 event.button = MouseButton::EXTRA_BUTTON; 773 retFlag = eventManager->DispatchMouseEventNG(event); 774 EXPECT_FALSE(retFlag); 775 776 event.action = MouseAction::MOVE; 777 event.button = MouseButton::TASK_BUTTON; 778 retFlag = eventManager->DispatchMouseEventNG(event); 779 EXPECT_FALSE(retFlag); 780 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 781 } 782 783 /** 784 * @tc.name: DispatchAxisEventIssueTest1 785 * @tc.desc: Test DispatchAxisEventNG, axisTestResults_ is deleted each time it is dispatched. 786 * @tc.type: FUNC 787 */ 788 HWTEST_F(EventManagerTestNg, DispatchAxisEventIssueTest1, TestSize.Level1) 789 { 790 /** 791 * @tc.steps: step1. Create EventManager. 792 * @tc.expected: eventManager is not null. 793 */ 794 auto eventManager = AceType::MakeRefPtr<EventManager>(); 795 ASSERT_NE(eventManager, nullptr); 796 797 /** 798 * @tc.steps: step4. Call DispatchAxisEventNG with axisTestResults_ not empty 799 * @tc.expected: eventManager->axisTestResults_ is empty 800 */ 801 auto axisEventTarget = AceType::MakeRefPtr<AxisEventTarget>(); __anone3a363091302(AxisInfo&) 802 auto onAxisCallback = [](AxisInfo&) -> void {}; 803 axisEventTarget->SetOnAxisCallback(onAxisCallback); 804 AxisEvent event; 805 event.horizontalAxis = 0; 806 event.verticalAxis = 0; 807 event.pinchAxisScale = 0; 808 eventManager->axisTestResults_.push_back(axisEventTarget); 809 eventManager->DispatchAxisEventNG(event); 810 EXPECT_TRUE(eventManager->axisTestResults_.empty()); 811 } 812 813 /** 814 * @tc.name: MouseLocationTest001 815 * @tc.desc: Test HandleMouseEvent in less than API 14, the x、y location use coordinateOffset_. 816 * @tc.type: FUNC 817 */ 818 HWTEST_F(EventManagerTestNg, MouseLocationTest001, TestSize.Level1) 819 { 820 /** 821 * @tc.steps: step1. Create EventManager and set mouse event target callback. 822 * @tc.expected: eventManager is not null. 823 */ 824 auto eventManager = AceType::MakeRefPtr<EventManager>(); 825 ASSERT_NE(eventManager, nullptr); 826 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); 827 eventManager->currMouseTestResults_.push_back(mouseEventTarget); 828 mouseEventTarget->coordinateOffset_ = Offset(-100, 0); 829 MouseInfo mouseInfo; __anone3a363091402(MouseInfo& info) 830 const OnMouseEventFunc onMouse = [&mouseInfo](MouseInfo& info) { mouseInfo = info; }; 831 mouseEventTarget->SetCallback(onMouse); 832 833 /** 834 * @tc.steps: step2. Call DispatchMouseEventNG. 835 * @tc.expected: the mouse local location value is right. 836 */ 837 MouseEvent event; 838 event.x = 200.0f; 839 event.y = 200.0f; 840 event.action = MouseAction::PRESS; 841 eventManager->DispatchMouseEventNG(event); 842 EXPECT_EQ(mouseInfo.GetLocalLocation().GetX(), 200.0f); 843 EXPECT_EQ(mouseInfo.GetLocalLocation().GetY(), 200.0f); 844 } 845 846 /** 847 * @tc.name: MouseLocationTest002 848 * @tc.desc: Test HandleMouseEvent in great or equal API 14, the x、y location use Transform. 849 * @tc.type: FUNC 850 */ 851 HWTEST_F(EventManagerTestNg, MouseLocationTest002, TestSize.Level1) 852 { 853 /** 854 * @tc.steps: step1. create FrameNode. 855 */ 856 RefPtr<FrameNode> FRAME_NODE_0 = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>()); 857 RefPtr<FrameNode> FRAME_NODE_1 = FrameNode::CreateFrameNode("1", 1, AceType::MakeRefPtr<Pattern>()); 858 RefPtr<FrameNode> FRAME_NODE_2 = FrameNode::CreateFrameNode("2", 2, AceType::MakeRefPtr<Pattern>()); 859 FRAME_NODE_2->SetParent(WeakPtr<FrameNode>(FRAME_NODE_1)); 860 FRAME_NODE_1->SetParent(WeakPtr<FrameNode>(FRAME_NODE_0)); 861 862 /** 863 * @tc.steps: step2. mock local matrix. 864 */ 865 FRAME_NODE_0->localMat_ = Matrix4::CreateIdentity(); 866 FRAME_NODE_1->localMat_ = Matrix4::CreateIdentity(); 867 FRAME_NODE_2->localMat_ = Matrix4::Invert(Matrix4::CreateTranslate(400, 0, 0)); 868 869 /** 870 * @tc.steps: step3. Create EventManager, and set mouse event target callback. 871 * @tc.expected: eventManager is not null. 872 */ 873 int32_t backupApiVersion = AceApplicationInfo::GetInstance().GetApiTargetVersion(); 874 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_TWENTY)); 875 auto eventManager = AceType::MakeRefPtr<EventManager>(); 876 ASSERT_NE(eventManager, nullptr); 877 878 auto mouseEventTarget = AceType::MakeRefPtr<MouseEventTarget>(MOUSE, NODEID); 879 eventManager->currMouseTestResults_.push_back(mouseEventTarget); 880 mouseEventTarget->coordinateOffset_ = Offset(-100, 0); 881 mouseEventTarget->AttachFrameNode(FRAME_NODE_2); 882 MouseInfo mouseInfo; __anone3a363091502(MouseInfo& info) 883 const OnMouseEventFunc onMouse = [&mouseInfo](MouseInfo& info) { mouseInfo = info; }; 884 mouseEventTarget->SetCallback(onMouse); 885 886 /** 887 * @tc.steps: step4. Call DispatchMouseEventNG. 888 * @tc.expected: the mouse local location value is right. 889 */ 890 MouseEvent event; 891 event.x = 200.0f; 892 event.y = 200.0f; 893 event.action = MouseAction::PRESS; 894 eventManager->DispatchMouseEventNG(event); 895 EXPECT_EQ(mouseInfo.GetLocalLocation().GetX(), -200.0f); 896 EXPECT_EQ(mouseInfo.GetLocalLocation().GetY(), 200.0f); 897 AceApplicationInfo::GetInstance().SetApiTargetVersion(backupApiVersion); 898 } 899 900 /** 901 * @tc.name: EventManagerDispatchMouseEventNGTest001 902 * @tc.desc: Pressed MouseTestTarget and Current MouseTestTarget no-intersect, test mouse event dispatch. 903 * @tc.type: FUNC 904 */ 905 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest001, TestSize.Level1) 906 { 907 /** 908 * @tc.steps: step1. Create EventManager. 909 * @tc.expected: eventManager is not null. 910 */ 911 auto eventManager = AceType::MakeRefPtr<EventManager>(); 912 ASSERT_NE(eventManager, nullptr); 913 914 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 915 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, true, 4), // stop event propagation. 916 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, false, 0), // not stop event propagation. 917 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, true, 4), // stop event propagation. 918 AceType::MakeRefPtr<MouseEventTargetTest>("3", 3, false, 0), // not stop event propagation. 919 }; 920 921 /** 922 * @tc.steps: step2. set pressMouseTestResults_ and currMouseTestResults_. 923 * @tc.expected: pressMouseTestResults_ and currMouseTestResults_ non-intersect. 924 */ 925 eventManager->pressMouseTestResults_.emplace_back(testCases[0]); 926 eventManager->pressMouseTestResults_.emplace_back(testCases[1]); 927 928 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 929 eventManager->currMouseTestResults_.emplace_back(testCases[3]); 930 931 const std::vector<MockMouseEvent> mockMouseEvents = { 932 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, true }, 933 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, true }, 934 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, true }, 935 { MouseAction::RELEASE, MouseButton::LEFT_BUTTON, true }, 936 }; 937 938 /** 939 * @tc.steps: step3. Inject mock mouseEvent 940 * @tc.expected: pressMouseTestResults stop propagation no work for DispatchMouseEventNG result. 941 */ 942 for (auto mockMouseEvent : mockMouseEvents) { 943 MouseEvent event; 944 event.action = mockMouseEvent.action; 945 event.button = mockMouseEvent.button; 946 auto result = eventManager->DispatchMouseEventNG(event); 947 EXPECT_EQ(result, mockMouseEvent.expectedResult); 948 } 949 950 /** 951 * @tc.expected: index == 1 and index == 3 can not be invoked. other can be invoked. 952 */ 953 for (auto i = 0; i < testCases.size(); i++) { 954 EXPECT_EQ(testCases[i]->GetCallbackInvokeCount(), testCases[i]->GetExpectedResult()) << i; 955 } 956 } 957 958 /** 959 * @tc.name: EventManagerDispatchMouseEventNGTest002 960 * @tc.desc: API level greater or equal to 13, Pressed MouseTestTarget and Current MouseTestTarget no-intersect, test 961 * mouse event dispatch. 962 * @tc.type: FUNC 963 */ 964 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest002, TestSize.Level1) 965 { 966 /** 967 * @tc.steps: step1. Set API level 13. 968 * @tc.expected: current API level equal to 13. 969 */ 970 APIVersionGuard aPIVersionGuard(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 971 ASSERT_EQ(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN), 972 AceApplicationInfo::GetInstance().GetApiTargetVersion()); 973 974 /** 975 * @tc.steps: step2. Create EventManager. 976 * @tc.expected: eventManager is not null. 977 */ 978 auto eventManager = AceType::MakeRefPtr<EventManager>(); 979 ASSERT_NE(eventManager, nullptr); 980 981 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 982 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, true, 4), // stop event propagation. 983 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, false, 0), // not stop event propagation. 984 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, true, 4), // stop event propagation. 985 AceType::MakeRefPtr<MouseEventTargetTest>("3", 3, false, 0), // not stop event propagation. 986 }; 987 988 /** 989 * @tc.steps: step3. set pressMouseTestResults_ and currMouseTestResults_. 990 * @tc.expected: pressMouseTestResults_ and currMouseTestResults_ non-intersect. 991 */ 992 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[0]); 993 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[1]); 994 995 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 996 eventManager->currMouseTestResults_.emplace_back(testCases[3]); 997 998 const std::vector<MockMouseEvent> mockMouseEvents = { 999 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, true }, 1000 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, true }, 1001 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, true }, 1002 { MouseAction::RELEASE, MouseButton::LEFT_BUTTON, true }, 1003 }; 1004 1005 /** 1006 * @tc.steps: step4. Inject mock mouseEvent 1007 * @tc.expected: pressMouseTestResults stop propagation no work for DispatchMouseEventNG result. 1008 */ 1009 for (auto mockMouseEvent : mockMouseEvents) { 1010 MouseEvent event; 1011 event.action = mockMouseEvent.action; 1012 event.button = mockMouseEvent.button; 1013 auto result = eventManager->DispatchMouseEventNG(event); 1014 EXPECT_EQ(result, mockMouseEvent.expectedResult); 1015 } 1016 1017 /** 1018 * @tc.expected: index == 0 and index == 3 can not be invoked. other can be invoked. 1019 */ 1020 for (auto i = 0; i < testCases.size(); i++) { 1021 EXPECT_EQ(testCases[i]->GetCallbackInvokeCount(), testCases[i]->GetExpectedResult()) << i; 1022 } 1023 } 1024 1025 /** 1026 * @tc.name: EventManagerDispatchMouseEventNGTest003 1027 * @tc.desc: Pressed MouseTestTarget and Current MouseTestTarget intersect, none one stop propagation, test mouse event 1028 * dispatch. expect every one will receive mouse event. 1029 * @tc.type: FUNC 1030 */ 1031 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest003, TestSize.Level1) 1032 { 1033 /** 1034 * @tc.steps: step1. Create EventManager. 1035 * @tc.expected: eventManager is not null. 1036 */ 1037 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1038 ASSERT_NE(eventManager, nullptr); 1039 1040 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 1041 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, false, 4), // not stop event propagation. 1042 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, false, 4), // not stop event propagation. 1043 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, false, 4), // not stop event propagation. 1044 AceType::MakeRefPtr<MouseEventTargetTest>("3", 3, false, 4), // not stop event propagation. 1045 AceType::MakeRefPtr<MouseEventTargetTest>("4", 4, false, 4), // not stop event propagation. 1046 }; 1047 1048 /** 1049 * @tc.steps: step2. set pressMouseTestResults_ and currMouseTestResults_. 1050 * @tc.expected: pressMouseTestResults_ and currMouseTestResults_ intersect. 1051 */ 1052 eventManager->pressMouseTestResults_.emplace_back(testCases[0]); 1053 eventManager->pressMouseTestResults_.emplace_back(testCases[1]); 1054 eventManager->pressMouseTestResults_.emplace_back(testCases[2]); 1055 eventManager->pressMouseTestResults_.emplace_back(testCases[3]); 1056 1057 eventManager->currMouseTestResults_.emplace_back(testCases[1]); 1058 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 1059 eventManager->currMouseTestResults_.emplace_back(testCases[3]); 1060 eventManager->currMouseTestResults_.emplace_back(testCases[4]); 1061 1062 const std::vector<MockMouseEvent> mockMouseEvents = { 1063 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1064 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1065 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1066 { MouseAction::RELEASE, MouseButton::LEFT_BUTTON, false }, 1067 }; 1068 1069 /** 1070 * @tc.steps: step3. Inject mock mouseEvent. 1071 */ 1072 for (auto mockMouseEvent : mockMouseEvents) { 1073 MouseEvent event; 1074 event.action = mockMouseEvent.action; 1075 event.button = mockMouseEvent.button; 1076 auto result = eventManager->DispatchMouseEventNG(event); 1077 EXPECT_EQ(result, mockMouseEvent.expectedResult); 1078 } 1079 1080 /** 1081 * @tc.expected: In this case, every mouse targer will receive four mouse events. 1082 */ 1083 for (auto i = 0; i < testCases.size(); i++) { 1084 EXPECT_EQ(testCases[i]->GetCallbackInvokeCount(), testCases[i]->GetExpectedResult()) << i; 1085 } 1086 } 1087 1088 /** 1089 * @tc.name: EventManagerDispatchMouseEventNGTest004 1090 * @tc.desc: API level greater or equal to 13, Pressed MouseTestTarget and Current MouseTestTarget intersect, none one 1091 * stop propagation, test mouse event dispatch. expect every one will receive mouse event. 1092 * @tc.type: FUNC 1093 */ 1094 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest004, TestSize.Level1) 1095 { 1096 /** 1097 * @tc.steps: step1. Set API level 13. 1098 * @tc.expected: current API level equal to 13. 1099 */ 1100 APIVersionGuard aPIVersionGuard(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 1101 ASSERT_EQ(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN), 1102 AceApplicationInfo::GetInstance().GetApiTargetVersion()); 1103 /** 1104 * @tc.steps: step2. Create EventManager. 1105 * @tc.expected: eventManager is not null. 1106 */ 1107 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1108 ASSERT_NE(eventManager, nullptr); 1109 1110 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 1111 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, false, 4), // not stop event propagation. 1112 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, false, 4), // not stop event propagation. 1113 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, false, 4), // not stop event propagation. 1114 AceType::MakeRefPtr<MouseEventTargetTest>("3", 3, false, 4), // not stop event propagation. 1115 AceType::MakeRefPtr<MouseEventTargetTest>("4", 4, false, 4), // not stop event propagation. 1116 }; 1117 1118 /** 1119 * @tc.steps: step3. set pressMouseTestResults_ and currMouseTestResults_. 1120 * @tc.expected: pressMouseTestResults_ and currMouseTestResults_ intersect. 1121 */ 1122 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[0]); 1123 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[1]); 1124 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[2]); 1125 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[3]); 1126 1127 eventManager->currMouseTestResults_.emplace_back(testCases[1]); 1128 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 1129 eventManager->currMouseTestResults_.emplace_back(testCases[3]); 1130 eventManager->currMouseTestResults_.emplace_back(testCases[4]); 1131 1132 const std::vector<MockMouseEvent> mockMouseEvents = { 1133 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1134 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1135 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1136 { MouseAction::RELEASE, MouseButton::LEFT_BUTTON, false }, 1137 }; 1138 1139 /** 1140 * @tc.steps: step4. Inject mock mouseEvent. 1141 */ 1142 for (auto mockMouseEvent : mockMouseEvents) { 1143 MouseEvent event; 1144 event.action = mockMouseEvent.action; 1145 event.button = mockMouseEvent.button; 1146 auto result = eventManager->DispatchMouseEventNG(event); 1147 EXPECT_EQ(result, mockMouseEvent.expectedResult); 1148 } 1149 1150 /** 1151 * @tc.expected: In this case, every mouse targer will receive four mouse events. 1152 */ 1153 for (auto i = 0; i < testCases.size(); i++) { 1154 EXPECT_EQ(testCases[i]->GetCallbackInvokeCount(), testCases[i]->GetExpectedResult()) << i; 1155 } 1156 } 1157 1158 /** 1159 * @tc.name: EventManagerDispatchMouseEventNGTest005 1160 * @tc.desc: Pressed MouseTestTarget and Current MouseTestTarget intersect, Pressed MouseTestTarget stop propagation 1161 * test mouse event dispatch. 1162 * @tc.type: FUNC 1163 */ 1164 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest005, TestSize.Level1) 1165 { 1166 /** 1167 * @tc.steps: step1. Create EventManager. 1168 * @tc.expected: eventManager is not null. 1169 */ 1170 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1171 ASSERT_NE(eventManager, nullptr); 1172 1173 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 1174 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, false, 4), 1175 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, false, 4), 1176 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, true, 4), 1177 AceType::MakeRefPtr<MouseEventTargetTest>("3", 3, true, 0), 1178 AceType::MakeRefPtr<MouseEventTargetTest>("4", 4, false, 4), 1179 }; 1180 1181 /** 1182 * @tc.steps: step2. set pressMouseTestResults_ and currMouseTestResults_. 1183 * @tc.expected: pressMouseTestResults_ == currMouseTestResults_. 1184 */ 1185 eventManager->pressMouseTestResults_.emplace_back(testCases[0]); 1186 eventManager->pressMouseTestResults_.emplace_back(testCases[1]); 1187 eventManager->pressMouseTestResults_.emplace_back(testCases[2]); 1188 eventManager->pressMouseTestResults_.emplace_back(testCases[3]); 1189 1190 eventManager->currMouseTestResults_.emplace_back(testCases[1]); 1191 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 1192 eventManager->currMouseTestResults_.emplace_back(testCases[3]); 1193 eventManager->currMouseTestResults_.emplace_back(testCases[4]); 1194 1195 const std::vector<MockMouseEvent> mockMouseEvents = { 1196 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1197 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1198 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1199 { MouseAction::RELEASE, MouseButton::LEFT_BUTTON, false }, 1200 }; 1201 1202 /** 1203 * @tc.steps: step3. Inject mouseEvent 1204 * @tc.expected: pressMouseTestResults stop propagation no work for DispatchMouseEventNG result 1205 */ 1206 for (auto i = 0; i < mockMouseEvents.size(); i++) { 1207 MouseEvent event; 1208 event.action = mockMouseEvents[i].action; 1209 event.button = mockMouseEvents[i].button; 1210 auto result = eventManager->DispatchMouseEventNG(event); 1211 EXPECT_EQ(result, mockMouseEvents[i].expectedResult) << i; 1212 } 1213 1214 /** 1215 * @tc.expected: In this case, except index == 0 can receive mouse event. other targets can not receive event. 1216 */ 1217 for (auto i = 0; i < testCases.size(); i++) { 1218 EXPECT_EQ(testCases[i]->GetCallbackInvokeCount(), testCases[i]->GetExpectedResult()) << i; 1219 } 1220 } 1221 1222 /** 1223 * @tc.name: EventManagerDispatchMouseEventNGTest006 1224 * @tc.desc: API level greater or equal to 13, Pressed MouseTestTarget and Current MouseTestTarget intersect, Pressed 1225 * MouseTestTarget stop propagation test mouse event dispatch. 1226 * @tc.type: FUNC 1227 */ 1228 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest006, TestSize.Level1) 1229 { 1230 /** 1231 * @tc.steps: step1. Set API level 13. 1232 * @tc.expected: current API level equal to 13. 1233 */ 1234 APIVersionGuard aPIVersionGuard(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 1235 ASSERT_EQ(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN), 1236 AceApplicationInfo::GetInstance().GetApiTargetVersion()); 1237 1238 /** 1239 * @tc.steps: step2. Create EventManager. 1240 * @tc.expected: eventManager is not null. 1241 */ 1242 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1243 ASSERT_NE(eventManager, nullptr); 1244 1245 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 1246 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, false, 4), 1247 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, false, 4), 1248 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, true, 4), 1249 AceType::MakeRefPtr<MouseEventTargetTest>("3", 3, true, 0), 1250 AceType::MakeRefPtr<MouseEventTargetTest>("4", 4, false, 4), 1251 }; 1252 1253 /** 1254 * @tc.steps: step3. set pressMouseTestResults_ and currMouseTestResults_. 1255 * @tc.expected: pressMouseTestResults_ == currMouseTestResults_. 1256 */ 1257 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[0]); 1258 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[1]); 1259 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[2]); 1260 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[3]); 1261 1262 eventManager->currMouseTestResults_.emplace_back(testCases[1]); 1263 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 1264 eventManager->currMouseTestResults_.emplace_back(testCases[3]); 1265 eventManager->currMouseTestResults_.emplace_back(testCases[4]); 1266 1267 const std::vector<MockMouseEvent> mockMouseEvents = { 1268 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1269 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1270 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1271 { MouseAction::RELEASE, MouseButton::LEFT_BUTTON, false }, 1272 }; 1273 1274 /** 1275 * @tc.steps: step3. Inject mouseEvent 1276 * @tc.expected: pressMouseTestResults stop propagation no work for DispatchMouseEventNG result 1277 */ 1278 for (auto i = 0; i < mockMouseEvents.size(); i++) { 1279 MouseEvent event; 1280 event.action = mockMouseEvents[i].action; 1281 event.button = mockMouseEvents[i].button; 1282 auto result = eventManager->DispatchMouseEventNG(event); 1283 EXPECT_EQ(result, mockMouseEvents[i].expectedResult) << i; 1284 } 1285 1286 /** 1287 * @tc.expected: In this case, except index == 0 can receive mouse event. other targets can not receive event. 1288 */ 1289 for (auto i = 0; i < testCases.size(); i++) { 1290 EXPECT_EQ(testCases[i]->GetCallbackInvokeCount(), testCases[i]->GetExpectedResult()) << i; 1291 } 1292 } 1293 1294 /** 1295 * @tc.name: EventManagerDispatchMouseEventNGTest007 1296 * @tc.desc: Pressed MouseTestTarget and Current MouseTestTarget intersect, Pressed MouseTestTarget stop propagation 1297 * will case which one in pressed MouseTestTarget can not be invoked. 1298 * @tc.type: FUNC 1299 */ 1300 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest007, TestSize.Level1) 1301 { 1302 /** 1303 * @tc.steps: step1. Create EventManager. 1304 * @tc.expected: eventManager is not null. 1305 */ 1306 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1307 ASSERT_NE(eventManager, nullptr); 1308 1309 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 1310 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, false, 4), 1311 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, true, 4), 1312 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, false, 0), 1313 AceType::MakeRefPtr<MouseEventTargetTest>("3", 3, false, 4), 1314 AceType::MakeRefPtr<MouseEventTargetTest>("4", 4, false, 4), 1315 }; 1316 1317 /** 1318 * @tc.steps: step2. set pressMouseTestResults_ and currMouseTestResults_. 1319 * @tc.expected: pressMouseTestResults_ == currMouseTestResults_. 1320 */ 1321 eventManager->pressMouseTestResults_.emplace_back(testCases[0]); 1322 eventManager->pressMouseTestResults_.emplace_back(testCases[1]); 1323 eventManager->pressMouseTestResults_.emplace_back(testCases[2]); 1324 1325 eventManager->currMouseTestResults_.emplace_back(testCases[0]); 1326 eventManager->currMouseTestResults_.emplace_back(testCases[1]); 1327 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 1328 eventManager->currMouseTestResults_.emplace_back(testCases[3]); 1329 eventManager->currMouseTestResults_.emplace_back(testCases[4]); 1330 1331 const std::vector<MockMouseEvent> mockMouseEvents = { 1332 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1333 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1334 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1335 { MouseAction::RELEASE, MouseButton::LEFT_BUTTON, false }, 1336 }; 1337 1338 /** 1339 * @tc.steps: step3. Inject mouseEvent 1340 * @tc.expected: pressMouseTestResults stop propagation no work for DispatchMouseEventNG result 1341 */ 1342 for (auto mockMouseEvent : mockMouseEvents) { 1343 MouseEvent event; 1344 event.action = mockMouseEvent.action; 1345 event.button = mockMouseEvent.button; 1346 auto result = eventManager->DispatchMouseEventNG(event); 1347 EXPECT_EQ(result, mockMouseEvent.expectedResult); 1348 } 1349 1350 /** 1351 * @tc.expected: In this case, except index == 0 can receive mouse event. other targets can not receive event. 1352 */ 1353 for (auto i = 0; i < testCases.size(); i++) { 1354 EXPECT_EQ(testCases[i]->GetCallbackInvokeCount(), testCases[i]->GetExpectedResult()) << i; 1355 } 1356 } 1357 1358 /** 1359 * @tc.name: EventManagerDispatchMouseEventNGTest008 1360 * @tc.desc: API level greater or equal to 13, Pressed MouseTestTarget and Current MouseTestTarget intersect, Pressed 1361 * MouseTestTarget stop propagation will case which one in pressed MouseTestTarget can not be invoked. 1362 * @tc.type: FUNC 1363 */ 1364 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest008, TestSize.Level1) 1365 { 1366 /** 1367 * @tc.steps: step1. Set API level 13. 1368 * @tc.expected: current API level equal to 13. 1369 */ 1370 APIVersionGuard aPIVersionGuard(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 1371 ASSERT_EQ(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN), 1372 AceApplicationInfo::GetInstance().GetApiTargetVersion()); 1373 1374 /** 1375 * @tc.steps: step1. Create EventManager. 1376 * @tc.expected: eventManager is not null. 1377 */ 1378 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1379 ASSERT_NE(eventManager, nullptr); 1380 1381 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 1382 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, false, 4), 1383 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, true, 4), 1384 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, false, 0), 1385 AceType::MakeRefPtr<MouseEventTargetTest>("3", 3, false, 4), 1386 AceType::MakeRefPtr<MouseEventTargetTest>("4", 4, false, 4), 1387 }; 1388 1389 /** 1390 * @tc.steps: step2. set pressMouseTestResults_ and currMouseTestResults_. 1391 * @tc.expected: pressMouseTestResults_ == currMouseTestResults_. 1392 */ 1393 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[0]); 1394 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[1]); 1395 eventManager->pressMouseTestResultsMap_[MouseButton::LEFT_BUTTON].emplace_back(testCases[2]); 1396 1397 eventManager->currMouseTestResults_.emplace_back(testCases[0]); 1398 eventManager->currMouseTestResults_.emplace_back(testCases[1]); 1399 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 1400 eventManager->currMouseTestResults_.emplace_back(testCases[3]); 1401 eventManager->currMouseTestResults_.emplace_back(testCases[4]); 1402 1403 const std::vector<MockMouseEvent> mockMouseEvents = { 1404 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1405 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1406 { MouseAction::MOVE, MouseButton::LEFT_BUTTON, false }, 1407 { MouseAction::RELEASE, MouseButton::LEFT_BUTTON, false }, 1408 }; 1409 1410 /** 1411 * @tc.steps: step3. Inject mouseEvent 1412 * @tc.expected: pressMouseTestResults stop propagation no work for DispatchMouseEventNG result 1413 */ 1414 for (auto mockMouseEvent : mockMouseEvents) { 1415 MouseEvent event; 1416 event.action = mockMouseEvent.action; 1417 event.button = mockMouseEvent.button; 1418 auto result = eventManager->DispatchMouseEventNG(event); 1419 EXPECT_EQ(result, mockMouseEvent.expectedResult); 1420 } 1421 1422 /** 1423 * @tc.expected: In this case, except index == 0 can receive mouse event. other targets can not receive event. 1424 */ 1425 for (auto i = 0; i < testCases.size(); i++) { 1426 EXPECT_EQ(testCases[i]->GetCallbackInvokeCount(), testCases[i]->GetExpectedResult()) << i; 1427 } 1428 } 1429 1430 /** 1431 * @tc.name: EventManagerDispatchMouseEventNGTest009 1432 * @tc.desc: API level less than 13, only MouseButton::LEFT_BUTTON mouse event can dispatch to pressedTestResult. 1433 * @tc.type: FUNC 1434 */ 1435 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest009, TestSize.Level1) 1436 { 1437 /** 1438 * @tc.steps: step1. Set API level 12. 1439 * @tc.expected: current API level equal to 12. 1440 */ 1441 APIVersionGuard aPIVersionGuard(static_cast<int32_t>(PlatformVersion::VERSION_TWELVE)); 1442 ASSERT_EQ( 1443 static_cast<int32_t>(PlatformVersion::VERSION_TWELVE), AceApplicationInfo::GetInstance().GetApiTargetVersion()); 1444 1445 const std::vector<MockMouseEvent> mockMouseEvents = { 1446 { MouseAction::PRESS, MouseButton::NONE_BUTTON, false }, 1447 { MouseAction::PRESS, MouseButton::LEFT_BUTTON, true }, 1448 { MouseAction::PRESS, MouseButton::RIGHT_BUTTON, false }, 1449 { MouseAction::PRESS, MouseButton::MIDDLE_BUTTON, false }, 1450 { MouseAction::PRESS, MouseButton::BACK_BUTTON, false }, 1451 { MouseAction::PRESS, MouseButton::FORWARD_BUTTON, false }, 1452 { MouseAction::PRESS, MouseButton::SIDE_BUTTON, false }, 1453 { MouseAction::PRESS, MouseButton::EXTRA_BUTTON, false }, 1454 { MouseAction::PRESS, MouseButton::TASK_BUTTON, false }, 1455 }; 1456 1457 /** 1458 * @tc.steps: step2. Inject mock mouse event contains MouseButton and MouseAction == MouseAction::PRESS. 1459 * @tc.expected: currMouseTestResults_ equals to pressMouseTestResults_. 1460 */ 1461 for (auto mockMouseEvent : mockMouseEvents) { 1462 MouseEvent event; 1463 event.action = mockMouseEvent.action; 1464 event.button = mockMouseEvent.button; 1465 1466 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 1467 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, false), 1468 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, false), 1469 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, false), 1470 }; 1471 1472 /** 1473 * @tc.steps: step3. Create EventManager. 1474 * @tc.expected: eventManager is not null. 1475 */ 1476 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1477 ASSERT_NE(eventManager, nullptr); 1478 1479 eventManager->currMouseTestResults_.emplace_back(testCases[0]); 1480 eventManager->currMouseTestResults_.emplace_back(testCases[1]); 1481 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 1482 1483 eventManager->DispatchMouseEventNG(event); 1484 EXPECT_EQ( 1485 eventManager->pressMouseTestResults_ == eventManager->currMouseTestResults_, mockMouseEvent.expectedResult); 1486 } 1487 } 1488 1489 /** 1490 * @tc.name: EventManagerDispatchMouseEventNGTest010 1491 * @tc.desc: API level greater and equal to 13, all kinds of MouseButton event can dispatch to pressedTestResult. 1492 * @tc.type: FUNC 1493 */ 1494 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest010, TestSize.Level1) 1495 { 1496 /** 1497 * @tc.steps: step1. Set API level 13. 1498 * @tc.expected: current API level equal to 13. 1499 */ 1500 APIVersionGuard aPIVersionGuard(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN)); 1501 ASSERT_EQ(static_cast<int32_t>(PlatformVersion::VERSION_THIRTEEN), 1502 AceApplicationInfo::GetInstance().GetApiTargetVersion()); 1503 1504 const std::vector<MockMouseEvent> mockMouseEvents = { 1505 { MouseAction::PRESS, MouseButton::NONE_BUTTON, false }, 1506 { MouseAction::PRESS, MouseButton::LEFT_BUTTON, true }, 1507 { MouseAction::PRESS, MouseButton::RIGHT_BUTTON, true }, 1508 { MouseAction::PRESS, MouseButton::MIDDLE_BUTTON, true }, 1509 { MouseAction::PRESS, MouseButton::BACK_BUTTON, true }, 1510 { MouseAction::PRESS, MouseButton::FORWARD_BUTTON, true }, 1511 { MouseAction::PRESS, MouseButton::SIDE_BUTTON, true }, 1512 { MouseAction::PRESS, MouseButton::EXTRA_BUTTON, true }, 1513 { MouseAction::PRESS, MouseButton::TASK_BUTTON, true }, 1514 }; 1515 1516 /** 1517 * @tc.steps: step2. Inject mock mouse event contains MouseButton and MouseAction == MouseAction::PRESS. 1518 * @tc.expected: currMouseTestResults_ equals to pressMouseTestResultsMap_[button] 1519 */ 1520 for (auto mockMouseEvent : mockMouseEvents) { 1521 MouseEvent event; 1522 event.action = mockMouseEvent.action; 1523 event.button = mockMouseEvent.button; 1524 1525 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 1526 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, false), 1527 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, false), 1528 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, false), 1529 }; 1530 1531 /** 1532 * @tc.steps: step3. Create EventManager. 1533 * @tc.expected: eventManager is not null. 1534 */ 1535 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1536 ASSERT_NE(eventManager, nullptr); 1537 1538 eventManager->currMouseTestResults_.emplace_back(testCases[0]); 1539 eventManager->currMouseTestResults_.emplace_back(testCases[1]); 1540 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 1541 1542 eventManager->DispatchMouseEventNG(event); 1543 EXPECT_EQ(eventManager->pressMouseTestResultsMap_[event.button] == eventManager->currMouseTestResults_, 1544 mockMouseEvent.expectedResult); 1545 } 1546 } 1547 1548 /** 1549 * @tc.name: EventManagerDispatchMouseEventNGTest011 1550 * @tc.desc: DispatchMouseEventNG only work for five kinds(press/release/move/window_enter/window_leave) mouse action. 1551 * @tc.type: FUNC 1552 */ 1553 HWTEST_F(EventManagerDispatchMouseEventNGTest, EventManagerDispatchMouseEventNGTest011, TestSize.Level1) 1554 { 1555 /** 1556 * @tc.steps: step1. Create mock mouse event with all kind of MouseAction. 1557 */ 1558 const std::vector<MockMouseEvent> mockMouseEvents = { 1559 { MouseAction::NONE, MouseButton::NONE_BUTTON, false }, 1560 { MouseAction::PRESS, MouseButton::LEFT_BUTTON, true }, 1561 { MouseAction::RELEASE, MouseButton::RIGHT_BUTTON, true }, 1562 { MouseAction::MOVE, MouseButton::MIDDLE_BUTTON, true }, 1563 { MouseAction::WINDOW_ENTER, MouseButton::BACK_BUTTON, true }, 1564 { MouseAction::WINDOW_LEAVE, MouseButton::FORWARD_BUTTON, true }, 1565 { MouseAction::HOVER, MouseButton::SIDE_BUTTON, false }, 1566 { MouseAction::HOVER_ENTER, MouseButton::EXTRA_BUTTON, false }, 1567 { MouseAction::HOVER_MOVE, MouseButton::TASK_BUTTON, false }, 1568 { MouseAction::HOVER_EXIT, MouseButton::NONE_BUTTON, false }, 1569 { MouseAction::PULL_DOWN, MouseButton::LEFT_BUTTON, false }, 1570 { MouseAction::PULL_MOVE, MouseButton::RIGHT_BUTTON, false }, 1571 { MouseAction::PULL_UP, MouseButton::MIDDLE_BUTTON, false }, 1572 { MouseAction::CANCEL, MouseButton::BACK_BUTTON, true }, 1573 }; 1574 1575 /** 1576 * @tc.steps: step2. traversal all kinds of MouseAction,inject mock mouse event into EventManager. 1577 * @tc.expected: result of invoke DispatchMouseEventNG equal to expected result. 1578 */ 1579 for (auto mockMouseEvent : mockMouseEvents) { 1580 MouseEvent event; 1581 event.action = mockMouseEvent.action; 1582 event.button = mockMouseEvent.button; 1583 1584 std::vector<RefPtr<MouseEventTargetTest>> testCases = { 1585 AceType::MakeRefPtr<MouseEventTargetTest>("0", 0, true), 1586 AceType::MakeRefPtr<MouseEventTargetTest>("1", 1, true), 1587 AceType::MakeRefPtr<MouseEventTargetTest>("2", 2, true), 1588 }; 1589 1590 /** 1591 * @tc.steps: step3. Create eventManager. 1592 * @tc.expected: eventManager not equal to nullptr. 1593 */ 1594 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1595 ASSERT_NE(eventManager, nullptr); 1596 1597 eventManager->currMouseTestResults_.emplace_back(testCases[0]); 1598 eventManager->currMouseTestResults_.emplace_back(testCases[1]); 1599 eventManager->currMouseTestResults_.emplace_back(testCases[2]); 1600 1601 auto result = eventManager->DispatchMouseEventNG(event); 1602 EXPECT_EQ(result, mockMouseEvent.expectedResult) << static_cast<int32_t>(event.action); 1603 } 1604 } 1605 1606 /** 1607 * @tc.name: GetOrRefreshMatrixFromCache 1608 * @tc.desc: Test GetOrRefreshMatrixFromCache func 1609 * @tc.type: FUNC 1610 */ 1611 HWTEST_F(EventManagerDispatchMouseEventNGTest, GetOrRefreshMatrixFromCacheNGTest001, TestSize.Level1) 1612 { 1613 /** 1614 * @tc.steps: step1. create 1615 * @tc.expected: expect The function return value is true when width or height is nearZero. 1616 */ 1617 MockPipelineContext::SetUp(); 1618 RefPtr<FrameNode> node = FrameNode::CreateFrameNode("0", 0, AceType::MakeRefPtr<Pattern>()); 1619 ASSERT_NE(node, nullptr); 1620 auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>(); 1621 ASSERT_NE(mockRenderContext, nullptr); 1622 auto pipeline = NG::PipelineContext::GetCurrentContext(); 1623 ASSERT_NE(pipeline, nullptr); 1624 node->renderContext_ = mockRenderContext; 1625 node->context_ = AceType::RawPtr(pipeline); 1626 1627 node->cacheMatrixInfo_ = CacheMatrixInfo(); 1628 mockRenderContext->paintRect_ = RectF(0, 0, 10, 0); 1629 CacheMatrixInfo cacheMatrixInfo = node->GetOrRefreshMatrixFromCache(); 1630 EXPECT_EQ(cacheMatrixInfo.paintRectWithTransform.Width(), 0); 1631 1632 node->isTransformNotChanged_ = false; 1633 mockRenderContext->rect_ = RectF(0, 0, 10, 0); 1634 mockRenderContext->paintRect_ = RectF(0, 0, 10, 0); 1635 cacheMatrixInfo = node->GetOrRefreshMatrixFromCache(); 1636 EXPECT_EQ(cacheMatrixInfo.paintRectWithTransform.Width(), 10); 1637 EXPECT_EQ(node->isTransformNotChanged_, true); 1638 1639 node->isTransformNotChanged_ = false; 1640 cacheMatrixInfo = node->GetOrRefreshMatrixFromCache(true); 1641 EXPECT_EQ(cacheMatrixInfo.paintRectWithTransform.Width(), 10); 1642 EXPECT_EQ(node->isTransformNotChanged_, true); 1643 1644 node->cacheMatrixInfo_ = CacheMatrixInfo(); 1645 node->isTransformNotChanged_ = false; 1646 cacheMatrixInfo = node->GetOrRefreshMatrixFromCache(); 1647 EXPECT_EQ(cacheMatrixInfo.paintRectWithTransform.Width(), 10); 1648 EXPECT_EQ(node->isTransformNotChanged_, true); 1649 MockPipelineContext::TearDown(); 1650 } 1651 } // namespace OHOS::Ace::NG