• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_EVENT_X = 1.0;
23 } // namespace
24 
25 namespace OHOS::Ace {
26 
27 /**
28  * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX001
29  * @tc.desc: Test the OH_ArkUI_PointerEvent_GetDisplayX function with null input.
30  * @tc.type: FUNC
31  */
32 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX001, TestSize.Level0)
33 {
34     auto result = OH_ArkUI_PointerEvent_GetDisplayX(nullptr);
35     EXPECT_EQ(result, 0.0f);
36 }
37 
38 /**
39  * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX002
40  * @tc.desc: Test the OH_ArkUI_PointerEvent_GetDisplayX function with C_TOUCH_EVENT_ID.
41  * @tc.type: FUNC
42  */
43 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX002, TestSize.Level0)
44 {
45     ArkUITouchEvent inputEvent;
46     ArkUIEventTypeId eventTypeId = C_TOUCH_EVENT_ID;
47 
48     std::vector<std::pair<ArkUI_UIInputEvent, float>> testCases = {
49         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, nullptr }, 0.0f },
50         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEvent }, ARKUI_EVENT_X - 1 }
51     };
52 
53     auto count = 0;
54     for (auto testCase : testCases) {
55         auto input = testCase.first;
56         auto expect = testCase.second;
57 
58         auto* touchEvent = reinterpret_cast<ArkUITouchEvent*>(input.inputEvent);
59         if (touchEvent) {
60             touchEvent->actionTouchPoint.nodeX = expect;
61         }
62 
63         auto result = OH_ArkUI_PointerEvent_GetDisplayX(&input);
64         EXPECT_FLOAT_EQ(result, expect) << "index = " << count << ",result = " << result << ",expect = " << expect;
65         count++;
66     }
67 }
68 
69 /**
70  * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX003
71  * @tc.desc: Test the OH_ArkUI_PointerEvent_GetDisplayX function with C_MOUSE_EVENT_ID.
72  * @tc.type: FUNC
73  */
74 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX003, TestSize.Level0)
75 {
76     ArkUIMouseEvent inputEvent;
77     ArkUIEventTypeId eventTypeId = C_MOUSE_EVENT_ID;
78 
79     std::vector<std::pair<ArkUI_UIInputEvent, float>> testCases = {
80         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, nullptr }, 0.0f },
81         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEvent }, ARKUI_EVENT_X - 1 }
82     };
83 
84     auto count = 0;
85     for (auto testCase : testCases) {
86         auto input = testCase.first;
87         auto expect = testCase.second;
88 
89         auto* mouseEvent = reinterpret_cast<ArkUIMouseEvent*>(input.inputEvent);
90         if (mouseEvent) {
91             mouseEvent->actionTouchPoint.nodeX = expect;
92         }
93 
94         auto result = OH_ArkUI_PointerEvent_GetDisplayX(&input);
95         EXPECT_FLOAT_EQ(result, expect) << "index = " << count << ",result = " << result << ",expect = " << expect;
96         count++;
97     }
98 }
99 
100 /**
101  * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX004
102  * @tc.desc: Test the OH_ArkUI_PointerEvent_GetDisplayX function with C_AXIS_EVENT_ID.
103  * @tc.type: FUNC
104  */
105 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX004, TestSize.Level0)
106 {
107     ArkUIAxisEvent inputEvent;
108     ArkUIEventTypeId eventTypeId = C_AXIS_EVENT_ID;
109 
110     std::vector<std::pair<ArkUI_UIInputEvent, float>> testCases = {
111         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, nullptr }, 0.0f },
112         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEvent }, ARKUI_EVENT_X - 1 }
113     };
114 
115     auto count = 0;
116     for (auto testCase : testCases) {
117         auto input = testCase.first;
118         auto expect = testCase.second;
119 
120         auto* axisEvent = reinterpret_cast<ArkUIAxisEvent*>(input.inputEvent);
121         if (axisEvent) {
122             axisEvent->actionTouchPoint.nodeX = expect;
123         }
124 
125         auto result = OH_ArkUI_PointerEvent_GetDisplayX(&input);
126         EXPECT_FLOAT_EQ(result, expect) << "index = " << count << ",result = " << result << ",expect = " << expect;
127         count++;
128     }
129 }
130 
131 /**
132  * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX005
133  * @tc.desc: Test the OH_ArkUI_PointerEvent_GetDisplayX function with C_CLICK_EVENT_ID.
134  * @tc.type: FUNC
135  */
136 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX005, TestSize.Level0)
137 {
138     ArkUIClickEvent inputEvent;
139     ArkUIEventTypeId eventTypeId = C_CLICK_EVENT_ID;
140 
141     std::vector<std::pair<ArkUI_UIInputEvent, float>> testCases = {
142         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, nullptr }, 0.0f },
143         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEvent }, ARKUI_EVENT_X - 1 }
144     };
145 
146     auto count = 0;
147     for (auto testCase : testCases) {
148         auto input = testCase.first;
149         auto expect = testCase.second;
150 
151         auto* clickEvent = reinterpret_cast<ArkUIClickEvent*>(input.inputEvent);
152         if (clickEvent) {
153             clickEvent->localX = expect;
154         }
155 
156         auto result = OH_ArkUI_PointerEvent_GetDisplayX(&input);
157         EXPECT_FLOAT_EQ(result, expect) << "index = " << count << ",result = " << result << ",expect = " << expect;
158         count++;
159     }
160 }
161 
162 /**
163  * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX006
164  * @tc.desc: Test the OH_ArkUI_PointerEvent_GetDisplayX function with AXIS_EVENT_ID.
165  * @tc.type: FUNC
166  */
167 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX006, TestSize.Level0)
168 {
169     OHOS::Ace::AxisEvent inputEvent;
170     ArkUIEventTypeId eventTypeId = AXIS_EVENT_ID;
171 
172     std::vector<std::pair<ArkUI_UIInputEvent, float>> testCases = {
173         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, nullptr }, 0.0f },
174         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEvent }, ARKUI_EVENT_X - 1 }
175     };
176 
177     auto count = 0;
178     for (auto testCase : testCases) {
179         auto input = testCase.first;
180         auto expect = testCase.second;
181 
182         auto* axisEvent = reinterpret_cast<OHOS::Ace::AxisEvent*>(input.inputEvent);
183         if (axisEvent) {
184             axisEvent->localX = expect;
185         }
186 
187         auto result = OH_ArkUI_PointerEvent_GetDisplayX(&input);
188         EXPECT_FLOAT_EQ(result, expect) << "index = " << count << ",result = " << result << ",expect = " << expect;
189         count++;
190     }
191 }
192 
193 /**
194  * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX007
195  * @tc.desc: Test the OH_ArkUI_PointerEvent_GetDisplayX function with TOUCH_EVENT_ID.
196  * @tc.type: FUNC
197  */
198 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX007, TestSize.Level0)
199 {
200     OHOS::Ace::TouchEvent inputEvent;
201     ArkUIEventTypeId eventTypeId = TOUCH_EVENT_ID;
202 
203     std::vector<std::pair<ArkUI_UIInputEvent, float>> testCases = {
204         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, nullptr }, 0.0f },
205         { ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, eventTypeId, &inputEvent }, ARKUI_EVENT_X - 1 }
206     };
207 
208     auto count = 0;
209     for (auto testCase : testCases) {
210         auto input = testCase.first;
211         auto expect = testCase.second;
212 
213         auto* touchEvent = reinterpret_cast<OHOS::Ace::TouchEvent*>(input.inputEvent);
214         if (touchEvent) {
215             touchEvent->localX = expect;
216         }
217 
218         auto result = OH_ArkUI_PointerEvent_GetDisplayX(&input);
219         EXPECT_FLOAT_EQ(result, expect) << "index = " << count << ",result = " << result << ",expect = " << expect;
220         count++;
221     }
222 }
223 
224 /**
225  * @tc.name: OH_ArkUI_PointerEvent_GetDisplayX008
226  * @tc.desc: Test the OH_ArkUI_PointerEvent_GetDisplayX function with unsupported event types.
227  * @tc.type: FUNC
228  */
229 HWTEST_F(UIInputEventTest, OH_ArkUI_PointerEvent_GetDisplayX008, TestSize.Level0)
230 {
231     std::vector<ArkUIEventTypeId> typeIds = { C_KEY_EVENT_ID, C_FOCUS_AXIS_EVENT_ID, C_HOVER_EVENT_ID };
232 
233     auto count = 0;
234     for (auto typeId : typeIds) {
235         auto uiInputEvent = ArkUI_UIInputEvent { ARKUI_UIINPUTEVENT_TYPE_UNKNOWN, typeId, nullptr };
236         auto result = OH_ArkUI_PointerEvent_GetDisplayX(&uiInputEvent);
237         EXPECT_EQ(result, 0.0f) << "Unsupported event type index = " << count;
238         count++;
239     }
240 }
241 } // namespace OHOS::Ace