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 "ui_input_event_test.h" 17 18 using namespace testing; 19 using namespace testing::ext; 20 namespace OHOS::Ace { 21 namespace { 22 constexpr int32_t ARKUI_DEVICE_ID = 1; 23 constexpr uint64_t ARKUI_TIME = 20; 24 constexpr ArkUI_Int32 AXIS_UPDATE = 2; 25 constexpr float ARKUI_X = 2.0; 26 constexpr float ARKUI_Y = 3.0; 27 constexpr float ARKUI_WIDTH = 2.0; 28 constexpr float ARKUI_HEIGHT = 3.0; 29 constexpr double ARKUI_TILTX = 2.0; 30 constexpr double ARKUI_TILTY = 3.0; 31 constexpr double ARKUI_PRESSURE = 1.0; 32 constexpr int32_t ARKUI_SOURCETYPE = 1; 33 constexpr int32_t ARKUI_TOOLTYPE = 7; 34 constexpr ArkUI_Uint64 ARKUI_MODIFIERKEYSTATE = 1; 35 constexpr ArkUI_Uint32 ARKUI_POINTERCOUNTER = 2; 36 } // namespace 37 /** 38 * @tc.name: UIInputEventTest001 39 * @tc.desc: Test the UIInputEvent property functions in focus axis event case. 40 * @tc.type: FUNC 41 */ 42 HWTEST_F(UIInputEventTest, UIInputEventTest001, TestSize.Level1) 43 { 44 /** 45 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 46 */ 47 ArkUI_NodeEvent nodeEvent; 48 ArkUINodeEvent event; 49 ArkUI_UIInputEvent uiInputEvent; 50 event.kind = ArkUIEventCategory::FOCUS_AXIS_EVENT; 51 event.focusAxisEvent.subKind = ArkUIEventSubKind::ON_FOCUS_AXIS; 52 event.focusAxisEvent.absXValue = 0.5; 53 event.focusAxisEvent.absYValue = 0.5; 54 event.focusAxisEvent.absZValue = 0.5; 55 event.focusAxisEvent.absRzValue = 0.5; 56 event.focusAxisEvent.absHat0XValue = 1; 57 event.focusAxisEvent.absHat0YValue = 1; 58 event.focusAxisEvent.absBrakeValue = 0.5; 59 event.focusAxisEvent.absGasValue = 0.5; 60 event.focusAxisEvent.sourceType = static_cast<int32_t>(SourceType::MOUSE); 61 event.focusAxisEvent.toolType = static_cast<int32_t>(SourceTool::JOYSTICK); 62 event.focusAxisEvent.deviceId = ARKUI_DEVICE_ID; 63 event.focusAxisEvent.timeStamp = ARKUI_TIME; 64 uiInputEvent.inputEvent = &event.focusAxisEvent; 65 uiInputEvent.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 66 nodeEvent.origin = &uiInputEvent; 67 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 68 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 69 70 /** 71 * @tc.steps: step2. call functions. 72 */ 73 auto absXValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_X); 74 auto absYValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_Y); 75 auto absZValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_Z); 76 auto absRzValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_RZ); 77 auto absHat0XValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_HAT0X); 78 auto absHat0YValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_HAT0Y); 79 auto absBrakeValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_BRAKE); 80 auto absGasValue = OH_ArkUI_FocusAxisEvent_GetAxisValue(inputEvent, UI_FOCUS_AXIS_EVENT_ABS_GAS); 81 auto diviceId = OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent); 82 auto time = OH_ArkUI_UIInputEvent_GetEventTime(inputEvent); 83 auto sourceType = OH_ArkUI_UIInputEvent_GetSourceType(inputEvent); 84 auto toolType = OH_ArkUI_UIInputEvent_GetToolType(inputEvent); 85 86 /** 87 * @tc.expected: Return expected results. 88 */ 89 EXPECT_EQ(absXValue, 0.5); 90 EXPECT_EQ(absYValue, 0.5); 91 EXPECT_EQ(absZValue, 0.5); 92 EXPECT_EQ(absRzValue, 0.5); 93 EXPECT_EQ(absHat0XValue, 1); 94 EXPECT_EQ(absHat0YValue, 1); 95 EXPECT_EQ(absBrakeValue, 0.5); 96 EXPECT_EQ(absGasValue, 0.5); 97 EXPECT_EQ(diviceId, ARKUI_DEVICE_ID); 98 EXPECT_EQ(time, ARKUI_TIME); 99 EXPECT_EQ(sourceType, UI_INPUT_EVENTT_SOURCE_TYPE_MOUSE); 100 EXPECT_EQ(toolType, UI_INPUT_EVENT_TOOL_TYPE_JOYSTICK); 101 } 102 103 /** 104 * @tc.name: NativeTouchEventTest001 105 * @tc.desc: Test OH_ArkUI_PointerEvent_GetChangedPointerId function. 106 * @tc.type: FUNC 107 */ 108 HWTEST_F(UIInputEventTest, NativeTouchEventTest001, TestSize.Level1) 109 { 110 /** 111 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 112 */ 113 ArkUI_NodeEvent nodeEvent; 114 ArkUINodeEvent event; 115 ArkUI_UIInputEvent uiInputEvent; 116 event.touchEvent.changedPointerId = 1; 117 event.touchEvent.touchPointSize = 1; 118 uint32_t pointerIndex = 0; 119 uiInputEvent.inputEvent = &event.touchEvent; 120 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 121 nodeEvent.origin = &uiInputEvent; 122 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 123 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 124 125 /** 126 * @tc.steps: step2. call functions. 127 */ 128 auto changed_PointerId = OH_ArkUI_PointerEvent_GetChangedPointerId(inputEvent, &pointerIndex); 129 130 /** 131 * @tc.expected: Return expected results. 132 */ 133 EXPECT_EQ(changed_PointerId, ArkUI_ErrorCode::ARKUI_ERROR_CODE_NO_ERROR); 134 EXPECT_EQ(pointerIndex, 1); 135 } 136 137 /** 138 * @tc.name: AxisEventGetActionTest001 139 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetAxisAction. 140 * @tc.type: FUNC 141 */ 142 HWTEST_F(UIInputEventTest, AxisEventGetActionTest001, TestSize.Level1) 143 { 144 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 145 EXPECT_NE(uiInputEvent, nullptr); 146 auto event = std::make_unique<OHOS::Ace::AxisEvent>(); 147 EXPECT_NE(event, nullptr); 148 149 event->action = AxisAction::BEGIN; 150 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 151 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 152 153 auto action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 154 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_BEGIN); 155 } 156 157 /** 158 * @tc.name: AxisEventGetActionTest002 159 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetAxisAction. 160 * @tc.type: FUNC 161 */ 162 HWTEST_F(UIInputEventTest, AxisEventGetActionTest002, TestSize.Level1) 163 { 164 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 165 EXPECT_NE(uiInputEvent, nullptr); 166 auto event = std::make_unique<ArkUIAxisEvent>(); 167 EXPECT_NE(event, nullptr); 168 169 event->action = AXIS_UPDATE; 170 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 171 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 172 173 auto action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 174 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_UPDATE); 175 } 176 177 /** 178 * @tc.name: AxisEventGetActionTest003 179 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetAxisActionfunction. 180 * @tc.type: FUNC 181 */ 182 HWTEST_F(UIInputEventTest, AxisEventGetActionTest003, TestSize.Level1) 183 { 184 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 185 EXPECT_NE(uiInputEvent, nullptr); 186 auto event = std::make_unique<ArkUIAxisEvent>(); 187 EXPECT_NE(event, nullptr); 188 189 event->action = AXIS_UPDATE; 190 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 191 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 192 193 auto action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 194 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_NONE); 195 196 action = OH_ArkUI_AxisEvent_GetAxisAction(nullptr); 197 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_NONE); 198 } 199 200 /** 201 * @tc.name: AxisEventGetActionTest004 202 * @tc.desc: Test function OH_ArkUI_AxisEvent_GetAxisAction. 203 * @tc.type: FUNC 204 */ 205 HWTEST_F(UIInputEventTest, AxisEventGetActionTest004, TestSize.Level1) 206 { 207 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 208 EXPECT_NE(uiInputEvent, nullptr); 209 210 uiInputEvent->inputEvent = nullptr; 211 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 212 auto action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 213 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_NONE); 214 215 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 216 action = OH_ArkUI_AxisEvent_GetAxisAction(uiInputEvent.get()); 217 EXPECT_EQ(action, UI_AXIS_EVENT_ACTION_NONE); 218 } 219 220 /** 221 * @tc.name: CapiInputTest001 222 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 223 * @tc.type: FUNC 224 */ 225 HWTEST_F(UIInputEventTest, CapiInputTest001, TestSize.Level1) 226 { 227 /** 228 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 229 */ 230 ArkUI_NodeEvent nodeEvent; 231 ArkUINodeEvent event; 232 ArkUI_UIInputEvent uiInputEvent; 233 event.kind = ArkUIEventCategory::CLICK_EVENT; 234 event.clickEvent.subKind = ArkUIEventSubKind::ON_CLICK_EVENT; 235 event.clickEvent.localX = ARKUI_X; 236 event.clickEvent.localY = ARKUI_Y; 237 event.clickEvent.timestamp = ARKUI_TIME; 238 event.clickEvent.sourceType = ARKUI_SOURCETYPE; 239 event.clickEvent.windowX = ARKUI_X; 240 event.clickEvent.windowY = ARKUI_Y; 241 event.clickEvent.displayX = ARKUI_X; 242 event.clickEvent.displayY = ARKUI_Y; 243 event.clickEvent.targetPositionX = ARKUI_X; 244 event.clickEvent.targetPositionY = ARKUI_Y; 245 event.clickEvent.targetGlobalPositionX = ARKUI_X; 246 event.clickEvent.targetGlobalPositionY = ARKUI_Y; 247 uiInputEvent.inputEvent = &event.clickEvent; 248 uiInputEvent.eventTypeId = C_CLICK_EVENT_ID; 249 nodeEvent.origin = &uiInputEvent; 250 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 251 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 252 253 /** 254 * @tc.expected: Return expected results. 255 */ 256 EXPECT_EQ(OH_ArkUI_PointerEvent_GetX(inputEvent), ARKUI_X); 257 EXPECT_EQ(OH_ArkUI_PointerEvent_GetY(inputEvent), ARKUI_Y); 258 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTime(inputEvent), ARKUI_TIME); 259 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetSourceType(inputEvent), ARKUI_SOURCETYPE); 260 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowX(inputEvent), ARKUI_X); 261 EXPECT_EQ(OH_ArkUI_PointerEvent_GetWindowY(inputEvent), ARKUI_Y); 262 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayX(inputEvent), ARKUI_X); 263 EXPECT_EQ(OH_ArkUI_PointerEvent_GetDisplayY(inputEvent), ARKUI_Y); 264 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 265 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 266 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 267 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 268 } 269 270 /** 271 * @tc.name: CapiInputTest002 272 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 273 * @tc.type: FUNC 274 */ 275 HWTEST_F(UIInputEventTest, CapiInputTest002, TestSize.Level1) 276 { 277 /** 278 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 279 */ 280 ArkUI_NodeEvent nodeEvent; 281 ArkUINodeEvent event; 282 ArkUI_UIInputEvent uiInputEvent; 283 event.kind = ArkUIEventCategory::CLICK_EVENT; 284 event.clickEvent.subKind = ArkUIEventSubKind::ON_CLICK_EVENT; 285 event.clickEvent.width = ARKUI_WIDTH; 286 event.clickEvent.height = ARKUI_HEIGHT; 287 event.clickEvent.tiltX = ARKUI_TILTX; 288 event.clickEvent.tiltY = ARKUI_TILTY; 289 event.clickEvent.pressure = ARKUI_PRESSURE; 290 event.clickEvent.toolType = ARKUI_TOOLTYPE; 291 event.clickEvent.deviceId = ARKUI_DEVICE_ID; 292 event.clickEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 293 event.clickEvent.clickPointSize = ARKUI_POINTERCOUNTER; 294 uiInputEvent.inputEvent = &event.clickEvent; 295 uiInputEvent.eventTypeId = C_CLICK_EVENT_ID; 296 nodeEvent.origin = &uiInputEvent; 297 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 298 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 299 300 /** 301 * @tc.expected: Return expected results. 302 */ 303 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_WIDTH); 304 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_HEIGHT); 305 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltX(inputEvent, 0), ARKUI_TILTX); 306 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltY(inputEvent, 0), ARKUI_TILTY); 307 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPressure(inputEvent, 0), ARKUI_PRESSURE); 308 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetToolType(inputEvent), NodeModel::ConvertToCInputEventToolType(ARKUI_TOOLTYPE)); 309 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 310 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 311 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPointerCount(inputEvent), ARKUI_POINTERCOUNTER); 312 } 313 314 /** 315 * @tc.name: CapiInputTest003 316 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 317 * @tc.type: FUNC 318 */ 319 HWTEST_F(UIInputEventTest, CapiInputTest003, TestSize.Level1) 320 { 321 /** 322 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 323 */ 324 ArkUI_NodeEvent nodeEvent; 325 ArkUINodeEvent event; 326 ArkUI_UIInputEvent uiInputEvent; 327 event.kind = ArkUIEventCategory::HOVER_EVENT; 328 event.hoverEvent.subKind = ON_HOVER_EVENT; 329 event.hoverEvent.isHover = true; 330 // width height x y globalx globaly 331 event.hoverEvent.targetPositionX = ARKUI_X; 332 event.hoverEvent.targetPositionY = ARKUI_Y; 333 event.hoverEvent.targetGlobalPositionX = ARKUI_X; 334 event.hoverEvent.targetGlobalPositionY = ARKUI_Y; 335 event.hoverEvent.width = ARKUI_WIDTH; 336 event.hoverEvent.height = ARKUI_HEIGHT; 337 // deviceid 338 event.hoverEvent.deviceId = ARKUI_DEVICE_ID; 339 // modifierkeystates 340 event.hoverEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 341 // timestamp 342 event.hoverEvent.timeStamp = ARKUI_TIME; 343 // sourcetool 344 event.hoverEvent.toolType = ARKUI_TOOLTYPE; 345 // source 346 event.hoverEvent.sourceType = ARKUI_SOURCETYPE; 347 // tiltX tiltY 348 event.hoverEvent.tiltX = ARKUI_TILTX; 349 event.hoverEvent.tiltY = ARKUI_TILTY; 350 // stoppropagation 351 event.hoverEvent.stopPropagation = false; 352 uiInputEvent.inputEvent = &event.hoverEvent; 353 uiInputEvent.eventTypeId = C_HOVER_EVENT_ID; 354 nodeEvent.origin = &uiInputEvent; 355 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 356 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 357 358 /** 359 * @tc.expected: Return expected results. 360 */ 361 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTime(inputEvent), ARKUI_TIME); 362 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetSourceType(inputEvent), ARKUI_SOURCETYPE); 363 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 364 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 365 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 366 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 367 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_X); 368 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_Y); 369 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltX(inputEvent, 0), ARKUI_TILTX); 370 EXPECT_EQ(OH_ArkUI_PointerEvent_GetTiltY(inputEvent, 0), ARKUI_TILTY); 371 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetToolType(inputEvent), NodeModel::ConvertToCInputEventToolType(ARKUI_TOOLTYPE)); 372 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 373 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 374 EXPECT_TRUE(OH_ArkUI_HoverEvent_IsHovered(inputEvent)); 375 const auto* hoverEvent = reinterpret_cast<ArkUIHoverEvent*>(inputEvent->inputEvent); 376 EXPECT_FALSE(hoverEvent->stopPropagation); 377 OH_ArkUI_PointerEvent_SetStopPropagation(inputEvent, true); 378 EXPECT_TRUE(hoverEvent->stopPropagation); 379 } 380 381 /** 382 * @tc.name: CapiInputTest004 383 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 384 * @tc.type: FUNC 385 */ 386 HWTEST_F(UIInputEventTest, CapiInputTest004, TestSize.Level1) 387 { 388 /** 389 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 390 */ 391 ArkUI_NodeEvent nodeEvent; 392 ArkUINodeEvent event; 393 ArkUI_UIInputEvent uiInputEvent; 394 event.kind = TOUCH_EVENT; 395 // width height x y globalx globaly 396 event.touchEvent.targetPositionX = ARKUI_X; 397 event.touchEvent.targetPositionY = ARKUI_Y; 398 event.touchEvent.targetGlobalPositionX = ARKUI_X; 399 event.touchEvent.targetGlobalPositionY = ARKUI_Y; 400 event.touchEvent.width = ARKUI_WIDTH; 401 event.touchEvent.height = ARKUI_HEIGHT; 402 // deviceid 403 event.touchEvent.deviceId = ARKUI_DEVICE_ID; 404 // modifierkeystates 405 event.touchEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 406 uiInputEvent.inputEvent = &event.touchEvent; 407 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 408 nodeEvent.origin = &uiInputEvent; 409 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 410 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 411 412 /** 413 * @tc.expected: Return expected results. 414 */ 415 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 416 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 417 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 418 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 419 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_X); 420 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_Y); 421 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 422 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 423 } 424 425 /** 426 * @tc.name: CapiInputTest005 427 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 428 * @tc.type: FUNC 429 */ 430 HWTEST_F(UIInputEventTest, CapiInputTest005, TestSize.Level1) 431 { 432 /** 433 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 434 */ 435 ArkUI_NodeEvent nodeEvent; 436 ArkUINodeEvent event; 437 ArkUI_UIInputEvent uiInputEvent; 438 event.kind = MOUSE_INPUT_EVENT; 439 event.mouseEvent.subKind = ON_MOUSE; 440 // width height x y globalx globaly 441 event.mouseEvent.targetPositionX = ARKUI_X; 442 event.mouseEvent.targetPositionY = ARKUI_Y; 443 event.mouseEvent.targetGlobalPositionX = ARKUI_X; 444 event.mouseEvent.targetGlobalPositionY = ARKUI_Y; 445 event.mouseEvent.width = ARKUI_WIDTH; 446 event.mouseEvent.height = ARKUI_HEIGHT; 447 // deviceid 448 event.mouseEvent.deviceId = ARKUI_DEVICE_ID; 449 // modifierkeystates 450 event.mouseEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 451 // pressure 452 event.mouseEvent.actionTouchPoint.pressure = ARKUI_PRESSURE; 453 // toolType 454 event.mouseEvent.actionTouchPoint.toolType = ARKUI_TOOLTYPE; 455 // source 456 event.mouseEvent.sourceType = ARKUI_SOURCETYPE; 457 // stoppropagation 458 event.mouseEvent.stopPropagation = false; 459 uiInputEvent.inputEvent = &event.mouseEvent; 460 uiInputEvent.eventTypeId = C_MOUSE_EVENT_ID; 461 nodeEvent.origin = &uiInputEvent; 462 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 463 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 464 465 /** 466 * @tc.expected: Return expected results. 467 */ 468 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 469 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 470 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 471 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 472 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_X); 473 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_Y); 474 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 475 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 476 EXPECT_EQ(OH_ArkUI_PointerEvent_GetPressure(inputEvent, 0), ARKUI_PRESSURE); 477 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetSourceType(inputEvent), ARKUI_SOURCETYPE); 478 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetToolType(inputEvent), NodeModel::ConvertToCInputEventToolType(ARKUI_TOOLTYPE)); 479 const auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(inputEvent->inputEvent); 480 EXPECT_FALSE(mouseEvent->stopPropagation); 481 OH_ArkUI_PointerEvent_SetStopPropagation(inputEvent, true); 482 EXPECT_TRUE(mouseEvent->stopPropagation); 483 } 484 485 /** 486 * @tc.name: CapiInputTest006 487 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 488 * @tc.type: FUNC 489 */ 490 HWTEST_F(UIInputEventTest, CapiInputTest006, TestSize.Level1) 491 { 492 /** 493 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 494 */ 495 ArkUI_NodeEvent nodeEvent; 496 ArkUINodeEvent event; 497 ArkUI_UIInputEvent uiInputEvent; 498 event.kind = ArkUIEventCategory::FOCUS_AXIS_EVENT; 499 event.focusAxisEvent.subKind = ArkUIEventCategory::FOCUS_AXIS_EVENT; 500 // width height x y globalx globaly 501 event.focusAxisEvent.targetPositionX = ARKUI_X; 502 event.focusAxisEvent.targetPositionY = ARKUI_Y; 503 event.focusAxisEvent.targetGlobalPositionX = ARKUI_X; 504 event.focusAxisEvent.targetGlobalPositionY = ARKUI_Y; 505 event.focusAxisEvent.width = ARKUI_WIDTH; 506 event.focusAxisEvent.height = ARKUI_HEIGHT; 507 // deviceid 508 event.focusAxisEvent.deviceId = ARKUI_DEVICE_ID; 509 // modifierkeystates 510 event.focusAxisEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 511 uiInputEvent.inputEvent = &event.focusAxisEvent; 512 uiInputEvent.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 513 nodeEvent.origin = &uiInputEvent; 514 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 515 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 516 517 /** 518 * @tc.expected: Return expected results. 519 */ 520 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionX(inputEvent), ARKUI_X); 521 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetPositionY(inputEvent), ARKUI_Y); 522 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(inputEvent), ARKUI_X); 523 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(inputEvent), ARKUI_Y); 524 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetWidth(inputEvent), ARKUI_X); 525 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetEventTargetHeight(inputEvent), ARKUI_Y); 526 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 527 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 528 } 529 530 /** 531 * @tc.name: CapiInputTest007 532 * @tc.desc: Test OH_ArkUI_UIInputEvent functions. 533 * @tc.type: FUNC 534 */ 535 HWTEST_F(UIInputEventTest, CapiInputTest007, TestSize.Level1) 536 { 537 /** 538 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 539 */ 540 ArkUI_NodeEvent nodeEvent; 541 ArkUINodeEvent event; 542 ArkUI_UIInputEvent uiInputEvent; 543 event.kind = ArkUIEventCategory::KEY_INPUT_EVENT; 544 event.keyEvent.subKind = ArkUIEventSubKind::ON_KEY_EVENT; 545 // deviceid 546 event.keyEvent.deviceId = ARKUI_DEVICE_ID; 547 // modifierkeystates 548 event.keyEvent.modifierKeyState = ARKUI_MODIFIERKEYSTATE; 549 uiInputEvent.inputEvent = &event.mouseEvent; 550 uiInputEvent.eventTypeId = C_KEY_EVENT_ID; 551 nodeEvent.origin = &uiInputEvent; 552 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 553 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 554 555 /** 556 * @tc.expected: Return expected results. 557 */ 558 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetDeviceId(inputEvent), ARKUI_DEVICE_ID); 559 EXPECT_EQ(OH_ArkUI_UIInputEvent_GetModifierKeyStates(inputEvent, 0), 401); 560 } 561 562 /** 563 * @tc.name: PointerEventGetInteractionHandTest001 564 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHand. 565 * @tc.type: FUNC 566 */ 567 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandTest001, TestSize.Level1) 568 { 569 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 570 EXPECT_NE(uiInputEvent, nullptr); 571 572 uiInputEvent->inputEvent = nullptr; 573 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 574 575 ArkUI_InteractionHand *hand = nullptr; 576 auto result = OH_ArkUI_PointerEvent_GetInteractionHand(uiInputEvent.get(), hand); 577 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 578 } 579 580 /** 581 * @tc.name: PointerEventGetInteractionHandTest002 582 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHand. 583 * @tc.type: FUNC 584 */ 585 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandTest002, TestSize.Level1) 586 { 587 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 588 EXPECT_NE(uiInputEvent, nullptr); 589 590 uiInputEvent->inputEvent = nullptr; 591 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 592 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 593 auto result = OH_ArkUI_PointerEvent_GetInteractionHand(uiInputEvent.get(), &hand); 594 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 595 EXPECT_EQ(hand, ARKUI_EVENT_HAND_NONE); 596 } 597 598 /** 599 * @tc.name: PointerEventGetInteractionHandTest003 600 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHand. 601 * @tc.type: FUNC 602 */ 603 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandTest003, TestSize.Level1) 604 { 605 ArkUINodeEvent event; 606 ArkUI_UIInputEvent uiInputEvent; 607 event.touchEvent.actionTouchPoint.operatingHand = ARKUI_EVENT_HAND_LEFT; 608 uiInputEvent.inputEvent = &event.touchEvent; 609 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 610 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 611 auto result = OH_ArkUI_PointerEvent_GetInteractionHand(&uiInputEvent, &hand); 612 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 613 EXPECT_EQ(hand, ARKUI_EVENT_HAND_LEFT); 614 } 615 616 /** 617 * @tc.name: PointerEventGetInteractionHandTest004 618 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHand. 619 * @tc.type: FUNC 620 */ 621 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandTest004, TestSize.Level1) 622 { 623 ArkUINodeEvent event; 624 ArkUI_UIInputEvent uiInputEvent; 625 event.touchEvent.actionTouchPoint.operatingHand = ARKUI_EVENT_HAND_RIGHT; 626 uiInputEvent.inputEvent = &event.touchEvent; 627 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 628 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 629 auto result = OH_ArkUI_PointerEvent_GetInteractionHand(&uiInputEvent, &hand); 630 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 631 EXPECT_EQ(hand, ARKUI_EVENT_HAND_RIGHT); 632 } 633 634 /** 635 * @tc.name: PointerEventGetInteractionHandByIndexTest001 636 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHandByIndex. 637 * @tc.type: FUNC 638 */ 639 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandByIndexTest001, TestSize.Level1) 640 { 641 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 642 EXPECT_NE(uiInputEvent, nullptr); 643 644 uiInputEvent->inputEvent = nullptr; 645 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 646 ArkUI_InteractionHand *hand = nullptr; 647 auto result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(uiInputEvent.get(), 0, hand); 648 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 649 } 650 651 /** 652 * @tc.name: PointerEventGetInteractionHandByIndexTest002 653 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHandByIndex. 654 * @tc.type: FUNC 655 */ 656 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandByIndexTest002, TestSize.Level1) 657 { 658 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 659 EXPECT_NE(uiInputEvent, nullptr); 660 661 uiInputEvent->inputEvent = nullptr; 662 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 663 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 664 auto result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(uiInputEvent.get(), 0, &hand); 665 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 666 EXPECT_EQ(hand, ARKUI_EVENT_HAND_NONE); 667 } 668 669 /** 670 * @tc.name: PointerEventGetInteractionHandByIndexTest003 671 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHandByIndex. 672 * @tc.type: FUNC 673 */ 674 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandByIndexTest003, TestSize.Level1) 675 { 676 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 677 EXPECT_NE(uiInputEvent, nullptr); 678 679 uiInputEvent->inputEvent = nullptr; 680 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 681 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 682 auto result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(uiInputEvent.get(), 0, &hand); 683 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 684 EXPECT_EQ(hand, ARKUI_EVENT_HAND_NONE); 685 } 686 687 /** 688 * @tc.name: PointerEventGetInteractionHandByIndexTest004 689 * @tc.desc: Test function OH_ArkUI_PointerEvent_GetInteractionHandByIndex. 690 * @tc.type: FUNC 691 */ 692 HWTEST_F(UIInputEventTest, PointerEventGetInteractionHandByIndexTest004, TestSize.Level1) 693 { 694 ArkUINodeEvent event; 695 ArkUI_UIInputEvent uiInputEvent; 696 ArkUITouchPoint points[2]; // 2 points 697 points[0].operatingHand = ARKUI_EVENT_HAND_LEFT; 698 points[1].operatingHand = ARKUI_EVENT_HAND_RIGHT; 699 event.touchEvent.touchPointes = points; 700 event.touchEvent.touchPointSize = 2; // 2 points 701 uiInputEvent.inputEvent = &event.touchEvent; 702 uiInputEvent.eventTypeId = C_TOUCH_EVENT_ID; 703 ArkUI_InteractionHand hand = ARKUI_EVENT_HAND_NONE; 704 int32_t result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(&uiInputEvent, 0, &hand); 705 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 706 EXPECT_EQ(hand, ARKUI_EVENT_HAND_LEFT); 707 708 hand = ARKUI_EVENT_HAND_NONE; 709 result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(&uiInputEvent, 1, &hand); 710 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 711 EXPECT_EQ(hand, ARKUI_EVENT_HAND_RIGHT); 712 713 hand = ARKUI_EVENT_HAND_NONE; 714 // 2 is out of range 715 result = OH_ArkUI_PointerEvent_GetInteractionHandByIndex(&uiInputEvent, 2, &hand); 716 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 717 EXPECT_EQ(hand, ARKUI_EVENT_HAND_NONE); 718 } 719 720 /** 721 * @tc.name: AxisEventScrollStepTest001 722 * @tc.desc: Test OH_ArkUI_AxisEvent_GetScrollStep function. 723 * @tc.type: FUNC 724 */ 725 HWTEST_F(UIInputEventTest, AxisEventScrollStepTest001, TestSize.Level1) 726 { 727 /** 728 * @tc.steps: step1.create ArkUI_NodeEvent, related function is called. 729 */ 730 ArkUI_NodeEvent nodeEvent; 731 ArkUINodeEvent event; 732 ArkUI_UIInputEvent uiInputEvent; 733 event.kind = ArkUIEventCategory::AXIS_EVENT; 734 event.axisEvent.subKind = ArkUIEventSubKind::ON_AXIS; 735 event.axisEvent.timeStamp = ARKUI_TIME; 736 event.axisEvent.scrollStep = 3; 737 uiInputEvent.inputEvent = &event.axisEvent; 738 uiInputEvent.eventTypeId = C_AXIS_EVENT_ID; 739 nodeEvent.origin = &uiInputEvent; 740 nodeEvent.category = NodeEventCategory::NODE_EVENT_CATEGORY_INPUT_EVENT; 741 auto inputEvent = OH_ArkUI_NodeEvent_GetInputEvent(&nodeEvent); 742 743 /** 744 * @tc.steps: step2. call functions. 745 */ 746 auto scroll_step = OH_ArkUI_AxisEvent_GetScrollStep(inputEvent); 747 748 /** 749 * @tc.expected: Return expected results. 750 */ 751 EXPECT_EQ(scroll_step, 3); 752 } 753 754 /* 755 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY001 756 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 757 * @tc.type: FUNC 758 */ 759 HWTEST_F(UIInputEventTest, MouseEventGetRawDeltaY001, TestSize.Level1) 760 { 761 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 762 EXPECT_NE(uiInputEvent, nullptr); 763 auto event = std::make_unique<ArkUIMouseEvent>(); 764 EXPECT_NE(event, nullptr); 765 766 event->rawDeltaY = 5.0; 767 uiInputEvent->inputEvent = event.get(); 768 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 769 770 auto action = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 771 EXPECT_EQ(action, 5.0); 772 } 773 774 /** 775 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY002 776 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 777 * @tc.type: FUNC 778 */ 779 HWTEST_F(UIInputEventTest, MouseEventGetRawDeltaY002, TestSize.Level1) 780 { 781 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 782 EXPECT_NE(uiInputEvent, nullptr); 783 auto event = std::make_unique<ArkUIMouseEvent>(); 784 EXPECT_NE(event, nullptr); 785 786 event->rawDeltaY = 5.0; 787 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 788 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 789 790 auto action = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 791 EXPECT_EQ(action, 0.0); 792 } 793 794 /** 795 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons001 796 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 797 * @tc.type: FUNC 798 */ 799 HWTEST_F(UIInputEventTest, MouseEventGetPressedButtons001, TestSize.Level1) 800 { 801 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 802 EXPECT_NE(uiInputEvent, nullptr); 803 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 804 auto event = std::make_unique<ArkUIMouseEvent>(); 805 event->pressedButtonsLength = 0; 806 EXPECT_NE(event, nullptr); 807 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 808 int32_t pressedButtons[] = {5, 5, 5}; 809 int32_t length = 1; 810 811 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 812 EXPECT_EQ(result, ARKUI_ERROR_CODE_NO_ERROR); 813 } 814 815 /** 816 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons002 817 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 818 * @tc.type: FUNC 819 */ 820 HWTEST_F(UIInputEventTest, MouseEventGetPressedButtons002, TestSize.Level1) 821 { 822 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 823 EXPECT_NE(uiInputEvent, nullptr); 824 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 825 auto event = std::make_unique<ArkUIMouseEvent>(); 826 event->pressedButtonsLength = 6; 827 EXPECT_NE(event, nullptr); 828 uiInputEvent->inputEvent = static_cast<void*>(event.get()); 829 int32_t pressedButtons[] = {5, 5, 5}; 830 int32_t length = 1; 831 832 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 833 EXPECT_EQ(result, ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH); 834 } 835 836 /** 837 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons003 838 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 839 * @tc.type: FUNC 840 */ 841 HWTEST_F(UIInputEventTest, MouseEventGetPressedButtons003, TestSize.Level1) 842 { 843 int32_t length = 1; 844 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(nullptr, nullptr, &length); 845 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 846 } 847 848 /** 849 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons004 850 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 851 * @tc.type: FUNC 852 */ 853 HWTEST_F(UIInputEventTest, MouseEventGetPressedButtons004, TestSize.Level1) 854 { 855 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 856 EXPECT_NE(uiInputEvent, nullptr); 857 uiInputEvent->inputEvent = nullptr; 858 int32_t pressedButtons[] = {5, 5, 5}; 859 int32_t length = 1; 860 861 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 862 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 863 } 864 865 /** 866 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId001 867 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 868 * @tc.type: FUNC 869 */ 870 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId001, TestSize.Level1) 871 { 872 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(nullptr); 873 EXPECT_EQ(result, 0); 874 } 875 876 /** 877 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId002 878 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 879 * @tc.type: FUNC 880 */ 881 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId002, TestSize.Level1) 882 { 883 auto event = std::make_unique<ArkUI_UIInputEvent>(); 884 event->eventTypeId = C_MOUSE_EVENT_ID; 885 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 886 mouseEvent->targetDisplayId = 1; 887 event->inputEvent = mouseEvent.get(); 888 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 889 EXPECT_EQ(result, 1); 890 } 891 892 /** 893 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId003 894 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 895 * @tc.type: FUNC 896 */ 897 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId003, TestSize.Level1) 898 { 899 auto event = std::make_unique<ArkUI_UIInputEvent>(); 900 event->eventTypeId = C_TOUCH_EVENT_ID; 901 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 902 touchEvent->targetDisplayId = 2; 903 event->inputEvent = touchEvent.get(); 904 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 905 EXPECT_EQ(result, 2); 906 } 907 908 /** 909 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId004 910 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 911 * @tc.type: FUNC 912 */ 913 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId004, TestSize.Level1) 914 { 915 auto event = std::make_unique<ArkUI_UIInputEvent>(); 916 event->eventTypeId = C_AXIS_EVENT_ID; 917 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 918 axisEvent->targetDisplayId = 3; 919 event->inputEvent = axisEvent.get(); 920 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 921 EXPECT_EQ(result, 3); 922 } 923 924 /** 925 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId005 926 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 927 * @tc.type: FUNC 928 */ 929 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId005, TestSize.Level1) 930 { 931 auto event = std::make_unique<ArkUI_UIInputEvent>(); 932 event->eventTypeId = C_FOCUS_AXIS_EVENT_ID; 933 auto focusAxisEvent = std::make_unique<ArkUIFocusAxisEvent>(); 934 focusAxisEvent->targetDisplayId = 4; 935 event->inputEvent = focusAxisEvent.get(); 936 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 937 EXPECT_EQ(result, 4); 938 } 939 940 /** 941 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId006 942 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 943 * @tc.type: FUNC 944 */ 945 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId006, TestSize.Level1) 946 { 947 auto event = std::make_unique<ArkUI_UIInputEvent>(); 948 event->eventTypeId = AXIS_EVENT_ID; 949 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(event.get()); 950 EXPECT_EQ(result, 0); 951 } 952 953 /** 954 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX001 955 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 956 * @tc.type: FUNC 957 */ 958 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX001, TestSize.Level1) 959 { 960 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(nullptr); 961 EXPECT_EQ(result, 0.0); 962 } 963 964 /** 965 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX002 966 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 967 * @tc.type: FUNC 968 */ 969 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX002, TestSize.Level1) 970 { 971 auto event = std::make_unique<ArkUI_UIInputEvent>(); 972 event->eventTypeId = C_MOUSE_EVENT_ID; 973 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 974 EXPECT_EQ(result, 0.0); 975 } 976 977 /** 978 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX003 979 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 980 * @tc.type: FUNC 981 */ 982 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX003, TestSize.Level1) 983 { 984 auto event = std::make_unique<ArkUI_UIInputEvent>(); 985 event->eventTypeId = C_MOUSE_EVENT_ID; 986 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 987 mouseEvent->rawDeltaX = 1; 988 event->inputEvent = mouseEvent.get(); 989 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 990 EXPECT_EQ(result, 1); 991 } 992 993 /** 994 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX004 995 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 996 * @tc.type: FUNC 997 */ 998 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX004, TestSize.Level1) 999 { 1000 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1001 event->eventTypeId = AXIS_EVENT_ID; 1002 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(event.get()); 1003 EXPECT_EQ(result, 0.0); 1004 } 1005 1006 /** 1007 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex001 1008 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1009 * @tc.type: FUNC 1010 */ 1011 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex001, TestSize.Level1) 1012 { 1013 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(nullptr, 0); 1014 EXPECT_EQ(result, 0); 1015 } 1016 1017 /** 1018 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex002 1019 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1020 * @tc.type: FUNC 1021 */ 1022 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex002, TestSize.Level1) 1023 { 1024 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1025 event->eventTypeId = C_TOUCH_EVENT_ID; 1026 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), -1); 1027 EXPECT_EQ(result, 0); 1028 } 1029 1030 /** 1031 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex003 1032 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1033 * @tc.type: FUNC 1034 */ 1035 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex003, TestSize.Level1) 1036 { 1037 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1038 event->eventTypeId = C_TOUCH_EVENT_ID; 1039 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), 0); 1040 EXPECT_EQ(result, 0); 1041 } 1042 1043 /** 1044 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex004 1045 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1046 * @tc.type: FUNC 1047 */ 1048 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex004, TestSize.Level1) 1049 { 1050 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1051 event->eventTypeId = C_TOUCH_EVENT_ID; 1052 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1053 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), -2); 1054 EXPECT_EQ(result, 0); 1055 } 1056 1057 /** 1058 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex005 1059 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1060 * @tc.type: FUNC 1061 */ 1062 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex005, TestSize.Level1) 1063 { 1064 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1065 event->eventTypeId = C_TOUCH_EVENT_ID; 1066 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1067 ArkUITouchPoint touchPoint; 1068 touchPoint.pressedTime = 20; 1069 touchEvent->touchPointes = &touchPoint; 1070 touchEvent->touchPointSize = 2; 1071 event->inputEvent = touchEvent.get(); 1072 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), 0); 1073 EXPECT_EQ(result, 20); 1074 } 1075 1076 /** 1077 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex006 1078 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1079 * @tc.type: FUNC 1080 */ 1081 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex006, TestSize.Level1) 1082 { 1083 auto event = std::make_unique<ArkUI_UIInputEvent>(); 1084 event->eventTypeId = AXIS_EVENT_ID; 1085 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(event.get(), 0); 1086 EXPECT_EQ(result, 0); 1087 } 1088 1089 /** 1090 * @tc.name: OH_ArkUI_PointerEvent_GetTouchAreaWidth 1091 * @tc.desc: test OH_ArkUI_PointerEvent_GetTouchAreaWidth 1092 * @tc.type: FUNC 1093 */ 1094 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTouchAreaWidth, TestSize.Level1) 1095 { 1096 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1097 auto result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(nullptr, 0); 1098 EXPECT_EQ(result, 0); 1099 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1100 result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(uiInputEvent.get(), 0); 1101 EXPECT_EQ(result, 0); 1102 1103 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1104 uiInputEvent->inputEvent = nullptr; 1105 result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(uiInputEvent.get(), 0); 1106 EXPECT_EQ(result, 0); 1107 1108 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1109 touchEvent->touchPointSize = 0; 1110 uiInputEvent->inputEvent = touchEvent.get(); 1111 result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(uiInputEvent.get(), 0); 1112 EXPECT_EQ(result, 0); 1113 1114 touchEvent->touchPointSize = 2; 1115 ArkUITouchPoint touchPointes[2]; 1116 touchPointes[1].contactAreaWidth = 1.0; 1117 touchEvent->touchPointes = touchPointes; 1118 uiInputEvent->inputEvent = touchEvent.get(); 1119 result = OH_ArkUI_PointerEvent_GetTouchAreaWidth(uiInputEvent.get(), 0); 1120 EXPECT_EQ(result, 1); 1121 } 1122 1123 /** 1124 * @tc.name: OH_ArkUI_PointerEvent_GetTouchAreaHeight 1125 * @tc.desc: test OH_ArkUI_PointerEvent_GetTouchAreaHeight 1126 * @tc.type: FUNC 1127 */ 1128 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTouchAreaHeight, TestSize.Level1) 1129 { 1130 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1131 auto result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(nullptr, 0); 1132 EXPECT_EQ(result, 0); 1133 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1134 result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(uiInputEvent.get(), 0); 1135 EXPECT_EQ(result, 0); 1136 1137 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1138 uiInputEvent->inputEvent = nullptr; 1139 result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(uiInputEvent.get(), 0); 1140 EXPECT_EQ(result, 0); 1141 1142 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1143 touchEvent->touchPointSize = 0; 1144 uiInputEvent->inputEvent = touchEvent.get(); 1145 result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(uiInputEvent.get(), 0); 1146 EXPECT_EQ(result, 0); 1147 1148 touchEvent->touchPointSize = 2; 1149 ArkUITouchPoint touchPointes[2]; 1150 touchPointes[1].contactAreaHeight = 1.0; 1151 touchEvent->touchPointes = touchPointes; 1152 uiInputEvent->inputEvent = touchEvent.get(); 1153 result = OH_ArkUI_PointerEvent_GetTouchAreaHeight(uiInputEvent.get(), 0); 1154 EXPECT_EQ(result, 1); 1155 } 1156 1157 /** 1158 * @tc.name: OH_ArkUI_PointerEvent_GetChangedPointerId 1159 * @tc.desc: test OH_ArkUI_PointerEvent_GetChangedPointerId 1160 * @tc.type: FUNC 1161 */ 1162 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetChangedPointerId, TestSize.Level1) 1163 { 1164 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1165 auto result = OH_ArkUI_PointerEvent_GetChangedPointerId(nullptr, 0); 1166 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1167 1168 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1169 result = OH_ArkUI_PointerEvent_GetChangedPointerId(uiInputEvent.get(), 0); 1170 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1171 1172 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1173 uiInputEvent->inputEvent = nullptr; 1174 result = OH_ArkUI_PointerEvent_GetChangedPointerId(uiInputEvent.get(), 0); 1175 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1176 1177 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1178 touchEvent->touchPointSize = 0; 1179 uiInputEvent->inputEvent = touchEvent.get(); 1180 result = OH_ArkUI_PointerEvent_GetChangedPointerId(uiInputEvent.get(), 0); 1181 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 1182 } 1183 1184 /** 1185 * @tc.name: OH_ArkUI_PointerEvent_GetHistorySize 1186 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistorySize 1187 * @tc.type: FUNC 1188 */ 1189 1190 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistorySize, TestSize.Level1) 1191 { 1192 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1193 auto result = OH_ArkUI_PointerEvent_GetHistorySize(nullptr); 1194 EXPECT_EQ(result, 0); 1195 1196 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1197 result = OH_ArkUI_PointerEvent_GetHistorySize(uiInputEvent.get()); 1198 EXPECT_EQ(result, 0); 1199 1200 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1201 uiInputEvent->inputEvent = nullptr; 1202 result = OH_ArkUI_PointerEvent_GetHistorySize(uiInputEvent.get()); 1203 EXPECT_EQ(result, 0); 1204 1205 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1206 ArkUIHistoryTouchEvent events[2]; 1207 touchEvent->historyEvents = events; 1208 touchEvent->historySize = 1; 1209 uiInputEvent->inputEvent = touchEvent.get(); 1210 result = OH_ArkUI_PointerEvent_GetHistorySize(uiInputEvent.get()); 1211 EXPECT_EQ(result, 1); 1212 } 1213 1214 /** 1215 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryEventTime 1216 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryEventTime 1217 * @tc.type: FUNC 1218 */ 1219 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryEventTime, TestSize.Level1) 1220 { 1221 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1222 auto result = OH_ArkUI_PointerEvent_GetHistoryEventTime(nullptr, 0); 1223 EXPECT_EQ(result, 0); 1224 1225 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1226 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 0); 1227 EXPECT_EQ(result, 0); 1228 1229 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1230 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1231 ArkUIHistoryTouchEvent events[2]; 1232 events[1].timeStamp = 1; 1233 touchEvent->historyEvents = events; 1234 touchEvent->historySize = 2; 1235 uiInputEvent->inputEvent = touchEvent.get(); 1236 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 1); 1237 EXPECT_EQ(result, 1); 1238 1239 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), -1); 1240 EXPECT_EQ(result, 0); 1241 1242 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 10); 1243 EXPECT_EQ(result, 0); 1244 1245 touchEvent->historyEvents = nullptr; 1246 uiInputEvent->inputEvent = touchEvent.get(); 1247 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 1); 1248 EXPECT_EQ(result, 0); 1249 1250 uiInputEvent->inputEvent = nullptr; 1251 result = OH_ArkUI_PointerEvent_GetHistoryEventTime(uiInputEvent.get(), 1); 1252 EXPECT_EQ(result, 0); 1253 } 1254 1255 /** 1256 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryPointerCount 1257 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryPointerCount 1258 * @tc.type: FUNC 1259 */ 1260 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryPointerCount, TestSize.Level1) 1261 { 1262 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1263 auto result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(nullptr, 0); 1264 EXPECT_EQ(result, 0); 1265 1266 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1267 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 0); 1268 EXPECT_EQ(result, 0); 1269 1270 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1271 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1272 ArkUIHistoryTouchEvent events[2]; 1273 events[1].touchPointSize = 1; 1274 touchEvent->historyEvents = events; 1275 touchEvent->historySize = 2; 1276 uiInputEvent->inputEvent = touchEvent.get(); 1277 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 1); 1278 EXPECT_EQ(result, 1); 1279 1280 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), -1); 1281 EXPECT_EQ(result, 0); 1282 1283 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 10); 1284 EXPECT_EQ(result, 0); 1285 1286 touchEvent->historyEvents = nullptr; 1287 uiInputEvent->inputEvent = touchEvent.get(); 1288 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 1); 1289 EXPECT_EQ(result, 0); 1290 1291 uiInputEvent->inputEvent = nullptr; 1292 result = OH_ArkUI_PointerEvent_GetHistoryPointerCount(uiInputEvent.get(), 1); 1293 EXPECT_EQ(result, 0); 1294 } 1295 1296 /** 1297 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryPointerId 1298 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryPointerId 1299 * @tc.type: FUNC 1300 */ 1301 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryPointerId, TestSize.Level1) 1302 { 1303 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1304 auto result = OH_ArkUI_PointerEvent_GetHistoryPointerId(nullptr, 0, 0); 1305 EXPECT_EQ(result, 0); 1306 1307 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1308 result = OH_ArkUI_PointerEvent_GetHistoryPointerId(uiInputEvent.get(), 0, 0); 1309 EXPECT_EQ(result, 0); 1310 1311 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1312 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1313 ArkUIHistoryTouchEvent events[2]; 1314 ArkUITouchPoint pointes[2]; 1315 events[1].touchPointSize = 2; 1316 pointes[1].id = 20; 1317 events[1].touchPointes = pointes; 1318 touchEvent->historyEvents = events; 1319 touchEvent->historySize = 2; 1320 uiInputEvent->inputEvent = touchEvent.get(); 1321 result = OH_ArkUI_PointerEvent_GetHistoryPointerId(uiInputEvent.get(), 1, 1); 1322 EXPECT_EQ(result, 20); 1323 1324 uiInputEvent->inputEvent = nullptr; 1325 result = OH_ArkUI_PointerEvent_GetHistoryPointerId(uiInputEvent.get(), 1, 1); 1326 EXPECT_EQ(result, 0); 1327 } 1328 1329 /** 1330 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryX 1331 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryX 1332 * @tc.type: FUNC 1333 */ 1334 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryX, TestSize.Level1) 1335 { 1336 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1337 auto result = OH_ArkUI_PointerEvent_GetHistoryX(nullptr, 0, 0); 1338 EXPECT_EQ(result, 0); 1339 1340 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1341 result = OH_ArkUI_PointerEvent_GetHistoryX(uiInputEvent.get(), 0, 0); 1342 EXPECT_EQ(result, 0); 1343 1344 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1345 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1346 ArkUIHistoryTouchEvent events[2]; 1347 ArkUITouchPoint pointes[2]; 1348 events[1].touchPointSize = 2; 1349 pointes[1].nodeX = 20; 1350 events[1].touchPointes = pointes; 1351 touchEvent->historyEvents = events; 1352 touchEvent->historySize = 2; 1353 uiInputEvent->inputEvent = touchEvent.get(); 1354 result = OH_ArkUI_PointerEvent_GetHistoryX(uiInputEvent.get(), 1, 1); 1355 EXPECT_EQ(result, 20); 1356 1357 uiInputEvent->inputEvent = nullptr; 1358 result = OH_ArkUI_PointerEvent_GetHistoryX(uiInputEvent.get(), 1, 1); 1359 EXPECT_EQ(result, 0); 1360 } 1361 1362 /** 1363 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryY 1364 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryY 1365 * @tc.type: FUNC 1366 */ 1367 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryY, TestSize.Level1) 1368 { 1369 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1370 auto result = OH_ArkUI_PointerEvent_GetHistoryY(nullptr, 0, 0); 1371 EXPECT_EQ(result, 0); 1372 1373 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1374 result = OH_ArkUI_PointerEvent_GetHistoryY(uiInputEvent.get(), 0, 0); 1375 EXPECT_EQ(result, 0); 1376 1377 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1378 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1379 ArkUIHistoryTouchEvent events[2]; 1380 ArkUITouchPoint pointes[2]; 1381 events[1].touchPointSize = 2; 1382 pointes[1].nodeY = 20; 1383 events[1].touchPointes = pointes; 1384 touchEvent->historyEvents = events; 1385 touchEvent->historySize = 2; 1386 uiInputEvent->inputEvent = touchEvent.get(); 1387 result = OH_ArkUI_PointerEvent_GetHistoryY(uiInputEvent.get(), 1, 1); 1388 EXPECT_EQ(result, 20); 1389 1390 uiInputEvent->inputEvent = nullptr; 1391 result = OH_ArkUI_PointerEvent_GetHistoryY(uiInputEvent.get(), 1, 1); 1392 EXPECT_EQ(result, 0); 1393 } 1394 1395 /** 1396 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryWindowX 1397 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryWindowX 1398 * @tc.type: FUNC 1399 */ 1400 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryWindowX, TestSize.Level1) 1401 { 1402 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1403 auto result = OH_ArkUI_PointerEvent_GetHistoryWindowX(nullptr, 0, 0); 1404 EXPECT_EQ(result, 0); 1405 1406 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1407 result = OH_ArkUI_PointerEvent_GetHistoryWindowX(uiInputEvent.get(), 0, 0); 1408 EXPECT_EQ(result, 0); 1409 1410 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1411 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1412 ArkUIHistoryTouchEvent events[2]; 1413 ArkUITouchPoint pointes[2]; 1414 events[1].touchPointSize = 2; 1415 pointes[1].windowX = 20; 1416 events[1].touchPointes = pointes; 1417 touchEvent->historyEvents = events; 1418 touchEvent->historySize = 2; 1419 uiInputEvent->inputEvent = touchEvent.get(); 1420 result = OH_ArkUI_PointerEvent_GetHistoryWindowX(uiInputEvent.get(), 1, 1); 1421 EXPECT_EQ(result, 20); 1422 1423 uiInputEvent->inputEvent = nullptr; 1424 result = OH_ArkUI_PointerEvent_GetHistoryWindowX(uiInputEvent.get(), 1, 1); 1425 EXPECT_EQ(result, 0); 1426 } 1427 1428 /** 1429 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryWindowY 1430 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryWindowY 1431 * @tc.type: FUNC 1432 */ 1433 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryWindowY, TestSize.Level1) 1434 { 1435 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1436 auto result = OH_ArkUI_PointerEvent_GetHistoryWindowY(nullptr, 0, 0); 1437 EXPECT_EQ(result, 0); 1438 1439 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1440 result = OH_ArkUI_PointerEvent_GetHistoryWindowY(uiInputEvent.get(), 0, 0); 1441 EXPECT_EQ(result, 0); 1442 1443 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1444 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1445 ArkUIHistoryTouchEvent events[2]; 1446 ArkUITouchPoint pointes[2]; 1447 events[1].touchPointSize = 2; 1448 pointes[1].windowY = 20; 1449 events[1].touchPointes = pointes; 1450 touchEvent->historyEvents = events; 1451 touchEvent->historySize = 2; 1452 uiInputEvent->inputEvent = touchEvent.get(); 1453 result = OH_ArkUI_PointerEvent_GetHistoryWindowY(uiInputEvent.get(), 1, 1); 1454 EXPECT_EQ(result, 20); 1455 1456 uiInputEvent->inputEvent = nullptr; 1457 result = OH_ArkUI_PointerEvent_GetHistoryWindowY(uiInputEvent.get(), 1, 1); 1458 EXPECT_EQ(result, 0); 1459 } 1460 1461 /** 1462 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryDisplayX 1463 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryDisplayX 1464 * @tc.type: FUNC 1465 */ 1466 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryDisplayX, TestSize.Level1) 1467 { 1468 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1469 auto result = OH_ArkUI_PointerEvent_GetHistoryDisplayX(nullptr, 0, 0); 1470 EXPECT_EQ(result, 0); 1471 1472 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1473 result = OH_ArkUI_PointerEvent_GetHistoryDisplayX(uiInputEvent.get(), 0, 0); 1474 EXPECT_EQ(result, 0); 1475 1476 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1477 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1478 ArkUIHistoryTouchEvent events[2]; 1479 ArkUITouchPoint pointes[2]; 1480 events[1].touchPointSize = 2; 1481 pointes[1].screenX = 20; 1482 events[1].touchPointes = pointes; 1483 touchEvent->historyEvents = events; 1484 touchEvent->historySize = 2; 1485 uiInputEvent->inputEvent = touchEvent.get(); 1486 result = OH_ArkUI_PointerEvent_GetHistoryDisplayX(uiInputEvent.get(), 1, 1); 1487 EXPECT_EQ(result, 20); 1488 1489 uiInputEvent->inputEvent = nullptr; 1490 result = OH_ArkUI_PointerEvent_GetHistoryDisplayX(uiInputEvent.get(), 1, 1); 1491 EXPECT_EQ(result, 0); 1492 } 1493 1494 /** 1495 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryDisplayY 1496 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryDisplayY 1497 * @tc.type: FUNC 1498 */ 1499 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryDisplayY, TestSize.Level1) 1500 { 1501 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1502 auto result = OH_ArkUI_PointerEvent_GetHistoryDisplayY(nullptr, 0, 0); 1503 EXPECT_EQ(result, 0); 1504 1505 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1506 result = OH_ArkUI_PointerEvent_GetHistoryDisplayY(uiInputEvent.get(), 0, 0); 1507 EXPECT_EQ(result, 0); 1508 1509 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1510 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1511 ArkUIHistoryTouchEvent events[2]; 1512 ArkUITouchPoint pointes[2]; 1513 events[1].touchPointSize = 2; 1514 pointes[1].screenY = 20; 1515 events[1].touchPointes = pointes; 1516 touchEvent->historyEvents = events; 1517 touchEvent->historySize = 2; 1518 uiInputEvent->inputEvent = touchEvent.get(); 1519 result = OH_ArkUI_PointerEvent_GetHistoryDisplayY(uiInputEvent.get(), 1, 1); 1520 EXPECT_EQ(result, 20); 1521 1522 uiInputEvent->inputEvent = nullptr; 1523 result = OH_ArkUI_PointerEvent_GetHistoryDisplayY(uiInputEvent.get(), 1, 1); 1524 EXPECT_EQ(result, 0); 1525 } 1526 1527 /** 1528 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryPressure 1529 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryPressure 1530 * @tc.type: FUNC 1531 */ 1532 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryPressure, TestSize.Level1) 1533 { 1534 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1535 auto result = OH_ArkUI_PointerEvent_GetHistoryPressure(nullptr, 0, 0); 1536 EXPECT_EQ(result, 0); 1537 1538 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1539 result = OH_ArkUI_PointerEvent_GetHistoryPressure(uiInputEvent.get(), 0, 0); 1540 EXPECT_EQ(result, 0); 1541 1542 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1543 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1544 ArkUIHistoryTouchEvent events[2]; 1545 ArkUITouchPoint pointes[2]; 1546 events[1].touchPointSize = 2; 1547 pointes[1].pressure = 20; 1548 events[1].touchPointes = pointes; 1549 touchEvent->historyEvents = events; 1550 touchEvent->historySize = 2; 1551 uiInputEvent->inputEvent = touchEvent.get(); 1552 result = OH_ArkUI_PointerEvent_GetHistoryPressure(uiInputEvent.get(), 1, 1); 1553 EXPECT_EQ(result, 20); 1554 1555 uiInputEvent->inputEvent = nullptr; 1556 result = OH_ArkUI_PointerEvent_GetHistoryPressure(uiInputEvent.get(), 1, 1); 1557 EXPECT_EQ(result, 0); 1558 } 1559 1560 /** 1561 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryTiltX 1562 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryTiltX 1563 * @tc.type: FUNC 1564 */ 1565 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryTiltX, TestSize.Level1) 1566 { 1567 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1568 auto result = OH_ArkUI_PointerEvent_GetHistoryTiltX(nullptr, 0, 0); 1569 EXPECT_EQ(result, 0); 1570 1571 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1572 result = OH_ArkUI_PointerEvent_GetHistoryTiltX(uiInputEvent.get(), 0, 0); 1573 EXPECT_EQ(result, 0); 1574 1575 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1576 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1577 ArkUIHistoryTouchEvent events[2]; 1578 ArkUITouchPoint pointes[2]; 1579 events[1].touchPointSize = 2; 1580 pointes[1].tiltX = 20; 1581 events[1].touchPointes = pointes; 1582 touchEvent->historyEvents = events; 1583 touchEvent->historySize = 2; 1584 uiInputEvent->inputEvent = touchEvent.get(); 1585 result = OH_ArkUI_PointerEvent_GetHistoryTiltX(uiInputEvent.get(), 1, 1); 1586 EXPECT_EQ(result, 20); 1587 1588 uiInputEvent->inputEvent = nullptr; 1589 result = OH_ArkUI_PointerEvent_GetHistoryTiltX(uiInputEvent.get(), 1, 1); 1590 EXPECT_EQ(result, 0); 1591 } 1592 1593 /** 1594 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryTiltY 1595 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryTiltY 1596 * @tc.type: FUNC 1597 */ 1598 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryTiltY, TestSize.Level1) 1599 { 1600 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1601 auto result = OH_ArkUI_PointerEvent_GetHistoryTiltY(nullptr, 0, 0); 1602 EXPECT_EQ(result, 0); 1603 1604 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1605 result = OH_ArkUI_PointerEvent_GetHistoryTiltY(uiInputEvent.get(), 0, 0); 1606 EXPECT_EQ(result, 0); 1607 1608 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1609 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1610 ArkUIHistoryTouchEvent events[2]; 1611 ArkUITouchPoint pointes[2]; 1612 events[1].touchPointSize = 2; 1613 pointes[1].tiltY = 20; 1614 events[1].touchPointes = pointes; 1615 touchEvent->historyEvents = events; 1616 touchEvent->historySize = 2; 1617 uiInputEvent->inputEvent = touchEvent.get(); 1618 result = OH_ArkUI_PointerEvent_GetHistoryTiltY(uiInputEvent.get(), 1, 1); 1619 EXPECT_EQ(result, 20); 1620 1621 uiInputEvent->inputEvent = nullptr; 1622 result = OH_ArkUI_PointerEvent_GetHistoryTiltY(uiInputEvent.get(), 1, 1); 1623 EXPECT_EQ(result, 0); 1624 } 1625 1626 /** 1627 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth 1628 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth 1629 * @tc.type: FUNC 1630 */ 1631 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth, TestSize.Level1) 1632 { 1633 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1634 auto result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(nullptr, 0, 0); 1635 EXPECT_EQ(result, 0); 1636 1637 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1638 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(uiInputEvent.get(), 0, 0); 1639 EXPECT_EQ(result, 0); 1640 1641 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1642 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1643 ArkUIHistoryTouchEvent events[2]; 1644 ArkUITouchPoint pointes[2]; 1645 events[1].touchPointSize = 2; 1646 pointes[1].contactAreaWidth = 20; 1647 events[1].touchPointes = pointes; 1648 touchEvent->historyEvents = events; 1649 touchEvent->historySize = 2; 1650 uiInputEvent->inputEvent = touchEvent.get(); 1651 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(uiInputEvent.get(), 1, 1); 1652 EXPECT_EQ(result, 20); 1653 1654 uiInputEvent->inputEvent = nullptr; 1655 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaWidth(uiInputEvent.get(), 1, 1); 1656 EXPECT_EQ(result, 0); 1657 } 1658 1659 /** 1660 * @tc.name: OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight 1661 * @tc.desc: test OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight 1662 * @tc.type: FUNC 1663 */ 1664 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight, TestSize.Level1) 1665 { 1666 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1667 auto result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(nullptr, 0, 0); 1668 EXPECT_EQ(result, 0); 1669 1670 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1671 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(uiInputEvent.get(), 0, 0); 1672 EXPECT_EQ(result, 0); 1673 1674 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1675 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1676 ArkUIHistoryTouchEvent events[2]; 1677 ArkUITouchPoint pointes[2]; 1678 events[1].touchPointSize = 2; 1679 pointes[1].contactAreaHeight = 20; 1680 events[1].touchPointes = pointes; 1681 touchEvent->historyEvents = events; 1682 touchEvent->historySize = 2; 1683 uiInputEvent->inputEvent = touchEvent.get(); 1684 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(uiInputEvent.get(), 1, 1); 1685 EXPECT_EQ(result, 20); 1686 1687 uiInputEvent->inputEvent = nullptr; 1688 result = OH_ArkUI_PointerEvent_GetHistoryTouchAreaHeight(uiInputEvent.get(), 1, 1); 1689 EXPECT_EQ(result, 0); 1690 } 1691 1692 /** 1693 * @tc.name: OH_ArkUI_AxisEvent_GetVerticalAxisValue 1694 * @tc.desc: test OH_ArkUI_AxisEvent_GetVerticalAxisValue 1695 * @tc.type: FUNC 1696 */ 1697 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_GetVerticalAxisValue, TestSize.Level1) 1698 { 1699 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1700 auto result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(nullptr); 1701 EXPECT_EQ(result, 0.0); 1702 1703 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1704 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 1705 EXPECT_EQ(result, 0.0); 1706 1707 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1708 auto axisEvent = std::make_unique<OHOS::Ace::AxisEvent>(); 1709 axisEvent->verticalAxis = 1.1; 1710 uiInputEvent->inputEvent = nullptr; 1711 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 1712 EXPECT_EQ(result, 0.0); 1713 1714 uiInputEvent->inputEvent = axisEvent.get(); 1715 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 1716 EXPECT_EQ(result, 1.1); 1717 1718 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 1719 1720 uiInputEvent->inputEvent = nullptr; 1721 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 1722 EXPECT_EQ(result, 0.0); 1723 1724 auto cAxisEvent = std::make_unique<ArkUIAxisEvent>(); 1725 cAxisEvent->verticalAxis = 1.1; 1726 uiInputEvent->inputEvent = cAxisEvent.get(); 1727 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 1728 EXPECT_EQ(result, 1.1); 1729 } 1730 1731 /** 1732 * @tc.name: OH_ArkUI_AxisEvent_GetHorizontalAxisValue 1733 * @tc.desc: test OH_ArkUI_AxisEvent_GetHorizontalAxisValue 1734 * @tc.type: FUNC 1735 */ 1736 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_GetHorizontalAxisValue, TestSize.Level1) 1737 { 1738 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1739 auto result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(nullptr); 1740 EXPECT_EQ(result, 0.0); 1741 1742 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1743 result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(uiInputEvent.get()); 1744 EXPECT_EQ(result, 0.0); 1745 1746 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1747 auto axisEvent = std::make_unique<OHOS::Ace::AxisEvent>(); 1748 axisEvent->horizontalAxis = 1.1; 1749 uiInputEvent->inputEvent = nullptr; 1750 result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(uiInputEvent.get()); 1751 EXPECT_EQ(result, 0.0); 1752 1753 uiInputEvent->inputEvent = axisEvent.get(); 1754 result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(uiInputEvent.get()); 1755 EXPECT_EQ(result, 1.1); 1756 1757 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 1758 uiInputEvent->inputEvent = nullptr; 1759 result = OH_ArkUI_AxisEvent_GetHorizontalAxisValue(uiInputEvent.get()); 1760 EXPECT_EQ(result, 0.0); 1761 1762 auto cAxisEvent = std::make_unique<ArkUIAxisEvent>(); 1763 cAxisEvent->verticalAxis = 1.1; 1764 uiInputEvent->inputEvent = cAxisEvent.get(); 1765 result = OH_ArkUI_AxisEvent_GetVerticalAxisValue(uiInputEvent.get()); 1766 EXPECT_EQ(result, 1.1); 1767 } 1768 1769 /** 1770 * @tc.name: OH_ArkUI_AxisEvent_GetPinchAxisScaleValue 1771 * @tc.desc: test OH_ArkUI_AxisEvent_GetPinchAxisScaleValue 1772 * @tc.type: FUNC 1773 */ 1774 HWTEST_F(UIInputEventTest, OH_ArkUI_AxisEvent_GetPinchAxisScaleValue, TestSize.Level1) 1775 { 1776 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1777 auto result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(nullptr); 1778 EXPECT_EQ(result, 0.0); 1779 1780 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1781 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 1782 EXPECT_EQ(result, 0.0); 1783 1784 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 1785 auto axisEvent = std::make_unique<OHOS::Ace::AxisEvent>(); 1786 axisEvent->pinchAxisScale = 1.1; 1787 uiInputEvent->inputEvent = nullptr; 1788 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 1789 EXPECT_EQ(result, 0.0); 1790 1791 uiInputEvent->inputEvent = axisEvent.get(); 1792 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 1793 EXPECT_EQ(result, 1.1); 1794 1795 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 1796 uiInputEvent->inputEvent = nullptr; 1797 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 1798 EXPECT_EQ(result, 0.0); 1799 1800 auto cAxisEvent = std::make_unique<ArkUIAxisEvent>(); 1801 cAxisEvent->pinchAxisScale = 1.1; 1802 uiInputEvent->inputEvent = cAxisEvent.get(); 1803 result = OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(uiInputEvent.get()); 1804 EXPECT_EQ(result, 1.1); 1805 } 1806 1807 /** 1808 * @tc.name: OH_ArkUI_PointerEvent_SetInterceptHitTestMode 1809 * @tc.desc: test OH_ArkUI_PointerEvent_SetInterceptHitTestMode 1810 * @tc.type: FUNC 1811 */ 1812 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetInterceptHitTestMode, TestSize.Level1) 1813 { 1814 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1815 auto mode = HTM_TRANSPARENT; 1816 auto result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(nullptr, mode); 1817 int32_t ERROR_CODE_PARAM_INVALID = 401; 1818 int32_t ERROR_CODE_NO_ERROR = 0; 1819 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 1820 1821 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1822 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1823 touchEvent->interceptResult = 0; 1824 uiInputEvent->inputEvent = touchEvent.get(); 1825 result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(uiInputEvent.get(), mode); 1826 EXPECT_EQ(touchEvent->interceptResult, static_cast<int32_t>(HTM_TRANSPARENT)); 1827 EXPECT_EQ(result, ERROR_CODE_NO_ERROR); 1828 1829 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 1830 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1831 mouseEvent->interceptResult = 0; 1832 uiInputEvent->inputEvent = nullptr; 1833 result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(uiInputEvent.get(), mode); 1834 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 1835 1836 uiInputEvent->inputEvent = mouseEvent.get(); 1837 result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(uiInputEvent.get(), mode); 1838 EXPECT_EQ(touchEvent->interceptResult, static_cast<int32_t>(HTM_TRANSPARENT)); 1839 1840 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 1841 result = OH_ArkUI_PointerEvent_SetInterceptHitTestMode(uiInputEvent.get(), mode); 1842 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 1843 } 1844 1845 /** 1846 * @tc.name: OH_ArkUI_PointerEvent_SetStopPropagation 1847 * @tc.desc: test OH_ArkUI_PointerEvent_SetStopPropagation 1848 * @tc.type: FUNC 1849 */ 1850 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_SetStopPropagation, TestSize.Level1) 1851 { 1852 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1853 auto stopPropagation = true; 1854 auto result = OH_ArkUI_PointerEvent_SetStopPropagation(nullptr, true); 1855 int32_t ERROR_CODE_PARAM_INVALID = 401; 1856 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 1857 1858 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1859 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1860 touchEvent->stopPropagation = false; 1861 uiInputEvent->inputEvent = touchEvent.get(); 1862 result = OH_ArkUI_PointerEvent_SetStopPropagation(uiInputEvent.get(), stopPropagation); 1863 EXPECT_EQ(touchEvent->stopPropagation, stopPropagation); 1864 1865 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 1866 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1867 mouseEvent->stopPropagation = false; 1868 uiInputEvent->inputEvent = mouseEvent.get(); 1869 result = OH_ArkUI_PointerEvent_SetStopPropagation(uiInputEvent.get(), stopPropagation); 1870 EXPECT_EQ(mouseEvent->stopPropagation, stopPropagation); 1871 1872 uiInputEvent->eventTypeId = C_HOVER_EVENT_ID; 1873 auto hoverEvent = std::make_unique<ArkUIHoverEvent>(); 1874 hoverEvent->stopPropagation = false; 1875 uiInputEvent->inputEvent = hoverEvent.get(); 1876 result = OH_ArkUI_PointerEvent_SetStopPropagation(uiInputEvent.get(), stopPropagation); 1877 EXPECT_EQ(hoverEvent->stopPropagation, stopPropagation); 1878 1879 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 1880 result = OH_ArkUI_PointerEvent_SetStopPropagation(uiInputEvent.get(), stopPropagation); 1881 EXPECT_EQ(result, ERROR_CODE_PARAM_INVALID); 1882 } 1883 1884 /** 1885 * @tc.name: OH_ArkUI_MouseEvent_GetMouseButton 1886 * @tc.desc: test OH_ArkUI_MouseEvent_GetMouseButton 1887 * @tc.type: FUNC 1888 */ 1889 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetMouseButton, TestSize.Level1) 1890 { 1891 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1892 auto result = OH_ArkUI_MouseEvent_GetMouseButton(nullptr); 1893 EXPECT_EQ(result, -1); 1894 1895 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 1896 result = OH_ArkUI_MouseEvent_GetMouseButton(uiInputEvent.get()); 1897 EXPECT_EQ(result, -1); 1898 1899 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1900 mouseEvent->button = 2; 1901 uiInputEvent->inputEvent = mouseEvent.get(); 1902 result = OH_ArkUI_MouseEvent_GetMouseButton(uiInputEvent.get()); 1903 EXPECT_EQ(result, 2); 1904 1905 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 1906 result = OH_ArkUI_MouseEvent_GetMouseButton(uiInputEvent.get()); 1907 EXPECT_EQ(result, -1); 1908 } 1909 1910 /** 1911 * @tc.name: OH_ArkUI_MouseEvent_GetMouseAction 1912 * @tc.desc: test OH_ArkUI_MouseEvent_GetMouseAction 1913 * @tc.type: FUNC 1914 */ 1915 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetMouseAction, TestSize.Level1) 1916 { 1917 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1918 auto result = OH_ArkUI_MouseEvent_GetMouseAction(nullptr); 1919 EXPECT_EQ(result, -1); 1920 1921 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 1922 result = OH_ArkUI_MouseEvent_GetMouseAction(uiInputEvent.get()); 1923 EXPECT_EQ(result, -1); 1924 1925 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1926 mouseEvent->action = 2; 1927 uiInputEvent->inputEvent = mouseEvent.get(); 1928 result = OH_ArkUI_MouseEvent_GetMouseAction(uiInputEvent.get()); 1929 EXPECT_EQ(result, 2); 1930 1931 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 1932 result = OH_ArkUI_MouseEvent_GetMouseAction(uiInputEvent.get()); 1933 EXPECT_EQ(result, -1); 1934 } 1935 1936 /** 1937 * @tc.name: OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1938 * @tc.desc: test OH_ArkUI_PointerEvent_GetPressedTimeByIndex 1939 * @tc.type: FUNC 1940 */ 1941 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetPressedTimeByIndex, TestSize.Level1) 1942 { 1943 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1944 auto result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(nullptr, 0); 1945 EXPECT_EQ(result, 0); 1946 1947 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 1948 result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(uiInputEvent.get(), 0); 1949 EXPECT_EQ(result, 0); 1950 1951 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 1952 touchEvent->touchPointSize = 2; 1953 ArkUITouchPoint touchPointes[2]; 1954 touchPointes[1].pressedTime = 1; 1955 touchEvent->touchPointes = touchPointes; 1956 uiInputEvent->inputEvent = touchEvent.get(); 1957 result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(uiInputEvent.get(), 1); 1958 EXPECT_EQ(result, 1); 1959 1960 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 1961 result = OH_ArkUI_PointerEvent_GetPressedTimeByIndex(uiInputEvent.get(), 1); 1962 EXPECT_EQ(result, 0); 1963 } 1964 1965 /** 1966 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaX 1967 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaX 1968 * @tc.type: FUNC 1969 */ 1970 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaX, TestSize.Level1) 1971 { 1972 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1973 auto result = OH_ArkUI_MouseEvent_GetRawDeltaX(nullptr); 1974 EXPECT_EQ(result, 0.0f); 1975 1976 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 1977 result = OH_ArkUI_MouseEvent_GetRawDeltaX(uiInputEvent.get()); 1978 EXPECT_EQ(result, 0.0f); 1979 1980 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 1981 mouseEvent->rawDeltaX = 2.0f; 1982 uiInputEvent->inputEvent = mouseEvent.get(); 1983 result = OH_ArkUI_MouseEvent_GetRawDeltaX(uiInputEvent.get()); 1984 EXPECT_EQ(result, 2.0f); 1985 1986 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 1987 result = OH_ArkUI_MouseEvent_GetRawDeltaX(uiInputEvent.get()); 1988 EXPECT_EQ(result, 0.0f); 1989 } 1990 1991 /** 1992 * @tc.name: OH_ArkUI_MouseEvent_GetRawDeltaY 1993 * @tc.desc: test OH_ArkUI_MouseEvent_GetRawDeltaY 1994 * @tc.type: FUNC 1995 */ 1996 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetRawDeltaY, TestSize.Level1) 1997 { 1998 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 1999 auto result = OH_ArkUI_MouseEvent_GetRawDeltaY(nullptr); 2000 EXPECT_EQ(result, 0.0f); 2001 2002 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2003 result = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 2004 EXPECT_EQ(result, 0.0f); 2005 2006 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2007 mouseEvent->rawDeltaY = 2.0f; 2008 uiInputEvent->inputEvent = mouseEvent.get(); 2009 result = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 2010 EXPECT_EQ(result, 2.0f); 2011 2012 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2013 result = OH_ArkUI_MouseEvent_GetRawDeltaY(uiInputEvent.get()); 2014 EXPECT_EQ(result, 0.0f); 2015 } 2016 2017 /** 2018 * @tc.name: OH_ArkUI_UIInputEvent_GetTargetDisplayId 2019 * @tc.desc: test OH_ArkUI_UIInputEvent_GetTargetDisplayId 2020 * @tc.type: FUNC 2021 */ 2022 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetTargetDisplayId, TestSize.Level1) 2023 { 2024 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2025 auto result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(nullptr); 2026 EXPECT_EQ(result, 0); 2027 2028 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2029 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2030 mouseEvent->targetDisplayId = 1; 2031 uiInputEvent->inputEvent = mouseEvent.get(); 2032 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2033 EXPECT_EQ(result, 1); 2034 2035 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2036 auto touchEvent = std::make_unique<ArkUITouchEvent>(); 2037 touchEvent->targetDisplayId = 2; 2038 uiInputEvent->inputEvent = touchEvent.get(); 2039 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2040 EXPECT_EQ(result, 2); 2041 2042 uiInputEvent->eventTypeId = C_AXIS_EVENT_ID; 2043 auto axisEvent = std::make_unique<ArkUIAxisEvent>(); 2044 axisEvent->targetDisplayId = 3; 2045 uiInputEvent->inputEvent = axisEvent.get(); 2046 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2047 EXPECT_EQ(result, 3); 2048 2049 uiInputEvent->eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2050 auto focusAxisEvent = std::make_unique<ArkUIFocusAxisEvent>(); 2051 focusAxisEvent->targetDisplayId = 4; 2052 uiInputEvent->inputEvent = focusAxisEvent.get(); 2053 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2054 EXPECT_EQ(result, 4); 2055 2056 uiInputEvent->eventTypeId = TOUCH_EVENT_ID; 2057 auto ohosTouchEvent = std::make_unique<OHOS::Ace::TouchEvent>(); 2058 ohosTouchEvent->targetDisplayId = 5; 2059 uiInputEvent->inputEvent = ohosTouchEvent.get(); 2060 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2061 EXPECT_EQ(result, 5); 2062 2063 uiInputEvent->eventTypeId = AXIS_EVENT_ID; 2064 auto ohosAxisEvent = std::make_unique<OHOS::Ace::AxisEvent>(); 2065 ohosAxisEvent->targetDisplayId = 6; 2066 uiInputEvent->inputEvent = ohosAxisEvent.get(); 2067 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2068 EXPECT_EQ(result, 6); 2069 2070 uiInputEvent->eventTypeId = C_HOVER_EVENT_ID; 2071 result = OH_ArkUI_UIInputEvent_GetTargetDisplayId(uiInputEvent.get()); 2072 EXPECT_EQ(result, 0); 2073 } 2074 2075 /** 2076 * @tc.name: OH_ArkUI_MouseEvent_GetPressedButtons 2077 * @tc.desc: test OH_ArkUI_MouseEvent_GetPressedButtons 2078 * @tc.type: FUNC 2079 */ 2080 HWTEST_F(UIInputEventTest, OH_ArkUI_MouseEvent_GetPressedButtons, TestSize.Level1) 2081 { 2082 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2083 int32_t pressedButtons[1] = { 0 }; 2084 int32_t length = 1; 2085 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2086 uiInputEvent->inputEvent = nullptr; 2087 auto result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 2088 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2089 2090 auto mouseEvent = std::make_unique<ArkUIMouseEvent>(); 2091 mouseEvent->pressedButtonsLength = 2; 2092 uiInputEvent->inputEvent = mouseEvent.get(); 2093 2094 uiInputEvent->eventTypeId = C_MOUSE_EVENT_ID; 2095 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 2096 EXPECT_EQ(result, ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH); 2097 2098 mouseEvent->pressedButtonsLength = 1; 2099 ArkUI_Int32 mousePressedButtons[1] = { 3 }; 2100 mouseEvent->pressedButtons = mousePressedButtons; 2101 uiInputEvent->inputEvent = mouseEvent.get(); 2102 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 2103 EXPECT_EQ(pressedButtons[0], 3); 2104 2105 uiInputEvent->eventTypeId = C_TOUCH_EVENT_ID; 2106 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, &length); 2107 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2108 2109 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), pressedButtons, nullptr); 2110 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2111 2112 result = OH_ArkUI_MouseEvent_GetPressedButtons(uiInputEvent.get(), nullptr, nullptr); 2113 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2114 2115 result = OH_ArkUI_MouseEvent_GetPressedButtons(nullptr, nullptr, nullptr); 2116 EXPECT_EQ(result, ARKUI_ERROR_CODE_PARAM_INVALID); 2117 } 2118 2119 /** 2120 * @tc.name: OH_ArkUI_FocusAxisEvent_GetAxisValue 2121 * @tc.desc: test OH_ArkUI_FocusAxisEvent_GetAxisValue 2122 * @tc.type: FUNC 2123 */ 2124 HWTEST_F(UIInputEventTest, OH_ArkUI_FocusAxisEvent_GetAxisValue, TestSize.Level1) 2125 { 2126 auto uiInputEvent = std::make_unique<ArkUI_UIInputEvent>(); 2127 int32_t axis = 100; 2128 auto result = OH_ArkUI_FocusAxisEvent_GetAxisValue(nullptr, axis); 2129 EXPECT_EQ(result, 0.0); 2130 2131 uiInputEvent->eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2132 result = OH_ArkUI_FocusAxisEvent_GetAxisValue(nullptr, axis); 2133 EXPECT_EQ(result, 0.0); 2134 2135 auto focusAxisEvent = std::make_unique<ArkUIFocusAxisEvent>(); 2136 uiInputEvent->inputEvent = focusAxisEvent.get(); 2137 EXPECT_EQ(result, 0.0); 2138 } 2139 2140 /** 2141 * @tc.name: OH_ArkUI_FocusAxisEvent_SetStopPropagation 2142 * @tc.desc: Test function OH_ArkUI_FocusAxisEvent_SetStopPropagation. 2143 * @tc.type: FUNC 2144 */ 2145 HWTEST_F(UIInputEventTest, OH_ArkUI_FocusAxisEvent_SetStopPropagation, TestSize.Level1) 2146 { 2147 int32_t ret = OH_ArkUI_FocusAxisEvent_SetStopPropagation(nullptr, true); 2148 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 2149 2150 ArkUI_UIInputEvent event; 2151 event.eventTypeId = C_TOUCH_EVENT_ID; 2152 ret = OH_ArkUI_FocusAxisEvent_SetStopPropagation(&event, true); 2153 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID); 2154 2155 ArkUIFocusAxisEvent focusAxisEvent; 2156 focusAxisEvent.stopPropagation = false; 2157 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2158 event.inputEvent = &focusAxisEvent; 2159 ret = OH_ArkUI_FocusAxisEvent_SetStopPropagation(&event, true); 2160 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR); 2161 EXPECT_TRUE(focusAxisEvent.stopPropagation); 2162 } 2163 2164 /** 2165 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetWidth001 2166 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetWidth. 2167 * @tc.type: FUNC 2168 */ 2169 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetWidth001, TestSize.Level1) 2170 { 2171 float width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(nullptr); 2172 EXPECT_EQ(width, 0.0f); 2173 ArkUI_UIInputEvent event; 2174 2175 ArkUITouchEvent touchEvent; 2176 touchEvent.width = 10.0f; 2177 event.eventTypeId = C_TOUCH_EVENT_ID; 2178 event.inputEvent = nullptr; 2179 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2180 EXPECT_EQ(width, 0.0f); 2181 event.inputEvent = &touchEvent; 2182 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2183 EXPECT_EQ(width, 10.0f); 2184 2185 OHOS::Ace::TouchEvent aceTouchEvent; 2186 aceTouchEvent.width = 20.0f; 2187 event.eventTypeId = TOUCH_EVENT_ID; 2188 event.inputEvent = nullptr; 2189 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2190 EXPECT_EQ(width, 0.0f); 2191 event.inputEvent = &aceTouchEvent; 2192 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2193 EXPECT_EQ(width, 20.0f); 2194 2195 OHOS::Ace::AxisEvent aceAxisEvent; 2196 aceAxisEvent.width = 30.0f; 2197 event.eventTypeId = AXIS_EVENT_ID; 2198 event.inputEvent = nullptr; 2199 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2200 EXPECT_EQ(width, 0.0f); 2201 event.inputEvent = &aceAxisEvent; 2202 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2203 EXPECT_EQ(width, 30.0f); 2204 2205 ArkUIMouseEvent mouseEvent; 2206 mouseEvent.width = 40.0f; 2207 event.eventTypeId = C_MOUSE_EVENT_ID; 2208 event.inputEvent = nullptr; 2209 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2210 EXPECT_EQ(width, 0.0f); 2211 event.inputEvent = &mouseEvent; 2212 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2213 EXPECT_EQ(width, 40.0f); 2214 } 2215 2216 /** 2217 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetWidth002 2218 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetWidth. 2219 * @tc.type: FUNC 2220 */ 2221 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetWidth002, TestSize.Level1) 2222 { 2223 float width = 1.0f; 2224 ArkUI_UIInputEvent event; 2225 2226 ArkUIAxisEvent axisEvent; 2227 axisEvent.width = 50.0f; 2228 event.eventTypeId = C_AXIS_EVENT_ID; 2229 event.inputEvent = nullptr; 2230 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2231 EXPECT_EQ(width, 0.0f); 2232 event.inputEvent = &axisEvent; 2233 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2234 EXPECT_EQ(width, 50.0f); 2235 2236 ArkUIFocusAxisEvent focusAxisEvent; 2237 focusAxisEvent.width = 60.0f; 2238 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2239 event.inputEvent = nullptr; 2240 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2241 EXPECT_EQ(width, 0.0f); 2242 event.inputEvent = &focusAxisEvent; 2243 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2244 EXPECT_EQ(width, 60.0f); 2245 2246 ArkUIHoverEvent hoverEvent; 2247 hoverEvent.width = 70.0f; 2248 event.eventTypeId = C_HOVER_EVENT_ID; 2249 event.inputEvent = nullptr; 2250 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2251 EXPECT_EQ(width, 0.0f); 2252 event.inputEvent = &hoverEvent; 2253 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2254 EXPECT_EQ(width, 70.0f); 2255 2256 ArkUIClickEvent clickEvent; 2257 clickEvent.width = 80.0f; 2258 event.eventTypeId = C_CLICK_EVENT_ID; 2259 event.inputEvent = nullptr; 2260 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2261 EXPECT_EQ(width, 0.0f); 2262 event.inputEvent = &clickEvent; 2263 width = OH_ArkUI_UIInputEvent_GetEventTargetWidth(&event); 2264 EXPECT_EQ(width, 80.0f); 2265 } 2266 2267 /** 2268 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetHeight001 2269 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetHeight. 2270 * @tc.type: FUNC 2271 */ 2272 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetHeight001, TestSize.Level1) 2273 { 2274 float height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(nullptr); 2275 EXPECT_EQ(height, 0.0f); 2276 2277 ArkUI_UIInputEvent event; 2278 2279 ArkUITouchEvent touchEvent; 2280 touchEvent.height = 15.0f; 2281 event.eventTypeId = C_TOUCH_EVENT_ID; 2282 event.inputEvent = nullptr; 2283 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2284 EXPECT_EQ(height, 0.0f); 2285 event.inputEvent = &touchEvent; 2286 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2287 EXPECT_EQ(height, 15.0f); 2288 2289 OHOS::Ace::TouchEvent aceTouchEvent; 2290 aceTouchEvent.height = 25.0f; 2291 event.eventTypeId = TOUCH_EVENT_ID; 2292 event.inputEvent = nullptr; 2293 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2294 EXPECT_EQ(height, 0.0f); 2295 event.inputEvent = &aceTouchEvent; 2296 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2297 EXPECT_EQ(height, 25.0f); 2298 2299 OHOS::Ace::AxisEvent aceAxisEvent; 2300 aceAxisEvent.height = 35.0f; 2301 event.eventTypeId = AXIS_EVENT_ID; 2302 event.inputEvent = nullptr; 2303 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2304 EXPECT_EQ(height, 0.0f); 2305 event.inputEvent = &aceAxisEvent; 2306 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2307 EXPECT_EQ(height, 35.0f); 2308 2309 ArkUIMouseEvent mouseEvent; 2310 mouseEvent.height = 45.0f; 2311 event.eventTypeId = C_MOUSE_EVENT_ID; 2312 event.inputEvent = nullptr; 2313 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2314 EXPECT_EQ(height, 0.0f); 2315 event.inputEvent = &mouseEvent; 2316 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2317 EXPECT_EQ(height, 45.0f); 2318 } 2319 2320 /** 2321 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetHeight002 2322 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetHeight. 2323 * @tc.type: FUNC 2324 */ 2325 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetHeight002, TestSize.Level1) 2326 { 2327 float height = 1.0f; 2328 ArkUI_UIInputEvent event; 2329 ArkUIAxisEvent axisEvent; 2330 axisEvent.height = 55.0f; 2331 event.eventTypeId = C_AXIS_EVENT_ID; 2332 event.inputEvent = nullptr; 2333 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2334 EXPECT_EQ(height, 0.0f); 2335 event.inputEvent = &axisEvent; 2336 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2337 EXPECT_EQ(height, 55.0f); 2338 2339 ArkUIFocusAxisEvent focusAxisEvent; 2340 focusAxisEvent.height = 65.0f; 2341 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2342 event.inputEvent = nullptr; 2343 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2344 EXPECT_EQ(height, 0.0f); 2345 event.inputEvent = &focusAxisEvent; 2346 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2347 EXPECT_EQ(height, 65.0f); 2348 2349 ArkUIHoverEvent hoverEvent; 2350 hoverEvent.height = 75.0f; 2351 event.eventTypeId = C_HOVER_EVENT_ID; 2352 event.inputEvent = nullptr; 2353 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2354 EXPECT_EQ(height, 0.0f); 2355 event.inputEvent = &hoverEvent; 2356 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2357 EXPECT_EQ(height, 75.0f); 2358 2359 ArkUIClickEvent clickEvent; 2360 clickEvent.height = 85.0f; 2361 event.eventTypeId = C_CLICK_EVENT_ID; 2362 event.inputEvent = nullptr; 2363 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2364 EXPECT_EQ(height, 0.0f); 2365 event.inputEvent = &clickEvent; 2366 height = OH_ArkUI_UIInputEvent_GetEventTargetHeight(&event); 2367 EXPECT_EQ(height, 85.0f); 2368 } 2369 2370 /** 2371 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetPositionX001 2372 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetPositionX. 2373 * @tc.type: FUNC 2374 */ 2375 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetPositionX001, TestSize.Level1) 2376 { 2377 float positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(nullptr); 2378 EXPECT_EQ(positionX, 0.0f); 2379 2380 ArkUI_UIInputEvent event; 2381 2382 ArkUITouchEvent touchEvent; 2383 touchEvent.targetPositionX = 100.5f; 2384 event.eventTypeId = C_TOUCH_EVENT_ID; 2385 event.inputEvent = nullptr; 2386 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2387 EXPECT_EQ(positionX, 0.0f); 2388 event.inputEvent = &touchEvent; 2389 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2390 EXPECT_EQ(positionX, 100.5f); 2391 2392 OHOS::Ace::TouchEvent aceTouchEvent; 2393 aceTouchEvent.targetPositionX = 200.5f; 2394 event.eventTypeId = TOUCH_EVENT_ID; 2395 event.inputEvent = nullptr; 2396 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2397 EXPECT_EQ(positionX, 0.0f); 2398 event.inputEvent = &aceTouchEvent; 2399 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2400 EXPECT_EQ(positionX, 200.5f); 2401 2402 OHOS::Ace::AxisEvent aceAxisEvent; 2403 aceAxisEvent.targetPositionX = 300.5f; 2404 event.eventTypeId = AXIS_EVENT_ID; 2405 event.inputEvent = nullptr; 2406 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2407 EXPECT_EQ(positionX, 0.0f); 2408 event.inputEvent = &aceAxisEvent; 2409 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2410 EXPECT_EQ(positionX, 300.5f); 2411 2412 ArkUIMouseEvent mouseEvent; 2413 mouseEvent.targetPositionX = 400.5f; 2414 event.eventTypeId = C_MOUSE_EVENT_ID; 2415 event.inputEvent = nullptr; 2416 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2417 EXPECT_EQ(positionX, 0.0f); 2418 event.inputEvent = &mouseEvent; 2419 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2420 EXPECT_EQ(positionX, 400.5f); 2421 } 2422 2423 /** 2424 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetPositionX002 2425 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetPositionX. 2426 * @tc.type: FUNC 2427 */ 2428 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetPositionX002, TestSize.Level1) 2429 { 2430 float positionX = 1.0f; 2431 ArkUI_UIInputEvent event; 2432 2433 ArkUIAxisEvent axisEvent; 2434 axisEvent.targetPositionX = 500.5f; 2435 event.eventTypeId = C_AXIS_EVENT_ID; 2436 event.inputEvent = nullptr; 2437 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2438 EXPECT_EQ(positionX, 0.0f); 2439 event.inputEvent = &axisEvent; 2440 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2441 EXPECT_EQ(positionX, 500.5f); 2442 2443 ArkUIFocusAxisEvent focusAxisEvent; 2444 focusAxisEvent.targetPositionX = 600.5f; 2445 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2446 event.inputEvent = nullptr; 2447 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2448 EXPECT_EQ(positionX, 0.0f); 2449 event.inputEvent = &focusAxisEvent; 2450 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2451 EXPECT_EQ(positionX, 600.5f); 2452 2453 ArkUIHoverEvent hoverEvent; 2454 hoverEvent.targetPositionX = 700.5f; 2455 event.eventTypeId = C_HOVER_EVENT_ID; 2456 event.inputEvent = nullptr; 2457 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2458 EXPECT_EQ(positionX, 0.0f); 2459 event.inputEvent = &hoverEvent; 2460 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2461 EXPECT_EQ(positionX, 700.5f); 2462 2463 ArkUIClickEvent clickEvent; 2464 clickEvent.targetPositionX = 800.5f; 2465 event.eventTypeId = C_CLICK_EVENT_ID; 2466 event.inputEvent = nullptr; 2467 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2468 EXPECT_EQ(positionX, 0.0f); 2469 event.inputEvent = &clickEvent; 2470 positionX = OH_ArkUI_UIInputEvent_GetEventTargetPositionX(&event); 2471 EXPECT_EQ(positionX, 800.5f); 2472 } 2473 2474 /** 2475 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetPositionY001 2476 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetPositionY. 2477 * @tc.type: FUNC 2478 */ 2479 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetPositionY001, TestSize.Level1) 2480 { 2481 float positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(nullptr); 2482 EXPECT_EQ(positionY, 0.0f); 2483 2484 ArkUI_UIInputEvent event; 2485 2486 ArkUITouchEvent touchEvent; 2487 touchEvent.targetPositionY = 150.5f; 2488 event.eventTypeId = C_TOUCH_EVENT_ID; 2489 event.inputEvent = nullptr; 2490 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2491 EXPECT_EQ(positionY, 0.0f); 2492 event.inputEvent = &touchEvent; 2493 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2494 EXPECT_EQ(positionY, 150.5f); 2495 2496 OHOS::Ace::TouchEvent aceTouchEvent; 2497 aceTouchEvent.targetPositionY = 250.5f; 2498 event.eventTypeId = TOUCH_EVENT_ID; 2499 event.inputEvent = nullptr; 2500 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2501 EXPECT_EQ(positionY, 0.0f); 2502 event.inputEvent = &aceTouchEvent; 2503 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2504 EXPECT_EQ(positionY, 250.5f); 2505 2506 OHOS::Ace::AxisEvent aceAxisEvent; 2507 aceAxisEvent.targetPositionY = 350.5f; 2508 event.eventTypeId = AXIS_EVENT_ID; 2509 event.inputEvent = nullptr; 2510 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2511 EXPECT_EQ(positionY, 0.0f); 2512 event.inputEvent = &aceAxisEvent; 2513 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2514 EXPECT_EQ(positionY, 350.5f); 2515 2516 ArkUIMouseEvent mouseEvent; 2517 mouseEvent.targetPositionY = 450.5f; 2518 event.eventTypeId = C_MOUSE_EVENT_ID; 2519 event.inputEvent = nullptr; 2520 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2521 EXPECT_EQ(positionY, 0.0f); 2522 event.inputEvent = &mouseEvent; 2523 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2524 EXPECT_EQ(positionY, 450.5f); 2525 } 2526 2527 /** 2528 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetPositionY002 2529 * @tc.desc: Test function OH_ArkUI_UIInputEvent_GetEventTargetPositionY. 2530 * @tc.type: FUNC 2531 */ 2532 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetPositionY002, TestSize.Level1) 2533 { 2534 float positionY = 1.0f; 2535 ArkUI_UIInputEvent event; 2536 2537 ArkUIAxisEvent axisEvent; 2538 axisEvent.targetPositionY = 550.5f; 2539 event.eventTypeId = C_AXIS_EVENT_ID; 2540 event.inputEvent = nullptr; 2541 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2542 EXPECT_EQ(positionY, 0.0f); 2543 event.inputEvent = &axisEvent; 2544 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2545 EXPECT_EQ(positionY, 550.5f); 2546 2547 ArkUIFocusAxisEvent focusAxisEvent; 2548 focusAxisEvent.targetPositionY = 650.5f; 2549 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2550 event.inputEvent = nullptr; 2551 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2552 EXPECT_EQ(positionY, 0.0f); 2553 event.inputEvent = &focusAxisEvent; 2554 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2555 EXPECT_EQ(positionY, 650.5f); 2556 2557 ArkUIHoverEvent hoverEvent; 2558 hoverEvent.targetPositionY = 750.5f; 2559 event.eventTypeId = C_HOVER_EVENT_ID; 2560 event.inputEvent = nullptr; 2561 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2562 EXPECT_EQ(positionY, 0.0f); 2563 event.inputEvent = &hoverEvent; 2564 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2565 EXPECT_EQ(positionY, 750.5f); 2566 2567 ArkUIClickEvent clickEvent; 2568 clickEvent.targetPositionY = 850.5f; 2569 event.eventTypeId = C_CLICK_EVENT_ID; 2570 event.inputEvent = nullptr; 2571 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2572 EXPECT_EQ(positionY, 0.0f); 2573 event.inputEvent = &clickEvent; 2574 positionY = OH_ArkUI_UIInputEvent_GetEventTargetPositionY(&event); 2575 EXPECT_EQ(positionY, 850.5f); 2576 } 2577 2578 /** 2579 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX001 2580 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX 2581 * @tc.type: FUNC 2582 */ 2583 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX001, TestSize.Level1) 2584 { 2585 float positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(nullptr); 2586 EXPECT_EQ(positionX, 0.0f); 2587 2588 ArkUI_UIInputEvent event; 2589 2590 ArkUITouchEvent touchEvent; 2591 touchEvent.targetGlobalPositionX = 1234.56f; 2592 event.eventTypeId = C_TOUCH_EVENT_ID; 2593 event.inputEvent = nullptr; 2594 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2595 EXPECT_EQ(positionX, 0.0f); 2596 event.inputEvent = &touchEvent; 2597 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2598 EXPECT_EQ(positionX, 1234.56f); 2599 2600 OHOS::Ace::TouchEvent aceTouchEvent; 2601 aceTouchEvent.targetGlobalPositionX = 2345.67f; 2602 event.eventTypeId = TOUCH_EVENT_ID; 2603 event.inputEvent = nullptr; 2604 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2605 EXPECT_EQ(positionX, 0.0f); 2606 event.inputEvent = &aceTouchEvent; 2607 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2608 EXPECT_EQ(positionX, 2345.67f); 2609 2610 OHOS::Ace::AxisEvent aceAxisEvent; 2611 aceAxisEvent.targetGlobalPositionX = 3456.78f; 2612 event.eventTypeId = AXIS_EVENT_ID; 2613 event.inputEvent = nullptr; 2614 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2615 EXPECT_EQ(positionX, 0.0f); 2616 event.inputEvent = &aceAxisEvent; 2617 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2618 EXPECT_EQ(positionX, 3456.78f); 2619 2620 ArkUIMouseEvent mouseEvent; 2621 mouseEvent.targetGlobalPositionX = 4567.89f; 2622 event.eventTypeId = C_MOUSE_EVENT_ID; 2623 event.inputEvent = nullptr; 2624 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2625 EXPECT_EQ(positionX, 0.0f); 2626 event.inputEvent = &mouseEvent; 2627 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2628 EXPECT_EQ(positionX, 4567.89f); 2629 } 2630 /** 2631 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX002 2632 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX 2633 * @tc.type: FUNC 2634 */ 2635 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX002, TestSize.Level1) 2636 { 2637 float positionX = 1.0f; 2638 ArkUI_UIInputEvent event; 2639 2640 ArkUIAxisEvent axisEvent; 2641 axisEvent.targetGlobalPositionX = 5678.90f; 2642 event.eventTypeId = C_AXIS_EVENT_ID; 2643 event.inputEvent = nullptr; 2644 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2645 EXPECT_EQ(positionX, 0.0f); 2646 event.inputEvent = &axisEvent; 2647 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2648 EXPECT_EQ(positionX, 5678.90f); 2649 2650 ArkUIFocusAxisEvent focusAxisEvent; 2651 focusAxisEvent.targetGlobalPositionX = 6789.01f; 2652 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2653 event.inputEvent = nullptr; 2654 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2655 EXPECT_EQ(positionX, 0.0f); 2656 event.inputEvent = &focusAxisEvent; 2657 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2658 EXPECT_EQ(positionX, 6789.01f); 2659 2660 ArkUIHoverEvent hoverEvent; 2661 hoverEvent.targetGlobalPositionX = 7890.12f; 2662 event.eventTypeId = C_HOVER_EVENT_ID; 2663 event.inputEvent = nullptr; 2664 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2665 EXPECT_EQ(positionX, 0.0f); 2666 event.inputEvent = &hoverEvent; 2667 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2668 EXPECT_EQ(positionX, 7890.12f); 2669 2670 ArkUIClickEvent clickEvent; 2671 clickEvent.targetGlobalPositionX = 8901.23f; 2672 event.eventTypeId = C_CLICK_EVENT_ID; 2673 event.inputEvent = nullptr; 2674 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2675 EXPECT_EQ(positionX, 0.0f); 2676 event.inputEvent = &clickEvent; 2677 positionX = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionX(&event); 2678 EXPECT_EQ(positionX, 8901.23f); 2679 } 2680 2681 /** 2682 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY001 2683 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY 2684 * @tc.type: FUNC 2685 */ 2686 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY001, TestSize.Level1) 2687 { 2688 float positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(nullptr); 2689 EXPECT_EQ(positionY, 0.0f); 2690 2691 ArkUI_UIInputEvent event; 2692 2693 ArkUITouchEvent touchEvent; 2694 touchEvent.targetGlobalPositionY = 1122.33f; 2695 event.eventTypeId = C_TOUCH_EVENT_ID; 2696 event.inputEvent = nullptr; 2697 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2698 EXPECT_EQ(positionY, 0.0f); 2699 event.inputEvent = &touchEvent; 2700 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2701 EXPECT_EQ(positionY, 1122.33f); 2702 2703 OHOS::Ace::TouchEvent aceTouchEvent; 2704 aceTouchEvent.targetGlobalPositionY = 2233.44f; 2705 event.eventTypeId = TOUCH_EVENT_ID; 2706 event.inputEvent = nullptr; 2707 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2708 EXPECT_EQ(positionY, 0.0f); 2709 event.inputEvent = &aceTouchEvent; 2710 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2711 EXPECT_EQ(positionY, 2233.44f); 2712 2713 OHOS::Ace::AxisEvent aceAxisEvent; 2714 aceAxisEvent.targetGlobalPositionY = 3344.55f; 2715 event.eventTypeId = AXIS_EVENT_ID; 2716 event.inputEvent = nullptr; 2717 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2718 EXPECT_EQ(positionY, 0.0f); 2719 event.inputEvent = &aceAxisEvent; 2720 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2721 EXPECT_EQ(positionY, 3344.55f); 2722 2723 ArkUIMouseEvent mouseEvent; 2724 mouseEvent.targetGlobalPositionY = 4455.66f; 2725 event.eventTypeId = C_MOUSE_EVENT_ID; 2726 event.inputEvent = nullptr; 2727 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2728 EXPECT_EQ(positionY, 0.0f); 2729 event.inputEvent = &mouseEvent; 2730 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2731 EXPECT_EQ(positionY, 4455.66f); 2732 } 2733 2734 /** 2735 * @tc.name: OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY002 2736 * @tc.desc: Test OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY 2737 * @tc.type: FUNC 2738 */ 2739 HWTEST_F(UIInputEventTest, OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY002, TestSize.Level1) 2740 { 2741 float positionY = 1.0f; 2742 ArkUI_UIInputEvent event; 2743 2744 ArkUIAxisEvent axisEvent; 2745 axisEvent.targetGlobalPositionY = 5566.77f; 2746 event.eventTypeId = C_AXIS_EVENT_ID; 2747 event.inputEvent = nullptr; 2748 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2749 EXPECT_EQ(positionY, 0.0f); 2750 event.inputEvent = &axisEvent; 2751 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2752 EXPECT_EQ(positionY, 5566.77f); 2753 2754 ArkUIFocusAxisEvent focusAxisEvent; 2755 focusAxisEvent.targetGlobalPositionY = 6677.88f; 2756 event.eventTypeId = C_FOCUS_AXIS_EVENT_ID; 2757 event.inputEvent = nullptr; 2758 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2759 EXPECT_EQ(positionY, 0.0f); 2760 event.inputEvent = &focusAxisEvent; 2761 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2762 EXPECT_EQ(positionY, 6677.88f); 2763 2764 ArkUIHoverEvent hoverEvent; 2765 hoverEvent.targetGlobalPositionY = 7788.99f; 2766 event.eventTypeId = C_HOVER_EVENT_ID; 2767 event.inputEvent = nullptr; 2768 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2769 EXPECT_EQ(positionY, 0.0f); 2770 event.inputEvent = &hoverEvent; 2771 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2772 EXPECT_EQ(positionY, 7788.99f); 2773 2774 ArkUIClickEvent clickEvent; 2775 clickEvent.targetGlobalPositionY = 8899.00f; 2776 event.eventTypeId = C_CLICK_EVENT_ID; 2777 event.inputEvent = nullptr; 2778 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2779 EXPECT_EQ(positionY, 0.0f); 2780 event.inputEvent = &clickEvent; 2781 positionY = OH_ArkUI_UIInputEvent_GetEventTargetGlobalPositionY(&event); 2782 EXPECT_EQ(positionY, 8899.00f); 2783 } 2784 } // namespace OHOS::Ace