1 /* 2 * Copyright (c) 2025 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 "test/unittest/core/event/event_manager_test_ng.h" 17 18 using namespace testing; 19 using namespace testing::ext; 20 namespace OHOS::Ace::NG { 21 constexpr int TOUCH_ID = 0; 22 23 class TouchDelegateTest : public TouchDelegate { DelegateTouchEvent(const TouchEvent & point)24 void DelegateTouchEvent(const TouchEvent& point) 25 { 26 return; 27 } 28 }; 29 /** 30 * @tc.name: ExecuteTouchTestDoneCallbackTest001 31 * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. 32 * @tc.type: FUNC 33 */ 34 HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest001, TestSize.Level1) 35 { 36 auto eventManager = AceType::MakeRefPtr<EventManager>(); 37 ASSERT_NE(eventManager, nullptr); 38 TouchEvent touchEvent; 39 touchEvent.deviceId = 1; 40 touchEvent.force = 1.0f; 41 touchEvent.pointers.push_back(TouchPoint()); 42 43 ResponseLinkResult responseLinkRecognizers; 44 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>( 45 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 46 ASSERT_NE(panHorizontal1, nullptr); 47 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); 48 ASSERT_NE(frameNode, nullptr); 49 auto eventHub = frameNode->GetOrCreateGestureEventHub(); 50 ASSERT_NE(eventHub, nullptr); 51 int32_t doneId = 0; 52 int32_t doneInnerId = 0; 53 auto touchTestDoneFunc = [&doneId](const std::shared_ptr<BaseGestureEvent>& event, __anon6a8b7da90102(const std::shared_ptr<BaseGestureEvent>& event, const std::list<RefPtr<NGGestureRecognizer>>& recognizer) 54 const std::list<RefPtr<NGGestureRecognizer>>& recognizer) { doneId++; }; 55 auto touchTestDoneForInnerFunc = [&doneInnerId](const std::shared_ptr<BaseGestureEvent>& event, __anon6a8b7da90202(const std::shared_ptr<BaseGestureEvent>& event, const std::list<RefPtr<NGGestureRecognizer>>& recognizer) 56 const std::list<RefPtr<NGGestureRecognizer>>& recognizer) { doneInnerId++; }; 57 eventHub->SetOnTouchTestDoneCallback(std::move(touchTestDoneFunc)); 58 eventHub->SetOnTouchTestDoneCallbackForInner(std::move(touchTestDoneForInnerFunc)); 59 eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr<NG::FrameNode>(frameNode)); 60 eventManager->ExecuteTouchTestDoneCallback(touchEvent, responseLinkRecognizers); 61 EXPECT_NE(doneId, 0); 62 EXPECT_NE(doneInnerId, 0); 63 } 64 65 /** 66 * @tc.name: ExecuteTouchTestDoneCallbackTest002 67 * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. 68 * @tc.type: FUNC 69 */ 70 HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest002, TestSize.Level1) 71 { 72 auto eventManager = AceType::MakeRefPtr<EventManager>(); 73 ASSERT_NE(eventManager, nullptr); 74 TouchEvent touchEvent; 75 touchEvent.deviceId = 1; 76 touchEvent.force = 1.0f; 77 touchEvent.pointers.push_back(TouchPoint()); 78 79 ResponseLinkResult responseLinkRecognizers; 80 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>( 81 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 82 83 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); 84 ASSERT_NE(frameNode, nullptr); 85 auto eventHub = frameNode->GetOrCreateGestureEventHub(); 86 ASSERT_NE(eventHub, nullptr); 87 int32_t doneId = 0; 88 auto touchTestDoneFunc = [&doneId](const std::shared_ptr<BaseGestureEvent>& event, __anon6a8b7da90302(const std::shared_ptr<BaseGestureEvent>& event, const std::list<RefPtr<NGGestureRecognizer>>& recognizer) 89 const std::list<RefPtr<NGGestureRecognizer>>& recognizer) { doneId++; }; 90 eventHub->SetOnTouchTestDoneCallback(std::move(touchTestDoneFunc)); 91 eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr<NG::FrameNode>(frameNode)); 92 eventManager->ExecuteTouchTestDoneCallback(touchEvent, responseLinkRecognizers); 93 EXPECT_NE(doneId, 0); 94 } 95 96 /** 97 * @tc.name: ExecuteTouchTestDoneCallbackTest003 98 * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. 99 * @tc.type: FUNC 100 */ 101 HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest003, TestSize.Level1) 102 { 103 auto eventManager = AceType::MakeRefPtr<EventManager>(); 104 ASSERT_NE(eventManager, nullptr); 105 TouchEvent touchEvent; 106 touchEvent.deviceId = 1; 107 touchEvent.force = 1.0f; 108 touchEvent.pointers.push_back(TouchPoint()); 109 110 ResponseLinkResult responseLinkRecognizers; 111 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>( 112 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 113 114 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); 115 ASSERT_NE(frameNode, nullptr); 116 auto eventHub = frameNode->GetOrCreateGestureEventHub(); 117 ASSERT_NE(eventHub, nullptr); 118 int32_t doneInnerId = 0; 119 auto touchTestDoneForInnerFunc = [&doneInnerId](const std::shared_ptr<BaseGestureEvent>& event, __anon6a8b7da90402(const std::shared_ptr<BaseGestureEvent>& event, const std::list<RefPtr<NGGestureRecognizer>>& recognizer) 120 const std::list<RefPtr<NGGestureRecognizer>>& recognizer) { doneInnerId++; }; 121 eventHub->SetOnTouchTestDoneCallbackForInner(std::move(touchTestDoneForInnerFunc)); 122 eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr<NG::FrameNode>(frameNode)); 123 eventManager->ExecuteTouchTestDoneCallback(touchEvent, responseLinkRecognizers); 124 EXPECT_NE(doneInnerId, 0); 125 } 126 127 /** 128 * @tc.name: ExecuteTouchTestDoneCallbackTest004 129 * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. 130 * @tc.type: FUNC 131 */ 132 HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest004, TestSize.Level1) 133 { 134 auto eventManager = AceType::MakeRefPtr<EventManager>(); 135 ASSERT_NE(eventManager, nullptr); 136 TouchEvent touchEvent; 137 touchEvent.deviceId = 1; 138 touchEvent.force = 1.0f; 139 touchEvent.pointers.push_back(TouchPoint()); 140 141 ResponseLinkResult responseLinkRecognizers; 142 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>( 143 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 144 145 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); 146 ASSERT_NE(frameNode, nullptr); 147 auto eventHub = frameNode->GetOrCreateGestureEventHub(); 148 ASSERT_NE(eventHub, nullptr); 149 eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr<NG::FrameNode>(frameNode)); 150 eventManager->ExecuteTouchTestDoneCallback(touchEvent, responseLinkRecognizers); 151 EXPECT_FALSE(eventManager->onTouchTestDoneFrameNodeList_.empty()); 152 } 153 154 /** 155 * @tc.name: ExecuteTouchTestDoneCallbackTest005 156 * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. 157 * @tc.type: FUNC 158 */ 159 HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest005, TestSize.Level1) 160 { 161 auto eventManager = AceType::MakeRefPtr<EventManager>(); 162 ASSERT_NE(eventManager, nullptr); 163 AxisEvent axisEvent; 164 axisEvent.deviceId = 1; 165 166 ResponseLinkResult responseLinkRecognizers; 167 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>( 168 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 169 170 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); 171 ASSERT_NE(frameNode, nullptr); 172 auto eventHub = frameNode->GetOrCreateGestureEventHub(); 173 ASSERT_NE(eventHub, nullptr); 174 int32_t doneId = 0; 175 int32_t doneInnerId = 0; 176 auto touchTestDoneFunc = [&doneId](const std::shared_ptr<BaseGestureEvent>& event, __anon6a8b7da90502(const std::shared_ptr<BaseGestureEvent>& event, const std::list<RefPtr<NGGestureRecognizer>>& recognizer) 177 const std::list<RefPtr<NGGestureRecognizer>>& recognizer) { doneId++; }; 178 auto touchTestDoneForInnerFunc = [&doneInnerId](const std::shared_ptr<BaseGestureEvent>& event, __anon6a8b7da90602(const std::shared_ptr<BaseGestureEvent>& event, const std::list<RefPtr<NGGestureRecognizer>>& recognizer) 179 const std::list<RefPtr<NGGestureRecognizer>>& recognizer) { doneInnerId++; }; 180 eventHub->SetOnTouchTestDoneCallback(std::move(touchTestDoneFunc)); 181 eventHub->SetOnTouchTestDoneCallbackForInner(std::move(touchTestDoneForInnerFunc)); 182 eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr<NG::FrameNode>(frameNode)); 183 eventManager->ExecuteTouchTestDoneCallback(axisEvent, responseLinkRecognizers); 184 EXPECT_NE(doneId, 0); 185 EXPECT_NE(doneInnerId, 0); 186 } 187 188 /** 189 * @tc.name: ExecuteTouchTestDoneCallbackTest006 190 * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. 191 * @tc.type: FUNC 192 */ 193 HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest006, TestSize.Level1) 194 { 195 auto eventManager = AceType::MakeRefPtr<EventManager>(); 196 ASSERT_NE(eventManager, nullptr); 197 AxisEvent axisEvent; 198 axisEvent.deviceId = 1; 199 200 ResponseLinkResult responseLinkRecognizers; 201 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>( 202 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 203 204 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); 205 ASSERT_NE(frameNode, nullptr); 206 auto eventHub = frameNode->GetOrCreateGestureEventHub(); 207 ASSERT_NE(eventHub, nullptr); 208 int32_t doneId = 0; 209 auto touchTestDoneFunc = [&doneId](const std::shared_ptr<BaseGestureEvent>& event, __anon6a8b7da90702(const std::shared_ptr<BaseGestureEvent>& event, const std::list<RefPtr<NGGestureRecognizer>>& recognizer) 210 const std::list<RefPtr<NGGestureRecognizer>>& recognizer) { doneId++; }; 211 eventHub->SetOnTouchTestDoneCallback(std::move(touchTestDoneFunc)); 212 eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr<NG::FrameNode>(frameNode)); 213 eventManager->ExecuteTouchTestDoneCallback(axisEvent, responseLinkRecognizers); 214 EXPECT_NE(doneId, 0); 215 } 216 217 /** 218 * @tc.name: ExecuteTouchTestDoneCallbackTest007 219 * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. 220 * @tc.type: FUNC 221 */ 222 HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest007, TestSize.Level1) 223 { 224 auto eventManager = AceType::MakeRefPtr<EventManager>(); 225 ASSERT_NE(eventManager, nullptr); 226 AxisEvent axisEvent; 227 axisEvent.deviceId = 1; 228 229 ResponseLinkResult responseLinkRecognizers; 230 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>( 231 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 232 233 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); 234 ASSERT_NE(frameNode, nullptr); 235 auto eventHub = frameNode->GetOrCreateGestureEventHub(); 236 ASSERT_NE(eventHub, nullptr); 237 int32_t doneInnerId = 0; 238 auto touchTestDoneForInnerFunc = [&doneInnerId](const std::shared_ptr<BaseGestureEvent>& event, __anon6a8b7da90802(const std::shared_ptr<BaseGestureEvent>& event, const std::list<RefPtr<NGGestureRecognizer>>& recognizer) 239 const std::list<RefPtr<NGGestureRecognizer>>& recognizer) { doneInnerId++; }; 240 eventHub->SetOnTouchTestDoneCallbackForInner(std::move(touchTestDoneForInnerFunc)); 241 eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr<NG::FrameNode>(frameNode)); 242 eventManager->ExecuteTouchTestDoneCallback(axisEvent, responseLinkRecognizers); 243 EXPECT_NE(doneInnerId, 0); 244 } 245 246 /** 247 * @tc.name: ExecuteTouchTestDoneCallbackTest008 248 * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. 249 * @tc.type: FUNC 250 */ 251 HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest008, TestSize.Level1) 252 { 253 auto eventManager = AceType::MakeRefPtr<EventManager>(); 254 ASSERT_NE(eventManager, nullptr); 255 AxisEvent axisEvent; 256 axisEvent.deviceId = 1; 257 258 ResponseLinkResult responseLinkRecognizers; 259 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>( 260 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 261 262 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); 263 ASSERT_NE(frameNode, nullptr); 264 auto eventHub = frameNode->GetOrCreateGestureEventHub(); 265 ASSERT_NE(eventHub, nullptr); 266 eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr<NG::FrameNode>(frameNode)); 267 eventManager->ExecuteTouchTestDoneCallback(axisEvent, responseLinkRecognizers); 268 EXPECT_FALSE(eventManager->onTouchTestDoneFrameNodeList_.empty()); 269 } 270 271 /** 272 * @tc.name: AddTouchDelegate001 273 * @tc.desc: Test AddTouchDelegate function. 274 * @tc.type: FUNC 275 */ 276 HWTEST_F(EventManagerTestNg, AddTouchDelegate001, TestSize.Level1) 277 { 278 /** 279 * @tc.steps: step1. Create eventManager, delegate. 280 * @tc.expected: recognizers is not null and axis direction is correct. 281 */ 282 auto eventManager = AceType::MakeRefPtr<EventManager>(); 283 ASSERT_NE(eventManager, nullptr); 284 auto delegate = AceType::MakeRefPtr<TouchDelegateTest>(); 285 ASSERT_NE(delegate, nullptr); 286 287 /** 288 * @tc.steps: step2. Call AddTouchDelegate twice. 289 * @tc.expected: touchDelegatesMap_ is not empty and size is 2. 290 */ 291 eventManager->AddTouchDelegate(TOUCH_ID, delegate); 292 eventManager->AddTouchDelegate(TOUCH_ID, delegate); 293 EXPECT_FALSE(eventManager->touchDelegatesMap_.empty()); 294 EXPECT_EQ(eventManager->touchDelegatesMap_[TOUCH_ID].size(), 2); 295 296 /** 297 * @tc.steps: step3. Call UpdateTouchDelegate. 298 * @tc.expected: touchDelegatesMap_ is not empty and size is 1. 299 */ 300 eventManager->UpdateTouchDelegate(TOUCH_ID, delegate); 301 EXPECT_FALSE(eventManager->touchDelegatesMap_.empty()); 302 EXPECT_EQ(eventManager->touchDelegatesMap_[TOUCH_ID].size(), 1); 303 304 /** 305 * @tc.steps: step4. Call UpdateTouchDelegate when eventManager->touchDelegatesMap_ is empty. 306 * @tc.expected: touchDelegatesMap_ is not empty and size is 1. 307 */ 308 eventManager->UnregisterTouchDelegate(TOUCH_ID); 309 EXPECT_TRUE(eventManager->touchDelegatesMap_.empty()); 310 eventManager->UpdateTouchDelegate(TOUCH_ID, delegate); 311 EXPECT_FALSE(eventManager->touchDelegatesMap_.empty()); 312 EXPECT_EQ(eventManager->touchDelegatesMap_[TOUCH_ID].size(), 1); 313 314 /** 315 * @tc.steps: step5. Call UpdateTouchDelegate when eventManager->touchDelegatesMap_[TOUCH_ID] is empty. 316 * @tc.expected: touchDelegatesMap_ is not empty and size is 1. 317 */ 318 eventManager->touchDelegatesMap_[TOUCH_ID].clear(); 319 EXPECT_FALSE(eventManager->touchDelegatesMap_.empty()); 320 EXPECT_TRUE(eventManager->touchDelegatesMap_[TOUCH_ID].empty()); 321 eventManager->UpdateTouchDelegate(TOUCH_ID, delegate); 322 EXPECT_FALSE(eventManager->touchDelegatesMap_.empty()); 323 EXPECT_EQ(eventManager->touchDelegatesMap_[TOUCH_ID].size(), 1); 324 } 325 326 /** 327 * @tc.name: ExecuteTouchTestDoneCallbackTest009 328 * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. 329 * @tc.type: FUNC 330 */ 331 HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest009, TestSize.Level1) 332 { 333 auto eventManager = AceType::MakeRefPtr<EventManager>(); 334 ASSERT_NE(eventManager, nullptr); 335 TouchEvent touchEvent; 336 touchEvent.deviceId = 1; 337 touchEvent.force = 1.0f; 338 touchEvent.tiltX = 1.0f; 339 touchEvent.tiltY = 1.0f; 340 touchEvent.rollAngle = 1.0f; 341 touchEvent.pointers.push_back(TouchPoint()); 342 343 ResponseLinkResult responseLinkRecognizers; 344 auto panHorizontal1 = AceType::MakeRefPtr<PanRecognizer>( 345 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 346 347 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); 348 ASSERT_NE(frameNode, nullptr); 349 auto eventHub = frameNode->GetOrCreateGestureEventHub(); 350 ASSERT_NE(eventHub, nullptr); 351 eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr<NG::FrameNode>(frameNode)); 352 eventManager->ExecuteTouchTestDoneCallback(touchEvent, responseLinkRecognizers); 353 EXPECT_FALSE(eventManager->onTouchTestDoneFrameNodeList_.empty()); 354 } 355 356 /** 357 * @tc.name: EventManagerTestAxisEvent001 358 * @tc.desc: Test TouchTest with FrameNode AxisEvent 359 * @tc.type: FUNC 360 */ 361 HWTEST_F(EventManagerTestNg, EventManagerTestAxisEvent001, TestSize.Level1) 362 { 363 /** 364 * @tc.steps: step1. Create EventManager. 365 * @tc.expected: eventManager is not null. 366 */ 367 auto eventManager = AceType::MakeRefPtr<EventManager>(); 368 ASSERT_NE(eventManager, nullptr); 369 370 /** 371 * @tc.steps: step2. Create FrameNode and Call TouchTest 372 * @tc.expected: touchTestResults_ has the touchPoint.id of instance 373 */ 374 const int nodeId = 10002; 375 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr); 376 TouchRestrict touchRestrict; 377 EXPECT_TRUE(eventManager->axisTouchTestResults_.empty()); 378 379 std::vector<AxisAction> actionVec = { AxisAction::NONE, AxisAction::BEGIN, AxisAction::UPDATE, AxisAction::END, 380 AxisAction::CANCEL }; 381 for (auto i = 0; i < actionVec.size(); ++i) { 382 AxisEvent axisEvent; 383 axisEvent.sourceType = SourceType::TOUCH; 384 axisEvent.action = actionVec[i]; 385 eventManager->TouchTest(axisEvent, frameNode, touchRestrict); 386 } 387 EXPECT_FALSE(eventManager->axisTouchTestResults_.empty()); 388 } 389 390 /** 391 * @tc.name: EventManagerHandleGlobal001 392 * @tc.desc: Test HandleGlobalEventNG 393 * @tc.type: FUNC 394 */ 395 HWTEST_F(EventManagerTestNg, EventManagerHandleGlobal001, TestSize.Level1) 396 { 397 /** 398 * @tc.steps: step1. Create EventManager. 399 * @tc.expected: eventManager is not null. 400 */ 401 auto eventManager = AceType::MakeRefPtr<EventManager>(); 402 ASSERT_NE(eventManager, nullptr); 403 404 /** 405 * @tc.steps: step2. Do not Call TouchTest to add touchTestResults_[touchPoint.id] 406 * @tc.expected: touchTestResults_ has the touchPoint.id of instance 407 */ 408 TouchEvent touchPoint; 409 touchPoint.type = TouchType::DOWN; 410 touchPoint.sourceType = SourceType::MOUSE; 411 412 const int nodeId = 10003; 413 auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr); 414 415 /** 416 * @tc.steps: step3. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id] 417 * @tc.expected: selectOverlayManager->touchTestResults_ is empty for do not have specific event 418 */ 419 EXPECT_TRUE(eventManager->touchTestResults_.empty()); 420 auto selectOverlayManager = AceType::MakeRefPtr<SelectOverlayManager>(frameNode); 421 NG::OffsetF rootOffset; 422 eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset); 423 EXPECT_TRUE(selectOverlayManager->touchTestResults_.empty()); 424 } 425 426 /** 427 * @tc.name: EventManagerHandleOut001 428 * @tc.desc: Test HandleOutOfRectCallback 429 * @tc.type: FUNC 430 */ 431 HWTEST_F(EventManagerTestNg, EventManagerHandleOut001, TestSize.Level1) 432 { 433 /** 434 * @tc.steps: step1. Create EventManager. 435 * @tc.expected: eventManager is not null. 436 */ 437 auto eventManager = AceType::MakeRefPtr<EventManager>(); 438 ASSERT_NE(eventManager, nullptr); 439 440 /** 441 * @tc.steps: step2. Create rectCallbackList 442 * @tc.expected: touchTestResults_ has the touchPoint.id of instance 443 */ 444 Point point(10, 20); 445 point.SetSourceType(SourceType::TOUCH); 446 __anon6a8b7da90902(std::vector<Rect>& rectList) 447 auto rectGetCallback1 = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect()); }; __anon6a8b7da90a02(std::vector<Rect>& rectList) 448 auto rectGetCallback2 = [](std::vector<Rect>& rectList) -> void { rectList.push_back(Rect(0, 0, 100, 100)); }; 449 __anon6a8b7da90b02() 450 auto touchCallback = []() -> void {}; __anon6a8b7da90c02() 451 auto mouseCallback = []() -> void {}; 452 std::vector<RectCallback> rectCallbackList { 453 RectCallback(rectGetCallback1, touchCallback, mouseCallback), 454 RectCallback(rectGetCallback2, touchCallback, mouseCallback), 455 RectCallback(nullptr, touchCallback, mouseCallback), 456 RectCallback(rectGetCallback2, touchCallback, nullptr) 457 }; 458 459 /** 460 * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::TOUCH 461 * @tc.expected: rectCallbackList.size() is 3 462 */ 463 eventManager->HandleOutOfRectCallback(point, rectCallbackList); 464 EXPECT_EQ(rectCallbackList.size(), 3); 465 466 /** 467 * @tc.steps: step4. Call HandleOutOfRectCallback with SourceType::MOUSE 468 * @tc.expected: rectCallbackList.size() is not empty 469 */ 470 point.SetSourceType(SourceType::MOUSE); 471 eventManager->HandleOutOfRectCallback(point, rectCallbackList); 472 EXPECT_FALSE(rectCallbackList.empty()); 473 } 474 475 /** 476 * @tc.name: EventManagerFlushEnd001 477 * @tc.desc: Test FlushTouchEventsEnd 478 * @tc.type: FUNC 479 */ 480 HWTEST_F(EventManagerTestNg, EventManagerFlushEnd001, TestSize.Level1) 481 { 482 /** 483 * @tc.steps: step1. Create EventManager. 484 * @tc.expected: eventManager is not null. 485 */ 486 auto eventManager = AceType::MakeRefPtr<EventManager>(); 487 ASSERT_NE(eventManager, nullptr); 488 489 auto resultId = ElementRegister::GetInstance()->MakeUniqueId(); 490 TouchTestResult touchTestResults; 491 492 touchTestResults.push_back(AceType::MakeRefPtr<MockTouchEventTarget>()); 493 eventManager->touchTestResults_.emplace(resultId, touchTestResults); 494 495 TouchEvent event {}; 496 event.id = 1; 497 std::list<TouchEvent> touchEvents { event }; 498 eventManager->FlushTouchEventsEnd(touchEvents); 499 EXPECT_EQ(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end()); 500 501 TouchEvent event2 {}; 502 event2.id = resultId; 503 event2.history.push_back(event); 504 std::list<TouchEvent> touchEvents2 { event2 }; 505 eventManager->FlushTouchEventsEnd(touchEvents2); 506 EXPECT_NE(eventManager->touchTestResults_.find(event2.id), eventManager->touchTestResults_.end()); 507 } 508 509 /** 510 * @tc.name: EventManagerClearPenStylus001 511 * @tc.desc: Test ClearTouchTestTargetForPenStylus func 512 * @tc.type: FUNC 513 */ 514 HWTEST_F(EventManagerTestNg, EventManagerClearPenStylus001, TestSize.Level1) 515 { 516 auto eventManager = AceType::MakeRefPtr<EventManager>(); 517 ASSERT_NE(eventManager, nullptr); 518 auto resultId = ElementRegister::GetInstance()->MakeUniqueId(); 519 TouchTestResult touchTestResults; 520 auto panRecognizer = AceType::MakeRefPtr<PanRecognizer>( 521 DEFAULT_PAN_FINGER, PanDirection { PanDirection::NONE }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 522 touchTestResults.push_back(panRecognizer); 523 eventManager->touchTestResults_.emplace(resultId, touchTestResults); 524 TouchEvent event; 525 event.id = resultId; 526 RefPtr<GestureScope> scope = AceType::MakeRefPtr<GestureScope>(resultId); 527 ASSERT_NE(scope, nullptr); 528 ASSERT_NE(eventManager->refereeNG_, nullptr); 529 scope->AddMember(panRecognizer); 530 eventManager->refereeNG_->gestureScopes_.insert(std::make_pair(resultId, scope)); 531 eventManager->referee_->gestureScopes_.insert(std::make_pair(resultId, scope)); 532 eventManager->downFingerIds_[1] = 1; 533 eventManager->ClearTouchTestTargetForPenStylus(event); 534 EXPECT_EQ(event.id, 1); 535 } 536 537 /** 538 * @tc.name: EventManagerClearHover001 539 * @tc.desc: Test CleanHoverStatusForDragBegin. 540 * @tc.type: FUNC 541 */ 542 HWTEST_F(EventManagerTestNg, EventManagerClearHover001, TestSize.Level1) 543 { 544 auto eventManager = AceType::MakeRefPtr<EventManager>(); 545 ASSERT_NE(eventManager, nullptr); 546 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_TWELVE)); 547 548 MouseEvent event; 549 TouchTestResult touchTestResults; 550 auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>(); 551 touchTestResults.push_back(eventTarget); 552 eventManager->mouseTestResults_.emplace(event.id, touchTestResults); 553 eventManager->CleanHoverStatusForDragBegin(); 554 EXPECT_TRUE(eventManager->mouseTestResults_.empty()); 555 } 556 557 /** 558 * @tc.name: EventManagerClearHover002 559 * @tc.desc: Test CleanHoverStatusForDragBegin. 560 * @tc.type: FUNC 561 */ 562 HWTEST_F(EventManagerTestNg, EventManagerClearHover002, TestSize.Level1) 563 { 564 auto eventManager = AceType::MakeRefPtr<EventManager>(); 565 ASSERT_NE(eventManager, nullptr); 566 AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast<int32_t>(PlatformVersion::VERSION_ELEVEN)); 567 568 MouseEvent event; 569 TouchTestResult touchTestResults; 570 auto eventTarget = AceType::MakeRefPtr<MockTouchEventTarget>(); 571 touchTestResults.push_back(eventTarget); 572 eventManager->mouseTestResults_.emplace(event.id, touchTestResults); 573 eventManager->CleanHoverStatusForDragBegin(); 574 EXPECT_FALSE(eventManager->mouseTestResults_.empty()); 575 } 576 577 /** 578 * @tc.name: EventManagerUpdateHover001 579 * @tc.desc: Test UpdateAccessibilityHoverNode. 580 * @tc.type: FUNC 581 */ 582 HWTEST_F(EventManagerTestNg, EventManagerUpdateHover001, TestSize.Level1) 583 { 584 auto eventManager = AceType::MakeRefPtr<EventManager>(); 585 ASSERT_NE(eventManager, nullptr); 586 int32_t doneId = 0; 587 TouchEvent event; 588 TouchTestResult touchTestResults; 589 auto panRecognizer = AceType::MakeRefPtr<PanRecognizer>( 590 DEFAULT_PAN_FINGER, PanDirection { PanDirection::NONE }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 591 touchTestResults.push_back(panRecognizer); 592 eventManager->UpdateAccessibilityHoverNode(event, touchTestResults); 593 EXPECT_EQ(doneId, 0); 594 595 touchTestResults.clear(); 596 const int nodeId = 10008; 597 auto hoverEventTarget = AceType::MakeRefPtr<HoverEventTarget>(V2::LOCATION_BUTTON_ETS_TAG, nodeId); 598 touchTestResults.push_back(hoverEventTarget); 599 eventManager->UpdateAccessibilityHoverNode(event, touchTestResults); 600 EXPECT_EQ(doneId, 0); 601 602 touchTestResults.clear(); 603 hoverEventTarget->SetAccessibilityHoverCallback(nullptr); 604 touchTestResults.push_back(hoverEventTarget); 605 eventManager->UpdateAccessibilityHoverNode(event, touchTestResults); 606 EXPECT_EQ(doneId, 0); 607 608 touchTestResults.clear(); __anon6a8b7da90d02(bool, AccessibilityHoverInfo& info) 609 auto OnAccessibilityHoverFunc = [&doneId](bool, AccessibilityHoverInfo& info) { ++doneId; }; 610 hoverEventTarget->SetAccessibilityHoverCallback(OnAccessibilityHoverFunc); 611 touchTestResults.push_back(hoverEventTarget); 612 eventManager->UpdateAccessibilityHoverNode(event, touchTestResults); 613 EXPECT_EQ(doneId, 0); 614 } 615 616 /** 617 * @tc.name: EventManagerDispatchHover001 618 * @tc.desc: Test HandleMouseHoverAnimation 619 * @tc.type: FUNC 620 */ 621 HWTEST_F(EventManagerTestNg, EventManagerDispatchHover001, TestSize.Level1) 622 { 623 auto eventManager = AceType::MakeRefPtr<EventManager>(); 624 ASSERT_NE(eventManager, nullptr); 625 MouseEvent event; 626 627 eventManager->currHoverNode_ = nullptr; 628 eventManager->lastHoverNode_ = nullptr; 629 630 event.action = MouseAction::WINDOW_ENTER; 631 eventManager->DispatchMouseHoverAnimationNG(event, true); 632 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); 633 634 event.action = MouseAction::WINDOW_LEAVE; 635 eventManager->DispatchMouseHoverAnimationNG(event, true); 636 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); 637 638 eventManager->currHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr); 639 eventManager->lastHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr); 640 641 event.action = MouseAction::WINDOW_ENTER; 642 eventManager->DispatchMouseHoverAnimationNG(event, true); 643 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); 644 645 event.action = MouseAction::WINDOW_LEAVE; 646 eventManager->DispatchMouseHoverAnimationNG(event, true); 647 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); 648 } 649 650 /** 651 * @tc.name: CheckMousePendingRecognizersState001 652 * @tc.desc: Test CheckMousePendingRecognizersState function. 653 * @tc.type: FUNC 654 */ 655 HWTEST_F(EventManagerTestNg, CheckMousePendingRecognizersState001, TestSize.Level1) 656 { 657 auto eventManager = AceType::MakeRefPtr<EventManager>(); 658 ASSERT_NE(eventManager, nullptr); 659 auto panHorizontal = AceType::MakeRefPtr<PanRecognizer>( 660 DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 661 panHorizontal->refereeState_ = RefereeState::SUCCEED; 662 663 TouchEvent touchEvent; 664 touchEvent.sourceType = SourceType::MOUSE; 665 666 eventManager->AddToMousePendingRecognizers(panHorizontal); 667 eventManager->CheckMousePendingRecognizersState(touchEvent); 668 EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); 669 670 eventManager->CheckMousePendingRecognizersState(touchEvent); 671 EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); 672 673 panHorizontal->refereeState_ = RefereeState::PENDING; 674 eventManager->AddToMousePendingRecognizers(panHorizontal); 675 eventManager->CheckMousePendingRecognizersState(touchEvent); 676 EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); 677 678 panHorizontal->refereeState_ = RefereeState::PENDING_BLOCKED; 679 eventManager->AddToMousePendingRecognizers(panHorizontal); 680 eventManager->CheckMousePendingRecognizersState(touchEvent); 681 EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); 682 683 touchEvent.sourceType = SourceType::TOUCH; 684 eventManager->AddToMousePendingRecognizers(panHorizontal); 685 eventManager->CheckMousePendingRecognizersState(touchEvent); 686 EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); 687 } 688 689 /** 690 * @tc.name: DumpEventWithCount001 691 * @tc.desc: Test DumpEventWithCount function. 692 * @tc.type: FUNC 693 */ 694 HWTEST_F(EventManagerTestNg, DumpEventWithCount001, TestSize.Level1) 695 { 696 auto eventManager = AceType::MakeRefPtr<EventManager>(); 697 ASSERT_NE(eventManager, nullptr); 698 699 NG::EventTreeType type = EventTreeType::TOUCH; 700 bool hasJson = false; 701 std::string param0 = "dump"; 702 std::string param1 = "-n"; 703 std::string param2 = "0"; 704 std::string param3 = "any"; 705 std::string param4 = "-d"; 706 std::string param5 = "3"; 707 std::string param6 = "6"; 708 709 std::vector<std::string> params0 = { param0 }; 710 eventManager->DumpEventWithCount(params0, type, hasJson); 711 std::vector<std::string> params1 = { param0, param1 }; 712 eventManager->DumpEventWithCount(params1, type, hasJson); 713 std::vector<std::string> params2 = { param0, param1, param2 }; 714 eventManager->DumpEventWithCount(params2, type, hasJson); 715 std::vector<std::string> params3 = { param0, param1, param2, param3 }; 716 eventManager->DumpEventWithCount(params3, type, hasJson); 717 std::vector<std::string> params4 = { param0, param4, param2, param3 }; 718 eventManager->DumpEventWithCount(params3, type, hasJson); 719 std::vector<std::string> params5 = { param0, param1, param6, param3 }; 720 eventManager->DumpEventWithCount(params5, type, hasJson); 721 std::vector<std::string> params6 = { param0, param1, param5, param3 }; 722 eventManager->DumpEventWithCount(params6, type, hasJson); 723 EXPECT_FALSE(hasJson); 724 } 725 726 /** 727 * @tc.name: TouchDelegate002 728 * @tc.desc: Test TouchDelegate 729 */ 730 HWTEST_F(EventManagerTestNg, TouchDelegate002, TestSize.Level1) 731 { 732 auto eventManager = AceType::MakeRefPtr<EventManager>(); 733 ASSERT_NE(eventManager, nullptr); 734 735 int32_t touchId = -1; 736 auto delegater1 = AceType::MakeRefPtr<NG::TouchDelegate>(); 737 auto delegater2 = AceType::MakeRefPtr<NG::TouchDelegate>(); 738 739 auto handler = eventManager->AddTouchDelegate(touchId, delegater1); 740 handler = eventManager->UpdateTouchDelegate(touchId, delegater2); 741 eventManager->touchDelegatesMap_.clear(); 742 eventManager->UnregisterTouchDelegate(handler); 743 EXPECT_TRUE(eventManager->touchDelegatesMap_.empty()); 744 745 handler = eventManager->AddTouchDelegate(touchId, delegater1); 746 EXPECT_EQ(eventManager->touchDelegatesMap_[touchId].size(), 1); 747 eventManager->UnregisterTouchDelegate(touchId - 1); 748 eventManager->UnregisterTouchDelegate(touchId); 749 EXPECT_TRUE(eventManager->touchDelegatesMap_.empty()); 750 751 TouchEvent touchEvent; 752 touchEvent.id = touchId; 753 eventManager->DelegateTouchEvent(touchEvent); 754 } 755 756 /** 757 * @tc.name: TouchDelegate003 758 * @tc.desc: Test TouchDelegate 759 */ 760 HWTEST_F(EventManagerTestNg, TouchDelegate003, TestSize.Level1) 761 { 762 auto eventManager = AceType::MakeRefPtr<EventManager>(); 763 ASSERT_NE(eventManager, nullptr); 764 int32_t touchId = 1; 765 auto delegater1 = AceType::MakeRefPtr<NG::TouchDelegate>(); 766 auto delegater2 = AceType::MakeRefPtr<NG::TouchDelegate>(); 767 768 auto handler = eventManager->AddTouchDelegate(touchId, delegater1); 769 handler = eventManager->UpdateTouchDelegate(touchId, delegater2); 770 eventManager->touchDelegatesMap_.clear(); 771 eventManager->UnregisterTouchDelegate(handler); 772 EXPECT_TRUE(eventManager->touchDelegatesMap_.empty()); 773 774 handler = eventManager->AddTouchDelegate(touchId, delegater1); 775 EXPECT_EQ(eventManager->touchDelegatesMap_[touchId].size(), 1); 776 eventManager->UnregisterTouchDelegate(touchId - 1); 777 eventManager->UnregisterTouchDelegate(touchId); 778 EXPECT_TRUE(eventManager->touchDelegatesMap_.empty()); 779 780 TouchEvent touchEvent; 781 touchEvent.id = touchId; 782 eventManager->DelegateTouchEvent(touchEvent); 783 } 784 785 /** 786 * @tc.name: TryResampleTouchEvent001 787 * @tc.desc: Test TryResampleTouchEvent function. 788 * @tc.type: FUNC 789 */ 790 HWTEST_F(EventManagerTestNg, TryResampleTouchEvent001, TestSize.Level1) 791 { 792 auto eventManager = AceType::MakeRefPtr<EventManager>(); 793 ASSERT_NE(eventManager, nullptr); 794 std::vector<TouchEvent> history; 795 std::vector<TouchEvent> current; 796 TouchEvent touchEvent1; 797 touchEvent1.SetTargetDisplayId(1); 798 TouchEvent touchEvent2; 799 touchEvent2.SetTargetDisplayId(1); 800 801 uint64_t resampleTime1 = 0.5 * 1000 * 1000; 802 std::chrono::nanoseconds nanoseconds1(resampleTime1); 803 TimeStamp ts1(nanoseconds1); 804 touchEvent1.time = ts1; 805 uint64_t resampleTime2 = 3 * 1000 * 1000; 806 std::chrono::nanoseconds nanoseconds2(resampleTime2); 807 TimeStamp ts2(nanoseconds2); 808 touchEvent2.time = ts2; 809 current.push_back(touchEvent1); 810 current.push_back(touchEvent2); 811 TouchEvent resample; 812 uint64_t resampleTime = 4 * 1000 * 1000; 813 814 SystemProperties::debugEnabled_ = true; 815 bool ret = eventManager->TryResampleTouchEvent(history, current, resampleTime, resample); 816 EXPECT_TRUE(ret); 817 818 SystemProperties::debugEnabled_ = false; 819 ret = eventManager->TryResampleTouchEvent(history, current, resampleTime, resample); 820 EXPECT_FALSE(ret); 821 } 822 823 /** 824 * @tc.name: TryResampleTouchEvent002 825 * @tc.desc: Test TryResampleTouchEvent function. 826 * @tc.type: FUNC 827 */ 828 HWTEST_F(EventManagerTestNg, TryResampleTouchEvent002, TestSize.Level1) 829 { 830 auto eventManager = AceType::MakeRefPtr<EventManager>(); 831 ASSERT_NE(eventManager, nullptr); 832 std::vector<TouchEvent> history; 833 std::vector<TouchEvent> current; 834 TouchEvent resample; 835 uint64_t resampleTime = 4 * 1000 * 1000; 836 837 SystemProperties::debugEnabled_ = true; 838 bool ret = eventManager->TryResampleTouchEvent(history, current, resampleTime, resample); 839 EXPECT_FALSE(ret); 840 841 TouchEvent touchEvent1; 842 touchEvent1.SetTargetDisplayId(1); 843 TouchEvent touchEvent2; 844 touchEvent2.SetTargetDisplayId(2); 845 current.push_back(touchEvent1); 846 current.push_back(touchEvent2); 847 ret = eventManager->TryResampleTouchEvent(history, current, resampleTime, resample); 848 EXPECT_FALSE(ret); 849 } 850 851 /** 852 * @tc.name: GetResamplePointerEvent001 853 * @tc.desc: Test GetResamplePointerEvent function. 854 * @tc.type: FUNC 855 */ 856 HWTEST_F(EventManagerTestNg, GetResamplePointerEvent001, TestSize.Level1) 857 { 858 std::vector<TouchEvent> events; 859 TouchEvent touchEvent1; 860 TouchEvent touchEvent2; 861 862 uint64_t resampleTime1 = 0.5 * 1000 * 1000; 863 std::chrono::nanoseconds nanoseconds1(resampleTime1); 864 TimeStamp ts1(nanoseconds1); 865 touchEvent1.time = ts1; 866 uint64_t resampleTime2 = 3 * 1000 * 1000; 867 std::chrono::nanoseconds nanoseconds2(resampleTime2); 868 TimeStamp ts2(nanoseconds2); 869 touchEvent2.time = ts2; 870 events.push_back(touchEvent1); 871 events.push_back(touchEvent2); 872 TouchEvent resample; 873 uint64_t resampleTime = 4 * 1000 * 1000; 874 875 ResamplePoint slope; 876 SystemProperties::debugEnabled_ = true; 877 bool ret = ResampleAlgo::GetResamplePointerEvent(events, resampleTime, resample, slope); 878 EXPECT_TRUE(ret); 879 } 880 881 /** 882 * @tc.name: GetResampleTouchEvent005 883 * @tc.desc: Test GetResampleTouchEvent function. 884 * @tc.type: FUNC 885 */ 886 HWTEST_F(EventManagerTestNg, GetResampleTouchEvent005, TestSize.Level1) 887 { 888 auto eventManager = AceType::MakeRefPtr<EventManager>(); 889 ASSERT_NE(eventManager, nullptr); 890 891 std::vector<TouchEvent> history; 892 std::vector<TouchEvent> current; 893 TouchEvent touchEvent1; 894 touchEvent1.SetTargetDisplayId(1); 895 TouchEvent touchEvent2; 896 touchEvent2.SetTargetDisplayId(2); 897 898 uint64_t resampleTime1 = 2 * 1000 * 1000; 899 std::chrono::nanoseconds nanoseconds1(resampleTime1); 900 TimeStamp ts1(nanoseconds1); 901 touchEvent1.time = ts1; 902 touchEvent2.time = ts1; 903 current.push_back(touchEvent1); 904 current.push_back(touchEvent2); 905 TouchEvent newEvent; 906 uint64_t resampleTime = 3 * 1000 * 1000; 907 908 SystemProperties::debugEnabled_ = true; 909 bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); 910 EXPECT_FALSE(ret); 911 } 912 913 /** 914 * @tc.name: GetResampleTouchEvent006 915 * @tc.desc: Test GetResampleTouchEvent function. 916 * @tc.type: FUNC 917 */ 918 HWTEST_F(EventManagerTestNg, GetResampleTouchEvent006, TestSize.Level1) 919 { 920 auto eventManager = AceType::MakeRefPtr<EventManager>(); 921 ASSERT_NE(eventManager, nullptr); 922 923 std::vector<TouchEvent> history; 924 std::vector<TouchEvent> current; 925 TouchEvent touchEvent1; 926 touchEvent1.SetTargetDisplayId(1); 927 TouchEvent touchEvent2; 928 touchEvent2.SetTargetDisplayId(2); 929 930 uint64_t resampleTime1 = 2 * 1000 * 1000; 931 std::chrono::nanoseconds nanoseconds1(resampleTime1); 932 TimeStamp ts1(nanoseconds1); 933 touchEvent1.time = ts1; 934 touchEvent2.time = ts1; 935 current.push_back(touchEvent1); 936 current.push_back(touchEvent2); 937 TouchEvent newEvent; 938 uint64_t resampleTime = 1 * 1000 * 1000; 939 940 SystemProperties::debugEnabled_ = true; 941 bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); 942 EXPECT_FALSE(ret); 943 } 944 945 /** 946 * @tc.name: GetResampleMouseEvent005 947 * @tc.desc: Test GetResampleMouseEvent function. 948 * @tc.type: FUNC 949 */ 950 HWTEST_F(EventManagerTestNg, GetResampleMouseEvent005, TestSize.Level1) 951 { 952 auto eventManager = AceType::MakeRefPtr<EventManager>(); 953 ASSERT_NE(eventManager, nullptr); 954 955 std::vector<MouseEvent> history; 956 std::vector<MouseEvent> current; 957 MouseEvent mouseEvent1; 958 mouseEvent1.targetDisplayId = 1; 959 MouseEvent mouseEvent2; 960 mouseEvent2.targetDisplayId = 2; 961 962 uint64_t resampleTime1 = 2 * 1000 * 1000; 963 std::chrono::nanoseconds nanoseconds1(resampleTime1); 964 TimeStamp ts1(nanoseconds1); 965 mouseEvent1.time = ts1; 966 mouseEvent2.time = ts1; 967 current.push_back(mouseEvent1); 968 current.push_back(mouseEvent2); 969 uint64_t resampleTime = 3 * 1000 * 1000; 970 971 SystemProperties::debugEnabled_ = true; 972 auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); 973 EXPECT_EQ(mouseEvent.x, 0.0f); 974 } 975 976 /** 977 * @tc.name: GetResampleMouseEvent006 978 * @tc.desc: Test GetResampleMouseEvent function. 979 * @tc.type: FUNC 980 */ 981 HWTEST_F(EventManagerTestNg, GetResampleMouseEvent006, TestSize.Level1) 982 { 983 auto eventManager = AceType::MakeRefPtr<EventManager>(); 984 ASSERT_NE(eventManager, nullptr); 985 986 std::vector<MouseEvent> history; 987 std::vector<MouseEvent> current; 988 MouseEvent mouseEvent1; 989 mouseEvent1.targetDisplayId = 1; 990 MouseEvent mouseEvent2; 991 mouseEvent2.targetDisplayId = 2; 992 993 uint64_t resampleTime1 = 2 * 1000 * 1000; 994 std::chrono::nanoseconds nanoseconds1(resampleTime1); 995 TimeStamp ts1(nanoseconds1); 996 mouseEvent1.time = ts1; 997 mouseEvent2.time = ts1; 998 current.push_back(mouseEvent1); 999 current.push_back(mouseEvent2); 1000 uint64_t resampleTime = 1 * 1000 * 1000; 1001 1002 SystemProperties::debugEnabled_ = true; 1003 auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); 1004 EXPECT_EQ(mouseEvent.x, 0.0f); 1005 } 1006 1007 /** 1008 * @tc.name: GetResamplePointerEvent005 1009 * @tc.desc: Test GetResamplePointerEvent function. 1010 * @tc.type: FUNC 1011 */ 1012 HWTEST_F(EventManagerTestNg, GetResamplePointerEvent005, TestSize.Level1) 1013 { 1014 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1015 ASSERT_NE(eventManager, nullptr); 1016 1017 std::vector<DragPointerEvent> history; 1018 std::vector<DragPointerEvent> current; 1019 DragPointerEvent dragPointerEvent1; 1020 dragPointerEvent1.targetWindowId = 1; 1021 DragPointerEvent dragPointerEvent2; 1022 dragPointerEvent2.targetWindowId = 2; 1023 1024 uint64_t resampleTime1 = 2 * 1000 * 1000; 1025 std::chrono::nanoseconds nanoseconds1(resampleTime1); 1026 TimeStamp ts1(nanoseconds1); 1027 dragPointerEvent1.time = ts1; 1028 dragPointerEvent2.time = ts1; 1029 current.push_back(dragPointerEvent1); 1030 current.push_back(dragPointerEvent2); 1031 uint64_t resampleTime = 3 * 1000 * 1000; 1032 1033 SystemProperties::debugEnabled_ = true; 1034 auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); 1035 EXPECT_EQ(dragPointerEvent.x, 0.0f); 1036 } 1037 1038 /** 1039 * @tc.name: GetResamplePointerEvent006 1040 * @tc.desc: Test GetResamplePointerEvent function. 1041 * @tc.type: FUNC 1042 */ 1043 HWTEST_F(EventManagerTestNg, GetResamplePointerEvent006, TestSize.Level1) 1044 { 1045 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1046 ASSERT_NE(eventManager, nullptr); 1047 1048 std::vector<DragPointerEvent> history; 1049 std::vector<DragPointerEvent> current; 1050 DragPointerEvent dragPointerEvent1; 1051 dragPointerEvent1.targetWindowId = 1; 1052 DragPointerEvent dragPointerEvent2; 1053 dragPointerEvent2.targetWindowId = 2; 1054 1055 uint64_t resampleTime1 = 2 * 1000 * 1000; 1056 std::chrono::nanoseconds nanoseconds1(resampleTime1); 1057 TimeStamp ts1(nanoseconds1); 1058 dragPointerEvent1.time = ts1; 1059 dragPointerEvent2.time = ts1; 1060 current.push_back(dragPointerEvent1); 1061 current.push_back(dragPointerEvent2); 1062 uint64_t resampleTime = 1 * 1000 * 1000; 1063 1064 SystemProperties::debugEnabled_ = true; 1065 auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); 1066 EXPECT_EQ(dragPointerEvent.x, 0.0f); 1067 } 1068 1069 /** 1070 * @tc.name: GetResampleTouchEvent0012 1071 * @tc.desc: Test GetResampleTouchEvent function. 1072 * @tc.type: FUNC 1073 */ 1074 HWTEST_F(EventManagerTestNg, GetResampleTouchEvent0012, TestSize.Level1) 1075 { 1076 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1077 ASSERT_NE(eventManager, nullptr); 1078 std::vector<TouchEvent> history; 1079 std::vector<TouchEvent> current; 1080 TouchEvent touchEvent1; 1081 touchEvent1.SetTargetDisplayId(1); 1082 TouchEvent touchEvent2; 1083 touchEvent2.SetTargetDisplayId(1); 1084 1085 uint64_t resampleTime1 = 2 * 1000 * 1000; 1086 std::chrono::nanoseconds nanoseconds1(resampleTime1); 1087 TimeStamp ts1(nanoseconds1); 1088 touchEvent1.time = ts1; 1089 touchEvent2.time = ts1; 1090 history.push_back(touchEvent1); 1091 1092 TouchEvent newEvent; 1093 uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; 1094 std::vector<std::pair<float, float>> xyVec = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}}; 1095 for (auto xy : xyVec) { 1096 current.clear(); 1097 touchEvent2.x = xy.first; 1098 touchEvent2.y = xy.second; 1099 current.push_back(touchEvent2); 1100 1101 SystemProperties::debugEnabled_ = true; 1102 bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); 1103 if (xy.first == 1.0f && xy.second == 1.0f) { 1104 EXPECT_TRUE(ret); 1105 } else { 1106 EXPECT_FALSE(ret); 1107 } 1108 1109 SystemProperties::debugEnabled_ = false; 1110 ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); 1111 if (xy.first == 1.0f && xy.second == 1.0f) { 1112 EXPECT_TRUE(ret); 1113 } else { 1114 EXPECT_FALSE(ret); 1115 } 1116 } 1117 } 1118 1119 /** 1120 * @tc.name: GetResampleMouseEvent0012 1121 * @tc.desc: Test GetResampleMouseEvent function. 1122 * @tc.type: FUNC 1123 */ 1124 HWTEST_F(EventManagerTestNg, GetResampleMouseEvent0012, TestSize.Level1) 1125 { 1126 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1127 ASSERT_NE(eventManager, nullptr); 1128 std::vector<MouseEvent> history; 1129 std::vector<MouseEvent> current; 1130 MouseEvent mouseEvent1; 1131 mouseEvent1.targetDisplayId = 1; 1132 MouseEvent mouseEvent2; 1133 mouseEvent2.targetDisplayId = 1; 1134 1135 uint64_t resampleTime1 = 2 * 1000 * 1000; 1136 std::chrono::nanoseconds nanoseconds1(resampleTime1); 1137 TimeStamp ts1(nanoseconds1); 1138 mouseEvent1.time = ts1; 1139 mouseEvent2.time = ts1; 1140 history.push_back(mouseEvent1); 1141 uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; 1142 1143 std::vector<std::pair<float, float>> xyVec = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}}; 1144 for (auto xy : xyVec) { 1145 current.clear(); 1146 mouseEvent2.x = xy.first; 1147 mouseEvent2.y = xy.second; 1148 current.push_back(mouseEvent2); 1149 1150 SystemProperties::debugEnabled_ = true; 1151 auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); 1152 EXPECT_EQ(mouseEvent.x, xy.first); 1153 1154 SystemProperties::debugEnabled_ = false; 1155 mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); 1156 EXPECT_EQ(mouseEvent.x, xy.first); 1157 } 1158 } 1159 1160 /** 1161 * 1162 * @tc.name: GetResamplePointerEvent0012 1163 * @tc.desc: Test GetResamplePointerEvent function. 1164 * @tc.type: FUNC 1165 */ 1166 HWTEST_F(EventManagerTestNg, GetResamplePointerEvent0012, TestSize.Level1) 1167 { 1168 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1169 ASSERT_NE(eventManager, nullptr); 1170 1171 std::vector<DragPointerEvent> history; 1172 std::vector<DragPointerEvent> current; 1173 DragPointerEvent dragPointerEvent1; 1174 dragPointerEvent1.targetWindowId = 1; 1175 DragPointerEvent dragPointerEvent2; 1176 dragPointerEvent2.targetWindowId = 1; 1177 1178 uint64_t resampleTime1 = 2 * 1000 * 1000; 1179 std::chrono::nanoseconds nanoseconds1(resampleTime1); 1180 TimeStamp ts1(nanoseconds1); 1181 dragPointerEvent1.time = ts1; 1182 dragPointerEvent2.time = ts1; 1183 history.push_back(dragPointerEvent1); 1184 uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; 1185 1186 std::vector<std::pair<float, float>> xyVec = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}}; 1187 for (auto xy : xyVec) { 1188 current.clear(); 1189 dragPointerEvent2.x = xy.first; 1190 dragPointerEvent2.y = xy.second; 1191 current.push_back(dragPointerEvent2); 1192 1193 SystemProperties::debugEnabled_ = true; 1194 auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); 1195 EXPECT_EQ(dragPointerEvent.x, xy.first); 1196 1197 SystemProperties::debugEnabled_ = false; 1198 dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); 1199 EXPECT_EQ(dragPointerEvent.x, xy.first); 1200 } 1201 } 1202 1203 /** 1204 * @tc.name: HandleMouseHoverAnimation001 1205 * @tc.desc: Test HandleMouseHoverAnimation 1206 * @tc.type: FUNC 1207 */ 1208 HWTEST_F(EventManagerTestNg, HandleMouseHoverAnimation001, TestSize.Level1) 1209 { 1210 /** 1211 * @tc.steps: step1. Create EventManager. 1212 * @tc.expected: eventManager is not null. 1213 */ 1214 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1215 ASSERT_NE(eventManager, nullptr); 1216 MouseEvent event; 1217 /** 1218 * @tc.steps: step2. Test mock event. 1219 * @tc.expected: currHoverNode is not null. 1220 */ 1221 eventManager->currHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr); 1222 eventManager->lastHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 1, nullptr); 1223 event.action = MouseAction::WINDOW_LEAVE; 1224 eventManager->DispatchMouseHoverAnimationNG(event, true); 1225 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); 1226 eventManager->lastHoverNode_ = nullptr; 1227 event.action = MouseAction::WINDOW_LEAVE; 1228 eventManager->DispatchMouseHoverAnimationNG(event, true); 1229 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); 1230 /** 1231 * @tc.steps: step3. Test normal event. 1232 * @tc.expected: currHoverNode is not null. 1233 */ 1234 eventManager->currHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr); 1235 eventManager->lastHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 1, nullptr); 1236 event.action = MouseAction::WINDOW_LEAVE; 1237 eventManager->DispatchMouseHoverAnimationNG(event, false); 1238 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); 1239 eventManager->lastHoverNode_ = nullptr; 1240 event.action = MouseAction::WINDOW_LEAVE; 1241 eventManager->DispatchMouseHoverAnimationNG(event, false); 1242 EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); 1243 } 1244 1245 /** 1246 * @tc.name: UpdateInfoWhenFinishDispatch001 1247 * @tc.desc: Test UpdateInfoWhenFinishDispatch function. 1248 * @tc.type: FUNC 1249 */ 1250 HWTEST_F(EventManagerTestNg, UpdateInfoWhenFinishDispatch001, TestSize.Level1) 1251 { 1252 /** 1253 * @tc.step1: Create EventManager. 1254 * @tc.expected: eventManager is not null. 1255 */ 1256 auto eventManager = AceType::MakeRefPtr<EventManager>(); 1257 ASSERT_NE(eventManager, nullptr); 1258 1259 /** 1260 * @tc.step2: Set refereeNG_ and touchTestResults_. 1261 * @tc.expected: refereeNG_ and touchTestResults_ not null. 1262 */ 1263 auto resultId = ElementRegister::GetInstance()->MakeUniqueId(); 1264 TouchTestResult touchTestResults; 1265 auto panRecognizer = AceType::MakeRefPtr<PanRecognizer>( 1266 DEFAULT_PAN_FINGER, PanDirection { PanDirection::NONE }, DEFAULT_PAN_DISTANCE.ConvertToPx()); 1267 panRecognizer->OnPending(); 1268 touchTestResults.push_back(panRecognizer); 1269 eventManager->touchTestResults_.emplace(resultId, touchTestResults); 1270 RefPtr<GestureScope> scope = AceType::MakeRefPtr<GestureScope>(resultId); 1271 ASSERT_NE(scope, nullptr); 1272 ASSERT_NE(eventManager->refereeNG_, nullptr); 1273 scope->AddMember(panRecognizer); 1274 eventManager->refereeNG_->gestureScopes_.insert(std::make_pair(resultId, scope)); 1275 TouchEvent event; 1276 event.id = resultId; 1277 event.type = TouchType::UP; 1278 event.sourceTool = SourceTool::FINGER; 1279 event.isFalsified = true; 1280 1281 /** 1282 * @tc.step3: Set refereeNG_ and touchTestResults_. 1283 * @tc.expected: refereeNG_ and touchTestResults_ not null. 1284 */ 1285 eventManager->UpdateInfoWhenFinishDispatch(event, true); 1286 EXPECT_FALSE(eventManager->touchTestResults_.empty()); 1287 1288 event.type = TouchType::DOWN; 1289 eventManager->UpdateInfoWhenFinishDispatch(event, true); 1290 EXPECT_FALSE(eventManager->touchTestResults_.empty()); 1291 1292 event.type = TouchType::CANCEL; 1293 eventManager->UpdateInfoWhenFinishDispatch(event, true); 1294 EXPECT_FALSE(eventManager->touchTestResults_.empty()); 1295 1296 event.type = TouchType::UP; 1297 event.isFalsified = false; 1298 eventManager->UpdateInfoWhenFinishDispatch(event, true); 1299 EXPECT_EQ(eventManager->lastSourceTool_, SourceTool::FINGER); 1300 1301 event.type = TouchType::CANCEL; 1302 event.isFalsified = false; 1303 eventManager->lastSourceTool_ = SourceTool::UNKNOWN; 1304 eventManager->UpdateInfoWhenFinishDispatch(event, true); 1305 EXPECT_EQ(eventManager->lastSourceTool_, SourceTool::FINGER); 1306 } 1307 } // namespace OHOS::Ace::NG