1 /* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "ui_input_event_test.h" 17 18 using namespace testing; 19 using namespace testing::ext; 20 namespace OHOS::Ace { 21 22 /** 23 * @tc.name: OH_ArkUI_HoverEvent_IsHovered 24 * @tc.desc: test OH_ArkUI_HoverEvent_IsHovered 25 * @tc.type: FUNC 26 */ 27 HWTEST_F(UIInputEventTest, OH_ArkUI_HoverEvent_IsHovered, TestSize.Level1) 28 { 29 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 30 auto result = OH_ArkUI_HoverEvent_IsHovered(nullptr); 31 EXPECT_EQ(result, false); 32 33 uiInputEvent->eventTypeId = C_HOVER_EVENT_ID; 34 auto hoverEvent = std::make_unique<ArkUIHoverEvent>(); 35 hoverEvent->isHover = true; 36 result = OH_ArkUI_HoverEvent_IsHovered(uiInputEvent.get()); 37 EXPECT_EQ(result, false); 38 uiInputEvent->inputEvent = hoverEvent.get(); 39 result = OH_ArkUI_HoverEvent_IsHovered(uiInputEvent.get()); 40 EXPECT_EQ(result, true); 41 42 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 43 result = OH_ArkUI_HoverEvent_IsHovered(uiInputEvent.get()); 44 EXPECT_EQ(result, false); 45 } 46 47 /** 48 * @tc.name: OH_ArkUI_AxisEvent_SetPropagation 49 * @tc.desc: Test function OH_ArkUI_AxisEvent_SetPropagation 50 * @tc.type: FUNC 51 */ 52 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_SetPropagation, TestSize.Level1) 53 { 54 int32_t ret = OH_ArkUI_AxisEvent_SetPropagation(nullptr, true); 55 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 56 57 ArkUI_UIInputEvent event; 58 ret = OH_ArkUI_AxisEvent_SetPropagation(&event, true); 59 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 60 61 event.eventTypeId = C_AXIS_EVENT_ID; 62 event.inputEvent = nullptr; 63 ret = OH_ArkUI_AxisEvent_SetPropagation(&event, true); 64 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 65 66 ArkUIAxisEvent axisEvent; 67 event.eventTypeId = C_AXIS_EVENT_ID; 68 event.inputEvent = &axisEvent; 69 ret = OH_ArkUI_AxisEvent_SetPropagation(&event, true); 70 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 71 EXPECT_TRUE(axisEvent.propagation); 72 } 73 74 /** 75 * @tc.name: OH_ArkUI_AxisEvent_GetScrollStep 76 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetScrollStep 77 * @tc.type: FUNC 78 */ 79 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_GetScrollStep, TestSize.Level1) 80 { 81 int32_t step = OH_ArkUI_AxisEvent_GetScrollStep(nullptr); 82 EXPECT_EQ(step, 0); 83 84 OHOS::Ace::AxisEvent aceAxisEvent; 85 aceAxisEvent.scrollStep = 5; 86 ArkUI_UIInputEvent event; 87 event.eventTypeId = AXIS_EVENT_ID; 88 event.inputEvent = &aceAxisEvent; 89 step = OH_ArkUI_AxisEvent_GetScrollStep(&event); 90 EXPECT_EQ(step, 5); 91 92 ArkUIAxisEvent axisEvent; 93 axisEvent.scrollStep = 3; 94 event.eventTypeId = C_AXIS_EVENT_ID; 95 event.inputEvent = &axisEvent; 96 step = OH_ArkUI_AxisEvent_GetScrollStep(&event); 97 EXPECT_EQ(step, 3); 98 99 event.eventTypeId = C_HOVER_EVENT_ID; 100 step = OH_ArkUI_AxisEvent_GetScrollStep(&event); 101 EXPECT_EQ(step, 0); 102 } 103 104 /** 105 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventLocalPosition 106 * @tc.desc: Test setting cloned event position 107 * @tc.type: FUNC 108 */ 109 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventLocalPosition, TestSize.Level1) 110 { 111 ArkUI_UIInputEvent event; 112 auto ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(nullptr, 0.0f, 0.0f); 113 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 114 115 event.isCloned = false; 116 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(&event, 0.0f, 0.0f); 117 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 118 119 event.isCloned = true; 120 event.inputEvent = nullptr; 121 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(&event, 0.0f, 0.0f); 122 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 123 124 ArkUITouchEvent touchEvent; 125 touchEvent.actionTouchPoint.nodeX = 0.0f; 126 touchEvent.actionTouchPoint.nodeY = 0.0f; 127 event.inputEvent = &touchEvent; 128 129 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPosition(&event, 1.1f, 2.2f); 130 EXPECT_EQ(touchEvent.actionTouchPoint.nodeX, 1.1f); 131 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 132 } 133 134 /** 135 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex 136 * @tc.desc: Test OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex 137 * @tc.type: FUNC 138 */ 139 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex, TestSize.Level1) 140 { 141 ArkUI_UIInputEvent event; 142 auto ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(nullptr, 0.0f, 0.0f, 1); 143 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 144 145 event.isCloned = false; 146 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(&event, 0.0f, 0.0f, 1); 147 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 148 149 event.isCloned = true; 150 event.inputEvent = nullptr; 151 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(&event, 0.0f, 0.0f, 1); 152 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 153 154 ArkUITouchEvent touchEvent; 155 touchEvent.touchPointSize = 0; 156 ArkUITouchPoint touchPointes[2]; 157 touchPointes[1].nodeX = 1.0f; 158 touchPointes[1].nodeY = 2.0f; 159 touchEvent.touchPointes = touchPointes; 160 event.inputEvent = &touchEvent; 161 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(&event, 1.1f, 2.2f, 1); 162 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 163 164 touchEvent.touchPointSize = 2; 165 event.inputEvent = &touchEvent; 166 167 ret = OH_ArkUI_PointerEvent_SetClonedEventLocalPositionByIndex(&event, 1.1f, 2.2f, 1); 168 EXPECT_EQ(touchPointes[1].nodeX, 1.1f); 169 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 170 } 171 172 /** 173 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventActionType 174 * @tc.desc: Test OH_ArkUI_PointerEvent_SetClonedEventActionType 175 * @tc.type: FUNC 176 */ 177 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventActionType, TestSize.Level1) 178 { 179 ArkUI_UIInputEvent event; 180 auto ret = OH_ArkUI_PointerEvent_SetClonedEventActionType(nullptr, 1); 181 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 182 183 event.isCloned = false; 184 ret = OH_ArkUI_PointerEvent_SetClonedEventActionType(&event, 1); 185 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 186 187 event.isCloned = true; 188 event.inputEvent = nullptr; 189 ret = OH_ArkUI_PointerEvent_SetClonedEventActionType(&event, 1); 190 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 191 192 ArkUITouchEvent touchEvent; 193 touchEvent.action = 0; 194 event.inputEvent = &touchEvent; 195 196 ret = OH_ArkUI_PointerEvent_SetClonedEventActionType(&event, 1); 197 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 198 } 199 200 /** 201 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId 202 * @tc.desc: Test OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId 203 * @tc.type: FUNC 204 */ 205 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId, TestSize.Level1) 206 { 207 ArkUI_UIInputEvent event; 208 auto ret = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(nullptr, 1); 209 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 210 211 event.isCloned = false; 212 ret = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(&event, 1); 213 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 214 215 event.isCloned = true; 216 event.inputEvent = nullptr; 217 ret = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(&event, 1); 218 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 219 220 ArkUITouchEvent touchEvent; 221 touchEvent.actionTouchPoint.id = 0; 222 event.inputEvent = &touchEvent; 223 224 ret = OH_ArkUI_PointerEvent_SetClonedEventChangedFingerId(&event, 1); 225 EXPECT_EQ(touchEvent.actionTouchPoint.id, 1); 226 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 227 } 228 229 /** 230 * @tc.name: OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex 231 * @tc.desc: Test OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex 232 * @tc.type: FUNC 233 */ 234 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex, TestSize.Level1) 235 { 236 ArkUI_UIInputEvent event; 237 auto ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(nullptr, 1, 1); 238 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 239 240 event.isCloned = false; 241 ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(&event, 1, 1); 242 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NOT_CLONED_POINTER_EVENT); 243 244 event.isCloned = true; 245 event.inputEvent = nullptr; 246 ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(&event, 1, 1); 247 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 248 249 ArkUITouchEvent touchEvent; 250 touchEvent.touchPointSize = 0; 251 ArkUITouchPoint touchPointes[2]; 252 touchPointes[1].id = 0; 253 touchPointes[1].nodeY = 2.0f; 254 touchEvent.touchPointes = touchPointes; 255 event.inputEvent = &touchEvent; 256 ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(&event, 1, 1); 257 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 258 259 touchEvent.touchPointSize = 2; 260 event.inputEvent = &touchEvent; 261 262 ret = OH_ArkUI_PointerEvent_SetClonedEventFingerIdByIndex(&event, 1, 1); 263 EXPECT_EQ(touchPointes[1].id, 1); 264 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 265 } 266 267 /** 268 * @tc.name: OH_ArkUI_UIInputEvent_GetType 269 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetType 270 * @tc.type: FUNC 271 */ 272 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetType, TestSize.Level1) 273 { 274 ArkUI_UIInputEvent event; 275 event.inputType = ARKUI_UIINPUTEVENT_TYPE_MOUSE; 276 auto ret = OH_ArkUI_UIInputEvent_GetType(&event); 277 EXPECT_EQ(ret, ARKUI_UIINPUTEVENT_TYPE_MOUSE); 278 279 ret = OH_ArkUI_UIInputEvent_GetType(nullptr); 280 EXPECT_EQ(ret, 0); 281 } 282 283 /** 284 * @tc.name: OH_ArkUI_UIInputEvent_GetAction 285 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetAction 286 * @tc.type: FUNC 287 */ 288 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetAction, TestSize.Level1) 289 { 290 ArkUI_UIInputEvent event; 291 auto ret = OH_ArkUI_UIInputEvent_GetAction(nullptr); 292 EXPECT_EQ(ret, -1); 293 294 event.eventTypeId = C_HOVER_EVENT_ID; 295 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 296 EXPECT_EQ(ret, -1); 297 298 event.eventTypeId = C_TOUCH_EVENT_ID; 299 ArkUITouchEvent touchEvent; 300 touchEvent.action = 1; 301 event.inputEvent = &touchEvent; 302 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 303 EXPECT_EQ(ret, 3); 304 event.inputEvent = nullptr; 305 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 306 EXPECT_EQ(ret, -1); 307 308 event.eventTypeId = C_MOUSE_EVENT_ID; 309 ArkUIMouseEvent mouseEvent; 310 mouseEvent.action = 1; 311 event.inputEvent = &mouseEvent; 312 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 313 EXPECT_EQ(ret, 1); 314 event.inputEvent = nullptr; 315 ret = OH_ArkUI_UIInputEvent_GetAction(&event); 316 EXPECT_EQ(ret, -1); 317 } 318 319 /** 320 * @tc.name: OH_ArkUI_UIInputEvent_GetSourceType001 321 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetSourceType 322 * @tc.type: FUNC 323 */ 324 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetSourceType001, TestSize.Level1) 325 { 326 ArkUI_UIInputEvent event; 327 auto ret = OH_ArkUI_UIInputEvent_GetSourceType(nullptr); 328 auto unknown = static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN); 329 EXPECT_EQ(ret, unknown); 330 331 event.eventTypeId = C_CLICK_EVENT_ID; 332 event.inputEvent = nullptr; 333 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 334 EXPECT_EQ(ret, unknown); 335 event.eventTypeId = C_MOUSE_EVENT_ID; 336 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 337 EXPECT_EQ(ret, unknown); 338 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 339 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 340 EXPECT_EQ(ret, unknown); 341 event.eventTypeId = C_HOVER_EVENT_ID; 342 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 343 EXPECT_EQ(ret, unknown); 344 event.eventTypeId = C_KEY_EVENT_ID; 345 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 346 EXPECT_EQ(ret, unknown); 347 } 348 /** 349 * @tc.name: OH_ArkUI_UIInputEvent_GetSourceType002 350 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetSourceType 351 * @tc.type: FUNC 352 */ 353 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetSourceType002, TestSize.Level1) 354 { 355 ArkUI_UIInputEvent event; 356 auto unknown = static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN); 357 358 event.eventTypeId = C_TOUCH_EVENT_ID; 359 event.inputEvent = nullptr; 360 auto ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 361 EXPECT_EQ(ret, unknown); 362 ArkUITouchEvent touchEvent; 363 touchEvent.sourceType = 1; 364 event.inputEvent = &touchEvent; 365 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 366 EXPECT_EQ(ret, 1); 367 368 event.eventTypeId = C_AXIS_EVENT_ID; 369 event.inputEvent = nullptr; 370 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 371 EXPECT_EQ(ret, unknown); 372 ArkUIAxisEvent axisEvent; 373 axisEvent.sourceType = 2; 374 event.inputEvent = &axisEvent; 375 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 376 EXPECT_EQ(ret, 2); 377 378 event.eventTypeId = AXIS_EVENT_ID; 379 event.inputEvent = nullptr; 380 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 381 EXPECT_EQ(ret, unknown); 382 OHOS::Ace::AxisEvent aceAxisEvent; 383 aceAxisEvent.sourceType = SourceType::CROWN; 384 event.inputEvent = &aceAxisEvent; 385 ret = OH_ArkUI_UIInputEvent_GetSourceType(&event); 386 EXPECT_EQ(ret, static_cast<int32_t>(SourceType::CROWN)); 387 } 388 /** 389 * @tc.name: OH_ArkUI_UIInputEvent_GetToolType001 390 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetToolType 391 * @tc.type: FUNC 392 */ 393 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetToolType001, TestSize.Level1) 394 { 395 ArkUI_UIInputEvent event; 396 auto ret = OH_ArkUI_UIInputEvent_GetSourceType(nullptr); 397 auto unknown = static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN); 398 EXPECT_EQ(ret, unknown); 399 400 event.eventTypeId = C_CLICK_EVENT_ID; 401 event.inputEvent = nullptr; 402 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 403 EXPECT_EQ(ret, unknown); 404 event.eventTypeId = C_MOUSE_EVENT_ID; 405 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 406 EXPECT_EQ(ret, unknown); 407 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 408 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 409 EXPECT_EQ(ret, unknown); 410 event.eventTypeId = C_HOVER_EVENT_ID; 411 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 412 EXPECT_EQ(ret, unknown); 413 event.eventTypeId = C_KEY_EVENT_ID; 414 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 415 EXPECT_EQ(ret, unknown); 416 } 417 418 /** 419 * @tc.name: OH_ArkUI_UIInputEvent_GetToolType002 420 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetToolType 421 * @tc.type: FUNC 422 */ 423 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetToolType002, TestSize.Level1) 424 { 425 ArkUI_UIInputEvent event; 426 auto unknown = static_cast<int32_t>(UI_INPUT_EVENT_TOOL_TYPE_UNKNOWN); 427 428 event.eventTypeId = C_TOUCH_EVENT_ID; 429 event.inputEvent = nullptr; 430 auto ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 431 EXPECT_EQ(ret, unknown); 432 ArkUITouchEvent touchEvent; 433 touchEvent.actionTouchPoint.toolType = 1; 434 event.inputEvent = &touchEvent; 435 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 436 EXPECT_EQ(ret, OHOS::Ace::NodeModel::ConvertToCInputEventToolType(touchEvent.actionTouchPoint.toolType)); 437 438 event.eventTypeId = C_AXIS_EVENT_ID; 439 event.inputEvent = nullptr; 440 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 441 EXPECT_EQ(ret, unknown); 442 ArkUIAxisEvent axisEvent; 443 axisEvent.actionTouchPoint.toolType = 2; 444 event.inputEvent = &axisEvent; 445 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 446 EXPECT_EQ(ret, OHOS::Ace::NodeModel::ConvertToCInputEventToolType(axisEvent.actionTouchPoint.toolType)); 447 448 event.eventTypeId = AXIS_EVENT_ID; 449 event.inputEvent = nullptr; 450 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 451 EXPECT_EQ(ret, unknown); 452 OHOS::Ace::AxisEvent aceAxisEvent; 453 aceAxisEvent.sourceTool = SourceTool::JOYSTICK; 454 event.inputEvent = &aceAxisEvent; 455 ret = OH_ArkUI_UIInputEvent_GetToolType(&event); 456 EXPECT_EQ(ret, OHOS::Ace::NodeModel::ConvertToCInputEventToolType(static_cast<int32_t>(aceAxisEvent.sourceTool))); 457 } 458 459 /** 460 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTime001 461 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTime 462 * @tc.type: FUNC 463 */ 464 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTime001, TestSize.Level1) 465 { 466 ArkUI_UIInputEvent event; 467 auto ret = OH_ArkUI_UIInputEvent_GetEventTime(nullptr); 468 EXPECT_EQ(ret, 0); 469 470 event.eventTypeId = C_CLICK_EVENT_ID; 471 event.inputEvent = nullptr; 472 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 473 EXPECT_EQ(ret, 0); 474 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 475 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 476 EXPECT_EQ(ret, 0); 477 event.eventTypeId = C_HOVER_EVENT_ID; 478 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 479 EXPECT_EQ(ret, 0); 480 481 event.eventTypeId = C_TOUCH_EVENT_ID; 482 event.inputEvent = nullptr; 483 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 484 EXPECT_EQ(ret, 0); 485 ArkUITouchEvent touchEvent; 486 touchEvent.timeStamp = 1; 487 event.inputEvent = &touchEvent; 488 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 489 EXPECT_EQ(ret, 1); 490 491 event.eventTypeId = TOUCH_EVENT_ID; 492 event.inputEvent = nullptr; 493 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 494 EXPECT_EQ(ret, 0); 495 OHOS::Ace::PointerEvent aceTouchEvent; 496 event.inputEvent = &aceTouchEvent; 497 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 498 EXPECT_EQ(ret, aceTouchEvent.time.time_since_epoch().count()); 499 } 500 501 /** 502 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTime002 503 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTime 504 * @tc.type: FUNC 505 */ 506 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTime002, TestSize.Level1) 507 { 508 ArkUI_UIInputEvent event; 509 510 event.eventTypeId = C_MOUSE_EVENT_ID; 511 event.inputEvent = nullptr; 512 auto ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 513 EXPECT_EQ(ret, 0); 514 ArkUIMouseEvent mouseEvent; 515 mouseEvent.timeStamp = 2; 516 event.inputEvent = &mouseEvent; 517 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 518 EXPECT_EQ(ret, 2); 519 520 event.eventTypeId = C_AXIS_EVENT_ID; 521 event.inputEvent = nullptr; 522 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 523 EXPECT_EQ(ret, 0); 524 ArkUIAxisEvent axisEvent; 525 axisEvent.timeStamp = 3; 526 event.inputEvent = &axisEvent; 527 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 528 EXPECT_EQ(ret, 3); 529 530 event.eventTypeId = AXIS_EVENT_ID; 531 event.inputEvent = nullptr; 532 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 533 EXPECT_EQ(ret, 0); 534 OHOS::Ace::PointerEvent aceAxisEvent; 535 event.inputEvent = &aceAxisEvent; 536 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 537 EXPECT_EQ(ret, aceAxisEvent.time.time_since_epoch().count()); 538 539 event.eventTypeId = C_KEY_EVENT_ID; 540 event.inputEvent = nullptr; 541 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 542 EXPECT_EQ(ret, 0); 543 ArkUIKeyEvent keyEvent; 544 keyEvent.timestamp = 4; 545 event.inputEvent = &keyEvent; 546 ret = OH_ArkUI_UIInputEvent_GetEventTime(&event); 547 EXPECT_EQ(ret, 4); 548 } 549 550 /** 551 * @tc.name: OH_ArkUI_UIInputEvent_GetDeviceId001 552 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetDeviceId 553 * @tc.type: FUNC 554 */ 555 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetDeviceId001, TestSize.Level1) 556 { 557 ArkUI_UIInputEvent event; 558 auto ret = OH_ArkUI_UIInputEvent_GetDeviceId(nullptr); 559 EXPECT_EQ(ret, -1); 560 561 event.eventTypeId = C_CLICK_EVENT_ID; 562 event.inputEvent = nullptr; 563 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 564 EXPECT_EQ(ret, -1); 565 event.eventTypeId = C_KEY_EVENT_ID; 566 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 567 EXPECT_EQ(ret, -1); 568 event.eventTypeId = C_MOUSE_EVENT_ID; 569 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 570 EXPECT_EQ(ret, -1); 571 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 572 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 573 EXPECT_EQ(ret, -1); 574 event.eventTypeId = C_HOVER_EVENT_ID; 575 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 576 EXPECT_EQ(ret, -1); 577 event.eventTypeId = C_TOUCH_EVENT_ID; 578 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 579 EXPECT_EQ(ret, -1); 580 } 581 582 /** 583 * @tc.name: OH_ArkUI_UIInputEvent_GetDeviceId002 584 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetDeviceId 585 * @tc.type: FUNC 586 */ 587 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetDeviceId002, TestSize.Level1) 588 { 589 ArkUI_UIInputEvent event; 590 event.eventTypeId = TOUCH_EVENT_ID; 591 event.apiVersion = 20; 592 event.inputEvent = nullptr; 593 auto ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 594 EXPECT_EQ(ret, -1); 595 OHOS::Ace::TouchEvent aceTouchEvent; 596 aceTouchEvent.deviceId = 1; 597 event.inputEvent = &aceTouchEvent; 598 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 599 EXPECT_EQ(ret, static_cast<int32_t>(aceTouchEvent.deviceId)); 600 601 event.eventTypeId = C_AXIS_EVENT_ID; 602 event.inputEvent = nullptr; 603 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 604 EXPECT_EQ(ret, -1); 605 ArkUIAxisEvent axisEvent; 606 axisEvent.deviceId = 2; 607 event.inputEvent = &axisEvent; 608 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 609 EXPECT_EQ(ret, static_cast<int32_t>(axisEvent.deviceId)); 610 611 event.eventTypeId = AXIS_EVENT_ID; 612 event.inputEvent = nullptr; 613 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 614 EXPECT_EQ(ret, -1); 615 OHOS::Ace::AxisEvent aceAxisEvent; 616 aceAxisEvent.deviceId = 3; 617 event.inputEvent = &aceAxisEvent; 618 ret = OH_ArkUI_UIInputEvent_GetDeviceId(&event); 619 EXPECT_EQ(ret, static_cast<int32_t>(aceAxisEvent.deviceId)); 620 } 621 622 /** 623 * @tc.name: OH_ArkUI_UIInputEvent_GetPressedKeys 624 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetPressedKeys 625 * @tc.type: FUNC 626 */ 627 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetPressedKeys, TestSize.Level1) 628 { 629 ArkUI_UIInputEvent event; 630 int32_t pressedKeyCodes[3]; 631 int32_t length = 0; 632 auto ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, pressedKeyCodes, &length); 633 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 634 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, nullptr, &length); 635 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 636 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(nullptr, pressedKeyCodes, &length); 637 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 638 639 ArkUIKeyEvent keyEvent; 640 length = 1; 641 event.inputEvent = nullptr; 642 keyEvent.keyCodesLength = 2; 643 ArkUI_Int32 keyPressedKeyCodes[2] = { 1, 2 }; 644 keyEvent.pressedKeyCodes = keyPressedKeyCodes; 645 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, pressedKeyCodes, &length); 646 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 647 event.inputEvent = &keyEvent; 648 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, pressedKeyCodes, &length); 649 EXPECT_EQ(ret, ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH); 650 length = 3; 651 ret = OH_ArkUI_UIInputEvent_GetPressedKeys(&event, pressedKeyCodes, &length); 652 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 653 } 654 655 /** 656 * @tc.name: OH_ArkUI_PointerEvent_GetPointerCount 657 * @tc.desc: Test OH_ArkUI_PointerEvent_GetPointerCount 658 * @tc.type: FUNC 659 */ 660 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPointerCount, TestSize.Level1) 661 { 662 ArkUI_UIInputEvent event; 663 auto ret = OH_ArkUI_PointerEvent_GetPointerCount(nullptr); 664 EXPECT_EQ(ret, 0); 665 666 event.eventTypeId = C_KEY_EVENT_ID; 667 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 668 EXPECT_EQ(ret, 0); 669 670 event.eventTypeId = C_TOUCH_EVENT_ID; 671 event.inputEvent = nullptr; 672 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 673 EXPECT_EQ(ret, 0); 674 ArkUITouchEvent touchEvent; 675 touchEvent.touchPointSize = 1; 676 event.inputEvent = &touchEvent; 677 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 678 EXPECT_EQ(ret, 1); 679 680 event.eventTypeId = C_MOUSE_EVENT_ID; 681 event.inputEvent = nullptr; 682 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 683 EXPECT_EQ(ret, 0); 684 ArkUIMouseEvent mouseEvent; 685 event.inputEvent = &mouseEvent; 686 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 687 EXPECT_EQ(ret, 1); 688 689 event.eventTypeId = C_MOUSE_EVENT_ID; 690 event.inputEvent = nullptr; 691 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 692 EXPECT_EQ(ret, 0); 693 ArkUIAxisEvent axisEvent; 694 event.inputEvent = &axisEvent; 695 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 696 EXPECT_EQ(ret, 1); 697 698 event.eventTypeId = C_CLICK_EVENT_ID; 699 event.inputEvent = nullptr; 700 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 701 EXPECT_EQ(ret, 0); 702 ArkUIClickEvent clickEvent; 703 clickEvent.clickPointSize = 2; 704 event.inputEvent = &clickEvent; 705 ret = OH_ArkUI_PointerEvent_GetPointerCount(&event); 706 EXPECT_EQ(ret, 2); 707 } 708 709 /** 710 * @tc.name: OH_ArkUI_PointerEvent_GetPointerId 711 * @tc.desc: Test OH_ArkUI_PointerEvent_GetPointerId 712 * @tc.type: FUNC 713 */ 714 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPointerId, TestSize.Level1) 715 { 716 ArkUI_UIInputEvent event; 717 auto ret = OH_ArkUI_PointerEvent_GetPointerId(nullptr, 0); 718 EXPECT_EQ(ret, 0); 719 720 event.eventTypeId = C_KEY_EVENT_ID; 721 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 722 EXPECT_EQ(ret, 0); 723 724 event.eventTypeId = C_TOUCH_EVENT_ID; 725 event.inputEvent = nullptr; 726 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 727 EXPECT_EQ(ret, 0); 728 ArkUITouchEvent touchEvent; 729 ArkUITouchPoint touchPointes[3]; 730 touchPointes[2].id = 10; 731 touchEvent.touchPointSize = 3; 732 touchEvent.touchPointes = touchPointes; 733 event.inputEvent = &touchEvent; 734 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 2); 735 EXPECT_EQ(ret, 10); 736 737 event.eventTypeId = C_MOUSE_EVENT_ID; 738 event.inputEvent = nullptr; 739 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 1); 740 EXPECT_EQ(ret, 0); 741 ArkUIMouseEvent mouseEvent; 742 mouseEvent.actionTouchPoint.id = 20; 743 event.inputEvent = &mouseEvent; 744 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 1); 745 EXPECT_EQ(ret, 0); 746 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 747 EXPECT_EQ(ret, 20); 748 749 event.eventTypeId = C_AXIS_EVENT_ID; 750 event.inputEvent = nullptr; 751 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 752 EXPECT_EQ(ret, 0); 753 ArkUIAxisEvent axisEvent; 754 axisEvent.actionTouchPoint.id = 30; 755 event.inputEvent = &axisEvent; 756 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 1); 757 EXPECT_EQ(ret, 0); 758 ret = OH_ArkUI_PointerEvent_GetPointerId(&event, 0); 759 EXPECT_EQ(ret, 30); 760 } 761 762 /** 763 * @tc.name: OH_ArkUI_PointerEvent_GetX001 764 * @tc.desc: Test OH_ArkUI_PointerEvent_GetX 765 * @tc.type: FUNC 766 */ 767 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetX001, TestSize.Level1) 768 { 769 ArkUI_UIInputEvent event; 770 auto ret = OH_ArkUI_PointerEvent_GetX(nullptr); 771 EXPECT_EQ(ret, 0.0f); 772 773 event.eventTypeId = C_KEY_EVENT_ID; 774 ret = OH_ArkUI_PointerEvent_GetX(&event); 775 EXPECT_EQ(ret, 0.0f); 776 777 event.eventTypeId = C_TOUCH_EVENT_ID; 778 ArkUITouchEvent touchEvent; 779 touchEvent.actionTouchPoint.nodeX = 1.1f; 780 event.inputEvent = nullptr; 781 ret = OH_ArkUI_PointerEvent_GetX(&event); 782 EXPECT_EQ(ret, 0.0f); 783 event.inputEvent = &touchEvent; 784 ret = OH_ArkUI_PointerEvent_GetX(&event); 785 EXPECT_EQ(ret, 1.1f); 786 787 event.eventTypeId = C_MOUSE_EVENT_ID; 788 ArkUIMouseEvent mouseEvent; 789 mouseEvent.actionTouchPoint.nodeX = 2.2f; 790 event.inputEvent = nullptr; 791 ret = OH_ArkUI_PointerEvent_GetX(&event); 792 EXPECT_EQ(ret, 0.0f); 793 event.inputEvent = &mouseEvent; 794 ret = OH_ArkUI_PointerEvent_GetX(&event); 795 EXPECT_EQ(ret, 2.2f); 796 } 797 798 /** 799 * @tc.name: OH_ArkUI_PointerEvent_GetX002 800 * @tc.desc: Test OH_ArkUI_PointerEvent_GetX 801 * @tc.type: FUNC 802 */ 803 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetX002, TestSize.Level1) 804 { 805 ArkUI_UIInputEvent event; 806 event.eventTypeId = C_AXIS_EVENT_ID; 807 ArkUIAxisEvent axisEvent; 808 axisEvent.actionTouchPoint.nodeX = 3.3f; 809 event.inputEvent = nullptr; 810 auto ret = OH_ArkUI_PointerEvent_GetX(&event); 811 EXPECT_EQ(ret, 0.0f); 812 event.inputEvent = &axisEvent; 813 ret = OH_ArkUI_PointerEvent_GetX(&event); 814 EXPECT_EQ(ret, 3.3f); 815 816 event.eventTypeId = TOUCH_EVENT_ID; 817 OHOS::Ace::TouchEvent aceTouchEvent; 818 aceTouchEvent.localX = 4.4f; 819 event.inputEvent = nullptr; 820 ret = OH_ArkUI_PointerEvent_GetX(&event); 821 EXPECT_EQ(ret, 0.0f); 822 event.inputEvent = &aceTouchEvent; 823 ret = OH_ArkUI_PointerEvent_GetX(&event); 824 EXPECT_EQ(ret, 4.4f); 825 826 event.eventTypeId = AXIS_EVENT_ID; 827 OHOS::Ace::AxisEvent aceAxisEvent; 828 aceAxisEvent.localX = 5.5f; 829 event.inputEvent = nullptr; 830 ret = OH_ArkUI_PointerEvent_GetX(&event); 831 EXPECT_EQ(ret, 0.0f); 832 event.inputEvent = &aceAxisEvent; 833 ret = OH_ArkUI_PointerEvent_GetX(&event); 834 EXPECT_EQ(ret, 5.5f); 835 } 836 837 /** 838 * @tc.name: OH_ArkUI_PointerEvent_GetY001 839 * @tc.desc: Test OH_ArkUI_PointerEvent_GetY 840 * @tc.type: FUNC 841 */ 842 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetY001, TestSize.Level1) 843 { 844 ArkUI_UIInputEvent event; 845 auto ret = OH_ArkUI_PointerEvent_GetY(nullptr); 846 EXPECT_EQ(ret, 0.0f); 847 848 event.eventTypeId = C_KEY_EVENT_ID; 849 ret = OH_ArkUI_PointerEvent_GetY(&event); 850 EXPECT_EQ(ret, 0.0f); 851 852 event.eventTypeId = C_TOUCH_EVENT_ID; 853 ArkUITouchEvent touchEvent; 854 touchEvent.actionTouchPoint.nodeY = 10.1f; 855 ret = OH_ArkUI_PointerEvent_GetY(&event); 856 EXPECT_EQ(ret, 0.0f); 857 event.inputEvent = &touchEvent; 858 ret = OH_ArkUI_PointerEvent_GetY(&event); 859 EXPECT_EQ(ret, 10.1f); 860 861 event.eventTypeId = C_MOUSE_EVENT_ID; 862 ArkUIMouseEvent mouseEvent; 863 mouseEvent.actionTouchPoint.nodeY = 20.2f; 864 event.inputEvent = nullptr; 865 ret = OH_ArkUI_PointerEvent_GetY(&event); 866 EXPECT_EQ(ret, 0.0f); 867 event.inputEvent = &mouseEvent; 868 ret = OH_ArkUI_PointerEvent_GetY(&event); 869 EXPECT_EQ(ret, 20.2f); 870 } 871 872 /** 873 * @tc.name: OH_ArkUI_PointerEvent_GetY002 874 * @tc.desc: Test OH_ArkUI_PointerEvent_GetY 875 * @tc.type: FUNC 876 */ 877 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetY002, TestSize.Level1) 878 { 879 ArkUI_UIInputEvent event; 880 881 event.eventTypeId = C_AXIS_EVENT_ID; 882 ArkUIAxisEvent axisEvent; 883 axisEvent.actionTouchPoint.nodeY = 30.3f; 884 event.inputEvent = nullptr; 885 auto ret = OH_ArkUI_PointerEvent_GetY(&event); 886 EXPECT_EQ(ret, 0.0f); 887 event.inputEvent = &axisEvent; 888 ret = OH_ArkUI_PointerEvent_GetY(&event); 889 EXPECT_EQ(ret, 30.3f); 890 891 event.eventTypeId = TOUCH_EVENT_ID; 892 OHOS::Ace::TouchEvent aceTouchEvent; 893 aceTouchEvent.localY = 40.4f; 894 event.inputEvent = nullptr; 895 ret = OH_ArkUI_PointerEvent_GetY(&event); 896 EXPECT_EQ(ret, 0.0f); 897 event.inputEvent = &aceTouchEvent; 898 ret = OH_ArkUI_PointerEvent_GetY(&event); 899 EXPECT_EQ(ret, 40.4f); 900 901 // AXIS_EVENT 类型测试（Ace AxisEvent） 902 event.eventTypeId = AXIS_EVENT_ID; 903 OHOS::Ace::AxisEvent aceAxisEvent; 904 aceAxisEvent.localY = 50.5f; 905 event.inputEvent = nullptr; 906 ret = OH_ArkUI_PointerEvent_GetY(&event); 907 EXPECT_EQ(ret, 0.0f); 908 event.inputEvent = &aceAxisEvent; 909 ret = OH_ArkUI_PointerEvent_GetY(&event); 910 EXPECT_EQ(ret, 50.5f); 911 } 912 913 /** 914 * @tc.name: OH_ArkUI_PointerEvent_GetWindowX001 915 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowX 916 * @tc.type: FUNC 917 */ 918 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowX001, TestSize.Level1) 919 { 920 ArkUI_UIInputEvent event; 921 auto ret = OH_ArkUI_PointerEvent_GetWindowX(nullptr); 922 EXPECT_EQ(ret, 0.0f); 923 924 event.eventTypeId = C_KEY_EVENT_ID; 925 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 926 EXPECT_EQ(ret, 0.0f); 927 928 event.eventTypeId = C_TOUCH_EVENT_ID; 929 ArkUITouchEvent touchEvent; 930 touchEvent.actionTouchPoint.windowX = 100.1f; 931 event.inputEvent = nullptr; 932 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 933 EXPECT_EQ(ret, 0.0f); 934 event.inputEvent = &touchEvent; 935 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 936 EXPECT_EQ(ret, 100.1f); 937 938 event.eventTypeId = C_MOUSE_EVENT_ID; 939 ArkUIMouseEvent mouseEvent; 940 mouseEvent.actionTouchPoint.windowX = 200.2f; 941 event.inputEvent = nullptr; 942 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 943 EXPECT_EQ(ret, 0.0f); 944 event.inputEvent = &mouseEvent; 945 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 946 EXPECT_EQ(ret, 200.2f); 947 } 948 949 /** 950 * @tc.name: OH_ArkUI_PointerEvent_GetWindowX002 951 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowX 952 * @tc.type: FUNC 953 */ 954 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowX002, TestSize.Level1) 955 { 956 ArkUI_UIInputEvent event; 957 958 event.eventTypeId = C_AXIS_EVENT_ID; 959 ArkUIAxisEvent axisEvent; 960 axisEvent.actionTouchPoint.windowX = 300.3f; 961 event.inputEvent = nullptr; 962 auto ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 963 EXPECT_EQ(ret, 0.0f); 964 event.inputEvent = &axisEvent; 965 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 966 EXPECT_EQ(ret, 300.3f); 967 968 event.eventTypeId = TOUCH_EVENT_ID; 969 OHOS::Ace::TouchEvent aceTouchEvent; 970 aceTouchEvent.x = 400.4f; 971 event.inputEvent = nullptr; 972 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 973 EXPECT_EQ(ret, 0.0f); 974 event.inputEvent = &aceTouchEvent; 975 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 976 EXPECT_EQ(ret, 400.4f); 977 978 event.eventTypeId = AXIS_EVENT_ID; 979 OHOS::Ace::AxisEvent aceAxisEvent; 980 aceAxisEvent.x = 500.5f; 981 event.inputEvent = nullptr; 982 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 983 EXPECT_EQ(ret, 0.0f); 984 event.inputEvent = &aceAxisEvent; 985 ret = OH_ArkUI_PointerEvent_GetWindowX(&event); 986 EXPECT_EQ(ret, 500.5f); 987 } 988 989 /** 990 * @tc.name: OH_ArkUI_PointerEvent_GetWindowY001 991 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowY 992 * @tc.type: FUNC 993 */ 994 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowY001, TestSize.Level1) 995 { 996 ArkUI_UIInputEvent event; 997 auto ret = OH_ArkUI_PointerEvent_GetWindowY(nullptr); 998 EXPECT_EQ(ret, 0.0f); 999 1000 event.eventTypeId = C_KEY_EVENT_ID; 1001 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1002 EXPECT_EQ(ret, 0.0f); 1003 1004 event.eventTypeId = C_TOUCH_EVENT_ID; 1005 ArkUITouchEvent touchEvent; 1006 touchEvent.actionTouchPoint.windowY = 100.1f; 1007 event.inputEvent = nullptr; 1008 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1009 EXPECT_EQ(ret, 0.0f); 1010 event.inputEvent = &touchEvent; 1011 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1012 EXPECT_EQ(ret, 100.1f); 1013 1014 event.eventTypeId = C_MOUSE_EVENT_ID; 1015 ArkUIMouseEvent mouseEvent; 1016 mouseEvent.actionTouchPoint.windowY = 200.2f; 1017 event.inputEvent = nullptr; 1018 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1019 EXPECT_EQ(ret, 0.0f); 1020 event.inputEvent = &mouseEvent; 1021 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1022 EXPECT_EQ(ret, 200.2f); 1023 } 1024 1025 /** 1026 * @tc.name: OH_ArkUI_PointerEvent_GetWindowY002 1027 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowY 1028 * @tc.type: FUNC 1029 */ 1030 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowY002, TestSize.Level1) 1031 { 1032 ArkUI_UIInputEvent event; 1033 event.eventTypeId = C_AXIS_EVENT_ID; 1034 ArkUIAxisEvent axisEvent; 1035 axisEvent.actionTouchPoint.windowY = 300.3f; 1036 event.inputEvent = nullptr; 1037 auto ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1038 EXPECT_EQ(ret, 0.0f); 1039 event.inputEvent = &axisEvent; 1040 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1041 EXPECT_EQ(ret, 300.3f); 1042 1043 event.eventTypeId = TOUCH_EVENT_ID; 1044 OHOS::Ace::TouchEvent aceTouchEvent; 1045 aceTouchEvent.y = 400.4f; 1046 event.inputEvent = nullptr; 1047 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1048 EXPECT_EQ(ret, 0.0f); 1049 event.inputEvent = &aceTouchEvent; 1050 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1051 EXPECT_EQ(ret, 400.4f); 1052 1053 event.eventTypeId = AXIS_EVENT_ID; 1054 OHOS::Ace::AxisEvent aceAxisEvent; 1055 aceAxisEvent.y = 500.5f; 1056 event.inputEvent = nullptr; 1057 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1058 EXPECT_EQ(ret, 0.0f); 1059 event.inputEvent = &aceAxisEvent; 1060 ret = OH_ArkUI_PointerEvent_GetWindowY(&event); 1061 EXPECT_EQ(ret, 500.5f); 1062 } 1063 1064 /** 1065 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX001 1066 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayX 1067 * @tc.type: FUNC 1068 */ 1069 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX001, TestSize.Level1) 1070 { 1071 ArkUI_UIInputEvent event; 1072 auto ret = OH_ArkUI_PointerEvent_GetDisplayX(nullptr); 1073 EXPECT_EQ(ret, 0.0f); 1074 1075 event.eventTypeId = C_KEY_EVENT_ID; 1076 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1077 EXPECT_EQ(ret, 0.0f); 1078 1079 event.eventTypeId = C_TOUCH_EVENT_ID; 1080 ArkUITouchEvent touchEvent; 1081 touchEvent.actionTouchPoint.screenX = 100.1f; 1082 event.inputEvent = nullptr; 1083 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1084 EXPECT_EQ(ret, 0.0f); 1085 event.inputEvent = &touchEvent; 1086 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1087 EXPECT_EQ(ret, 100.1f); 1088 1089 event.eventTypeId = C_MOUSE_EVENT_ID; 1090 ArkUIMouseEvent mouseEvent; 1091 mouseEvent.actionTouchPoint.screenX = 200.2f; 1092 event.inputEvent = nullptr; 1093 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1094 EXPECT_EQ(ret, 0.0f); 1095 event.inputEvent = &mouseEvent; 1096 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1097 EXPECT_EQ(ret, 200.2f); 1098 } 1099 1100 /** 1101 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX002 1102 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayX 1103 * @tc.type: FUNC 1104 */ 1105 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX002, TestSize.Level1) 1106 { 1107 ArkUI_UIInputEvent event; 1108 event.eventTypeId = C_AXIS_EVENT_ID; 1109 ArkUIAxisEvent axisEvent; 1110 axisEvent.actionTouchPoint.screenX = 300.3f; 1111 event.inputEvent = nullptr; 1112 auto ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1113 EXPECT_EQ(ret, 0.0f); 1114 event.inputEvent = &axisEvent; 1115 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1116 EXPECT_EQ(ret, 300.3f); 1117 1118 event.eventTypeId = TOUCH_EVENT_ID; 1119 OHOS::Ace::TouchEvent aceTouchEvent; 1120 aceTouchEvent.screenX = 400.4f; 1121 event.inputEvent = nullptr; 1122 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1123 EXPECT_EQ(ret, 0.0f); 1124 event.inputEvent = &aceTouchEvent; 1125 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1126 EXPECT_EQ(ret, 400.4f); 1127 1128 event.eventTypeId = AXIS_EVENT_ID; 1129 OHOS::Ace::AxisEvent aceAxisEvent; 1130 aceAxisEvent.screenX = 500.5f; 1131 event.inputEvent = nullptr; 1132 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1133 EXPECT_EQ(ret, 0.0f); 1134 event.inputEvent = &aceAxisEvent; 1135 ret = OH_ArkUI_PointerEvent_GetDisplayX(&event); 1136 EXPECT_EQ(ret, 500.5f); 1137 } 1138 1139 /** 1140 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayY001 1141 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayY 1142 * @tc.type: FUNC 1143 */ 1144 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayY001, TestSize.Level1) 1145 { 1146 ArkUI_UIInputEvent event; 1147 auto ret = OH_ArkUI_PointerEvent_GetDisplayY(nullptr); 1148 EXPECT_EQ(ret, 0.0f); 1149 1150 event.eventTypeId = C_KEY_EVENT_ID; 1151 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1152 EXPECT_EQ(ret, 0.0f); 1153 1154 event.eventTypeId = C_TOUCH_EVENT_ID; 1155 ArkUITouchEvent touchEvent; 1156 touchEvent.actionTouchPoint.screenY = 100.1f; 1157 event.inputEvent = nullptr; 1158 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1159 EXPECT_EQ(ret, 0.0f); 1160 event.inputEvent = &touchEvent; 1161 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1162 EXPECT_EQ(ret, 100.1f); 1163 1164 event.eventTypeId = C_MOUSE_EVENT_ID; 1165 ArkUIMouseEvent mouseEvent; 1166 mouseEvent.actionTouchPoint.screenY = 200.2f; 1167 event.inputEvent = nullptr; 1168 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1169 EXPECT_EQ(ret, 0.0f); 1170 event.inputEvent = &mouseEvent; 1171 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1172 EXPECT_EQ(ret, 200.2f); 1173 } 1174 1175 /** 1176 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayY002 1177 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayY 1178 * @tc.type: FUNC 1179 */ 1180 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayY002, TestSize.Level1) 1181 { 1182 ArkUI_UIInputEvent event; 1183 event.eventTypeId = C_AXIS_EVENT_ID; 1184 ArkUIAxisEvent axisEvent; 1185 axisEvent.actionTouchPoint.screenY = 300.3f; 1186 event.inputEvent = nullptr; 1187 auto ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1188 EXPECT_EQ(ret, 0.0f); 1189 event.inputEvent = &axisEvent; 1190 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1191 EXPECT_EQ(ret, 300.3f); 1192 1193 event.eventTypeId = TOUCH_EVENT_ID; 1194 OHOS::Ace::TouchEvent aceTouchEvent; 1195 aceTouchEvent.screenY = 400.4f; 1196 event.inputEvent = nullptr; 1197 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1198 EXPECT_EQ(ret, 0.0f); 1199 event.inputEvent = &aceTouchEvent; 1200 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1201 EXPECT_EQ(ret, 400.4f); 1202 1203 event.eventTypeId = AXIS_EVENT_ID; 1204 OHOS::Ace::AxisEvent aceAxisEvent; 1205 aceAxisEvent.screenY = 500.5f; 1206 event.inputEvent = nullptr; 1207 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1208 EXPECT_EQ(ret, 0.0f); 1209 event.inputEvent = &aceAxisEvent; 1210 ret = OH_ArkUI_PointerEvent_GetDisplayY(&event); 1211 EXPECT_EQ(ret, 500.5f); 1212 } 1213 /** 1214 * @tc.name: OH_ArkUI_PointerEvent_GetXByIndex 1215 * @tc.desc: Test OH_ArkUI_PointerEvent_GetXByIndex 1216 * @tc.type: FUNC 1217 */ 1218 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetXByIndex, TestSize.Level1) 1219 { 1220 ArkUI_UIInputEvent event; 1221 auto ret = OH_ArkUI_PointerEvent_GetXByIndex(nullptr, 0); 1222 EXPECT_EQ(ret, 0); 1223 1224 event.eventTypeId = C_KEY_EVENT_ID; 1225 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1226 EXPECT_EQ(ret, 0); 1227 1228 event.eventTypeId = C_TOUCH_EVENT_ID; 1229 event.inputEvent = nullptr; 1230 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1231 EXPECT_EQ(ret, 0); 1232 ArkUITouchEvent touchEvent; 1233 ArkUITouchPoint touchPointes[3]; 1234 touchPointes[2].nodeX = 10; 1235 touchEvent.touchPointSize = 3; 1236 touchEvent.touchPointes = touchPointes; 1237 event.inputEvent = &touchEvent; 1238 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 2); 1239 EXPECT_EQ(ret, 10); 1240 1241 event.eventTypeId = C_MOUSE_EVENT_ID; 1242 event.inputEvent = nullptr; 1243 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 1); 1244 EXPECT_EQ(ret, 0); 1245 ArkUIMouseEvent mouseEvent; 1246 mouseEvent.actionTouchPoint.nodeX = 20; 1247 event.inputEvent = &mouseEvent; 1248 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 1); 1249 EXPECT_EQ(ret, 0); 1250 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1251 EXPECT_EQ(ret, 20); 1252 1253 event.eventTypeId = C_AXIS_EVENT_ID; 1254 event.inputEvent = nullptr; 1255 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1256 EXPECT_EQ(ret, 0); 1257 ArkUIAxisEvent axisEvent; 1258 axisEvent.actionTouchPoint.nodeX = 30; 1259 event.inputEvent = &axisEvent; 1260 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 1); 1261 EXPECT_EQ(ret, 0); 1262 ret = OH_ArkUI_PointerEvent_GetXByIndex(&event, 0); 1263 EXPECT_EQ(ret, 30); 1264 } 1265 1266 /** 1267 * @tc.name: OH_ArkUI_PointerEvent_GetYByIndex 1268 * @tc.desc: Test OH_ArkUI_PointerEvent_GetYByIndex 1269 * @tc.type: FUNC 1270 */ 1271 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetYByIndex, TestSize.Level1) 1272 { 1273 ArkUI_UIInputEvent event; 1274 auto ret = OH_ArkUI_PointerEvent_GetYByIndex(nullptr, 0); 1275 EXPECT_EQ(ret, 0); 1276 1277 event.eventTypeId = C_KEY_EVENT_ID; 1278 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1279 EXPECT_EQ(ret, 0); 1280 1281 event.eventTypeId = C_TOUCH_EVENT_ID; 1282 event.inputEvent = nullptr; 1283 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1284 EXPECT_EQ(ret, 0); 1285 ArkUITouchEvent touchEvent; 1286 ArkUITouchPoint touchPointes[3]; 1287 touchPointes[2].nodeY = 10; 1288 touchEvent.touchPointSize = 3; 1289 touchEvent.touchPointes = touchPointes; 1290 event.inputEvent = &touchEvent; 1291 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 2); 1292 EXPECT_EQ(ret, 10); 1293 1294 event.eventTypeId = C_MOUSE_EVENT_ID; 1295 event.inputEvent = nullptr; 1296 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 1); 1297 EXPECT_EQ(ret, 0); 1298 ArkUIMouseEvent mouseEvent; 1299 mouseEvent.actionTouchPoint.nodeY = 20; 1300 event.inputEvent = &mouseEvent; 1301 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 1); 1302 EXPECT_EQ(ret, 0); 1303 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1304 EXPECT_EQ(ret, 20); 1305 1306 event.eventTypeId = C_AXIS_EVENT_ID; 1307 event.inputEvent = nullptr; 1308 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1309 EXPECT_EQ(ret, 0); 1310 ArkUIAxisEvent axisEvent; 1311 axisEvent.actionTouchPoint.nodeY = 30; 1312 event.inputEvent = &axisEvent; 1313 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 1); 1314 EXPECT_EQ(ret, 0); 1315 ret = OH_ArkUI_PointerEvent_GetYByIndex(&event, 0); 1316 EXPECT_EQ(ret, 30); 1317 } 1318 1319 /** 1320 * @tc.name: OH_ArkUI_PointerEvent_GetWindowXByIndex 1321 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowXByIndex 1322 * @tc.type: FUNC 1323 */ 1324 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowXByIndex, TestSize.Level1) 1325 { 1326 ArkUI_UIInputEvent event; 1327 auto ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(nullptr, 0); 1328 EXPECT_EQ(ret, 0); 1329 1330 event.eventTypeId = C_KEY_EVENT_ID; 1331 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1332 EXPECT_EQ(ret, 0); 1333 1334 event.eventTypeId = C_TOUCH_EVENT_ID; 1335 event.inputEvent = nullptr; 1336 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1337 EXPECT_EQ(ret, 0); 1338 ArkUITouchEvent touchEvent; 1339 ArkUITouchPoint touchPointes[3]; 1340 touchPointes[2].windowX = 10; 1341 touchEvent.touchPointSize = 3; 1342 touchEvent.touchPointes = touchPointes; 1343 event.inputEvent = &touchEvent; 1344 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 2); 1345 EXPECT_EQ(ret, 10); 1346 1347 event.eventTypeId = C_MOUSE_EVENT_ID; 1348 event.inputEvent = nullptr; 1349 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 1); 1350 EXPECT_EQ(ret, 0); 1351 ArkUIMouseEvent mouseEvent; 1352 mouseEvent.actionTouchPoint.windowX = 20; 1353 event.inputEvent = &mouseEvent; 1354 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 1); 1355 EXPECT_EQ(ret, 0); 1356 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1357 EXPECT_EQ(ret, 20); 1358 1359 event.eventTypeId = C_AXIS_EVENT_ID; 1360 event.inputEvent = nullptr; 1361 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1362 EXPECT_EQ(ret, 0); 1363 ArkUIAxisEvent axisEvent; 1364 axisEvent.actionTouchPoint.windowX = 30; 1365 event.inputEvent = &axisEvent; 1366 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 1); 1367 EXPECT_EQ(ret, 0); 1368 ret = OH_ArkUI_PointerEvent_GetWindowXByIndex(&event, 0); 1369 EXPECT_EQ(ret, 30); 1370 } 1371 1372 /** 1373 * @tc.name: OH_ArkUI_PointerEvent_GetWindowYByIndex 1374 * @tc.desc: Test OH_ArkUI_PointerEvent_GetWindowYByIndex 1375 * @tc.type: FUNC 1376 */ 1377 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetWindowYByIndex, TestSize.Level1) 1378 { 1379 ArkUI_UIInputEvent event; 1380 auto ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(nullptr, 0); 1381 EXPECT_EQ(ret, 0); 1382 1383 event.eventTypeId = C_KEY_EVENT_ID; 1384 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1385 EXPECT_EQ(ret, 0); 1386 1387 event.eventTypeId = C_TOUCH_EVENT_ID; 1388 event.inputEvent = nullptr; 1389 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1390 EXPECT_EQ(ret, 0); 1391 ArkUITouchEvent touchEvent; 1392 ArkUITouchPoint touchPointes[3]; 1393 touchPointes[2].windowY = 10; 1394 touchEvent.touchPointSize = 3; 1395 touchEvent.touchPointes = touchPointes; 1396 event.inputEvent = &touchEvent; 1397 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 2); 1398 EXPECT_EQ(ret, 10); 1399 1400 event.eventTypeId = C_MOUSE_EVENT_ID; 1401 event.inputEvent = nullptr; 1402 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 1); 1403 EXPECT_EQ(ret, 0); 1404 ArkUIMouseEvent mouseEvent; 1405 mouseEvent.actionTouchPoint.windowY = 20; 1406 event.inputEvent = &mouseEvent; 1407 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 1); 1408 EXPECT_EQ(ret, 0); 1409 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1410 EXPECT_EQ(ret, 20); 1411 1412 event.eventTypeId = C_AXIS_EVENT_ID; 1413 event.inputEvent = nullptr; 1414 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1415 EXPECT_EQ(ret, 0); 1416 ArkUIAxisEvent axisEvent; 1417 axisEvent.actionTouchPoint.windowY = 30; 1418 event.inputEvent = &axisEvent; 1419 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 1); 1420 EXPECT_EQ(ret, 0); 1421 ret = OH_ArkUI_PointerEvent_GetWindowYByIndex(&event, 0); 1422 EXPECT_EQ(ret, 30); 1423 } 1424 1425 /** 1426 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayXByIndex 1427 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayXByIndex 1428 * @tc.type: FUNC 1429 */ 1430 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayXByIndex, TestSize.Level1) 1431 { 1432 ArkUI_UIInputEvent event; 1433 auto ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(nullptr, 0); 1434 EXPECT_EQ(ret, 0); 1435 1436 event.eventTypeId = C_KEY_EVENT_ID; 1437 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1438 EXPECT_EQ(ret, 0); 1439 1440 event.eventTypeId = C_TOUCH_EVENT_ID; 1441 event.inputEvent = nullptr; 1442 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1443 EXPECT_EQ(ret, 0); 1444 ArkUITouchEvent touchEvent; 1445 ArkUITouchPoint touchPointes[3]; 1446 touchPointes[2].screenX = 10; 1447 touchEvent.touchPointSize = 3; 1448 touchEvent.touchPointes = touchPointes; 1449 event.inputEvent = &touchEvent; 1450 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 2); 1451 EXPECT_EQ(ret, 10); 1452 1453 event.eventTypeId = C_MOUSE_EVENT_ID; 1454 event.inputEvent = nullptr; 1455 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 1); 1456 EXPECT_EQ(ret, 0); 1457 ArkUIMouseEvent mouseEvent; 1458 mouseEvent.actionTouchPoint.screenX = 20; 1459 event.inputEvent = &mouseEvent; 1460 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 1); 1461 EXPECT_EQ(ret, 0); 1462 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1463 EXPECT_EQ(ret, 20); 1464 1465 event.eventTypeId = C_AXIS_EVENT_ID; 1466 event.inputEvent = nullptr; 1467 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1468 EXPECT_EQ(ret, 0); 1469 ArkUIAxisEvent axisEvent; 1470 axisEvent.actionTouchPoint.screenX = 30; 1471 event.inputEvent = &axisEvent; 1472 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 1); 1473 EXPECT_EQ(ret, 0); 1474 ret = OH_ArkUI_PointerEvent_GetDisplayXByIndex(&event, 0); 1475 EXPECT_EQ(ret, 30); 1476 } 1477 1478 /** 1479 * @tc.name: OH_ArkUI_PointerEvent_GetDisplayYByIndex 1480 * @tc.desc: Test OH_ArkUI_PointerEvent_GetDisplayYByIndex 1481 * @tc.type: FUNC 1482 */ 1483 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayYByIndex, TestSize.Level1) 1484 { 1485 ArkUI_UIInputEvent event; 1486 auto ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(nullptr, 0); 1487 EXPECT_EQ(ret, 0); 1488 1489 event.eventTypeId = C_KEY_EVENT_ID; 1490 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1491 EXPECT_EQ(ret, 0); 1492 1493 event.eventTypeId = C_TOUCH_EVENT_ID; 1494 event.inputEvent = nullptr; 1495 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1496 EXPECT_EQ(ret, 0); 1497 ArkUITouchEvent touchEvent; 1498 ArkUITouchPoint touchPointes[3]; 1499 touchPointes[2].screenY = 10; 1500 touchEvent.touchPointSize = 3; 1501 touchEvent.touchPointes = touchPointes; 1502 event.inputEvent = &touchEvent; 1503 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 2); 1504 EXPECT_EQ(ret, 10); 1505 1506 event.eventTypeId = C_MOUSE_EVENT_ID; 1507 event.inputEvent = nullptr; 1508 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 1); 1509 EXPECT_EQ(ret, 0); 1510 ArkUIMouseEvent mouseEvent; 1511 mouseEvent.actionTouchPoint.screenY = 20; 1512 event.inputEvent = &mouseEvent; 1513 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 1); 1514 EXPECT_EQ(ret, 0); 1515 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1516 EXPECT_EQ(ret, 20); 1517 1518 event.eventTypeId = C_AXIS_EVENT_ID; 1519 event.inputEvent = nullptr; 1520 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1521 EXPECT_EQ(ret, 0); 1522 ArkUIAxisEvent axisEvent; 1523 axisEvent.actionTouchPoint.screenY = 30; 1524 event.inputEvent = &axisEvent; 1525 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 1); 1526 EXPECT_EQ(ret, 0); 1527 ret = OH_ArkUI_PointerEvent_GetDisplayYByIndex(&event, 0); 1528 EXPECT_EQ(ret, 30); 1529 } 1530 1531 /** 1532 * @tc.name: OH_ArkUI_PointerEvent_GetRollAngle 1533 * @tc.desc: Test OH_ArkUI_PointerEvent_GetRollAngle 1534 * @tc.type: FUNC 1535 */ 1536 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetRollAngle, TestSize.Level1) 1537 { 1538 ArkUI_UIInputEvent event; 1539 double rollAngle = 2.0; 1540 auto ret = OH_ArkUI_PointerEvent_GetRollAngle(nullptr, &rollAngle); 1541 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1542 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, nullptr); 1543 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1544 1545 event.eventTypeId = C_KEY_EVENT_ID; 1546 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1547 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1548 1549 event.eventTypeId = C_TOUCH_EVENT_ID; 1550 event.inputEvent = nullptr; 1551 ArkUITouchEvent touchEvent; 1552 touchEvent.actionTouchPoint.rollAngle = 3.0; 1553 touchEvent.touchPointSize = 0; 1554 touchEvent.subKind = ON_AXIS; 1555 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1556 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1557 event.inputEvent = &touchEvent; 1558 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1559 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1560 touchEvent.touchPointSize = 3; 1561 ArkUITouchPoint pointes[3]; 1562 pointes[2].rollAngle = 4.0; 1563 touchEvent.touchPointes = pointes; 1564 event.inputEvent = &touchEvent; 1565 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1566 EXPECT_FLOAT_EQ(rollAngle, 4.0); 1567 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 1568 touchEvent.subKind = ON_HOVER_MOVE; 1569 event.inputEvent = &touchEvent; 1570 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1571 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 1572 EXPECT_FLOAT_EQ(rollAngle, 3.0); 1573 1574 event.eventTypeId = C_HOVER_EVENT_ID; 1575 event.inputEvent = nullptr; 1576 ArkUIHoverEvent hoverEvent; 1577 hoverEvent.rollAngle = 2.2; 1578 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1579 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 1580 event.inputEvent = &hoverEvent; 1581 ret = OH_ArkUI_PointerEvent_GetRollAngle(&event, &rollAngle); 1582 EXPECT_FLOAT_EQ(rollAngle, 2.2); 1583 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 1584 } 1585 1586 /** 1587 * @tc.name: OH_ArkUI_PointerEvent_GetGlobalDisplayX001 1588 * @tc.desc: Test OH_ArkUI_PointerEvent_GetGlobalDisplayX 1589 * @tc.type: FUNC 1590 */ 1591 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetGlobalDisplayX001, TestSize.Level1) 1592 { 1593 ArkUI_UIInputEvent event; 1594 auto ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(nullptr); 1595 EXPECT_EQ(ret, 0.0f); 1596 1597 event.eventTypeId = C_KEY_EVENT_ID; 1598 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1599 EXPECT_EQ(ret, 0.0f); 1600 1601 event.eventTypeId = C_TOUCH_EVENT_ID; 1602 ArkUITouchEvent touchEvent; 1603 touchEvent.actionTouchPoint.globalDisplayX = 100.1f; 1604 event.inputEvent = nullptr; 1605 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1606 EXPECT_EQ(ret, 0.0f); 1607 event.inputEvent = &touchEvent; 1608 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1609 EXPECT_EQ(ret, 100.1f); 1610 1611 event.eventTypeId = C_MOUSE_EVENT_ID; 1612 ArkUIMouseEvent mouseEvent; 1613 mouseEvent.actionTouchPoint.globalDisplayX = 200.2f; 1614 event.inputEvent = nullptr; 1615 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1616 EXPECT_EQ(ret, 0.0f); 1617 event.inputEvent = &mouseEvent; 1618 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1619 EXPECT_EQ(ret, 200.2f); 1620 } 1621 1622 /** 1623 * @tc.name: OH_ArkUI_PointerEvent_GetGlobalDisplayX002 1624 * @tc.desc: Test OH_ArkUI_PointerEvent_GetGlobalDisplayX 1625 * @tc.type: FUNC 1626 */ 1627 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetGlobalDisplayX002, TestSize.Level1) 1628 { 1629 ArkUI_UIInputEvent event; 1630 event.eventTypeId = C_AXIS_EVENT_ID; 1631 ArkUIAxisEvent axisEvent; 1632 axisEvent.actionTouchPoint.globalDisplayX = 300.3f; 1633 event.inputEvent = nullptr; 1634 auto ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1635 EXPECT_EQ(ret, 0.0f); 1636 event.inputEvent = &axisEvent; 1637 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1638 EXPECT_EQ(ret, 300.3f); 1639 1640 event.eventTypeId = TOUCH_EVENT_ID; 1641 OHOS::Ace::TouchEvent aceTouchEvent; 1642 aceTouchEvent.globalDisplayX = 400.4f; 1643 event.inputEvent = nullptr; 1644 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1645 EXPECT_EQ(ret, 0.0f); 1646 event.inputEvent = &aceTouchEvent; 1647 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1648 EXPECT_EQ(ret, 400.4f); 1649 1650 event.eventTypeId = AXIS_EVENT_ID; 1651 OHOS::Ace::AxisEvent aceAxisEvent; 1652 aceAxisEvent.globalDisplayX = 500.5f; 1653 event.inputEvent = nullptr; 1654 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1655 EXPECT_EQ(ret, 0.0f); 1656 event.inputEvent = &aceAxisEvent; 1657 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1658 EXPECT_EQ(ret, 500.5f); 1659 } 1660 1661 /** 1662 * @tc.name: OH_ArkUI_PointerEvent_GetGlobalDisplayX003 1663 * @tc.desc: Test OH_ArkUI_PointerEvent_GetGlobalDisplayX 1664 * @tc.type: FUNC 1665 */ 1666 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetGlobalDisplayX003, TestSize.Level1) 1667 { 1668 ArkUI_UIInputEvent event; 1669 event.eventTypeId = C_CLICK_EVENT_ID; 1670 ArkUIClickEvent clickEvent; 1671 clickEvent.globalDisplayX = 300.3f; 1672 event.inputEvent = nullptr; 1673 auto ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1674 EXPECT_EQ(ret, 0.0f); 1675 event.inputEvent = &clickEvent; 1676 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1677 EXPECT_EQ(ret, 300.3f); 1678 1679 event.eventTypeId = C_HOVER_EVENT_ID; 1680 ArkUIHoverEvent hoverEvent; 1681 hoverEvent.globalDisplayX = 400.4f; 1682 event.inputEvent = nullptr; 1683 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1684 EXPECT_EQ(ret, 0.0f); 1685 event.inputEvent = &hoverEvent; 1686 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayX(&event); 1687 EXPECT_EQ(ret, 400.4f); 1688 } 1689 1690 /** 1691 * @tc.name: OH_ArkUI_PointerEvent_GetGlobalDisplayY001 1692 * @tc.desc: Test OH_ArkUI_PointerEvent_GetGlobalDisplayY 1693 * @tc.type: FUNC 1694 */ 1695 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetGlobalDisplayY001, TestSize.Level1) 1696 { 1697 ArkUI_UIInputEvent event; 1698 auto ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(nullptr); 1699 EXPECT_EQ(ret, 0.0f); 1700 1701 event.eventTypeId = C_KEY_EVENT_ID; 1702 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1703 EXPECT_EQ(ret, 0.0f); 1704 1705 event.eventTypeId = C_TOUCH_EVENT_ID; 1706 ArkUITouchEvent touchEvent; 1707 touchEvent.actionTouchPoint.globalDisplayY = 100.1f; 1708 event.inputEvent = nullptr; 1709 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1710 EXPECT_EQ(ret, 0.0f); 1711 event.inputEvent = &touchEvent; 1712 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1713 EXPECT_EQ(ret, 100.1f); 1714 1715 event.eventTypeId = C_MOUSE_EVENT_ID; 1716 ArkUIMouseEvent mouseEvent; 1717 mouseEvent.actionTouchPoint.globalDisplayY = 200.2f; 1718 event.inputEvent = nullptr; 1719 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1720 EXPECT_EQ(ret, 0.0f); 1721 event.inputEvent = &mouseEvent; 1722 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1723 EXPECT_EQ(ret, 200.2f); 1724 } 1725 1726 /** 1727 * @tc.name: OH_ArkUI_PointerEvent_GetGlobalDisplayY002 1728 * @tc.desc: Test OH_ArkUI_PointerEvent_GetGlobalDisplayY 1729 * @tc.type: FUNC 1730 */ 1731 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetGlobalDisplayY002, TestSize.Level1) 1732 { 1733 ArkUI_UIInputEvent event; 1734 event.eventTypeId = C_AXIS_EVENT_ID; 1735 ArkUIAxisEvent axisEvent; 1736 axisEvent.actionTouchPoint.globalDisplayY = 300.3f; 1737 event.inputEvent = nullptr; 1738 auto ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1739 EXPECT_EQ(ret, 0.0f); 1740 event.inputEvent = &axisEvent; 1741 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1742 EXPECT_EQ(ret, 300.3f); 1743 1744 event.eventTypeId = TOUCH_EVENT_ID; 1745 OHOS::Ace::TouchEvent aceTouchEvent; 1746 aceTouchEvent.globalDisplayY = 400.4f; 1747 event.inputEvent = nullptr; 1748 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1749 EXPECT_EQ(ret, 0.0f); 1750 event.inputEvent = &aceTouchEvent; 1751 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1752 EXPECT_EQ(ret, 400.4f); 1753 1754 event.eventTypeId = AXIS_EVENT_ID; 1755 OHOS::Ace::AxisEvent aceAxisEvent; 1756 aceAxisEvent.globalDisplayY = 500.5f; 1757 event.inputEvent = nullptr; 1758 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1759 EXPECT_EQ(ret, 0.0f); 1760 event.inputEvent = &aceAxisEvent; 1761 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1762 EXPECT_EQ(ret, 500.5f); 1763 } 1764 1765 /** 1766 * @tc.name: OH_ArkUI_PointerEvent_GetGlobalDisplayY003 1767 * @tc.desc: Test OH_ArkUI_PointerEvent_GetGlobalDisplayY 1768 * @tc.type: FUNC 1769 */ 1770 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetGlobalDisplayY003, TestSize.Level1) 1771 { 1772 ArkUI_UIInputEvent event; 1773 event.eventTypeId = C_CLICK_EVENT_ID; 1774 ArkUIClickEvent clickEvent; 1775 clickEvent.globalDisplayY = 300.3f; 1776 event.inputEvent = nullptr; 1777 auto ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1778 EXPECT_EQ(ret, 0.0f); 1779 event.inputEvent = &clickEvent; 1780 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1781 EXPECT_EQ(ret, 300.3f); 1782 1783 event.eventTypeId = C_HOVER_EVENT_ID; 1784 ArkUIHoverEvent hoverEvent; 1785 hoverEvent.globalDisplayY = 400.4f; 1786 event.inputEvent = nullptr; 1787 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1788 EXPECT_EQ(ret, 0.0f); 1789 event.inputEvent = &hoverEvent; 1790 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayY(&event); 1791 EXPECT_EQ(ret, 400.4f); 1792 } 1793 1794 /** 1795 * @tc.name: OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex 1796 * @tc.desc: Test OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex 1797 * @tc.type: FUNC 1798 */ 1799 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex, TestSize.Level1) 1800 { 1801 ArkUI_UIInputEvent event; 1802 auto ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(nullptr, 0); 1803 EXPECT_EQ(ret, 0); 1804 1805 event.eventTypeId = C_KEY_EVENT_ID; 1806 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(&event, 0); 1807 EXPECT_EQ(ret, 0); 1808 1809 event.eventTypeId = C_TOUCH_EVENT_ID; 1810 event.inputEvent = nullptr; 1811 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(&event, 0); 1812 EXPECT_EQ(ret, 0); 1813 ArkUITouchEvent touchEvent; 1814 ArkUITouchPoint touchPointes[3]; 1815 touchPointes[2].globalDisplayX = 10; 1816 touchEvent.touchPointSize = 3; 1817 touchEvent.touchPointes = touchPointes; 1818 event.inputEvent = &touchEvent; 1819 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(&event, 2); 1820 EXPECT_EQ(ret, 10); 1821 1822 event.eventTypeId = C_MOUSE_EVENT_ID; 1823 event.inputEvent = nullptr; 1824 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(&event, 1); 1825 EXPECT_EQ(ret, 0); 1826 ArkUIMouseEvent mouseEvent; 1827 mouseEvent.actionTouchPoint.globalDisplayX = 20; 1828 event.inputEvent = &mouseEvent; 1829 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(&event, 1); 1830 EXPECT_EQ(ret, 0); 1831 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(&event, 0); 1832 EXPECT_EQ(ret, 20); 1833 1834 event.eventTypeId = C_AXIS_EVENT_ID; 1835 event.inputEvent = nullptr; 1836 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(&event, 0); 1837 EXPECT_EQ(ret, 0); 1838 ArkUIAxisEvent axisEvent; 1839 axisEvent.actionTouchPoint.globalDisplayX = 30; 1840 event.inputEvent = &axisEvent; 1841 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(&event, 1); 1842 EXPECT_EQ(ret, 0); 1843 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayXByIndex(&event, 0); 1844 EXPECT_EQ(ret, 30); 1845 } 1846 1847 /** 1848 * @tc.name: OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex 1849 * @tc.desc: Test OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex 1850 * @tc.type: FUNC 1851 */ 1852 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex, TestSize.Level1) 1853 { 1854 ArkUI_UIInputEvent event; 1855 auto ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(nullptr, 0); 1856 EXPECT_EQ(ret, 0); 1857 1858 event.eventTypeId = C_KEY_EVENT_ID; 1859 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(&event, 0); 1860 EXPECT_EQ(ret, 0); 1861 1862 event.eventTypeId = C_TOUCH_EVENT_ID; 1863 event.inputEvent = nullptr; 1864 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(&event, 0); 1865 EXPECT_EQ(ret, 0); 1866 ArkUITouchEvent touchEvent; 1867 ArkUITouchPoint touchPointes[3]; 1868 touchPointes[2].globalDisplayY = 10; 1869 touchEvent.touchPointSize = 3; 1870 touchEvent.touchPointes = touchPointes; 1871 event.inputEvent = &touchEvent; 1872 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(&event, 2); 1873 EXPECT_EQ(ret, 10); 1874 1875 event.eventTypeId = C_MOUSE_EVENT_ID; 1876 event.inputEvent = nullptr; 1877 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(&event, 1); 1878 EXPECT_EQ(ret, 0); 1879 ArkUIMouseEvent mouseEvent; 1880 mouseEvent.actionTouchPoint.globalDisplayY = 20; 1881 event.inputEvent = &mouseEvent; 1882 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(&event, 1); 1883 EXPECT_EQ(ret, 0); 1884 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(&event, 0); 1885 EXPECT_EQ(ret, 20); 1886 1887 event.eventTypeId = C_AXIS_EVENT_ID; 1888 event.inputEvent = nullptr; 1889 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(&event, 0); 1890 EXPECT_EQ(ret, 0); 1891 ArkUIAxisEvent axisEvent; 1892 axisEvent.actionTouchPoint.globalDisplayY = 30; 1893 event.inputEvent = &axisEvent; 1894 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(&event, 1); 1895 EXPECT_EQ(ret, 0); 1896 ret = OH_ArkUI_PointerEvent_GetGlobalDisplayYByIndex(&event, 0); 1897 EXPECT_EQ(ret, 30); 1898 } 1899 1900 /** 1901 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX 1902 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX 1903 * @tc.type: FUNC 1904 */ 1905 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX, TestSize.Level1) 1906 { 1907 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1908 auto result = OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX(nullptr, 0, 0); 1909 EXPECT_EQ(result, 0); 1910 1911 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1912 result = OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX(uiInputEvent.get(), 0, 0); 1913 EXPECT_EQ(result, 0); 1914 1915 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1916 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1917 ArkUIHistoryTouchEvent events[2]; 1918 ArkUITouchPoint pointes[2]; 1919 events[1].touchPointSize = 2; 1920 pointes[1].globalDisplayX = 30; 1921 events[1].touchPointes = pointes; 1922 touchEvent->historyEvents = events; 1923 touchEvent->historySize = 2; 1924 uiInputEvent->inputEvent = touchEvent.get(); 1925 result = OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX(uiInputEvent.get(), 1, 1); 1926 EXPECT_EQ(result, 30); 1927 1928 uiInputEvent->inputEvent = nullptr; 1929 result = OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayX(uiInputEvent.get(), 1, 1); 1930 EXPECT_EQ(result, 0); 1931 } 1932 1933 /** 1934 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY 1935 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY 1936 * @tc.type: FUNC 1937 */ 1938 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY, TestSize.Level1) 1939 { 1940 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1941 auto result = OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY(nullptr, 0, 0); 1942 EXPECT_EQ(result, 0); 1943 1944 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1945 result = OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY(uiInputEvent.get(), 0, 0); 1946 EXPECT_EQ(result, 0); 1947 1948 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1949 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1950 ArkUIHistoryTouchEvent events[2]; 1951 ArkUITouchPoint pointes[2]; 1952 events[1].touchPointSize = 2; 1953 pointes[1].globalDisplayY = 40; 1954 events[1].touchPointes = pointes; 1955 touchEvent->historyEvents = events; 1956 touchEvent->historySize = 2; 1957 uiInputEvent->inputEvent = touchEvent.get(); 1958 result = OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY(uiInputEvent.get(), 1, 1); 1959 EXPECT_EQ(result, 40); 1960 1961 uiInputEvent->inputEvent = nullptr; 1962 result = OH_ArkUI_PointerEvent_GetHistoryGlobalDisplayY(uiInputEvent.get(), 1, 1); 1963 EXPECT_EQ(result, 0); 1964 } 1965 1966 /** 1967 * @tc.name: CheckIsSupportedScenario001 1968 * @tc.desc: Test CheckIsSupportedScenario 1969 * @tc.type: FUNC 1970 */ 1971 HWTEST_F(UIInputEventTest, CheckIsSupportedScenario001, TestSize.Level1) 1972 { 1973 auto errorCode = CheckIsSupportedScenario(S_UNKNOWN, nullptr); 1974 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_PARAM_INVALID); 1975 1976 ArkUI_UIInputEvent event; 1977 event.inputType = ARKUI_UIINPUTEVENT_TYPE_AXIS; 1978 event.eventTypeId = AXIS_EVENT_ID; 1979 errorCode = CheckIsSupportedScenario(S_NXC_DISPATCH_AXIS_EVENT, &event); 1980 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 1981 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 1982 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 1983 1984 event.inputType = ARKUI_UIINPUTEVENT_TYPE_TOUCH; 1985 event.eventTypeId = TOUCH_EVENT_ID; 1986 errorCode = CheckIsSupportedScenario(S_NXC_ON_TOUCH_INTERCEPT, &event); 1987 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 1988 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 1989 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 1990 } 1991 1992 /** 1993 * @tc.name: CheckIsSupportedScenario002 1994 * @tc.desc: Test CheckIsSupportedScenario 1995 * @tc.type: FUNC 1996 */ 1997 HWTEST_F(UIInputEventTest, CheckIsSupportedScenario002, TestSize.Level1) 1998 { 1999 ArkUI_UIInputEvent event; 2000 ArkUITouchEvent touchEvent; 2001 event.inputType = ARKUI_UIINPUTEVENT_TYPE_TOUCH; 2002 event.eventTypeId = C_TOUCH_EVENT_ID; 2003 event.inputEvent = nullptr; 2004 auto errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2005 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_PARAM_INVALID); 2006 event.inputEvent = &touchEvent; 2007 touchEvent.subKind = ON_TOUCH; 2008 errorCode = CheckIsSupportedScenario(S_NODE_TOUCH_EVENT, &event); 2009 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2010 touchEvent.subKind = ON_TOUCH_INTERCEPT; 2011 errorCode = CheckIsSupportedScenario(S_NODE_ON_TOUCH_INTERCEPT, &event); 2012 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2013 touchEvent.subKind = ON_HOVER_MOVE; 2014 errorCode = CheckIsSupportedScenario(S_NODE_ON_HOVER_MOVE, &event); 2015 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2016 touchEvent.subKind = 0; 2017 errorCode = CheckIsSupportedScenario(S_GESTURE_TOUCH_EVENT, &event); 2018 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2019 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2020 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 2021 2022 ArkUIMouseEvent mouseEvent; 2023 event.inputType = ARKUI_UIINPUTEVENT_TYPE_MOUSE; 2024 event.eventTypeId = C_MOUSE_EVENT_ID; 2025 event.inputEvent = nullptr; 2026 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2027 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_PARAM_INVALID); 2028 event.inputEvent = &mouseEvent; 2029 mouseEvent.subKind = ON_MOUSE; 2030 errorCode = CheckIsSupportedScenario(S_NODE_ON_MOUSE, &event); 2031 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2032 mouseEvent.subKind = 0; 2033 errorCode = CheckIsSupportedScenario(S_GESTURE_MOUSE_EVENT, &event); 2034 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2035 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2036 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 2037 } 2038 2039 /** 2040 * @tc.name: CheckIsSupportedScenario003 2041 * @tc.desc: Test CheckIsSupportedScenario 2042 * @tc.type: FUNC 2043 */ 2044 HWTEST_F(UIInputEventTest, CheckIsSupportedScenario003, TestSize.Level1) 2045 { 2046 ArkUI_UIInputEvent event; 2047 ArkUIAxisEvent axisEvent; 2048 event.inputType = ARKUI_UIINPUTEVENT_TYPE_AXIS; 2049 event.eventTypeId = C_AXIS_EVENT_ID; 2050 event.inputEvent = nullptr; 2051 auto errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2052 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_PARAM_INVALID); 2053 event.inputEvent = &axisEvent; 2054 axisEvent.subKind = ON_AXIS; 2055 errorCode = CheckIsSupportedScenario(S_NODE_ON_AXIS, &event); 2056 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2057 axisEvent.subKind = 0; 2058 errorCode = CheckIsSupportedScenario(S_GESTURE_AXIS_EVENT, &event); 2059 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2060 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2061 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 2062 2063 ArkUIKeyEvent keyEvent; 2064 event.inputType = ARKUI_UIINPUTEVENT_TYPE_KEY; 2065 event.eventTypeId = C_KEY_EVENT_ID; 2066 event.inputEvent = nullptr; 2067 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2068 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_PARAM_INVALID); 2069 event.inputEvent = &keyEvent; 2070 keyEvent.subKind = ON_KEY_EVENT; 2071 errorCode = CheckIsSupportedScenario(S_NODE_ON_KEY_EVENT, &event); 2072 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2073 event.inputEvent = &keyEvent; 2074 keyEvent.subKind = ON_KEY_PREIME; 2075 errorCode = CheckIsSupportedScenario(S_NODE_ON_KEY_PRE_IME, &event); 2076 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2077 event.inputEvent = &keyEvent; 2078 keyEvent.subKind = ON_KEY_DISPATCH; 2079 errorCode = CheckIsSupportedScenario(S_NODE_DISPATCH_KEY_EVENT, &event); 2080 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2081 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2082 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 2083 } 2084 2085 /** 2086 * @tc.name: CheckIsSupportedScenario004 2087 * @tc.desc: Test CheckIsSupportedScenario 2088 * @tc.type: FUNC 2089 */ 2090 HWTEST_F(UIInputEventTest, CheckIsSupportedScenario004, TestSize.Level1) 2091 { 2092 ArkUI_UIInputEvent event; 2093 event.inputType = ARKUI_UIINPUTEVENT_TYPE_UNKNOWN; 2094 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2095 auto errorCode = CheckIsSupportedScenario(S_NODE_ON_FOCUS_AXIS, &event); 2096 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2097 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2098 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 2099 2100 event.inputType = ARKUI_UIINPUTEVENT_TYPE_UNKNOWN; 2101 event.eventTypeId = C_CLICK_EVENT_ID; 2102 errorCode = CheckIsSupportedScenario(S_NODE_ON_CLICK_EVENT, &event); 2103 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2104 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2105 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 2106 2107 event.inputType = ARKUI_UIINPUTEVENT_TYPE_KEY; 2108 errorCode = CheckIsSupportedScenario(S_GESTURE_CLICK_EVENT, &event); 2109 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2110 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2111 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 2112 2113 event.inputType = ARKUI_UIINPUTEVENT_TYPE_UNKNOWN; 2114 event.eventTypeId = C_HOVER_EVENT_ID; 2115 errorCode = CheckIsSupportedScenario(S_NODE_ON_HOVER_EVENT, &event); 2116 EXPECT_EQ(errorCode, ARKUI_ERROR_CODE_NO_ERROR); 2117 errorCode = CheckIsSupportedScenario(S_UNKNOWN, &event); 2118 EXPECT_EQ(errorCode, ARKUI_ERROR_INPUT_EVENT_TYPE_NOT_SUPPORT); 2119 } 2120 } // namespace OHOS::Ace 2121