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