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 <gtest/gtest.h>
17
18#include "oh_input_manager.h"
19#include "oh_key_code.h"
20
21namespace OHOS {
22namespace MMI {
23namespace {
24using namespace testing::ext;
25} // namespace
26
27class InputNativeTest : public testing::Test {
28public:
29    static void SetUpTestCase(void) {}
30    static void TearDownTestCase(void) {}
31
32    void SetUp() {}
33    void TearDown() {}
34};
35
36/**
37 * @tc.name: InputNativeTest_KeyState_001
38 * @tc.desc: Verify the create and destroy of key states
39 * @tc.type: FUNC
40 * @tc.require:
41 */
42HWTEST_F(InputNativeTest, InputNativeTest_KeyState_001, TestSize.Level1)
43{
44    struct Input_KeyState *keyState = OH_Input_CreateKeyState();
45    if (keyState == nullptr) {
46        ASSERT_EQ(keyState, nullptr);
47    } else {
48        ASSERT_NE(keyState, nullptr);
49        OH_Input_DestroyKeyState(&keyState);
50    }
51}
52
53/**
54 * @tc.name: InputNativeTest_KeyCode_001
55 * @tc.desc: Verify the set and get of key states
56 * @tc.type: FUNC
57 * @tc.require:
58 */
59HWTEST_F(InputNativeTest, InputNativeTest_KeyCode_001, TestSize.Level1)
60{
61    struct Input_KeyState *keyState = OH_Input_CreateKeyState();
62    ASSERT_NE(keyState, nullptr);
63    OH_Input_SetKeyCode(keyState, 2000);
64    int32_t keyCode = OH_Input_GetKeyCode(keyState);
65    ASSERT_EQ(keyCode, 2000);
66    OH_Input_DestroyKeyState(&keyState);
67}
68
69/**
70 * @tc.name: InputNativeTest_KeyPressed_001
71 * @tc.desc: Verify the set and get of key pressed
72 * @tc.type: FUNC
73 * @tc.require:
74 */
75HWTEST_F(InputNativeTest, InputNativeTest_KeyPressed_001, TestSize.Level1)
76{
77    struct Input_KeyState *keyState = OH_Input_CreateKeyState();
78    ASSERT_NE(keyState, nullptr);
79    OH_Input_SetKeyPressed(keyState, 0);
80    int32_t keyAction = OH_Input_GetKeyPressed(keyState);
81    ASSERT_EQ(keyAction, 0);
82    OH_Input_DestroyKeyState(&keyState);
83}
84
85/**
86 * @tc.name: InputNativeTest_KeySwitch_001
87 * @tc.desc: Verify the set and get of key switch
88 * @tc.type: FUNC
89 * @tc.require:
90 */
91HWTEST_F(InputNativeTest, InputNativeTest_KeySwitch_001, TestSize.Level1)
92{
93    struct Input_KeyState *keyState = OH_Input_CreateKeyState();
94    ASSERT_NE(keyState, nullptr);
95    OH_Input_SetKeySwitch(keyState, 2);
96    int32_t keySwitch = OH_Input_GetKeySwitch(keyState);
97    ASSERT_EQ(keySwitch, 2);
98    OH_Input_DestroyKeyState(&keyState);
99}
100
101/**
102 * @tc.name: InputNativeTest_GetKeyState_001
103 * @tc.desc: Verify the GetKeyState
104 * @tc.type: FUNC
105 * @tc.require:
106 */
107HWTEST_F(InputNativeTest, InputNativeTest_GetKeyState_001, TestSize.Level1)
108{
109    struct Input_KeyState* keyState = OH_Input_CreateKeyState();
110    ASSERT_NE(keyState, nullptr);
111    OH_Input_SetKeyCode(keyState, KEYCODE_DPAD_UP);
112    OH_Input_GetKeyState(keyState);
113    EXPECT_EQ(OH_Input_GetKeyPressed(keyState), KEY_RELEASED);
114    EXPECT_EQ(OH_Input_GetKeySwitch(keyState), KEY_DEFAULT);
115    EXPECT_EQ(OH_Input_GetKeyState(keyState), INPUT_SUCCESS);
116    OH_Input_DestroyKeyState(&keyState);
117}
118
119/**
120 * @tc.name: InputNativeTest_InjectKeyEvent_001
121 * @tc.desc: Verify the InjectKeyEvent
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_001, TestSize.Level1)
126{
127    Input_KeyEvent *keyEvent = OH_Input_CreateKeyEvent();
128    ASSERT_NE(keyEvent, nullptr);
129    OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_DOWN);
130    OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_UNKNOWN);
131    OH_Input_SetKeyEventActionTime(keyEvent, -1);
132    int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
133    EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
134    OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_UP);
135    OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_UNKNOWN);
136    OH_Input_SetKeyEventActionTime(keyEvent, -1);
137    retResult = OH_Input_InjectKeyEvent(keyEvent);
138    EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
139    OH_Input_CancelInjection();
140    OH_Input_DestroyKeyEvent(&keyEvent);
141    EXPECT_EQ(keyEvent, nullptr);
142}
143
144/**
145 * @tc.name: InputNativeTest_KeyEventAction_001
146 * @tc.desc: Verify the set and get of keyEvent action
147 * @tc.type: FUNC
148 * @tc.require:
149 */
150HWTEST_F(InputNativeTest, InputNativeTest_KeyEventAction_001, TestSize.Level1)
151{
152    Input_KeyEvent *keyEvent = OH_Input_CreateKeyEvent();
153    ASSERT_NE(keyEvent, nullptr);
154    OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_DOWN);
155    int32_t action = OH_Input_GetKeyEventAction(keyEvent);
156    EXPECT_EQ(action, KEY_ACTION_DOWN);
157    OH_Input_DestroyKeyEvent(&keyEvent);
158    EXPECT_EQ(keyEvent, nullptr);
159}
160
161/**
162 * @tc.name: InputNativeTest_KeyEventKeyCode_001
163 * @tc.desc: Verify the set and get of keyEvent code
164 * @tc.type: FUNC
165 * @tc.require:
166 */
167HWTEST_F(InputNativeTest, InputNativeTest_KeyEventKeyCode_001, TestSize.Level1)
168{
169    Input_KeyEvent *keyEvent = OH_Input_CreateKeyEvent();
170    ASSERT_NE(keyEvent, nullptr);
171    OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_A);
172    int32_t keyCode = OH_Input_GetKeyEventKeyCode(keyEvent);
173    EXPECT_EQ(keyCode, KEYCODE_A);
174    OH_Input_DestroyKeyEvent(&keyEvent);
175    EXPECT_EQ(keyEvent, nullptr);
176}
177
178/**
179 * @tc.name: InputNativeTest_KeyEventActionTime_001
180 * @tc.desc: Verify the set and get of keyEvent time
181 * @tc.type: FUNC
182 * @tc.require:
183 */
184HWTEST_F(InputNativeTest, InputNativeTest_KeyEventActionTime_001, TestSize.Level1)
185{
186    Input_KeyEvent *keyEvent = OH_Input_CreateKeyEvent();
187    ASSERT_NE(keyEvent, nullptr);
188    OH_Input_SetKeyEventActionTime(keyEvent, 200);
189    int64_t actionTime = OH_Input_GetKeyEventActionTime(keyEvent);
190    EXPECT_EQ(actionTime, 200);
191    OH_Input_DestroyKeyEvent(&keyEvent);
192    EXPECT_EQ(keyEvent, nullptr);
193}
194
195/**
196 * @tc.name: InputNativeTest_InjectMouseEvent_001
197 * @tc.desc: Verify the InjectMouseEvent
198 * @tc.type: FUNC
199 * @tc.require:
200 */
201HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_001, TestSize.Level1)
202{
203    Input_MouseEvent *mouseEvent = OH_Input_CreateMouseEvent();
204    ASSERT_NE(mouseEvent, nullptr);
205    OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_MOVE);
206    OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
207    OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
208    OH_Input_SetMouseEventButton(mouseEvent, -2);
209    OH_Input_SetMouseEventActionTime(mouseEvent, -1);
210    int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
211    EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
212    OH_Input_DestroyMouseEvent(&mouseEvent);
213    EXPECT_EQ(mouseEvent, nullptr);
214}
215
216/**
217 * @tc.name: InputNativeTest_InjectMouseEvent_002
218 * @tc.desc: Verify the InjectMouseEvent
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_002, TestSize.Level1)
223{
224    Input_MouseEvent *mouseEvent = OH_Input_CreateMouseEvent();
225    ASSERT_NE(mouseEvent, nullptr);
226    OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
227    OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
228    OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
229    OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
230    OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
231    OH_Input_SetMouseEventButton(mouseEvent, -2);
232    OH_Input_SetMouseEventActionTime(mouseEvent, -1);
233    int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
234    EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
235    OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_END);
236    OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
237    OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
238    OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
239    OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
240    OH_Input_SetMouseEventButton(mouseEvent, -2);
241    OH_Input_SetMouseEventActionTime(mouseEvent, -1);
242    retResult = OH_Input_InjectMouseEvent(mouseEvent);
243    EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
244    OH_Input_DestroyMouseEvent(&mouseEvent);
245    EXPECT_EQ(mouseEvent, nullptr);
246}
247
248/**
249 * @tc.name: InputNativeTest_MouseEventAction_001
250 * @tc.desc: Verify the set and get of mouseEvent action
251 * @tc.type: FUNC
252 * @tc.require:
253 */
254HWTEST_F(InputNativeTest, InputNativeTest_MouseEventAction_001, TestSize.Level1)
255{
256    Input_MouseEvent *mouseEvent = OH_Input_CreateMouseEvent();
257    ASSERT_NE(mouseEvent, nullptr);
258    OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_BUTTON_DOWN);
259    int32_t action = OH_Input_GetMouseEventAction(mouseEvent);
260    EXPECT_EQ(action, MOUSE_ACTION_BUTTON_DOWN);
261    OH_Input_DestroyMouseEvent(&mouseEvent);
262    EXPECT_EQ(mouseEvent, nullptr);
263}
264
265/**
266 * @tc.name: InputNativeTest_MouseEventDisplayX_001
267 * @tc.desc: Verify the set and get of mouseEvent displayX
268 * @tc.type: FUNC
269 * @tc.require:
270 */
271HWTEST_F(InputNativeTest, InputNativeTest_MouseEventDisplayX_001, TestSize.Level1)
272{
273    Input_MouseEvent *mouseEvent = OH_Input_CreateMouseEvent();
274    ASSERT_NE(mouseEvent, nullptr);
275    OH_Input_SetMouseEventDisplayX(mouseEvent, 100);
276    int32_t displayX = OH_Input_GetMouseEventDisplayX(mouseEvent);
277    EXPECT_EQ(displayX, 100);
278    OH_Input_DestroyMouseEvent(&mouseEvent);
279    EXPECT_EQ(mouseEvent, nullptr);
280}
281
282/**
283 * @tc.name: InputNativeTest_MouseEventDisplayY_001
284 * @tc.desc: Verify the set and get of mouseEvent displayY
285 * @tc.type: FUNC
286 * @tc.require:
287 */
288HWTEST_F(InputNativeTest, InputNativeTest_MouseEventDisplayY_001, TestSize.Level1)
289{
290    Input_MouseEvent *mouseEvent = OH_Input_CreateMouseEvent();
291    ASSERT_NE(mouseEvent, nullptr);
292    OH_Input_SetMouseEventDisplayY(mouseEvent, 100);
293    int32_t displayY = OH_Input_GetMouseEventDisplayY(mouseEvent);
294    EXPECT_EQ(displayY, 100);
295    OH_Input_DestroyMouseEvent(&mouseEvent);
296    EXPECT_EQ(mouseEvent, nullptr);
297}
298
299/**
300 * @tc.name: InputNativeTest_MouseEventButton_001
301 * @tc.desc: Verify the set and get of mouseEvent button
302 * @tc.type: FUNC
303 * @tc.require:
304 */
305HWTEST_F(InputNativeTest, InputNativeTest_MouseEventButton_001, TestSize.Level1)
306{
307    Input_MouseEvent *mouseEvent = OH_Input_CreateMouseEvent();
308    ASSERT_NE(mouseEvent, nullptr);
309    OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_LEFT);
310    int32_t button = OH_Input_GetMouseEventButton(mouseEvent);
311    EXPECT_EQ(button, MOUSE_BUTTON_LEFT);
312    OH_Input_DestroyMouseEvent(&mouseEvent);
313    EXPECT_EQ(mouseEvent, nullptr);
314}
315
316/**
317 * @tc.name: InputNativeTest_MouseEventAxisType_001
318 * @tc.desc: Verify the set and get of mouseEvent axisType
319 * @tc.type: FUNC
320 * @tc.require:
321 */
322HWTEST_F(InputNativeTest, InputNativeTest_MouseEventAxisType_001, TestSize.Level1)
323{
324    Input_MouseEvent *mouseEvent = OH_Input_CreateMouseEvent();
325    ASSERT_NE(mouseEvent, nullptr);
326    OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
327    int32_t axisType = OH_Input_GetMouseEventAxisType(mouseEvent);
328    EXPECT_EQ(axisType, MOUSE_BUTTON_LEFT);
329    OH_Input_DestroyMouseEvent(&mouseEvent);
330    EXPECT_EQ(mouseEvent, nullptr);
331}
332
333/**
334 * @tc.name: InputNativeTest_MouseEventAxisValue_001
335 * @tc.desc: Verify the set and get of mouseEvent axisValue
336 * @tc.type: FUNC
337 * @tc.require:
338 */
339HWTEST_F(InputNativeTest, InputNativeTest_MouseEventAxisValue_001, TestSize.Level1)
340{
341    Input_MouseEvent *mouseEvent = OH_Input_CreateMouseEvent();
342    ASSERT_NE(mouseEvent, nullptr);
343    OH_Input_SetMouseEventAxisValue(mouseEvent, 15.0);
344    float axisValue = OH_Input_GetMouseEventAxisValue(mouseEvent);
345    EXPECT_EQ(axisValue, 15.0);
346    OH_Input_DestroyMouseEvent(&mouseEvent);
347    EXPECT_EQ(mouseEvent, nullptr);
348}
349
350/**
351 * @tc.name: InputNativeTest_MouseEventActionTime_001
352 * @tc.desc: Verify the set and get of mouseEvent actionTime
353 * @tc.type: FUNC
354 * @tc.require:
355 */
356HWTEST_F(InputNativeTest, InputNativeTest_MouseEventActionTime_001, TestSize.Level1)
357{
358    Input_MouseEvent *mouseEvent = OH_Input_CreateMouseEvent();
359    ASSERT_NE(mouseEvent, nullptr);
360    OH_Input_SetMouseEventActionTime(mouseEvent, 200);
361    int64_t actionTime = OH_Input_GetMouseEventActionTime(mouseEvent);
362    EXPECT_EQ(actionTime, 200);
363    OH_Input_DestroyMouseEvent(&mouseEvent);
364    EXPECT_EQ(mouseEvent, nullptr);
365}
366
367/**
368 * @tc.name: InputNativeTest_InjectTouchEvent_001
369 * @tc.desc: Verify the InjectTouchEvent
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_001, TestSize.Level1)
374{
375    Input_TouchEvent *touchEvent = OH_Input_CreateTouchEvent();
376    ASSERT_NE(touchEvent, nullptr);
377    OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
378    OH_Input_SetTouchEventFingerId(touchEvent, 0);
379    OH_Input_SetTouchEventDisplayX(touchEvent, 671);
380    OH_Input_SetTouchEventDisplayY(touchEvent, -10);
381    OH_Input_SetTouchEventActionTime(touchEvent, -1);
382    int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
383    EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
384    OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_UP);
385    OH_Input_SetTouchEventFingerId(touchEvent, 0);
386    OH_Input_SetTouchEventDisplayX(touchEvent, 671);
387    OH_Input_SetTouchEventDisplayY(touchEvent, -10);
388    OH_Input_SetTouchEventActionTime(touchEvent, -1);
389    retResult = OH_Input_InjectTouchEvent(touchEvent);
390    EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
391    OH_Input_DestroyTouchEvent(&touchEvent);
392    EXPECT_EQ(touchEvent, nullptr);
393}
394
395/**
396 * @tc.name: InputNativeTest_TouchEventAction_001
397 * @tc.desc: Verify the set and get of touchEvent action
398 * @tc.type: FUNC
399 * @tc.require:
400 */
401HWTEST_F(InputNativeTest, InputNativeTest_TouchEventAction_001, TestSize.Level1)
402{
403    Input_TouchEvent *touchEvent = OH_Input_CreateTouchEvent();
404    ASSERT_NE(touchEvent, nullptr);
405    OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
406    int32_t action = OH_Input_GetTouchEventAction(touchEvent);
407    EXPECT_EQ(action, TOUCH_ACTION_DOWN);
408    OH_Input_DestroyTouchEvent(&touchEvent);
409    EXPECT_EQ(touchEvent, nullptr);
410}
411
412/**
413 * @tc.name: InputNativeTest_TouchEventFingerId_001
414 * @tc.desc: Verify the set and get of touchEvent id
415 * @tc.type: FUNC
416 * @tc.require:
417 */
418HWTEST_F(InputNativeTest, InputNativeTest_TouchEventFingerId_001, TestSize.Level1)
419{
420    Input_TouchEvent *touchEvent = OH_Input_CreateTouchEvent();
421    ASSERT_NE(touchEvent, nullptr);
422    OH_Input_SetTouchEventFingerId(touchEvent, 0);
423    int32_t id = OH_Input_GetTouchEventFingerId(touchEvent);
424    EXPECT_EQ(id, 0);
425    OH_Input_DestroyTouchEvent(&touchEvent);
426    EXPECT_EQ(touchEvent, nullptr);
427}
428
429/**
430 * @tc.name: InputNativeTest_TouchEventDisplayX_001
431 * @tc.desc: Verify the set and get of touchEvent displayX
432 * @tc.type: FUNC
433 * @tc.require:
434 */
435HWTEST_F(InputNativeTest, InputNativeTest_TouchEventDisplayX_001, TestSize.Level1)
436{
437    Input_TouchEvent *touchEvent = OH_Input_CreateTouchEvent();
438    ASSERT_NE(touchEvent, nullptr);
439    OH_Input_SetTouchEventDisplayX(touchEvent, 100);
440    int32_t displayX = OH_Input_GetTouchEventDisplayX(touchEvent);
441    EXPECT_EQ(displayX, 100);
442    OH_Input_DestroyTouchEvent(&touchEvent);
443    EXPECT_EQ(touchEvent, nullptr);
444}
445
446/**
447 * @tc.name: InputNativeTest_TouchEventDisplayY_001
448 * @tc.desc: Verify the set and get of touchEvent displayY
449 * @tc.type: FUNC
450 * @tc.require:
451 */
452HWTEST_F(InputNativeTest, InputNativeTest_TouchEventDisplayY_001, TestSize.Level1)
453{
454    Input_TouchEvent *touchEvent = OH_Input_CreateTouchEvent();
455    ASSERT_NE(touchEvent, nullptr);
456    OH_Input_SetTouchEventDisplayY(touchEvent, 100);
457    int32_t displayY = OH_Input_GetTouchEventDisplayY(touchEvent);
458    EXPECT_EQ(displayY, 100);
459    OH_Input_DestroyTouchEvent(&touchEvent);
460    EXPECT_EQ(touchEvent, nullptr);
461}
462
463/**
464 * @tc.name: InputNativeTest_TouchEventActionTime_001
465 * @tc.desc: Verify the set and get of touchEvent actionTime
466 * @tc.type: FUNC
467 * @tc.require:
468 */
469HWTEST_F(InputNativeTest, InputNativeTest_TouchEventActionTime_001, TestSize.Level1)
470{
471    Input_TouchEvent *touchEvent = OH_Input_CreateTouchEvent();
472    ASSERT_NE(touchEvent, nullptr);
473    OH_Input_SetTouchEventActionTime(touchEvent, 200);
474    int64_t actionTime = OH_Input_GetTouchEventActionTime(touchEvent);
475    EXPECT_EQ(actionTime, 200);
476    OH_Input_DestroyTouchEvent(&touchEvent);
477    EXPECT_EQ(touchEvent, nullptr);
478}
479} // namespace MMI
480} // namespace OHOS