1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "event/ui_input_event_impl.h" 17 #include "gtest/gtest.h" 18 #include "interfaces/native/node/event_converter.h" 19 #include "native_node.h" 20 #include "ui_input_event.h" 21 #include "frameworks/core/event/ace_events.h" 22 #include "frameworks/core/event/axis_event.h" 23 24 using namespace testing; 25 using namespace testing::ext; 26 namespace OHOS::Ace { 27 namespace { 28 constexpr int32_t ARKUI_EVENT_NULL = -1; 29 constexpr int32_t ARKUI_EVENT_ACTION = 1; 30 constexpr int32_t ARKUI_MOUSE_ACTION = 0; 31 } // namespace 32 class UIInputEventTest : public testing::Test { 33 public: SetUpTestSuite()34 static void SetUpTestSuite() {} TearDownTestSuite()35 static void TearDownTestSuite() {} 36 }; 37 38 /** 39 * @tc.name:UIInputEventGetType001 OH_ArkUI_UIInputEvent_GetType 40 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 41 * @tc.type: FUNC 42 */ 43 HWTEST_F(UIInputEventTest, UIInputEventGetType001, TestSize.Level1) 44 { 45 /** 46 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called 47 */ 48 ArkUI_NodeEvent nodeEvent; 49 ArkUINodeEvent event; 50 ArkUI_UIInputEvent uiInputEvent; 51 uiInputEvent.inputEvent = &event.clickEvent; 52 uiInputEvent.eventTypeId = C_CLICK_EVENT_ID; 53 nodeEvent.origin = &uiInputEvent; 54 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 55 56 auto sourceType = OH_ArkUI_UIInputEvent_GetType(inputEvent); 57 EXPECT_NE(sourceType, UI_INPUT_EVENTT_SOURCE_TYPE_MOUSE); 58 59 inputEvent = nullptr; 60 sourceType = OH_ArkUI_UIInputEvent_GetType(inputEvent); 61 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 62 } 63 64 /** 65 * @tc.name:UIInputEventGetAction001 OH_ArkUI_UIInputEvent_GetAction 66 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 67 * @tc.type: FUNC 68 */ 69 HWTEST_F(UIInputEventTest, UIInputEventGetAction001, TestSize.Level1) 70 { 71 /** 72 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 73 */ 74 ArkUI_NodeEvent nodeEvent; 75 ArkUI_UIInputEvent uiInputEvent; 76 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 77 nodeEvent.origin = &uiInputEvent; 78 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 79 80 auto sourceType = OH_ArkUI_UIInputEvent_GetAction(inputEvent); 81 EXPECT_EQ(sourceType, ARKUI_EVENT_NULL); 82 83 inputEvent = nullptr; 84 sourceType = OH_ArkUI_UIInputEvent_GetAction(inputEvent); 85 EXPECT_EQ(sourceType, ARKUI_EVENT_NULL); 86 } 87 88 /** 89 * @tc.name:UIInputEventGetAction002 90 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 91 * @tc.type: FUNC 92 */ 93 HWTEST_F(UIInputEventTest, UIInputEventGetAction002, TestSize.Level1) 94 { 95 /** 96 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 97 */ 98 ArkUI_NodeEvent nodeEvent; 99 ArkUINodeEvent event; 100 ArkUI_UIInputEvent uiInputEvent; 101 uiInputEvent.inputEvent = &event.clickEvent; 102 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 103 nodeEvent.origin = &uiInputEvent; 104 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 105 106 auto sourceType = OH_ArkUI_UIInputEvent_GetAction(inputEvent); 107 EXPECT_EQ(sourceType, ARKUI_EVENT_ACTION); 108 } 109 110 /** 111 * @tc.name:UIInputEventGetAction003 112 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 113 * @tc.type: FUNC 114 */ 115 HWTEST_F(UIInputEventTest, UIInputEventGetAction003, TestSize.Level1) 116 { 117 /** 118 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 119 */ 120 ArkUI_NodeEvent nodeEvent; 121 ArkUI_UIInputEvent uiInputEvent; 122 uiInputEvent.eventTypeId = C_MOUSE_EVENT_ID; 123 nodeEvent.origin = &uiInputEvent; 124 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 125 126 auto sourceType = OH_ArkUI_UIInputEvent_GetAction(inputEvent); 127 EXPECT_EQ(sourceType, ARKUI_EVENT_NULL); 128 } 129 130 /** 131 * @tc.name:UIInputEventGetAction004 132 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 133 * @tc.type: FUNC 134 */ 135 HWTEST_F(UIInputEventTest, UIInputEventGetAction004, TestSize.Level1) 136 { 137 /** 138 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 139 */ 140 ArkUI_NodeEvent nodeEvent; 141 ArkUINodeEvent event; 142 ArkUI_UIInputEvent uiInputEvent; 143 uiInputEvent.inputEvent = &event.clickEvent; 144 uiInputEvent.eventTypeId = C_MOUSE_EVENT_ID; 145 nodeEvent.origin = &uiInputEvent; 146 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 147 148 auto sourceType = OH_ArkUI_UIInputEvent_GetAction(inputEvent); 149 EXPECT_EQ(sourceType, ARKUI_MOUSE_ACTION); 150 } 151 152 /** 153 * @tc.name:PointerEventGetPointerId001 OH_ArkUI_PointerEvent_GetPointerId 154 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 155 * @tc.type: FUNC 156 */ 157 HWTEST_F(UIInputEventTest, PointerEventGetPointerId001, TestSize.Level1) 158 { 159 /** 160 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 161 */ 162 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 163 EXPECT_NE(uiInputEvent, nullptr); 164 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 165 166 uint32_t pointerIndex = 0; 167 ArkUINodeEvent event; 168 event.touchEvent.touchPointSize = 1; 169 ArkUITouchPoint points[2]; 170 points[0].operatingHand = ARKUI_EVENT_HAND_LEFT; 171 points[1].operatingHand = ARKUI_EVENT_HAND_RIGHT; 172 event.touchEvent.touchPointes = points; 173 auto sourceType = OH_ArkUI_PointerEvent_GetPointerId(uiInputEvent.get(), pointerIndex); 174 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 175 } 176 177 /** 178 * @tc.name:PointerEventGetPointerId002 179 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 180 * @tc.type: FUNC 181 */ 182 HWTEST_F(UIInputEventTest, PointerEventGetPointerId002, TestSize.Level1) 183 { 184 /** 185 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 186 */ 187 auto event = std::make_unique<ArkUI_UIInputEvent>(); 188 EXPECT_NE(event, nullptr); 189 event->eventTypeId = C_MOUSE_EVENT_ID; 190 event->inputEvent = nullptr; 191 uint32_t pointerIndex = 1; 192 auto sourceType = OH_ArkUI_PointerEvent_GetPointerId(event.get(), pointerIndex); 193 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 194 } 195 196 /** 197 * @tc.name:PointerEventGetPointerId003 198 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 199 * @tc.type: FUNC 200 */ 201 HWTEST_F(UIInputEventTest, PointerEventGetPointerId003, TestSize.Level1) 202 { 203 /** 204 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 205 */ 206 auto event = std::make_unique<ArkUI_UIInputEvent>(); 207 EXPECT_NE(event, nullptr); 208 event->eventTypeId = C_MOUSE_EVENT_ID; 209 210 uint32_t pointerIndex = 0; 211 auto sourceType = OH_ArkUI_PointerEvent_GetPointerId(event.get(), pointerIndex); 212 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 213 } 214 215 /** 216 * @tc.name:PointerEventGetPointerId004 217 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 218 * @tc.type: FUNC 219 */ 220 HWTEST_F(UIInputEventTest, PointerEventGetPointerId004, TestSize.Level1) 221 { 222 /** 223 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 224 */ 225 auto event = std::make_unique<ArkUI_UIInputEvent>(); 226 EXPECT_NE(event, nullptr); 227 event->eventTypeId = C_MOUSE_EVENT_ID; 228 uint32_t pointerIndex = 0; 229 event->inputEvent = nullptr; 230 auto sourceType = OH_ArkUI_PointerEvent_GetPointerId(event.get(), pointerIndex); 231 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 232 } 233 234 /** 235 * @tc.name:PointerEventGetPointerId005 236 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 237 * @tc.type: FUNC 238 */ 239 HWTEST_F(UIInputEventTest, PointerEventGetPointerId005, TestSize.Level1) 240 { 241 /** 242 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 243 */ 244 auto event = std::make_unique<ArkUI_UIInputEvent>(); 245 EXPECT_NE(event, nullptr); 246 event->eventTypeId = C_AXIS_EVENT_ID; 247 uint32_t pointerIndex = 0; 248 249 auto sourceType = OH_ArkUI_PointerEvent_GetPointerId(event.get(), pointerIndex); 250 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 251 } 252 253 /** 254 * @tc.name:PointerEventGetPointerId006 255 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 256 * @tc.type: FUNC 257 */ 258 HWTEST_F(UIInputEventTest, PointerEventGetPointerId006, TestSize.Level1) 259 { 260 /** 261 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 262 */ 263 auto event = std::make_unique<ArkUI_UIInputEvent>(); 264 EXPECT_NE(event, nullptr); 265 event->eventTypeId = C_AXIS_EVENT_ID; 266 event->inputEvent = nullptr; 267 uint32_t pointerIndex = 1; 268 269 auto sourceType = OH_ArkUI_PointerEvent_GetPointerId(event.get(), pointerIndex); 270 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 271 } 272 273 /** 274 * @tc.name:PointerEventGetPointerId007 275 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 276 * @tc.type: FUNC 277 */ 278 HWTEST_F(UIInputEventTest, PointerEventGetPointerId007, TestSize.Level1) 279 { 280 /** 281 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 282 */ 283 auto event = std::make_unique<ArkUI_UIInputEvent>(); 284 EXPECT_NE(event, nullptr); 285 event->eventTypeId = C_AXIS_EVENT_ID; 286 event->inputEvent = nullptr; 287 uint32_t pointerIndex = 0; 288 289 auto sourceType = OH_ArkUI_PointerEvent_GetPointerId(event.get(), pointerIndex); 290 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 291 } 292 293 /** 294 * @tc.name:PointerEventGetPointerId008 295 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 296 * @tc.type: FUNC 297 */ 298 HWTEST_F(UIInputEventTest, PointerEventGetPointerId008, TestSize.Level1) 299 { 300 /** 301 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 302 */ 303 auto sourceType = OH_ArkUI_PointerEvent_GetPointerId(nullptr, 0); 304 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 305 } 306 307 /** 308 * @tc.name:PointerEventGetXByIndex001 OH_ArkUI_PointerEvent_GetXByIndex 309 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 310 * @tc.type: FUNC 311 */ 312 HWTEST_F(UIInputEventTest, PointerEventGetXByIndex001, TestSize.Level1) 313 { 314 /** 315 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 316 */ 317 auto sourceType = OH_ArkUI_PointerEvent_GetXByIndex(nullptr, 0); 318 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 319 } 320 321 /** 322 * @tc.name:PointerEventGetXByIndex002 323 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 324 * @tc.type: FUNC 325 */ 326 HWTEST_F(UIInputEventTest, PointerEventGetXByIndex002, TestSize.Level1) 327 { 328 /** 329 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 330 */ 331 auto event = std::make_unique<ArkUI_UIInputEvent>(); 332 EXPECT_NE(event, nullptr); 333 event->eventTypeId = C_TOUCH_EVENT_ID; 334 335 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 336 uint32_t pointerIndex = 1; 337 auto sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 338 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 339 } 340 341 /** 342 * @tc.name:PointerEventGetXByIndex003 343 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 344 * @tc.type: FUNC 345 */ 346 HWTEST_F(UIInputEventTest, PointerEventGetXByIndex003, TestSize.Level1) 347 { 348 /** 349 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 350 */ 351 auto event = std::make_unique<ArkUI_UIInputEvent>(); 352 EXPECT_NE(event, nullptr); 353 event->eventTypeId = C_TOUCH_EVENT_ID; 354 355 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 356 event->inputEvent = static_cast<void*>(touchEvent.get()); 357 touchEvent->touchPointSize = 3; 358 uint32_t pointerIndex = 1; 359 ArkUITouchPoint touchPoint; 360 touchEvent->touchPointes = &touchPoint; 361 362 auto sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 363 EXPECT_NE(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 364 } 365 366 /** 367 * @tc.name:PointerEventGetXByIndex004 368 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 369 * @tc.type: FUNC 370 */ 371 HWTEST_F(UIInputEventTest, PointerEventGetXByIndex004, TestSize.Level1) 372 { 373 /** 374 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 375 */ 376 auto event = std::make_unique<ArkUI_UIInputEvent>(); 377 EXPECT_NE(event, nullptr); 378 event->eventTypeId = C_MOUSE_EVENT_ID; 379 380 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 381 event->inputEvent = static_cast<void*>(mouseEvent.get()); 382 uint32_t pointerIndex = 1; 383 auto sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 384 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 385 } 386 387 /** 388 * @tc.name:PointerEventGetXByIndex005 389 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 390 * @tc.type: FUNC 391 */ 392 HWTEST_F(UIInputEventTest, PointerEventGetXByIndex005, TestSize.Level1) 393 { 394 /** 395 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 396 */ 397 auto event = std::make_unique<ArkUI_UIInputEvent>(); 398 EXPECT_NE(event, nullptr); 399 event->eventTypeId = C_MOUSE_EVENT_ID; 400 401 uint32_t pointerIndex = 0; 402 auto sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 403 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 404 405 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 406 event->inputEvent = static_cast<void*>(mouseEvent.get()); 407 pointerIndex = 1; 408 sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 409 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 410 } 411 412 /** 413 * @tc.name:PointerEventGetXByIndex006 414 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 415 * @tc.type: FUNC 416 */ 417 HWTEST_F(UIInputEventTest, PointerEventGetXByIndex006, TestSize.Level1) 418 { 419 /** 420 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 421 */ 422 auto event = std::make_unique<ArkUI_UIInputEvent>(); 423 EXPECT_NE(event, nullptr); 424 event->eventTypeId = C_MOUSE_EVENT_ID; 425 426 uint32_t pointerIndex = 0; 427 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 428 event->inputEvent = static_cast<void*>(mouseEvent.get()); 429 auto sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 430 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 431 } 432 433 /** 434 * @tc.name:PointerEventGetXByIndex007 435 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 436 * @tc.type: FUNC 437 */ 438 HWTEST_F(UIInputEventTest, PointerEventGetXByIndex007, TestSize.Level1) 439 { 440 /** 441 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 442 */ 443 auto event = std::make_unique<ArkUI_UIInputEvent>(); 444 EXPECT_NE(event, nullptr); 445 event->eventTypeId = C_AXIS_EVENT_ID; 446 447 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 448 event->inputEvent = static_cast<void*>(axisEvent.get()); 449 uint32_t pointerIndex = 1; 450 auto sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 451 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 452 } 453 454 /** 455 * @tc.name:PointerEventGetXByIndex008 456 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 457 * @tc.type: FUNC 458 */ 459 HWTEST_F(UIInputEventTest, PointerEventGetXByIndex008, TestSize.Level1) 460 { 461 /** 462 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 463 */ 464 auto event = std::make_unique<ArkUI_UIInputEvent>(); 465 EXPECT_NE(event, nullptr); 466 event->eventTypeId = C_AXIS_EVENT_ID; 467 468 uint32_t pointerIndex = 0; 469 auto sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 470 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 471 472 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 473 event->inputEvent = static_cast<void*>(axisEvent.get()); 474 pointerIndex = 1; 475 sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 476 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 477 } 478 479 /** 480 * @tc.name:PointerEventGetXByIndex009 481 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 482 * @tc.type: FUNC 483 */ 484 HWTEST_F(UIInputEventTest, PointerEventGetXByIndex009, TestSize.Level1) 485 { 486 /** 487 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 488 */ 489 auto event = std::make_unique<ArkUI_UIInputEvent>(); 490 EXPECT_NE(event, nullptr); 491 event->eventTypeId = C_AXIS_EVENT_ID; 492 493 uint32_t pointerIndex = 0; 494 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 495 event->inputEvent = static_cast<void*>(axisEvent.get()); 496 auto sourceType = OH_ArkUI_PointerEvent_GetXByIndex(event.get(), pointerIndex); 497 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 498 } 499 500 /** 501 * @tc.name:PointerEventGetYByIndex001 502 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 503 * @tc.type: FUNC 504 */ 505 HWTEST_F(UIInputEventTest, PointerEventGetYByIndex001, TestSize.Level1) 506 { 507 /** 508 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 509 */ 510 auto sourceType = OH_ArkUI_PointerEvent_GetYByIndex(nullptr, 0); 511 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 512 513 auto event = std::make_unique<ArkUI_UIInputEvent>(); 514 EXPECT_NE(event, nullptr); 515 event->eventTypeId = C_TOUCH_EVENT_ID; 516 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 517 uint32_t pointerIndex = 1; 518 sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 519 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 520 } 521 522 /** 523 * @tc.name:PointerEventGetYByIndex002 524 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 525 * @tc.type: FUNC 526 */ 527 HWTEST_F(UIInputEventTest, PointerEventGetYByIndex002, TestSize.Level1) 528 { 529 /** 530 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 531 */ 532 auto event = std::make_unique<ArkUI_UIInputEvent>(); 533 EXPECT_NE(event, nullptr); 534 event->eventTypeId = C_TOUCH_EVENT_ID; 535 536 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 537 event->inputEvent = static_cast<void*>(touchEvent.get()); 538 touchEvent->touchPointSize = 3; 539 uint32_t pointerIndex = 1; 540 ArkUITouchPoint touchPoint; 541 touchEvent->touchPointes = &touchPoint; 542 543 auto sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 544 EXPECT_NE(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 545 } 546 547 /** 548 * @tc.name:PointerEventGetYByIndex003 549 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 550 * @tc.type: FUNC 551 */ 552 HWTEST_F(UIInputEventTest, PointerEventGetYByIndex003, TestSize.Level1) 553 { 554 /** 555 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 556 */ 557 auto event = std::make_unique<ArkUI_UIInputEvent>(); 558 EXPECT_NE(event, nullptr); 559 event->eventTypeId = C_MOUSE_EVENT_ID; 560 561 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 562 event->inputEvent = static_cast<void*>(mouseEvent.get()); 563 uint32_t pointerIndex = 1; 564 auto sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 565 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 566 } 567 568 /** 569 * @tc.name:PointerEventGetYByIndex004 570 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 571 * @tc.type: FUNC 572 */ 573 HWTEST_F(UIInputEventTest, PointerEventGetYByIndex004, TestSize.Level1) 574 { 575 /** 576 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 577 */ 578 auto event = std::make_unique<ArkUI_UIInputEvent>(); 579 EXPECT_NE(event, nullptr); 580 event->eventTypeId = C_MOUSE_EVENT_ID; 581 582 uint32_t pointerIndex = 0; 583 auto sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 584 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 585 586 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 587 event->inputEvent = static_cast<void*>(mouseEvent.get()); 588 pointerIndex = 1; 589 sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 590 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 591 } 592 593 /** 594 * @tc.name:PointerEventGetYByIndex005 595 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 596 * @tc.type: FUNC 597 */ 598 HWTEST_F(UIInputEventTest, PointerEventGetYByIndex005, TestSize.Level1) 599 { 600 /** 601 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 602 */ 603 auto event = std::make_unique<ArkUI_UIInputEvent>(); 604 EXPECT_NE(event, nullptr); 605 event->eventTypeId = C_MOUSE_EVENT_ID; 606 607 uint32_t pointerIndex = 0; 608 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 609 event->inputEvent = static_cast<void*>(mouseEvent.get()); 610 auto sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 611 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 612 } 613 614 /** 615 * @tc.name:PointerEventGetYByIndex006 616 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 617 * @tc.type: FUNC 618 */ 619 HWTEST_F(UIInputEventTest, PointerEventGetYByIndex006, TestSize.Level1) 620 { 621 /** 622 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 623 */ 624 auto event = std::make_unique<ArkUI_UIInputEvent>(); 625 EXPECT_NE(event, nullptr); 626 event->eventTypeId = C_AXIS_EVENT_ID; 627 628 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 629 event->inputEvent = static_cast<void*>(axisEvent.get()); 630 uint32_t pointerIndex = 1; 631 auto sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 632 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 633 } 634 635 /** 636 * @tc.name:PointerEventGetYByIndex007 637 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 638 * @tc.type: FUNC 639 */ 640 HWTEST_F(UIInputEventTest, PointerEventGetYByIndex007, TestSize.Level1) 641 { 642 /** 643 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 644 */ 645 auto event = std::make_unique<ArkUI_UIInputEvent>(); 646 EXPECT_NE(event, nullptr); 647 event->eventTypeId = C_AXIS_EVENT_ID; 648 649 uint32_t pointerIndex = 0; 650 auto sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 651 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 652 653 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 654 event->inputEvent = static_cast<void*>(axisEvent.get()); 655 pointerIndex = 1; 656 sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 657 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 658 } 659 660 /** 661 * @tc.name:PointerEventGetYByIndex008 662 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 663 * @tc.type: FUNC 664 */ 665 HWTEST_F(UIInputEventTest, PointerEventGetYByIndex008, TestSize.Level1) 666 { 667 /** 668 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 669 */ 670 auto event = std::make_unique<ArkUI_UIInputEvent>(); 671 EXPECT_NE(event, nullptr); 672 event->eventTypeId = C_AXIS_EVENT_ID; 673 674 uint32_t pointerIndex = 0; 675 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 676 event->inputEvent = static_cast<void*>(axisEvent.get()); 677 auto sourceType = OH_ArkUI_PointerEvent_GetYByIndex(event.get(), pointerIndex); 678 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 679 } 680 681 /** 682 * @tc.name:PointerEventGetWindowXByIndex001 683 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 684 * @tc.type: FUNC 685 */ 686 HWTEST_F(UIInputEventTest, PointerEventGetWindowXByIndex001, TestSize.Level1) 687 { 688 /** 689 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 690 */ 691 auto sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(nullptr, 0); 692 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 693 694 auto event = std::make_unique<ArkUI_UIInputEvent>(); 695 EXPECT_NE(event, nullptr); 696 event->eventTypeId = C_TOUCH_EVENT_ID; 697 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 698 uint32_t pointerIndex = 1; 699 sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 700 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 701 } 702 703 /** 704 * @tc.name:PointerEventGetWindowXByIndex002 705 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 706 * @tc.type: FUNC 707 */ 708 HWTEST_F(UIInputEventTest, PointerEventGetWindowXByIndex002, TestSize.Level1) 709 { 710 /** 711 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 712 */ 713 auto event = std::make_unique<ArkUI_UIInputEvent>(); 714 EXPECT_NE(event, nullptr); 715 event->eventTypeId = C_TOUCH_EVENT_ID; 716 717 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 718 event->inputEvent = static_cast<void*>(touchEvent.get()); 719 touchEvent->touchPointSize = 3; 720 uint32_t pointerIndex = 1; 721 ArkUITouchPoint touchPoint; 722 touchEvent->touchPointes = &touchPoint; 723 724 auto sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 725 EXPECT_NE(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 726 } 727 728 /** 729 * @tc.name:PointerEventGetWindowXByIndex003 730 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 731 * @tc.type: FUNC 732 */ 733 HWTEST_F(UIInputEventTest, PointerEventGetWindowXByIndex003, TestSize.Level1) 734 { 735 /** 736 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 737 */ 738 auto event = std::make_unique<ArkUI_UIInputEvent>(); 739 EXPECT_NE(event, nullptr); 740 event->eventTypeId = C_MOUSE_EVENT_ID; 741 742 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 743 event->inputEvent = static_cast<void*>(mouseEvent.get()); 744 uint32_t pointerIndex = 1; 745 auto sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 746 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 747 } 748 749 /** 750 * @tc.name:PointerEventGetWindowXByIndex004 751 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 752 * @tc.type: FUNC 753 */ 754 HWTEST_F(UIInputEventTest, PointerEventGetWindowXByIndex004, TestSize.Level1) 755 { 756 /** 757 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 758 */ 759 auto event = std::make_unique<ArkUI_UIInputEvent>(); 760 EXPECT_NE(event, nullptr); 761 event->eventTypeId = C_MOUSE_EVENT_ID; 762 763 uint32_t pointerIndex = 0; 764 auto sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 765 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 766 767 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 768 event->inputEvent = static_cast<void*>(mouseEvent.get()); 769 pointerIndex = 1; 770 sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 771 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 772 } 773 774 /** 775 * @tc.name:PointerEventGetWindowXByIndex005 776 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 777 * @tc.type: FUNC 778 */ 779 HWTEST_F(UIInputEventTest, PointerEventGetWindowXByIndex005, TestSize.Level1) 780 { 781 /** 782 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 783 */ 784 auto event = std::make_unique<ArkUI_UIInputEvent>(); 785 EXPECT_NE(event, nullptr); 786 event->eventTypeId = C_MOUSE_EVENT_ID; 787 788 uint32_t pointerIndex = 0; 789 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 790 event->inputEvent = static_cast<void*>(mouseEvent.get()); 791 auto sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 792 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 793 } 794 795 /** 796 * @tc.name:PointerEventGetWindowXByIndex006 797 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 798 * @tc.type: FUNC 799 */ 800 HWTEST_F(UIInputEventTest, PointerEventGetWindowXByIndex006, TestSize.Level1) 801 { 802 /** 803 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 804 */ 805 auto event = std::make_unique<ArkUI_UIInputEvent>(); 806 EXPECT_NE(event, nullptr); 807 event->eventTypeId = C_AXIS_EVENT_ID; 808 809 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 810 event->inputEvent = static_cast<void*>(axisEvent.get()); 811 uint32_t pointerIndex = 1; 812 auto sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 813 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 814 } 815 816 /** 817 * @tc.name:PointerEventGetWindowXByIndex007 818 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 819 * @tc.type: FUNC 820 */ 821 HWTEST_F(UIInputEventTest, PointerEventGetWindowXByIndex007, TestSize.Level1) 822 { 823 /** 824 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 825 */ 826 auto event = std::make_unique<ArkUI_UIInputEvent>(); 827 EXPECT_NE(event, nullptr); 828 event->eventTypeId = C_AXIS_EVENT_ID; 829 830 uint32_t pointerIndex = 0; 831 auto sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 832 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 833 834 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 835 event->inputEvent = static_cast<void*>(axisEvent.get()); 836 pointerIndex = 1; 837 sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 838 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 839 } 840 841 /** 842 * @tc.name:PointerEventGetWindowXByIndex008 843 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 844 * @tc.type: FUNC 845 */ 846 HWTEST_F(UIInputEventTest, PointerEventGetWindowXByIndex008, TestSize.Level1) 847 { 848 /** 849 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 850 */ 851 auto event = std::make_unique<ArkUI_UIInputEvent>(); 852 EXPECT_NE(event, nullptr); 853 event->eventTypeId = C_AXIS_EVENT_ID; 854 855 uint32_t pointerIndex = 0; 856 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 857 event->inputEvent = static_cast<void*>(axisEvent.get()); 858 auto sourceType = OH_ArkUI_PointerEvent_GetWindowXByIndex(event.get(), pointerIndex); 859 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 860 } 861 862 /** 863 * @tc.name:PointerEventGetWindowYByIndex001 864 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 865 * @tc.type: FUNC 866 */ 867 HWTEST_F(UIInputEventTest, PointerEventGetWindowYByIndex001, TestSize.Level1) 868 { 869 /** 870 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 871 */ 872 auto sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(nullptr, 0); 873 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 874 875 auto event = std::make_unique<ArkUI_UIInputEvent>(); 876 EXPECT_NE(event, nullptr); 877 event->eventTypeId = C_TOUCH_EVENT_ID; 878 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 879 uint32_t pointerIndex = 1; 880 sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 881 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 882 } 883 884 /** 885 * @tc.name:PointerEventGetWindowYByIndex002 886 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 887 * @tc.type: FUNC 888 */ 889 HWTEST_F(UIInputEventTest, PointerEventGetWindowYByIndex002, TestSize.Level1) 890 { 891 /** 892 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 893 */ 894 auto event = std::make_unique<ArkUI_UIInputEvent>(); 895 EXPECT_NE(event, nullptr); 896 event->eventTypeId = C_TOUCH_EVENT_ID; 897 898 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 899 event->inputEvent = static_cast<void*>(touchEvent.get()); 900 touchEvent->touchPointSize = 3; 901 uint32_t pointerIndex = 1; 902 ArkUITouchPoint touchPoint; 903 touchEvent->touchPointes = &touchPoint; 904 905 auto sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 906 EXPECT_NE(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 907 } 908 909 /** 910 * @tc.name:PointerEventGetWindowYByIndex003 911 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 912 * @tc.type: FUNC 913 */ 914 HWTEST_F(UIInputEventTest, PointerEventGetWindowYByIndex003, TestSize.Level1) 915 { 916 /** 917 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 918 */ 919 auto event = std::make_unique<ArkUI_UIInputEvent>(); 920 EXPECT_NE(event, nullptr); 921 event->eventTypeId = C_MOUSE_EVENT_ID; 922 923 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 924 event->inputEvent = static_cast<void*>(mouseEvent.get()); 925 uint32_t pointerIndex = 1; 926 auto sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 927 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 928 } 929 930 /** 931 * @tc.name:PointerEventGetWindowYByIndex004 932 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 933 * @tc.type: FUNC 934 */ 935 HWTEST_F(UIInputEventTest, PointerEventGetWindowYByIndex004, TestSize.Level1) 936 { 937 /** 938 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 939 */ 940 auto event = std::make_unique<ArkUI_UIInputEvent>(); 941 EXPECT_NE(event, nullptr); 942 event->eventTypeId = C_MOUSE_EVENT_ID; 943 944 uint32_t pointerIndex = 0; 945 auto sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 946 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 947 948 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 949 event->inputEvent = static_cast<void*>(mouseEvent.get()); 950 pointerIndex = 1; 951 sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 952 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 953 } 954 955 /** 956 * @tc.name:PointerEventGetWindowYByIndex005 957 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 958 * @tc.type: FUNC 959 */ 960 HWTEST_F(UIInputEventTest, PointerEventGetWindowYByIndex005, TestSize.Level1) 961 { 962 /** 963 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 964 */ 965 auto event = std::make_unique<ArkUI_UIInputEvent>(); 966 EXPECT_NE(event, nullptr); 967 event->eventTypeId = C_MOUSE_EVENT_ID; 968 969 uint32_t pointerIndex = 0; 970 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 971 event->inputEvent = static_cast<void*>(mouseEvent.get()); 972 auto sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 973 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 974 } 975 976 /** 977 * @tc.name:PointerEventGetWindowYByIndex006 978 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 979 * @tc.type: FUNC 980 */ 981 HWTEST_F(UIInputEventTest, PointerEventGetWindowYByIndex006, TestSize.Level1) 982 { 983 /** 984 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 985 */ 986 auto event = std::make_unique<ArkUI_UIInputEvent>(); 987 EXPECT_NE(event, nullptr); 988 event->eventTypeId = C_AXIS_EVENT_ID; 989 990 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 991 event->inputEvent = static_cast<void*>(axisEvent.get()); 992 uint32_t pointerIndex = 1; 993 auto sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 994 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 995 } 996 997 /** 998 * @tc.name:PointerEventGetWindowYByIndex007 999 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1000 * @tc.type: FUNC 1001 */ 1002 HWTEST_F(UIInputEventTest, PointerEventGetWindowYByIndex007, TestSize.Level1) 1003 { 1004 /** 1005 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1006 */ 1007 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1008 EXPECT_NE(event, nullptr); 1009 event->eventTypeId = C_AXIS_EVENT_ID; 1010 1011 uint32_t pointerIndex = 0; 1012 auto sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 1013 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1014 1015 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1016 event->inputEvent = static_cast<void*>(axisEvent.get()); 1017 pointerIndex = 1; 1018 sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 1019 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1020 } 1021 1022 /** 1023 * @tc.name:PointerEventGetWindowYByIndex008 1024 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1025 * @tc.type: FUNC 1026 */ 1027 HWTEST_F(UIInputEventTest, PointerEventGetWindowYByIndex008, TestSize.Level1) 1028 { 1029 /** 1030 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1031 */ 1032 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1033 EXPECT_NE(event, nullptr); 1034 event->eventTypeId = C_AXIS_EVENT_ID; 1035 1036 uint32_t pointerIndex = 0; 1037 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1038 event->inputEvent = static_cast<void*>(axisEvent.get()); 1039 auto sourceType = OH_ArkUI_PointerEvent_GetWindowYByIndex(event.get(), pointerIndex); 1040 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1041 } 1042 1043 /** 1044 * @tc.name:PointerEventGetDisplayXByIndex001 1045 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1046 * @tc.type: FUNC 1047 */ 1048 HWTEST_F(UIInputEventTest, PointerEventGetDisplayXByIndex001, TestSize.Level1) 1049 { 1050 /** 1051 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1052 */ 1053 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(nullptr, 0); 1054 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1055 1056 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1057 EXPECT_NE(event, nullptr); 1058 event->eventTypeId = C_TOUCH_EVENT_ID; 1059 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1060 uint32_t pointerIndex = 1; 1061 sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1062 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1063 } 1064 1065 /** 1066 * @tc.name:PointerEventGetDisplayXByIndex002 1067 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1068 * @tc.type: FUNC 1069 */ 1070 HWTEST_F(UIInputEventTest, PointerEventGetDisplayXByIndex002, TestSize.Level1) 1071 { 1072 /** 1073 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1074 */ 1075 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1076 EXPECT_NE(event, nullptr); 1077 event->eventTypeId = C_TOUCH_EVENT_ID; 1078 1079 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1080 event->inputEvent = static_cast<void*>(touchEvent.get()); 1081 touchEvent->touchPointSize = 3; 1082 uint32_t pointerIndex = 1; 1083 ArkUITouchPoint touchPoint; 1084 touchEvent->touchPointes = &touchPoint; 1085 1086 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1087 EXPECT_NE(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1088 } 1089 1090 /** 1091 * @tc.name:PointerEventGetDisplayXByIndex003 1092 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1093 * @tc.type: FUNC 1094 */ 1095 HWTEST_F(UIInputEventTest, PointerEventGetDisplayXByIndex003, TestSize.Level1) 1096 { 1097 /** 1098 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1099 */ 1100 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1101 EXPECT_NE(event, nullptr); 1102 event->eventTypeId = C_MOUSE_EVENT_ID; 1103 1104 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1105 event->inputEvent = static_cast<void*>(mouseEvent.get()); 1106 uint32_t pointerIndex = 1; 1107 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1108 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1109 } 1110 1111 /** 1112 * @tc.name:PointerEventGetDisplayXByIndex004 1113 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1114 * @tc.type: FUNC 1115 */ 1116 HWTEST_F(UIInputEventTest, PointerEventGetDisplayXByIndex004, TestSize.Level1) 1117 { 1118 /** 1119 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1120 */ 1121 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1122 EXPECT_NE(event, nullptr); 1123 event->eventTypeId = C_MOUSE_EVENT_ID; 1124 1125 uint32_t pointerIndex = 0; 1126 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1127 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1128 1129 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1130 event->inputEvent = static_cast<void*>(mouseEvent.get()); 1131 pointerIndex = 1; 1132 sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1133 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1134 } 1135 1136 /** 1137 * @tc.name:PointerEventGetDisplayXByIndex005 1138 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1139 * @tc.type: FUNC 1140 */ 1141 HWTEST_F(UIInputEventTest, PointerEventGetDisplayXByIndex005, TestSize.Level1) 1142 { 1143 /** 1144 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1145 */ 1146 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1147 EXPECT_NE(event, nullptr); 1148 event->eventTypeId = C_MOUSE_EVENT_ID; 1149 1150 uint32_t pointerIndex = 0; 1151 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1152 event->inputEvent = static_cast<void*>(mouseEvent.get()); 1153 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1154 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1155 } 1156 1157 /** 1158 * @tc.name:PointerEventGetDisplayXByIndex006 1159 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1160 * @tc.type: FUNC 1161 */ 1162 HWTEST_F(UIInputEventTest, PointerEventGetDisplayXByIndex006, TestSize.Level1) 1163 { 1164 /** 1165 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1166 */ 1167 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1168 EXPECT_NE(event, nullptr); 1169 event->eventTypeId = C_AXIS_EVENT_ID; 1170 1171 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1172 event->inputEvent = static_cast<void*>(axisEvent.get()); 1173 uint32_t pointerIndex = 1; 1174 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1175 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1176 } 1177 1178 /** 1179 * @tc.name:PointerEventGetDisplayXByIndex007 1180 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1181 * @tc.type: FUNC 1182 */ 1183 HWTEST_F(UIInputEventTest, PointerEventGetDisplayXByIndex007, TestSize.Level1) 1184 { 1185 /** 1186 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1187 */ 1188 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1189 EXPECT_NE(event, nullptr); 1190 event->eventTypeId = C_AXIS_EVENT_ID; 1191 1192 uint32_t pointerIndex = 0; 1193 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1194 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1195 1196 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1197 event->inputEvent = static_cast<void*>(axisEvent.get()); 1198 pointerIndex = 1; 1199 sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1200 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1201 } 1202 1203 /** 1204 * @tc.name:PointerEventGetDisplayXByIndex008 1205 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1206 * @tc.type: FUNC 1207 */ 1208 HWTEST_F(UIInputEventTest, PointerEventGetDisplayXByIndex008, TestSize.Level1) 1209 { 1210 /** 1211 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1212 */ 1213 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1214 EXPECT_NE(event, nullptr); 1215 event->eventTypeId = C_AXIS_EVENT_ID; 1216 1217 uint32_t pointerIndex = 0; 1218 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1219 event->inputEvent = static_cast<void*>(axisEvent.get()); 1220 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayXByIndex(event.get(), pointerIndex); 1221 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1222 } 1223 1224 /** 1225 * @tc.name:PointerEventGetDisplayYByIndex001 1226 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1227 * @tc.type: FUNC 1228 */ 1229 HWTEST_F(UIInputEventTest, PointerEventGetDisplayYByIndex001, TestSize.Level1) 1230 { 1231 /** 1232 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1233 */ 1234 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(nullptr, 0); 1235 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1236 1237 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1238 EXPECT_NE(event, nullptr); 1239 event->eventTypeId = C_TOUCH_EVENT_ID; 1240 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1241 uint32_t pointerIndex = 1; 1242 sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1243 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1244 } 1245 1246 /** 1247 * @tc.name:PointerEventGetDisplayYByIndex002 1248 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1249 * @tc.type: FUNC 1250 */ 1251 HWTEST_F(UIInputEventTest, PointerEventGetDisplayYByIndex002, TestSize.Level1) 1252 { 1253 /** 1254 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1255 */ 1256 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1257 EXPECT_NE(event, nullptr); 1258 event->eventTypeId = C_TOUCH_EVENT_ID; 1259 1260 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1261 event->inputEvent = static_cast<void*>(touchEvent.get()); 1262 touchEvent->touchPointSize = 3; 1263 uint32_t pointerIndex = 1; 1264 ArkUITouchPoint touchPoint; 1265 touchEvent->touchPointes = &touchPoint; 1266 1267 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1268 EXPECT_NE(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1269 } 1270 1271 /** 1272 * @tc.name:PointerEventGetDisplayYByIndex003 1273 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1274 * @tc.type: FUNC 1275 */ 1276 HWTEST_F(UIInputEventTest, PointerEventGetDisplayYByIndex003, TestSize.Level1) 1277 { 1278 /** 1279 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1280 */ 1281 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1282 EXPECT_NE(event, nullptr); 1283 event->eventTypeId = C_MOUSE_EVENT_ID; 1284 1285 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1286 event->inputEvent = static_cast<void*>(mouseEvent.get()); 1287 uint32_t pointerIndex = 1; 1288 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1289 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1290 } 1291 1292 /** 1293 * @tc.name:PointerEventGetDisplayYByIndex004 1294 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1295 * @tc.type: FUNC 1296 */ 1297 HWTEST_F(UIInputEventTest, PointerEventGetDisplayYByIndex004, TestSize.Level1) 1298 { 1299 /** 1300 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1301 */ 1302 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1303 EXPECT_NE(event, nullptr); 1304 event->eventTypeId = C_MOUSE_EVENT_ID; 1305 1306 uint32_t pointerIndex = 0; 1307 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1308 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1309 1310 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1311 event->inputEvent = static_cast<void*>(mouseEvent.get()); 1312 pointerIndex = 1; 1313 sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1314 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1315 } 1316 1317 /** 1318 * @tc.name:PointerEventGetDisplayYByIndex005 1319 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1320 * @tc.type: FUNC 1321 */ 1322 HWTEST_F(UIInputEventTest, PointerEventGetDisplayYByIndex005, TestSize.Level1) 1323 { 1324 /** 1325 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1326 */ 1327 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1328 EXPECT_NE(event, nullptr); 1329 event->eventTypeId = C_MOUSE_EVENT_ID; 1330 1331 uint32_t pointerIndex = 0; 1332 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1333 event->inputEvent = static_cast<void*>(mouseEvent.get()); 1334 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1335 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1336 } 1337 1338 /** 1339 * @tc.name:PointerEventGetDisplayYByIndex006 1340 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1341 * @tc.type: FUNC 1342 */ 1343 HWTEST_F(UIInputEventTest, PointerEventGetDisplayYByIndex006, TestSize.Level1) 1344 { 1345 /** 1346 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1347 */ 1348 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1349 EXPECT_NE(event, nullptr); 1350 event->eventTypeId = C_AXIS_EVENT_ID; 1351 1352 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1353 event->inputEvent = static_cast<void*>(axisEvent.get()); 1354 uint32_t pointerIndex = 1; 1355 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1356 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1357 } 1358 1359 /** 1360 * @tc.name:PointerEventGetDisplayYByIndex007 1361 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1362 * @tc.type: FUNC 1363 */ 1364 HWTEST_F(UIInputEventTest, PointerEventGetDisplayYByIndex007, TestSize.Level1) 1365 { 1366 /** 1367 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1368 */ 1369 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1370 EXPECT_NE(event, nullptr); 1371 event->eventTypeId = C_AXIS_EVENT_ID; 1372 1373 uint32_t pointerIndex = 0; 1374 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1375 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1376 1377 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1378 event->inputEvent = static_cast<void*>(axisEvent.get()); 1379 pointerIndex = 1; 1380 sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1381 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1382 } 1383 1384 /** 1385 * @tc.name:PointerEventGetDisplayYByIndex008 1386 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 1387 * @tc.type: FUNC 1388 */ 1389 HWTEST_F(UIInputEventTest, PointerEventGetDisplayYByIndex008, TestSize.Level1) 1390 { 1391 /** 1392 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 1393 */ 1394 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1395 EXPECT_NE(event, nullptr); 1396 event->eventTypeId = C_AXIS_EVENT_ID; 1397 1398 uint32_t pointerIndex = 0; 1399 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 1400 event->inputEvent = static_cast<void*>(axisEvent.get()); 1401 auto sourceType = OH_ArkUI_PointerEvent_GetDisplayYByIndex(event.get(), pointerIndex); 1402 EXPECT_EQ(sourceType, UI_INPUT_EVENT_SOURCE_TYPE_UNKNOWN); 1403 } 1404 } // namespace OHOS::Ace