1 /* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "../ui_input_event_test.h" 17 18 using namespace testing; 19 using namespace testing::ext; 20 21 namespace { 22 constexpr float ARKUI_TILT_X = 15.0f; 23 constexpr float ARKUI_NEGATIVE_TILT_X = -30.0f; 24 constexpr float ARKUI_TILT_X_OVER_MAX = 95.0f; // Over maximum valid value 25 constexpr float ARKUI_TILT_X_UNDER_MIN = -95.0f; // Under minimum valid value 26 } // namespace 27 28 namespace OHOS::Ace { 29 30 namespace { 31 struct GetTiltXTestInputType { GetTiltXTestInputTypeOHOS::Ace::__anonfed156b70211::GetTiltXTestInputType32 explicit GetTiltXTestInputType(const ArkUI_UIInputEvent event, uint32_t pointerIndex = 0) 33 : event(event), pointerIndex(pointerIndex) {}; 34 ArkUI_UIInputEvent event; 35 uint32_t pointerIndex; 36 }; 37 } // namespace 38 39 /** 40 * @tc.name: OH_ArkUI_PointerEvent_GetTiltX001 41 * @tc.desc: Test the OH_ArkUI_PointerEvent_GetTiltX function with null event. 42 * @tc.type: FUNC 43 */ 44 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTiltX001, TestSize.Level0) 45 { 46 auto result = OH_ArkUI_PointerEvent_GetTiltX(nullptr, 0); 47 EXPECT_EQ(result, 0.0f); 48 } 49 /** 50 * @tc.name: OH_ArkUI_PointerEvent_GetTiltX101 51 * @tc.desc: Test the OH_ArkUI_PointerEvent_GetTiltX function with touch event including negative values. 52 * @tc.type: FUNC 53 */ 54 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTiltX101, TestSize.Level0) 55 { 56 static ArkUITouchPoint points[3]; 57 points[0].tiltX = ARKUI_TILT_X; // 15.0f 58 points[1].tiltX = ARKUI_NEGATIVE_TILT_X; // -30.0f 59 points[2].tiltX = ARKUI_TILT_X_OVER_MAX; // 95.0f 60 61 static ArkUITouchEvent inputEvent; 62 inputEvent.touchPointes = &points[0]; 63 inputEvent.touchPointSize = 3; 64 65 static ArkUITouchEvent inputEventHover; 66 inputEventHover.subKind = ON_HOVER_MOVE; 67 inputEventHover.actionTouchPoint.tiltX = ARKUI_NEGATIVE_TILT_X; // -30.0f 68 69 static ArkUITouchEvent inputEventNegative; 70 inputEventNegative.touchPointes = &points[1]; 71 inputEventNegative.touchPointSize = 1; 72 73 static ArkUITouchEvent inputEventEmpty; 74 75 static ArkUITouchEvent inputEventUnderMin; 76 static ArkUITouchPoint underMinPoint; 77 underMinPoint.tiltX = ARKUI_TILT_X_UNDER_MIN; // -95.0f 78 inputEventUnderMin.touchPointes = &underMinPoint; 79 inputEventUnderMin.touchPointSize = 1; 80 81 ArkUIEventTypeId eventTypeId = C_TOUCH_EVENT_ID; 82 83 std::vector<std::pair<GetTiltXTestInputType, float>> testCases = { 84 // case 1: null touch event 85 { GetTiltXTestInputType(ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, nullptr }, 0), 86 0.0f }, 87 // case 2: empty touch points 88 { GetTiltXTestInputType( 89 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEventEmpty }, 0), 90 0.0f }, 91 // case 3: hover move subkind with negative tilt 92 { GetTiltXTestInputType( 93 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEventHover }, 0), 94 ARKUI_NEGATIVE_TILT_X }, 95 // case 4: normal touch event with mixed values 96 { GetTiltXTestInputType(ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEvent }, 0), 97 ARKUI_TILT_X_OVER_MAX }, 98 // case 5: touch event with only negative value 99 { GetTiltXTestInputType( 100 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEventNegative }, 0), 101 ARKUI_NEGATIVE_TILT_X }, 102 // case 6: value below minimum 103 { GetTiltXTestInputType( 104 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEventUnderMin }, 0), 105 ARKUI_TILT_X_UNDER_MIN }, 106 }; 107 108 for (size_t i = 0; i < testCases.size(); ++i) { 109 const auto& testCase = testCases[i]; 110 auto result = OH_ArkUI_PointerEvent_GetTiltX(&testCase.first.event, testCase.first.pointerIndex); 111 EXPECT_FLOAT_EQ(result, testCase.second) << "Test case " << i << " failed"; 112 } 113 } 114 115 /** 116 * @tc.name: OH_ArkUI_PointerEvent_GetTiltX102 117 * @tc.desc: Test the OH_ArkUI_PointerEvent_GetTiltX function with click event including negative values. 118 * @tc.type: FUNC 119 */ 120 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTiltX102, TestSize.Level0) 121 { 122 ArkUIClickEvent inputEvent; 123 ArkUIClickEvent inputEventNegative; 124 ArkUIClickEvent inputEventOverMax; 125 ArkUIEventTypeId eventTypeId = C_CLICK_EVENT_ID; 126 inputEvent.tiltX = ARKUI_TILT_X; 127 inputEventNegative.tiltX = ARKUI_NEGATIVE_TILT_X; 128 inputEventOverMax.tiltX = ARKUI_TILT_X_OVER_MAX; 129 130 std::vector<std::pair<GetTiltXTestInputType, float>> testCases = { 131 // case 1: null click event 132 { GetTiltXTestInputType(ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, nullptr }, 0), 133 0.0f }, 134 // case 2: valid click event with positive tilt 135 { GetTiltXTestInputType(ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEvent }, 0), 136 ARKUI_TILT_X }, 137 // case 3: click event with negative tilt 138 { GetTiltXTestInputType( 139 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEventNegative }, 0), 140 ARKUI_NEGATIVE_TILT_X }, 141 // case 4: click event with tilt over maximum (should be clamped) 142 { GetTiltXTestInputType( 143 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEventOverMax }, 0), 144 ARKUI_TILT_X_OVER_MAX }, 145 }; 146 147 for (size_t i = 0; i < testCases.size(); ++i) { 148 const auto& testCase = testCases[i]; 149 auto result = OH_ArkUI_PointerEvent_GetTiltX(&testCase.first.event, testCase.first.pointerIndex); 150 EXPECT_FLOAT_EQ(result, testCase.second) << "Test case " << i << " failed"; 151 } 152 } 153 154 /** 155 * @tc.name: OH_ArkUI_PointerEvent_GetTiltX103 156 * @tc.desc: Test the OH_ArkUI_PointerEvent_GetTiltX function with hover event including negative values. 157 * @tc.type: FUNC 158 */ 159 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTiltX103, TestSize.Level0) 160 { 161 ArkUIHoverEvent inputEvent; 162 ArkUIHoverEvent inputEventNegative; 163 ArkUIHoverEvent inputEventUnderMin; 164 ArkUIEventTypeId eventTypeId = C_HOVER_EVENT_ID; 165 inputEvent.tiltX = ARKUI_TILT_X; 166 inputEventNegative.tiltX = ARKUI_NEGATIVE_TILT_X; 167 inputEventUnderMin.tiltX = ARKUI_TILT_X_UNDER_MIN; 168 169 std::vector<std::pair<GetTiltXTestInputType, float>> testCases = { 170 // case 1: null hover event 171 { GetTiltXTestInputType(ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, nullptr }, 0), 172 0.0f }, 173 // case 2: valid hover event with positive tilt 174 { GetTiltXTestInputType(ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEvent }, 0), 175 ARKUI_TILT_X }, 176 // case 3: hover event with negative tilt 177 { GetTiltXTestInputType( 178 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEventNegative }, 0), 179 ARKUI_NEGATIVE_TILT_X }, 180 // case 4: hover event with tilt under minimum (should be clamped) 181 { GetTiltXTestInputType( 182 ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEventUnderMin }, 0), 183 ARKUI_TILT_X_UNDER_MIN }, 184 }; 185 186 for (size_t i = 0; i < testCases.size(); ++i) { 187 const auto& testCase = testCases[i]; 188 auto result = OH_ArkUI_PointerEvent_GetTiltX(&testCase.first.event, testCase.first.pointerIndex); 189 EXPECT_FLOAT_EQ(result, testCase.second) << "Test case " << i << " failed"; 190 } 191 } 192 193 /** 194 * @tc.name: OH_ArkUI_PointerEvent_GetTiltX104 195 * @tc.desc: Test the OH_ArkUI_PointerEvent_GetTiltX function with unsupported event types. 196 * @tc.type: FUNC 197 */ 198 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetTiltX104, TestSize.Level0) 199 { 200 std::vector<ArkUIEventTypeId> unsupportedTypeIds = { AXIS_EVENT_ID, C_MOUSE_EVENT_ID, C_KEY_EVENT_ID, 201 C_FOCUS_AXIS_EVENT_ID }; 202 203 uint32_t pointerIndex = 0; 204 for (size_t i = 0; i < unsupportedTypeIds.size(); ++i) { 205 auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, unsupportedTypeIds[i], nullptr }; 206 auto result = OH_ArkUI_PointerEvent_GetTiltX(&uiInputEvent, pointerIndex); 207 EXPECT_EQ(result, 0.0f) << "Unsupported type test " << i << " failed"; 208 } 209 } 210 211 } // namespace OHOS::Ace