1 /*
2 * Copyright (c) 2021-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 "input_manager.h"
19 #include "key_event.h"
20 #include "mmi_log.h"
21 #include "oh_input_manager.h"
22 #include "oh_key_code.h"
23 #ifdef OHOS_BUILD_ENABLE_INFRARED_EMITTER
24 #include "infrared_emitter_controller.h"
25 #endif
26
27 #undef MMI_LOG_TAG
28 #define MMI_LOG_TAG "InputNativeTest"
29
30 namespace OHOS {
31 namespace MMI {
32 namespace {
33 using namespace testing::ext;
34
35 constexpr float DISPLAY_X { 100.0 };
36 constexpr float DISPLAY_Y { 200.0 };
37 constexpr double DEFAULT_AXIS_VALUE { 50.0 };
38 constexpr double AXIS_VALUE { 100.0 };
39 constexpr int64_t DEFAULT_ACTION_TIME { 10 };
40 constexpr int64_t ACTIONE_TIME { 20 };
41 } // namespace
42
43 class InputNativeTest : public testing::Test {
44 public:
SetUpTestCase(void)45 static void SetUpTestCase(void) {}
TearDownTestCase(void)46 static void TearDownTestCase(void) {}
SetUp()47 void SetUp() {}
TearDown()48 void TearDown() {}
49 };
50
51 /**
52 * @tc.name: InputNativeTest_KeyState_001
53 * @tc.desc: Verify the create and destroy of key states
54 * @tc.type: FUNC
55 * @tc.require:
56 */
57 HWTEST_F(InputNativeTest, InputNativeTest_KeyState_001, TestSize.Level1)
58 {
59 struct Input_KeyState* keyState = OH_Input_CreateKeyState();
60 if (keyState != nullptr) {
61 OH_Input_DestroyKeyState(&keyState);
62 }
63 }
64
65 /**
66 * @tc.name: InputNativeTest_KeyCode_001
67 * @tc.desc: Verify the set and get of key states
68 * @tc.type: FUNC
69 * @tc.require:
70 */
71 HWTEST_F(InputNativeTest, InputNativeTest_KeyCode_001, TestSize.Level1)
72 {
73 struct Input_KeyState* keyState = OH_Input_CreateKeyState();
74 ASSERT_NE(keyState, nullptr);
75 OH_Input_SetKeyCode(keyState, 2000);
76 int32_t keyCode = OH_Input_GetKeyCode(keyState);
77 ASSERT_EQ(keyCode, 2000);
78 OH_Input_DestroyKeyState(&keyState);
79 }
80
81 /**
82 * @tc.name: InputNativeTest_KeyPressed_001
83 * @tc.desc: Verify the set and get of key pressed
84 * @tc.type: FUNC
85 * @tc.require:
86 */
87 HWTEST_F(InputNativeTest, InputNativeTest_KeyPressed_001, TestSize.Level1)
88 {
89 struct Input_KeyState* keyState = OH_Input_CreateKeyState();
90 ASSERT_NE(keyState, nullptr);
91 OH_Input_SetKeyPressed(keyState, 0);
92 int32_t keyAction = OH_Input_GetKeyPressed(keyState);
93 ASSERT_EQ(keyAction, 0);
94 OH_Input_DestroyKeyState(&keyState);
95 }
96
97 /**
98 * @tc.name: InputNativeTest_KeySwitch_001
99 * @tc.desc: Verify the set and get of key switch
100 * @tc.type: FUNC
101 * @tc.require:
102 */
103 HWTEST_F(InputNativeTest, InputNativeTest_KeySwitch_001, TestSize.Level1)
104 {
105 struct Input_KeyState* keyState = OH_Input_CreateKeyState();
106 ASSERT_NE(keyState, nullptr);
107 OH_Input_SetKeySwitch(keyState, 2);
108 int32_t keySwitch = OH_Input_GetKeySwitch(keyState);
109 ASSERT_EQ(keySwitch, 2);
110 OH_Input_DestroyKeyState(&keyState);
111 }
112
113 /**
114 * @tc.name: InputNativeTest_GetKeyState_001
115 * @tc.desc: Verify the GetKeyState
116 * @tc.type: FUNC
117 * @tc.require:
118 */
119 HWTEST_F(InputNativeTest, InputNativeTest_GetKeyState_001, TestSize.Level1)
120 {
121 struct Input_KeyState* keyState = OH_Input_CreateKeyState();
122 ASSERT_NE(keyState, nullptr);
123 OH_Input_SetKeyCode(keyState, KEYCODE_DPAD_UP);
124 EXPECT_NE(OH_Input_GetKeyPressed(keyState), KEY_RELEASED);
125 EXPECT_NE(OH_Input_GetKeySwitch(keyState), KEY_DEFAULT);
126 EXPECT_EQ(OH_Input_GetKeyState(keyState), INPUT_SUCCESS);
127 OH_Input_DestroyKeyState(&keyState);
128 }
129
130 /**
131 * @tc.name: InputNativeTest_InjectKeyEvent_001
132 * @tc.desc: Verify the InjectKeyEvent
133 * @tc.type: FUNC
134 * @tc.require:
135 */
136 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_001, TestSize.Level1)
137 {
138 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
139 ASSERT_NE(keyEvent, nullptr);
140 OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_DOWN);
141 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_UNKNOWN);
142 OH_Input_SetKeyEventActionTime(keyEvent, -1);
143 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
144 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
145 OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_UP);
146 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_UNKNOWN);
147 OH_Input_SetKeyEventActionTime(keyEvent, -1);
148 retResult = OH_Input_InjectKeyEvent(keyEvent);
149 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
150 InputManager::GetInstance()->Authorize(true);
151 OH_Input_CancelInjection();
152 OH_Input_DestroyKeyEvent(&keyEvent);
153 EXPECT_EQ(keyEvent, nullptr);
154 }
155
156 /**
157 * @tc.name: InputNativeTest_KeyEventAction_001
158 * @tc.desc: Verify the set and get of keyEvent action
159 * @tc.type: FUNC
160 * @tc.require:
161 */
162 HWTEST_F(InputNativeTest, InputNativeTest_KeyEventAction_001, TestSize.Level1)
163 {
164 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
165 ASSERT_NE(keyEvent, nullptr);
166 OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_DOWN);
167 int32_t action = OH_Input_GetKeyEventAction(keyEvent);
168 EXPECT_EQ(action, KEY_ACTION_DOWN);
169 OH_Input_DestroyKeyEvent(&keyEvent);
170 EXPECT_EQ(keyEvent, nullptr);
171 }
172
173 /**
174 * @tc.name: InputNativeTest_KeyEventKeyCode_001
175 * @tc.desc: Verify the set and get of keyEvent code
176 * @tc.type: FUNC
177 * @tc.require:
178 */
179 HWTEST_F(InputNativeTest, InputNativeTest_KeyEventKeyCode_001, TestSize.Level1)
180 {
181 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
182 ASSERT_NE(keyEvent, nullptr);
183 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_A);
184 int32_t keyCode = OH_Input_GetKeyEventKeyCode(keyEvent);
185 EXPECT_EQ(keyCode, KEYCODE_A);
186 OH_Input_DestroyKeyEvent(&keyEvent);
187 EXPECT_EQ(keyEvent, nullptr);
188 }
189
190 /**
191 * @tc.name: InputNativeTest_KeyEventActionTime_001
192 * @tc.desc: Verify the set and get of keyEvent time
193 * @tc.type: FUNC
194 * @tc.require:
195 */
196 HWTEST_F(InputNativeTest, InputNativeTest_KeyEventActionTime_001, TestSize.Level1)
197 {
198 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
199 ASSERT_NE(keyEvent, nullptr);
200 OH_Input_SetKeyEventActionTime(keyEvent, 200);
201 int64_t actionTime = OH_Input_GetKeyEventActionTime(keyEvent);
202 EXPECT_EQ(actionTime, 200);
203 OH_Input_DestroyKeyEvent(&keyEvent);
204 EXPECT_EQ(keyEvent, nullptr);
205 }
206
207 /**
208 * @tc.name: InputNativeTest_KeyEventWindowId_001
209 * @tc.desc: Verify the set and get of keyEvent windowId
210 * @tc.type: FUNC
211 * @tc.require:
212 */
213 HWTEST_F(InputNativeTest, InputNativeTest_KeyEventWindowId_001, TestSize.Level1)
214 {
215 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
216 ASSERT_NE(keyEvent, nullptr);
217 OH_Input_SetKeyEventWindowId(keyEvent, 100);
218 OH_Input_SetKeyEventWindowId(nullptr, 100);
219 int32_t windowId = OH_Input_GetKeyEventWindowId(keyEvent);
220 EXPECT_EQ(windowId, 100);
221 OH_Input_DestroyKeyEvent(&keyEvent);
222 EXPECT_EQ(keyEvent, nullptr);
223 }
224
225 /**
226 * @tc.name: InputNativeTest_KeyEventDisplayId_001
227 * @tc.desc: Verify the set and get of keyEvent displayId
228 * @tc.type: FUNC
229 * @tc.require:
230 */
231 HWTEST_F(InputNativeTest, InputNativeTest_KeyEventDisplayId_001, TestSize.Level1)
232 {
233 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
234 ASSERT_NE(keyEvent, nullptr);
235 OH_Input_SetKeyEventDisplayId(keyEvent, 100);
236 OH_Input_SetKeyEventDisplayId(nullptr, 100);
237 int32_t displayId = OH_Input_GetKeyEventDisplayId(keyEvent);
238 EXPECT_EQ(displayId, 100);
239 OH_Input_DestroyKeyEvent(&keyEvent);
240 EXPECT_EQ(keyEvent, nullptr);
241 }
242
243 /**
244 * @tc.name: InputNativeTest_InjectMouseEvent_001
245 * @tc.desc: Verify the InjectMouseEvent
246 * @tc.type: FUNC
247 * @tc.require:
248 */
249 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_001, TestSize.Level1)
250 {
251 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
252 ASSERT_NE(mouseEvent, nullptr);
253 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_MOVE);
254 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
255 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
256 OH_Input_SetMouseEventButton(mouseEvent, -2);
257 OH_Input_SetMouseEventActionTime(mouseEvent, -1);
258 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
259 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
260 OH_Input_DestroyMouseEvent(&mouseEvent);
261 EXPECT_EQ(mouseEvent, nullptr);
262 }
263
264 /**
265 * @tc.name: InputNativeTest_InjectMouseEvent_002
266 * @tc.desc: Verify the InjectMouseEvent
267 * @tc.type: FUNC
268 * @tc.require:
269 */
270 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_002, TestSize.Level1)
271 {
272 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
273 ASSERT_NE(mouseEvent, nullptr);
274 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
275 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
276 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
277 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
278 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
279 OH_Input_SetMouseEventButton(mouseEvent, -2);
280 OH_Input_SetMouseEventActionTime(mouseEvent, -1);
281 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
282 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
283 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_END);
284 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
285 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
286 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
287 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
288 OH_Input_SetMouseEventButton(mouseEvent, -2);
289 OH_Input_SetMouseEventActionTime(mouseEvent, -1);
290 retResult = OH_Input_InjectMouseEvent(mouseEvent);
291 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
292 OH_Input_DestroyMouseEvent(&mouseEvent);
293 EXPECT_EQ(mouseEvent, nullptr);
294 }
295
296 /**
297 * @tc.name: InputNativeTest_MouseEventAction_001
298 * @tc.desc: Verify the set and get of mouseEvent action
299 * @tc.type: FUNC
300 * @tc.require:
301 */
302 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventAction_001, TestSize.Level1)
303 {
304 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
305 ASSERT_NE(mouseEvent, nullptr);
306 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_BUTTON_DOWN);
307 int32_t action = OH_Input_GetMouseEventAction(mouseEvent);
308 EXPECT_EQ(action, MOUSE_ACTION_BUTTON_DOWN);
309 OH_Input_DestroyMouseEvent(&mouseEvent);
310 EXPECT_EQ(mouseEvent, nullptr);
311 }
312
313 /**
314 * @tc.name: InputNativeTest_MouseEventDisplayX_001
315 * @tc.desc: Verify the set and get of mouseEvent displayX
316 * @tc.type: FUNC
317 * @tc.require:
318 */
319 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventDisplayX_001, TestSize.Level1)
320 {
321 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
322 ASSERT_NE(mouseEvent, nullptr);
323 OH_Input_SetMouseEventDisplayX(mouseEvent, 100);
324 int32_t displayX = OH_Input_GetMouseEventDisplayX(mouseEvent);
325 EXPECT_EQ(displayX, 100);
326 OH_Input_DestroyMouseEvent(&mouseEvent);
327 EXPECT_EQ(mouseEvent, nullptr);
328 }
329
330 /**
331 * @tc.name: InputNativeTest_MouseEventDisplayY_001
332 * @tc.desc: Verify the set and get of mouseEvent displayY
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventDisplayY_001, TestSize.Level1)
337 {
338 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
339 ASSERT_NE(mouseEvent, nullptr);
340 OH_Input_SetMouseEventDisplayY(mouseEvent, 100);
341 int32_t displayY = OH_Input_GetMouseEventDisplayY(mouseEvent);
342 EXPECT_EQ(displayY, 100);
343 OH_Input_DestroyMouseEvent(&mouseEvent);
344 EXPECT_EQ(mouseEvent, nullptr);
345 }
346
347 /**
348 * @tc.name: InputNativeTest_MouseEventButton_001
349 * @tc.desc: Verify the set and get of mouseEvent button
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventButton_001, TestSize.Level1)
354 {
355 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
356 ASSERT_NE(mouseEvent, nullptr);
357 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_LEFT);
358 int32_t button = OH_Input_GetMouseEventButton(mouseEvent);
359 EXPECT_EQ(button, MOUSE_BUTTON_LEFT);
360 OH_Input_DestroyMouseEvent(&mouseEvent);
361 EXPECT_EQ(mouseEvent, nullptr);
362 }
363
364 /**
365 * @tc.name: InputNativeTest_MouseEventAxisType_001
366 * @tc.desc: Verify the set and get of mouseEvent axisType
367 * @tc.type: FUNC
368 * @tc.require:
369 */
370 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventAxisType_001, TestSize.Level1)
371 {
372 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
373 ASSERT_NE(mouseEvent, nullptr);
374 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
375 int32_t axisType = OH_Input_GetMouseEventAxisType(mouseEvent);
376 EXPECT_EQ(axisType, MOUSE_BUTTON_LEFT);
377 OH_Input_DestroyMouseEvent(&mouseEvent);
378 EXPECT_EQ(mouseEvent, nullptr);
379 }
380
381 /**
382 * @tc.name: InputNativeTest_MouseEventAxisValue_001
383 * @tc.desc: Verify the set and get of mouseEvent axisValue
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventAxisValue_001, TestSize.Level1)
388 {
389 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
390 ASSERT_NE(mouseEvent, nullptr);
391 OH_Input_SetMouseEventAxisValue(mouseEvent, 15.0);
392 float axisValue = OH_Input_GetMouseEventAxisValue(mouseEvent);
393 EXPECT_EQ(axisValue, 15.0);
394 OH_Input_DestroyMouseEvent(&mouseEvent);
395 EXPECT_EQ(mouseEvent, nullptr);
396 }
397
398 /**
399 * @tc.name: InputNativeTest_MouseEventActionTime_001
400 * @tc.desc: Verify the set and get of mouseEvent actionTime
401 * @tc.type: FUNC
402 * @tc.require:
403 */
404 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventActionTime_001, TestSize.Level1)
405 {
406 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
407 ASSERT_NE(mouseEvent, nullptr);
408 OH_Input_SetMouseEventActionTime(mouseEvent, 200);
409 int64_t actionTime = OH_Input_GetMouseEventActionTime(mouseEvent);
410 EXPECT_EQ(actionTime, 200);
411 OH_Input_DestroyMouseEvent(&mouseEvent);
412 EXPECT_EQ(mouseEvent, nullptr);
413 }
414
415 /**
416 * @tc.name: InputNativeTest_MouseEventWindowId_001
417 * @tc.desc: Verify the set and get of mouseEvent windowId
418 * @tc.type: FUNC
419 * @tc.require:
420 */
421 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventWindowId_001, TestSize.Level1)
422 {
423 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
424 ASSERT_NE(mouseEvent, nullptr);
425 OH_Input_SetMouseEventWindowId(mouseEvent, 100);
426 OH_Input_SetMouseEventWindowId(nullptr, 100);
427 int32_t windowId = OH_Input_GetMouseEventWindowId(mouseEvent);
428 EXPECT_EQ(windowId, 100);
429 OH_Input_DestroyMouseEvent(&mouseEvent);
430 EXPECT_EQ(mouseEvent, nullptr);
431 }
432
433 /**
434 * @tc.name: InputNativeTest_MouseEventDisplayId_001
435 * @tc.desc: Verify the set and get of mouseEvent displayId
436 * @tc.type: FUNC
437 * @tc.require:
438 */
439 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventDisplayId_001, TestSize.Level1)
440 {
441 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
442 ASSERT_NE(mouseEvent, nullptr);
443 OH_Input_SetMouseEventDisplayId(mouseEvent, 100);
444 OH_Input_SetMouseEventDisplayId(nullptr, 100);
445 int32_t displayId = OH_Input_GetMouseEventDisplayId(mouseEvent);
446 EXPECT_EQ(displayId, 100);
447 OH_Input_DestroyMouseEvent(&mouseEvent);
448 EXPECT_EQ(mouseEvent, nullptr);
449 }
450
451 /**
452 * @tc.name: InputNativeTest_InjectTouchEvent_001
453 * @tc.desc: Verify the InjectTouchEvent
454 * @tc.type: FUNC
455 * @tc.require:
456 */
457 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_001, TestSize.Level1)
458 {
459 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
460 ASSERT_NE(touchEvent, nullptr);
461 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
462 OH_Input_SetTouchEventFingerId(touchEvent, 0);
463 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
464 OH_Input_SetTouchEventDisplayY(touchEvent, -10);
465 OH_Input_SetTouchEventActionTime(touchEvent, -1);
466 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
467 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
468 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_UP);
469 OH_Input_SetTouchEventFingerId(touchEvent, 0);
470 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
471 OH_Input_SetTouchEventDisplayY(touchEvent, -10);
472 OH_Input_SetTouchEventActionTime(touchEvent, -1);
473 retResult = OH_Input_InjectTouchEvent(touchEvent);
474 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
475 OH_Input_DestroyTouchEvent(&touchEvent);
476 EXPECT_EQ(touchEvent, nullptr);
477 }
478
479 /**
480 * @tc.name: InputNativeTest_TouchEventAction_001
481 * @tc.desc: Verify the set and get of touchEvent action
482 * @tc.type: FUNC
483 * @tc.require:
484 */
485 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventAction_001, TestSize.Level1)
486 {
487 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
488 ASSERT_NE(touchEvent, nullptr);
489 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
490 int32_t action = OH_Input_GetTouchEventAction(touchEvent);
491 EXPECT_EQ(action, TOUCH_ACTION_DOWN);
492 OH_Input_DestroyTouchEvent(&touchEvent);
493 EXPECT_EQ(touchEvent, nullptr);
494 }
495
496 /**
497 * @tc.name: InputNativeTest_TouchEventFingerId_001
498 * @tc.desc: Verify the set and get of touchEvent id
499 * @tc.type: FUNC
500 * @tc.require:
501 */
502 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventFingerId_001, TestSize.Level1)
503 {
504 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
505 ASSERT_NE(touchEvent, nullptr);
506 OH_Input_SetTouchEventFingerId(touchEvent, 0);
507 int32_t id = OH_Input_GetTouchEventFingerId(touchEvent);
508 EXPECT_EQ(id, 0);
509 OH_Input_DestroyTouchEvent(&touchEvent);
510 EXPECT_EQ(touchEvent, nullptr);
511 }
512
513 /**
514 * @tc.name: InputNativeTest_TouchEventDisplayX_001
515 * @tc.desc: Verify the set and get of touchEvent displayX
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventDisplayX_001, TestSize.Level1)
520 {
521 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
522 ASSERT_NE(touchEvent, nullptr);
523 OH_Input_SetTouchEventDisplayX(touchEvent, 100);
524 int32_t displayX = OH_Input_GetTouchEventDisplayX(touchEvent);
525 EXPECT_EQ(displayX, 100);
526 OH_Input_DestroyTouchEvent(&touchEvent);
527 EXPECT_EQ(touchEvent, nullptr);
528 }
529
530 /**
531 * @tc.name: InputNativeTest_TouchEventDisplayY_001
532 * @tc.desc: Verify the set and get of touchEvent displayY
533 * @tc.type: FUNC
534 * @tc.require:
535 */
536 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventDisplayY_001, TestSize.Level1)
537 {
538 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
539 ASSERT_NE(touchEvent, nullptr);
540 OH_Input_SetTouchEventDisplayY(touchEvent, 100);
541 int32_t displayY = OH_Input_GetTouchEventDisplayY(touchEvent);
542 EXPECT_EQ(displayY, 100);
543 OH_Input_DestroyTouchEvent(&touchEvent);
544 EXPECT_EQ(touchEvent, nullptr);
545 }
546
547 /**
548 * @tc.name: InputNativeTest_TouchEventActionTime_001
549 * @tc.desc: Verify the set and get of touchEvent actionTime
550 * @tc.type: FUNC
551 * @tc.require:
552 */
553 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventActionTime_001, TestSize.Level1)
554 {
555 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
556 ASSERT_NE(touchEvent, nullptr);
557 OH_Input_SetTouchEventActionTime(touchEvent, 200);
558 int64_t actionTime = OH_Input_GetTouchEventActionTime(touchEvent);
559 EXPECT_EQ(actionTime, 200);
560 OH_Input_DestroyTouchEvent(&touchEvent);
561 EXPECT_EQ(touchEvent, nullptr);
562 }
563
564 /**
565 * @tc.name: InputNativeTest_TouchEventWindowId_001
566 * @tc.desc: Verify the set and get of touchEvent windowId
567 * @tc.type: FUNC
568 * @tc.require:
569 */
570 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventWindowId_001, TestSize.Level1)
571 {
572 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
573 ASSERT_NE(touchEvent, nullptr);
574 OH_Input_SetTouchEventWindowId(touchEvent, 100);
575 OH_Input_SetTouchEventWindowId(nullptr, 100);
576 int32_t windowId = OH_Input_GetTouchEventWindowId(touchEvent);
577 EXPECT_EQ(windowId, 100);
578 OH_Input_DestroyTouchEvent(&touchEvent);
579 EXPECT_EQ(touchEvent, nullptr);
580 }
581
582 /**
583 * @tc.name: InputNativeTest_TouchEventDisplayId_001
584 * @tc.desc: Verify the set and get of touchEvent displayId
585 * @tc.type: FUNC
586 * @tc.require:
587 */
588 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventDisplayId_001, TestSize.Level1)
589 {
590 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
591 ASSERT_NE(touchEvent, nullptr);
592 OH_Input_SetTouchEventDisplayId(touchEvent, 100);
593 OH_Input_SetTouchEventDisplayId(nullptr, 100);
594 int32_t displayId = OH_Input_GetTouchEventDisplayId(touchEvent);
595 EXPECT_EQ(displayId, 100);
596 OH_Input_DestroyTouchEvent(&touchEvent);
597 EXPECT_EQ(touchEvent, nullptr);
598 }
599
600 /**
601 * @tc.name: InputNativeTest_InjectKeyEvent_002
602 * @tc.desc: Verify the InjectKeyEvent
603 * @tc.type: FUNC
604 * @tc.require:
605 */
606 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_002, TestSize.Level1)
607 {
608 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
609 ASSERT_NE(keyEvent, nullptr);
610 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
611 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
612 g_keyEvent->SetAction(OHOS::MMI::KeyEvent::KEY_ACTION_UP);
613 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
614 EXPECT_EQ(retResult, INPUT_SUCCESS);
615 }
616
617 /**
618 * @tc.name: InputNativeTest_InjectKeyEvent_003
619 * @tc.desc: Verify the InjectKeyEvent
620 * @tc.type: FUNC
621 * @tc.require:
622 */
623 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_003, TestSize.Level1)
624 {
625 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
626 ASSERT_NE(keyEvent, nullptr);
627 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
628 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
629 g_keyEvent->SetAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
630 OH_Input_SetKeyEventActionTime(keyEvent, -1);
631 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
632 EXPECT_EQ(retResult, INPUT_SUCCESS);
633 }
634
635 /**
636 * @tc.name: InputNativeTest_InjectKeyEvent_004
637 * @tc.desc: Verify the InjectKeyEvent
638 * @tc.type: FUNC
639 * @tc.require:
640 */
641 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_004, TestSize.Level1)
642 {
643 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
644 ASSERT_NE(keyEvent, nullptr);
645 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
646 OH_Input_SetKeyEventActionTime(keyEvent, 2);
647 OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_DOWN);
648 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
649 EXPECT_EQ(retResult, INPUT_SUCCESS);
650 }
651
652 /**
653 * @tc.name: InputNativeTest_InjectKeyEvent_005
654 * @tc.desc: Verify the InjectKeyEvent
655 * @tc.type: FUNC
656 * @tc.require:
657 */
658 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_005, TestSize.Level1)
659 {
660 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
661 ASSERT_NE(keyEvent, nullptr);
662 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
663 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
664 g_keyEvent->SetAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
665 OH_Input_SetKeyEventActionTime(keyEvent, 2);
666 OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_UP);
667 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
668 EXPECT_EQ(retResult, INPUT_SUCCESS);
669 }
670
671 /**
672 * @tc.name: InputNativeTest_InjectKeyEvent_006
673 * @tc.desc: Verify the InjectKeyEvent
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_006, TestSize.Level1)
678 {
679 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
680 ASSERT_NE(keyEvent, nullptr);
681 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
682 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
683 g_keyEvent->SetAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
684 OH_Input_SetKeyEventActionTime(keyEvent, 2);
685 OH_Input_SetKeyEventAction(keyEvent, KeyEvent::KEY_ACTION_UNKNOWN);
686 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
687 EXPECT_EQ(retResult, INPUT_SUCCESS);
688 }
689
690 /**
691 * @tc.name: InputNativeTest_InjectMouseEvent_003
692 * @tc.desc: Verify the InjectMouseEvent
693 * @tc.type: FUNC
694 * @tc.require:
695 */
696 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_003, TestSize.Level1)
697 {
698 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
699 ASSERT_NE(mouseEvent, nullptr);
700 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
701 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
702 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
703 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
704 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
705 OH_Input_SetMouseEventButton(mouseEvent, 3);
706 OH_Input_SetMouseEventActionTime(mouseEvent, -1);
707 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
708 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
709 }
710
711 /**
712 * @tc.name: InputNativeTest_InjectTouchEvent_002
713 * @tc.desc: Verify the InjectTouchEvent
714 * @tc.type: FUNC
715 * @tc.require:
716 */
717 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_002, TestSize.Level1)
718 {
719 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
720 ASSERT_NE(touchEvent, nullptr);
721 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_UP);
722 OH_Input_SetTouchEventFingerId(touchEvent, 0);
723 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
724 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
725 OH_Input_SetTouchEventActionTime(touchEvent, -1);
726 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
727 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
728 }
729
730 /**
731 * @tc.name: InputNativeTest_InjectTouchEvent_003
732 * @tc.desc: Verify the InjectTouchEvent
733 * @tc.type: FUNC
734 * @tc.require:
735 */
736 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_003, TestSize.Level1)
737 {
738 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
739 ASSERT_NE(touchEvent, nullptr);
740 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
741 OH_Input_SetTouchEventFingerId(touchEvent, 0);
742 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
743 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
744 OH_Input_SetTouchEventActionTime(touchEvent, -1);
745 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
746 EXPECT_EQ(retResult, INPUT_SUCCESS);
747 }
748
749 /**
750 * @tc.name: InputNativeTest_InjectMouseEvent_004
751 * @tc.desc: Verify the InjectMouseEvent
752 * @tc.type: FUNC
753 * @tc.require:
754 */
755 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_004, TestSize.Level1)
756 {
757 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
758 ASSERT_NE(mouseEvent, nullptr);
759 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_CANCEL);
760 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
761 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
762 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
763 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
764 OH_Input_SetMouseEventActionTime(mouseEvent, 2);
765 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
766 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
767 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_MOVE);
768 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_NONE);
769 retResult = OH_Input_InjectMouseEvent(mouseEvent);
770 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
771 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_BUTTON_DOWN);
772 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_LEFT);
773 retResult = OH_Input_InjectMouseEvent(mouseEvent);
774 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
775 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_BUTTON_UP);
776 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_MIDDLE);
777 retResult = OH_Input_InjectMouseEvent(mouseEvent);
778 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
779 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
780 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_RIGHT);
781 retResult = OH_Input_InjectMouseEvent(mouseEvent);
782 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
783 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_UPDATE);
784 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_FORWARD);
785 retResult = OH_Input_InjectMouseEvent(mouseEvent);
786 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
787 }
788
789 /**
790 * @tc.name: InputNativeTest_InjectMouseEvent_005
791 * @tc.desc: Verify the InjectMouseEvent
792 * @tc.type: FUNC
793 * @tc.require:
794 */
795 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_005, TestSize.Level1)
796 {
797 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
798 ASSERT_NE(mouseEvent, nullptr);
799 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
800 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
801 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
802 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
803 OH_Input_SetMouseEventActionTime(mouseEvent, 2);
804 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_END);
805 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_BACK);
806 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
807 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_END);
808 OH_Input_SetMouseEventButton(mouseEvent, 7);
809 retResult = OH_Input_InjectMouseEvent(mouseEvent);
810 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
811 OH_Input_SetMouseEventAction(mouseEvent, 10);
812 retResult = OH_Input_InjectMouseEvent(mouseEvent);
813 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
814 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_HORIZONTAL);
815 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
816 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_BACK);
817 retResult = OH_Input_InjectMouseEvent(mouseEvent);
818 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
819 OH_Input_SetMouseEventAxisType(mouseEvent, 5);
820 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
821 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_BACK);
822 retResult = OH_Input_InjectMouseEvent(mouseEvent);
823 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
824 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
825 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
826 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_BACK);
827 retResult = OH_Input_InjectMouseEvent(mouseEvent);
828 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
829 }
830
831 /**
832 * @tc.name: InputNativeTest_InjectTouchEvent_004
833 * @tc.desc: Verify the InjectTouchEvent
834 * @tc.type: FUNC
835 * @tc.require:
836 */
837 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_004, TestSize.Level1)
838 {
839 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
840 ASSERT_NE(touchEvent, nullptr);
841 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
842 ASSERT_NE(g_keyEvent, nullptr);
843 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_CANCEL);
844 OH_Input_SetTouchEventFingerId(touchEvent, 0);
845 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
846 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
847 OH_Input_SetTouchEventActionTime(touchEvent, 2);
848 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
849 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
850 OH_Input_SetTouchEventActionTime(touchEvent, 2);
851 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
852 retResult = OH_Input_InjectTouchEvent(touchEvent);
853 EXPECT_EQ(retResult, INPUT_SUCCESS);
854 OH_Input_SetTouchEventActionTime(touchEvent, 2);
855 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_MOVE);
856 retResult = OH_Input_InjectTouchEvent(touchEvent);
857 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
858 OH_Input_SetTouchEventActionTime(touchEvent, 2);
859 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_UP);
860 retResult = OH_Input_InjectTouchEvent(touchEvent);
861 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
862 OH_Input_SetTouchEventActionTime(touchEvent, 2);
863 OH_Input_SetTouchEventAction(touchEvent, 10);
864 retResult = OH_Input_InjectTouchEvent(touchEvent);
865 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
866 }
867
868 /**
869 * @tc.name: InputNativeTest_InjectTouchEvent_005
870 * @tc.desc: Verify the InjectTouchEvent
871 * @tc.type: FUNC
872 * @tc.require:
873 */
874 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_005, TestSize.Level1)
875 {
876 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
877 ASSERT_NE(touchEvent, nullptr);
878 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
879 ASSERT_NE(g_keyEvent, nullptr);
880 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_CANCEL);
881 OH_Input_SetTouchEventFingerId(touchEvent, 0);
882 OH_Input_SetTouchEventDisplayX(touchEvent, -10);
883 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
884 OH_Input_SetTouchEventActionTime(touchEvent, 2);
885 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
886 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
887 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
888 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
889 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
890 OH_Input_SetTouchEventActionTime(touchEvent, 2);
891 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
892 retResult = OH_Input_InjectTouchEvent(touchEvent);
893 EXPECT_EQ(retResult, INPUT_SUCCESS);
894 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
895 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
896 OH_Input_SetTouchEventActionTime(touchEvent, 2);
897 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_MOVE);
898 retResult = OH_Input_InjectTouchEvent(touchEvent);
899 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
900 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
901 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
902 OH_Input_SetTouchEventActionTime(touchEvent, 2);
903 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_CANCEL);
904 retResult = OH_Input_InjectTouchEvent(touchEvent);
905 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
906 }
907
908 /**
909 * @tc.name: InputNativeTest_OH_Input_CreateAxisEvent_001
910 * @tc.desc: Verify the OH_Input_CreateAxisEvent
911 * @tc.type: FUNC
912 * @tc.require:
913 */
914 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_CreateAxisEvent_001, TestSize.Level1)
915 {
916 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
917 ASSERT_NE(axisEvent, nullptr);
918
919 InputEvent_AxisAction action = AXIS_ACTION_BEGIN;
920 Input_Result result = OH_Input_SetAxisEventAction(axisEvent, action);
921 EXPECT_EQ(result, INPUT_SUCCESS);
922 action = AXIS_ACTION_UPDATE;
923 result = OH_Input_GetAxisEventAction(axisEvent, &action);
924 EXPECT_EQ(result, INPUT_SUCCESS);
925 EXPECT_EQ(action, AXIS_ACTION_BEGIN);
926
927 float displayX = DISPLAY_X;
928 result = OH_Input_SetAxisEventDisplayX(axisEvent, displayX);
929 EXPECT_EQ(result, INPUT_SUCCESS);
930 displayX = DISPLAY_Y;
931 result = OH_Input_GetAxisEventDisplayX(axisEvent, &displayX);
932 EXPECT_EQ(result, INPUT_SUCCESS);
933 EXPECT_FLOAT_EQ(displayX, DISPLAY_X);
934
935 float displayY = DISPLAY_Y;
936 result = OH_Input_SetAxisEventDisplayY(axisEvent, displayY);
937 EXPECT_EQ(result, INPUT_SUCCESS);
938 displayY = DISPLAY_X;
939 result = OH_Input_GetAxisEventDisplayY(axisEvent, &displayY);
940 EXPECT_EQ(result, INPUT_SUCCESS);
941 EXPECT_FLOAT_EQ(displayY, DISPLAY_Y);
942
943 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
944 double axisValue = DEFAULT_AXIS_VALUE;
945 result = OH_Input_SetAxisEventAxisValue(axisEvent, axisType, axisValue);
946 EXPECT_EQ(result, INPUT_SUCCESS);
947 axisValue = AXIS_VALUE;
948 result = OH_Input_GetAxisEventAxisValue(axisEvent, axisType, &axisValue);
949 EXPECT_EQ(result, INPUT_SUCCESS);
950 EXPECT_DOUBLE_EQ(axisValue, DEFAULT_AXIS_VALUE);
951
952 int64_t actionTime = DEFAULT_ACTION_TIME;
953 result = OH_Input_SetAxisEventActionTime(axisEvent, actionTime);
954 EXPECT_EQ(result, INPUT_SUCCESS);
955 actionTime = ACTIONE_TIME;
956 result = OH_Input_GetAxisEventActionTime(axisEvent, &actionTime);
957 EXPECT_EQ(result, INPUT_SUCCESS);
958 EXPECT_EQ(actionTime, DEFAULT_ACTION_TIME);
959
960 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
961 result = OH_Input_SetAxisEventType(axisEvent, axisEventType);
962 EXPECT_EQ(result, INPUT_SUCCESS);
963 axisEventType = AXIS_EVENT_TYPE_SCROLL;
964 result = OH_Input_GetAxisEventType(axisEvent, &axisEventType);
965 EXPECT_EQ(result, INPUT_SUCCESS);
966 EXPECT_EQ(axisEventType, AXIS_EVENT_TYPE_PINCH);
967
968 InputEvent_SourceType sourceType = SOURCE_TYPE_MOUSE;
969 result = OH_Input_SetAxisEventSourceType(axisEvent, sourceType);
970 EXPECT_EQ(result, INPUT_SUCCESS);
971 sourceType = SOURCE_TYPE_TOUCHSCREEN;
972 result = OH_Input_GetAxisEventSourceType(axisEvent, &sourceType);
973 EXPECT_EQ(result, INPUT_SUCCESS);
974 EXPECT_EQ(sourceType, SOURCE_TYPE_MOUSE);
975
976 result = OH_Input_DestroyAxisEvent(&axisEvent);
977 EXPECT_EQ(result, INPUT_SUCCESS);
978 }
979
980 /**
981 * @tc.name: InputNativeTest_OH_Input_DestroyAxisEvent_001
982 * @tc.desc: Verify the OH_Input_DestroyAxisEvent
983 * @tc.type: FUNC
984 * @tc.require:
985 */
986 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_DestroyAxisEvent_001, TestSize.Level1)
987 {
988 Input_Result result = OH_Input_DestroyAxisEvent(nullptr);
989 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
990 }
991
992 /**
993 * @tc.name: InputNativeTest_OH_Input_SetAxisEventAction_001
994 * @tc.desc: Verify the OH_Input_SetAxisEventAction
995 * @tc.type: FUNC
996 * @tc.require:
997 */
998 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventAction_001, TestSize.Level1)
999 {
1000 InputEvent_AxisAction action = AXIS_ACTION_BEGIN;
1001 Input_Result result = OH_Input_SetAxisEventAction(nullptr, action);
1002 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1003 }
1004
1005 /**
1006 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAction_001
1007 * @tc.desc: Verify the OH_Input_GetAxisEventAction
1008 * @tc.type: FUNC
1009 * @tc.require:
1010 */
1011 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAction_001, TestSize.Level1)
1012 {
1013 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1014 ASSERT_NE(axisEvent, nullptr);
1015 Input_Result result = OH_Input_GetAxisEventAction(axisEvent, nullptr);
1016 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1017 result = OH_Input_DestroyAxisEvent(&axisEvent);
1018 EXPECT_EQ(result, INPUT_SUCCESS);
1019 }
1020
1021 /**
1022 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAction_002
1023 * @tc.desc: Verify the OH_Input_GetAxisEventAction
1024 * @tc.type: FUNC
1025 * @tc.require:
1026 */
1027 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAction_002, TestSize.Level1)
1028 {
1029 InputEvent_AxisAction action = AXIS_ACTION_END;
1030 Input_Result result = OH_Input_GetAxisEventAction(nullptr, &action);
1031 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1032 }
1033
1034 /**
1035 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAction_003
1036 * @tc.desc: Verify the OH_Input_GetAxisEventAction
1037 * @tc.type: FUNC
1038 * @tc.require:
1039 */
1040 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAction_003, TestSize.Level1)
1041 {
1042 Input_Result result = OH_Input_GetAxisEventAction(nullptr, nullptr);
1043 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1044 }
1045
1046 /**
1047 * @tc.name: InputNativeTest_OH_Input_SetAxisEventDisplayX_001
1048 * @tc.desc: Verify the OH_Input_SetAxisEventDisplayX
1049 * @tc.type: FUNC
1050 * @tc.require:
1051 */
1052 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventDisplayX_001, TestSize.Level1)
1053 {
1054 float displayX = DISPLAY_X;
1055 Input_Result result = OH_Input_SetAxisEventDisplayX(nullptr, displayX);
1056 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1057 }
1058
1059 /**
1060 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayX_001
1061 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayX
1062 * @tc.type: FUNC
1063 * @tc.require:
1064 */
1065 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayX_001, TestSize.Level1)
1066 {
1067 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1068 ASSERT_NE(axisEvent, nullptr);
1069 Input_Result result = OH_Input_GetAxisEventDisplayX(axisEvent, nullptr);
1070 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1071 result = OH_Input_DestroyAxisEvent(&axisEvent);
1072 EXPECT_EQ(result, INPUT_SUCCESS);
1073 }
1074
1075 /**
1076 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayX_002
1077 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayX
1078 * @tc.type: FUNC
1079 * @tc.require:
1080 */
1081 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayX_002, TestSize.Level1)
1082 {
1083 float displayX = DISPLAY_X;
1084 Input_Result result = OH_Input_GetAxisEventDisplayX(nullptr, &displayX);
1085 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1086 }
1087
1088 /**
1089 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayX_003
1090 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayX
1091 * @tc.type: FUNC
1092 * @tc.require:
1093 */
1094 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayX_003, TestSize.Level1)
1095 {
1096 Input_Result result = OH_Input_GetAxisEventDisplayX(nullptr, nullptr);
1097 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1098 }
1099
1100 /**
1101 * @tc.name: InputNativeTest_OH_Input_SetAxisEventDisplayY_001
1102 * @tc.desc: Verify the OH_Input_SetAxisEventDisplayY
1103 * @tc.type: FUNC
1104 * @tc.require:
1105 */
1106 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventDisplayY_001, TestSize.Level1)
1107 {
1108 float displayY = DISPLAY_Y;
1109 Input_Result result = OH_Input_SetAxisEventDisplayY(nullptr, displayY);
1110 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1111 }
1112
1113 /**
1114 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayY_001
1115 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayY
1116 * @tc.type: FUNC
1117 * @tc.require:
1118 */
1119 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayY_001, TestSize.Level1)
1120 {
1121 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1122 ASSERT_NE(axisEvent, nullptr);
1123 Input_Result result = OH_Input_GetAxisEventDisplayY(axisEvent, nullptr);
1124 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1125 result = OH_Input_DestroyAxisEvent(&axisEvent);
1126 EXPECT_EQ(result, INPUT_SUCCESS);
1127 }
1128
1129 /**
1130 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayY_002
1131 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayY
1132 * @tc.type: FUNC
1133 * @tc.require:
1134 */
1135 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayY_002, TestSize.Level1)
1136 {
1137 float displayY = DISPLAY_Y;
1138 Input_Result result = OH_Input_GetAxisEventDisplayY(nullptr, &displayY);
1139 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1140 }
1141
1142 /**
1143 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayY_003
1144 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayY
1145 * @tc.type: FUNC
1146 * @tc.require:
1147 */
1148 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayY_003, TestSize.Level1)
1149 {
1150 Input_Result result = OH_Input_GetAxisEventDisplayY(nullptr, nullptr);
1151 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1152 }
1153
1154 /**
1155 * @tc.name: InputNativeTest_OH_Input_SetAxisEventAxisValue_001
1156 * @tc.desc: Verify the OH_Input_SetAxisEventAxisValue
1157 * @tc.type: FUNC
1158 * @tc.require:
1159 */
1160 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventAxisValue_001, TestSize.Level1)
1161 {
1162 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1163 double axisValue = DEFAULT_AXIS_VALUE;
1164 Input_Result result = OH_Input_SetAxisEventAxisValue(nullptr, axisType, axisValue);
1165 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1166 }
1167
1168 /**
1169 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAxisValue_001
1170 * @tc.desc: Verify the OH_Input_GetAxisEventAxisValue
1171 * @tc.type: FUNC
1172 * @tc.require:
1173 */
1174 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAxisValue_001, TestSize.Level1)
1175 {
1176 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1177 ASSERT_NE(axisEvent, nullptr);
1178 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1179 Input_Result result = OH_Input_GetAxisEventAxisValue(axisEvent, axisType, nullptr);
1180 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1181 result = OH_Input_DestroyAxisEvent(&axisEvent);
1182 EXPECT_EQ(result, INPUT_SUCCESS);
1183 }
1184
1185 /**
1186 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAxisValue_002
1187 * @tc.desc: Verify the OH_Input_GetAxisEventAxisValue
1188 * @tc.type: FUNC
1189 * @tc.require:
1190 */
1191 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAxisValue_002, TestSize.Level1)
1192 {
1193 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1194 double axisValue = DEFAULT_AXIS_VALUE;
1195 Input_Result result = OH_Input_GetAxisEventAxisValue(nullptr, axisType, &axisValue);
1196 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1197 }
1198
1199 /**
1200 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAxisValue_003
1201 * @tc.desc: Verify the OH_Input_GetAxisEventAxisValue
1202 * @tc.type: FUNC
1203 * @tc.require:
1204 */
1205 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAxisValue_003, TestSize.Level1)
1206 {
1207 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1208 Input_Result result = OH_Input_GetAxisEventAxisValue(nullptr, axisType, nullptr);
1209 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1210 }
1211
1212 /**
1213 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAxisValue_004
1214 * @tc.desc: Verify the OH_Input_GetAxisEventAxisValue
1215 * @tc.type: FUNC
1216 * @tc.require:
1217 */
1218 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAxisValue_004, TestSize.Level1)
1219 {
1220 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1221 ASSERT_NE(axisEvent, nullptr);
1222 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1223 double axisValue = DEFAULT_AXIS_VALUE;
1224 Input_Result result = OH_Input_GetAxisEventAxisValue(axisEvent, axisType, &axisValue);
1225 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1226 result = OH_Input_DestroyAxisEvent(&axisEvent);
1227 EXPECT_EQ(result, INPUT_SUCCESS);
1228 }
1229
1230 /**
1231 * @tc.name: InputNativeTest_OH_Input_SetAxisEventActionTime_001
1232 * @tc.desc: Verify the OH_Input_SetAxisEventActionTime
1233 * @tc.type: FUNC
1234 * @tc.require:
1235 */
1236 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventActionTime_001, TestSize.Level1)
1237 {
1238 int64_t actionTime = DEFAULT_ACTION_TIME;
1239 Input_Result result = OH_Input_SetAxisEventActionTime(nullptr, actionTime);
1240 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1241 }
1242
1243 /**
1244 * @tc.name: InputNativeTest_OH_Input_GetAxisEventActionTime_001
1245 * @tc.desc: Verify the OH_Input_GetAxisEventActionTime
1246 * @tc.type: FUNC
1247 * @tc.require:
1248 */
1249 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventActionTime_001, TestSize.Level1)
1250 {
1251 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1252 ASSERT_NE(axisEvent, nullptr);
1253 Input_Result result = OH_Input_GetAxisEventActionTime(axisEvent, nullptr);
1254 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1255 result = OH_Input_DestroyAxisEvent(&axisEvent);
1256 EXPECT_EQ(result, INPUT_SUCCESS);
1257 }
1258
1259 /**
1260 * @tc.name: InputNativeTest_OH_Input_GetAxisEventActionTime_002
1261 * @tc.desc: Verify the OH_Input_GetAxisEventActionTime
1262 * @tc.type: FUNC
1263 * @tc.require:
1264 */
1265 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventActionTime_002, TestSize.Level1)
1266 {
1267 int64_t actionTime = DEFAULT_ACTION_TIME;
1268 Input_Result result = OH_Input_GetAxisEventActionTime(nullptr, &actionTime);
1269 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1270 }
1271
1272 /**
1273 * @tc.name: InputNativeTest_OH_Input_GetAxisEventActionTime_003
1274 * @tc.desc: Verify the OH_Input_GetAxisEventActionTime
1275 * @tc.type: FUNC
1276 * @tc.require:
1277 */
1278 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventActionTime_003, TestSize.Level1)
1279 {
1280 Input_Result result = OH_Input_GetAxisEventActionTime(nullptr, nullptr);
1281 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1282 }
1283
1284 /**
1285 * @tc.name: InputNativeTest_OH_Input_SetAxisEventType_001
1286 * @tc.desc: Verify the OH_Input_SetAxisEventType
1287 * @tc.type: FUNC
1288 * @tc.require:
1289 */
1290 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventType_001, TestSize.Level1)
1291 {
1292 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1293 Input_Result result = OH_Input_SetAxisEventType(nullptr, axisEventType);
1294 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1295 }
1296
1297 /**
1298 * @tc.name: InputNativeTest_OH_Input_GetAxisEventType_001
1299 * @tc.desc: Verify the OH_Input_GetAxisEventType
1300 * @tc.type: FUNC
1301 * @tc.require:
1302 */
1303 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventType_001, TestSize.Level1)
1304 {
1305 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1306 ASSERT_NE(axisEvent, nullptr);
1307 Input_Result result = OH_Input_GetAxisEventType(axisEvent, nullptr);
1308 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1309 result = OH_Input_DestroyAxisEvent(&axisEvent);
1310 EXPECT_EQ(result, INPUT_SUCCESS);
1311 }
1312
1313 /**
1314 * @tc.name: InputNativeTest_OH_Input_GetAxisEventType_002
1315 * @tc.desc: Verify the OH_Input_GetAxisEventType
1316 * @tc.type: FUNC
1317 * @tc.require:
1318 */
1319 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventType_002, TestSize.Level1)
1320 {
1321 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1322 Input_Result result = OH_Input_GetAxisEventType(nullptr, &axisEventType);
1323 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1324 }
1325
1326 /**
1327 * @tc.name: InputNativeTest_OH_Input_GetAxisEventType_003
1328 * @tc.desc: Verify the OH_Input_GetAxisEventType
1329 * @tc.type: FUNC
1330 * @tc.require:
1331 */
1332 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventType_003, TestSize.Level1)
1333 {
1334 Input_Result result = OH_Input_GetAxisEventType(nullptr, nullptr);
1335 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1336 }
1337
1338 /**
1339 * @tc.name: InputNativeTest_OH_Input_SetAxisEventSourceType_001
1340 * @tc.desc: Verify the OH_Input_SetAxisEventSourceType
1341 * @tc.type: FUNC
1342 * @tc.require:
1343 */
1344 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventSourceType_001, TestSize.Level1)
1345 {
1346 InputEvent_SourceType sourceType = SOURCE_TYPE_MOUSE;
1347 Input_Result result = OH_Input_SetAxisEventSourceType(nullptr, sourceType);
1348 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1349 }
1350
1351 /**
1352 * @tc.name: InputNativeTest_OH_Input_GetAxisEventSourceType_001
1353 * @tc.desc: Verify the OH_Input_GetAxisEventSourceType
1354 * @tc.type: FUNC
1355 * @tc.require:
1356 */
1357 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventSourceType_001, TestSize.Level1)
1358 {
1359 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1360 ASSERT_NE(axisEvent, nullptr);
1361 Input_Result result = OH_Input_GetAxisEventSourceType(axisEvent, nullptr);
1362 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1363 result = OH_Input_DestroyAxisEvent(&axisEvent);
1364 EXPECT_EQ(result, INPUT_SUCCESS);
1365 }
1366
1367 /**
1368 * @tc.name: InputNativeTest_OH_Input_GetAxisEventSourceType_002
1369 * @tc.desc: Verify the OH_Input_GetAxisEventSourceType
1370 * @tc.type: FUNC
1371 * @tc.require:
1372 */
1373 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventSourceType_002, TestSize.Level1)
1374 {
1375 InputEvent_SourceType sourceType = SOURCE_TYPE_MOUSE;
1376 Input_Result result = OH_Input_GetAxisEventSourceType(nullptr, &sourceType);
1377 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1378 }
1379
1380 /**
1381 * @tc.name: InputNativeTest_OH_Input_GetAxisEventSourceType_003
1382 * @tc.desc: Verify the OH_Input_GetAxisEventSourceType
1383 * @tc.type: FUNC
1384 * @tc.require:
1385 */
1386 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventSourceType_003, TestSize.Level1)
1387 {
1388 Input_Result result = OH_Input_GetAxisEventSourceType(nullptr, nullptr);
1389 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1390 }
1391
1392 /**
1393 * @tc.name: InputNativeTest_OH_Input_AxisEventWindowId_001
1394 * @tc.desc: Verify the OH_Input_AxisEventWindowId
1395 * @tc.type: FUNC
1396 * @tc.require:
1397 */
1398 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AxisEventWindowId_001, TestSize.Level1)
1399 {
1400 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1401 ASSERT_NE(axisEvent, nullptr);
1402 int32_t windowId = -1;
1403 Input_Result result = OH_Input_GetAxisEventWindowId(axisEvent, nullptr);
1404 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1405 result = OH_Input_GetAxisEventWindowId(nullptr, &windowId);
1406 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1407 result = OH_Input_GetAxisEventWindowId(nullptr, nullptr);
1408 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1409 result = OH_Input_SetAxisEventWindowId(axisEvent, 100);
1410 EXPECT_EQ(result, INPUT_SUCCESS);
1411 result = OH_Input_GetAxisEventWindowId(axisEvent, &windowId);
1412 EXPECT_EQ(result, INPUT_SUCCESS);
1413 EXPECT_EQ(windowId, 100);
1414 result = OH_Input_DestroyAxisEvent(&axisEvent);
1415 EXPECT_EQ(result, INPUT_SUCCESS);
1416 EXPECT_EQ(axisEvent, nullptr);
1417 }
1418
1419 /**
1420 * @tc.name: InputNativeTest_OH_Input_AxisEventDisplayId_001
1421 * @tc.desc: Verify the OH_Input_AxisEventDisplayId
1422 * @tc.type: FUNC
1423 * @tc.require:
1424 */
1425 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AxisEventDisplayId_001, TestSize.Level1)
1426 {
1427 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1428 ASSERT_NE(axisEvent, nullptr);
1429 int32_t displayId = -1;
1430 Input_Result result = OH_Input_GetAxisEventDisplayId(axisEvent, nullptr);
1431 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1432 result = OH_Input_GetAxisEventDisplayId(nullptr, &displayId);
1433 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1434 result = OH_Input_GetAxisEventDisplayId(nullptr, nullptr);
1435 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1436 result = OH_Input_SetAxisEventDisplayId(axisEvent, 100);
1437 EXPECT_EQ(result, INPUT_SUCCESS);
1438 result = OH_Input_GetAxisEventDisplayId(axisEvent, &displayId);
1439 EXPECT_EQ(result, INPUT_SUCCESS);
1440 EXPECT_EQ(displayId, 100);
1441 result = OH_Input_DestroyAxisEvent(&axisEvent);
1442 EXPECT_EQ(result, INPUT_SUCCESS);
1443 EXPECT_EQ(axisEvent, nullptr);
1444 }
1445
KeyEventCallback(const struct Input_KeyEvent * keyEvent)1446 static void KeyEventCallback(const struct Input_KeyEvent* keyEvent)
1447 {
1448 ASSERT_NE(keyEvent, nullptr);
1449 int32_t action = OH_Input_GetKeyEventAction(keyEvent);
1450 int32_t keyCode = OH_Input_GetKeyEventKeyCode(keyEvent);
1451 MMI_HILOGI("KeyEventCallback, action:%{public}d, keyCode:%{private}d,", action, keyCode);
1452 }
1453
MouseEventCallback(const struct Input_MouseEvent * mouseEvent)1454 static void MouseEventCallback(const struct Input_MouseEvent* mouseEvent)
1455 {
1456 ASSERT_NE(mouseEvent, nullptr);
1457 int32_t action = OH_Input_GetMouseEventAction(mouseEvent);
1458 int32_t displayX = OH_Input_GetMouseEventDisplayX(mouseEvent);
1459 int32_t displayY = OH_Input_GetMouseEventDisplayY(mouseEvent);
1460 MMI_HILOGI("MouseEventCallback, action:%{public}d, displayX:%{private}d, displayY:%{private}d",
1461 action, displayX, displayY);
1462 }
1463
TouchEventCallback(const struct Input_TouchEvent * touchEvent)1464 static void TouchEventCallback(const struct Input_TouchEvent* touchEvent)
1465 {
1466 ASSERT_NE(touchEvent, nullptr);
1467 int32_t action = OH_Input_GetTouchEventAction(touchEvent);
1468 int32_t id = OH_Input_GetTouchEventFingerId(touchEvent);
1469 MMI_HILOGI("TouchEventCallback, action:%{public}d, id:%{public}d", action, id);
1470 }
1471
AxisEventCallbackAll(const struct Input_AxisEvent * axisEvent)1472 static void AxisEventCallbackAll(const struct Input_AxisEvent* axisEvent)
1473 {
1474 ASSERT_NE(axisEvent, nullptr);
1475 InputEvent_AxisAction axisAction = AXIS_ACTION_BEGIN;
1476 OH_Input_GetAxisEventAction(axisEvent, &axisAction);
1477 InputEvent_AxisEventType sourceType = AXIS_EVENT_TYPE_PINCH;
1478 OH_Input_GetAxisEventType(axisEvent, &sourceType);
1479 InputEvent_SourceType axisEventType = SOURCE_TYPE_MOUSE;
1480 OH_Input_GetAxisEventSourceType(axisEvent, &axisEventType);
1481 MMI_HILOGI("AxisEventCallbackAll, axisAction:%{public}d, sourceType:%{public}d, axisEventType:%{public}d",
1482 axisAction, sourceType, axisEventType);
1483 }
1484
AxisEventCallback(const struct Input_AxisEvent * axisEvent)1485 static void AxisEventCallback(const struct Input_AxisEvent* axisEvent)
1486 {
1487 ASSERT_NE(axisEvent, nullptr);
1488 InputEvent_AxisAction axisAction = AXIS_ACTION_BEGIN;
1489 OH_Input_GetAxisEventAction(axisEvent, &axisAction);
1490 InputEvent_AxisEventType sourceType = AXIS_EVENT_TYPE_PINCH;
1491 OH_Input_GetAxisEventType(axisEvent, &sourceType);
1492 InputEvent_SourceType axisEventType = SOURCE_TYPE_MOUSE;
1493 OH_Input_GetAxisEventSourceType(axisEvent, &axisEventType);
1494 MMI_HILOGI("AxisEventCallback, axisAction:%{public}d, sourceType:%{public}d, axisEventType:%{public}d",
1495 axisAction, sourceType, axisEventType);
1496 }
1497
1498 /**
1499 * @tc.name: InputNativeTest_OH_Input_AddKeyEventMonitor_001
1500 * @tc.desc: Verify the OH_Input_AddKeyEventMonitor
1501 * @tc.type: FUNC
1502 * @tc.require:
1503 */
1504 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddKeyEventMonitor_001, TestSize.Level1)
1505 {
1506 Input_Result retResult = OH_Input_AddKeyEventMonitor(KeyEventCallback);
1507 EXPECT_EQ(retResult, INPUT_SUCCESS);
1508 retResult = OH_Input_RemoveKeyEventMonitor(KeyEventCallback);
1509 EXPECT_EQ(retResult, INPUT_SUCCESS);
1510 }
1511
1512 /**
1513 * @tc.name: InputNativeTest_OH_Input_AddKeyEventMonitor_002
1514 * @tc.desc: Verify the OH_Input_AddKeyEventMonitor
1515 * @tc.type: FUNC
1516 * @tc.require:
1517 */
1518 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddKeyEventMonitor_002, TestSize.Level1)
1519 {
1520 Input_Result retResult = OH_Input_AddKeyEventMonitor(nullptr);
1521 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1522 }
1523
1524 /**
1525 * @tc.name: InputNativeTest_OH_Input_RemoveKeyEventMonitor_001
1526 * @tc.desc: Verify the OH_Input_RemoveKeyEventMonitor
1527 * @tc.type: FUNC
1528 * @tc.require:
1529 */
1530 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveKeyEventMonitor_001, TestSize.Level1)
1531 {
1532 Input_Result retResult = OH_Input_RemoveKeyEventMonitor(nullptr);
1533 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1534 }
1535
1536 /**
1537 * @tc.name: InputNativeTest_OH_Input_RemoveKeyEventMonitor_002
1538 * @tc.desc: Verify the OH_Input_RemoveKeyEventMonitor
1539 * @tc.type: FUNC
1540 * @tc.require:
1541 */
1542 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveKeyEventMonitor_002, TestSize.Level1)
1543 {
1544 Input_Result retResult = OH_Input_RemoveKeyEventMonitor(KeyEventCallback);
1545 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1546 retResult = OH_Input_AddKeyEventMonitor(KeyEventCallback);
1547 EXPECT_EQ(retResult, INPUT_SUCCESS);
1548 retResult = OH_Input_RemoveKeyEventMonitor(KeyEventCallback);
1549 EXPECT_EQ(retResult, INPUT_SUCCESS);
1550 }
1551
1552
1553 /**
1554 * @tc.name: InputNativeTest_OH_Input_AddMouseEventMonitor_001
1555 * @tc.desc: Verify the OH_Input_AddMouseEventMonitor
1556 * @tc.type: FUNC
1557 * @tc.require:
1558 */
1559 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddMouseEventMonitor_001, TestSize.Level1)
1560 {
1561 Input_Result retResult = OH_Input_AddMouseEventMonitor(MouseEventCallback);
1562 EXPECT_EQ(retResult, INPUT_SUCCESS);
1563 retResult = OH_Input_RemoveMouseEventMonitor(MouseEventCallback);
1564 EXPECT_EQ(retResult, INPUT_SUCCESS);
1565 }
1566
1567 /**
1568 * @tc.name: InputNativeTest_OH_Input_AddMouseEventMonitor_002
1569 * @tc.desc: Verify the OH_Input_AddMouseEventMonitor
1570 * @tc.type: FUNC
1571 * @tc.require:
1572 */
1573 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddMouseEventMonitor_002, TestSize.Level1)
1574 {
1575 Input_Result retResult = OH_Input_AddMouseEventMonitor(nullptr);
1576 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1577 }
1578
1579 /**
1580 * @tc.name: InputNativeTest_OH_Input_RemoveMouseEventMonitor_001
1581 * @tc.desc: Verify the OH_Input_RemoveMouseEventMonitor
1582 * @tc.type: FUNC
1583 * @tc.require:
1584 */
1585 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveMouseEventMonitor_001, TestSize.Level1)
1586 {
1587 Input_Result retResult = OH_Input_RemoveMouseEventMonitor(nullptr);
1588 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1589 }
1590
1591 /**
1592 * @tc.name: InputNativeTest_OH_Input_RemoveMouseEventMonitor_002
1593 * @tc.desc: Verify the OH_Input_RemoveMouseEventMonitor
1594 * @tc.type: FUNC
1595 * @tc.require:
1596 */
1597 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveMouseEventMonitor_002, TestSize.Level1)
1598 {
1599 Input_Result retResult = OH_Input_RemoveMouseEventMonitor(MouseEventCallback);
1600 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1601 retResult = OH_Input_AddMouseEventMonitor(MouseEventCallback);
1602 EXPECT_EQ(retResult, INPUT_SUCCESS);
1603 retResult = OH_Input_RemoveMouseEventMonitor(MouseEventCallback);
1604 EXPECT_EQ(retResult, INPUT_SUCCESS);
1605 }
1606
1607 /**
1608 * @tc.name: InputNativeTest_OH_Input_AddTouchEventMonitor_001
1609 * @tc.desc: Verify the OH_Input_AddTouchEventMonitor
1610 * @tc.type: FUNC
1611 * @tc.require:
1612 */
1613 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddTouchEventMonitor_001, TestSize.Level1)
1614 {
1615 Input_Result retResult = OH_Input_AddTouchEventMonitor(TouchEventCallback);
1616 EXPECT_EQ(retResult, INPUT_SUCCESS);
1617 retResult = OH_Input_RemoveTouchEventMonitor(TouchEventCallback);
1618 EXPECT_EQ(retResult, INPUT_SUCCESS);
1619 }
1620
1621 /**
1622 * @tc.name: InputNativeTest_OH_Input_AddTouchEventMonitor_002
1623 * @tc.desc: Verify the OH_Input_AddTouchEventMonitor
1624 * @tc.type: FUNC
1625 * @tc.require:
1626 */
1627 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddTouchEventMonitor_002, TestSize.Level1)
1628 {
1629 Input_Result retResult = OH_Input_AddTouchEventMonitor(nullptr);
1630 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1631 }
1632
1633 /**
1634 * @tc.name: InputNativeTest_OH_Input_RemoveTouchEventMonitor_001
1635 * @tc.desc: Verify the OH_Input_RemoveTouchEventMonitor
1636 * @tc.type: FUNC
1637 * @tc.require:
1638 */
1639 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveTouchEventMonitor_001, TestSize.Level1)
1640 {
1641 Input_Result retResult = OH_Input_RemoveTouchEventMonitor(nullptr);
1642 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1643 }
1644
1645 /**
1646 * @tc.name: InputNativeTest_OH_Input_RemoveTouchEventMonitor_002
1647 * @tc.desc: Verify the OH_Input_RemoveTouchEventMonitor
1648 * @tc.type: FUNC
1649 * @tc.require:
1650 */
1651 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveTouchEventMonitor_002, TestSize.Level1)
1652 {
1653 Input_Result retResult = OH_Input_RemoveTouchEventMonitor(TouchEventCallback);
1654 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1655 retResult = OH_Input_AddTouchEventMonitor(TouchEventCallback);
1656 EXPECT_EQ(retResult, INPUT_SUCCESS);
1657 retResult = OH_Input_RemoveTouchEventMonitor(TouchEventCallback);
1658 EXPECT_EQ(retResult, INPUT_SUCCESS);
1659 }
1660
1661
1662 /**
1663 * @tc.name: InputNativeTest_OH_Input_AddAxisEventMonitorForAll_001
1664 * @tc.desc: Verify the OH_Input_AddAxisEventMonitorForAll
1665 * @tc.type: FUNC
1666 * @tc.require:
1667 */
1668 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddAxisEventMonitorForAll_001, TestSize.Level1)
1669 {
1670 Input_Result retResult = OH_Input_AddAxisEventMonitorForAll(AxisEventCallbackAll);
1671 EXPECT_EQ(retResult, INPUT_SUCCESS);
1672 retResult = OH_Input_RemoveAxisEventMonitorForAll(AxisEventCallbackAll);
1673 EXPECT_EQ(retResult, INPUT_SUCCESS);
1674 }
1675
1676 /**
1677 * @tc.name: InputNativeTest_OH_Input_AddAxisEventMonitorForAll_002
1678 * @tc.desc: Verify the OH_Input_AddAxisEventMonitorForAll
1679 * @tc.type: FUNC
1680 * @tc.require:
1681 */
1682 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddAxisEventMonitorForAll_002, TestSize.Level1)
1683 {
1684 Input_Result retResult = OH_Input_AddAxisEventMonitorForAll(nullptr);
1685 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1686 }
1687
1688 /**
1689 * @tc.name: InputNativeTest_OH_Input_RemoveAxisEventMonitorForAll_001
1690 * @tc.desc: Verify the OH_Input_RemoveAxisEventMonitorForAll
1691 * @tc.type: FUNC
1692 * @tc.require:
1693 */
1694 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveAxisEventMonitorForAll_001, TestSize.Level1)
1695 {
1696 Input_Result retResult = OH_Input_RemoveAxisEventMonitorForAll(nullptr);
1697 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1698 }
1699
1700 /**
1701 * @tc.name: InputNativeTest_OH_Input_RemoveAxisEventMonitorForAll_002
1702 * @tc.desc: Verify the OH_Input_RemoveAxisEventMonitorForAll
1703 * @tc.type: FUNC
1704 * @tc.require:
1705 */
1706 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveAxisEventMonitorForAll_002, TestSize.Level1)
1707 {
1708 Input_Result retResult = OH_Input_RemoveAxisEventMonitorForAll(AxisEventCallbackAll);
1709 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1710 retResult = OH_Input_AddAxisEventMonitorForAll(AxisEventCallbackAll);
1711 EXPECT_EQ(retResult, INPUT_SUCCESS);
1712 retResult = OH_Input_RemoveAxisEventMonitorForAll(AxisEventCallbackAll);
1713 EXPECT_EQ(retResult, INPUT_SUCCESS);
1714 }
1715
1716 /**
1717 * @tc.name: InputNativeTest_OH_Input_AddAxisEventMonitor_001
1718 * @tc.desc: Verify the OH_Input_AddAxisEventMonitor
1719 * @tc.type: FUNC
1720 * @tc.require:
1721 */
1722 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddAxisEventMonitor_001, TestSize.Level1)
1723 {
1724 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1725 Input_Result retResult = OH_Input_AddAxisEventMonitor(axisEventType, AxisEventCallback);
1726 EXPECT_EQ(retResult, INPUT_SUCCESS);
1727 retResult = OH_Input_RemoveAxisEventMonitor(axisEventType, AxisEventCallback);
1728 EXPECT_EQ(retResult, INPUT_SUCCESS);
1729 }
1730
1731 /**
1732 * @tc.name: InputNativeTest_OH_Input_AddAxisEventMonitor_002
1733 * @tc.desc: Verify the OH_Input_AddAxisEventMonitor
1734 * @tc.type: FUNC
1735 * @tc.require:
1736 */
1737 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddAxisEventMonitor_002, TestSize.Level1)
1738 {
1739 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1740 Input_Result retResult = OH_Input_AddAxisEventMonitor(axisEventType, nullptr);
1741 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1742 }
1743
1744 /**
1745 * @tc.name: InputNativeTest_OH_Input_RemoveAxisEventMonitor_001
1746 * @tc.desc: Verify the OH_Input_RemoveAxisEventMonitor
1747 * @tc.type: FUNC
1748 * @tc.require:
1749 */
1750 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveAxisEventMonitor_001, TestSize.Level1)
1751 {
1752 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1753 Input_Result retResult = OH_Input_RemoveAxisEventMonitor(axisEventType, nullptr);
1754 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1755 }
1756
1757 /**
1758 * @tc.name: InputNativeTest_OH_Input_RemoveAxisEventMonitor_002
1759 * @tc.desc: Verify the OH_Input_RemoveAxisEventMonitor
1760 * @tc.type: FUNC
1761 * @tc.require:
1762 */
1763 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveAxisEventMonitor_002, TestSize.Level1)
1764 {
1765 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1766 Input_Result retResult = OH_Input_RemoveAxisEventMonitor(axisEventType, AxisEventCallback);
1767 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1768 retResult = OH_Input_AddAxisEventMonitor(axisEventType, AxisEventCallback);
1769 EXPECT_EQ(retResult, INPUT_SUCCESS);
1770 retResult = OH_Input_RemoveAxisEventMonitor(AXIS_EVENT_TYPE_SCROLL, AxisEventCallback);
1771 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1772 retResult = OH_Input_RemoveAxisEventMonitor(axisEventType, AxisEventCallback);
1773 EXPECT_EQ(retResult, INPUT_SUCCESS);
1774 }
1775
1776 /**
1777 * @tc.name: InputNativeTest_OH_Input_AddKeyEventInterceptor_001
1778 * @tc.desc: Verify the OH_Input_AddKeyEventInterceptor
1779 * @tc.type: FUNC
1780 * @tc.require:
1781 */
1782 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddKeyEventInterceptor_001, TestSize.Level1)
1783 {
1784 Input_Result retResult = OH_Input_AddKeyEventInterceptor(nullptr, nullptr);
1785 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1786 }
1787
1788 /**
1789 * @tc.name: InputNativeTest_OH_Input_AddKeyEventInterceptor_002
1790 * @tc.desc: Verify the OH_Input_AddKeyEventInterceptor
1791 * @tc.type: FUNC
1792 * @tc.require:
1793 */
1794 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddKeyEventInterceptor_002, TestSize.Level1)
1795 {
1796 Input_Result retResult = OH_Input_AddKeyEventInterceptor(KeyEventCallback, nullptr);
1797 EXPECT_EQ(retResult, INPUT_SUCCESS);
1798 retResult = OH_Input_AddKeyEventInterceptor(KeyEventCallback, nullptr);
1799 EXPECT_EQ(retResult, INPUT_REPEAT_INTERCEPTOR);
1800 retResult = OH_Input_RemoveKeyEventInterceptor();
1801 EXPECT_EQ(retResult, INPUT_SUCCESS);
1802 }
1803
1804 /**
1805 * @tc.name: InputNativeTest_OH_Input_RemoveKeyEventInterceptor_001
1806 * @tc.desc: Verify the OH_Input_RemoveKeyEventInterceptor
1807 * @tc.type: FUNC
1808 * @tc.require:
1809 */
1810 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveKeyEventInterceptor_001, TestSize.Level1)
1811 {
1812 Input_Result retResult = OH_Input_RemoveKeyEventInterceptor();
1813 EXPECT_EQ(retResult, INPUT_SERVICE_EXCEPTION);
1814 retResult = OH_Input_AddKeyEventInterceptor(KeyEventCallback, nullptr);
1815 EXPECT_EQ(retResult, INPUT_SUCCESS);
1816 retResult = OH_Input_RemoveKeyEventInterceptor();
1817 EXPECT_EQ(retResult, INPUT_SUCCESS);
1818 }
1819
1820 /**
1821 * @tc.name: InputNativeTest_OH_Input_AddInputEventInterceptor_001
1822 * @tc.desc: Verify the OH_Input_AddInputEventInterceptor
1823 * @tc.type: FUNC
1824 * @tc.require:
1825 */
1826 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddInputEventInterceptor_001, TestSize.Level1)
1827 {
1828 Input_InterceptorOptions *option = nullptr;
1829 Input_Result retResult = OH_Input_AddInputEventInterceptor(nullptr, option);
1830 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1831 }
1832
1833 /**
1834 * @tc.name: InputNativeTest_OH_Input_AddInputEventInterceptor_002
1835 * @tc.desc: Verify the OH_Input_AddInputEventInterceptor
1836 * @tc.type: FUNC
1837 * @tc.require:
1838 */
1839 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddInputEventInterceptor_002, TestSize.Level1)
1840 {
1841 Input_InterceptorEventCallback callback;
1842 callback.mouseCallback = MouseEventCallback;
1843 callback.touchCallback = TouchEventCallback;
1844 callback.axisCallback = AxisEventCallback;
1845 Input_InterceptorOptions *option = nullptr;
1846 Input_Result retResult = OH_Input_AddInputEventInterceptor(&callback, option);
1847 EXPECT_EQ(retResult, INPUT_SUCCESS);
1848 retResult = OH_Input_AddInputEventInterceptor(&callback, option);
1849 EXPECT_EQ(retResult, INPUT_REPEAT_INTERCEPTOR);
1850 retResult = OH_Input_RemoveInputEventInterceptor();
1851 EXPECT_EQ(retResult, INPUT_SUCCESS);
1852 }
1853
1854 /**
1855 * @tc.name: InputNativeTest_OH_Input_RemoveInputEventInterceptor_001
1856 * @tc.desc: Verify the OH_Input_RemoveInputEventInterceptor
1857 * @tc.type: FUNC
1858 * @tc.require:
1859 */
1860 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveInputEventInterceptor_001, TestSize.Level1)
1861 {
1862 Input_Result retResult = OH_Input_RemoveInputEventInterceptor();
1863 EXPECT_EQ(retResult, INPUT_SERVICE_EXCEPTION);
1864 Input_InterceptorEventCallback callback;
1865 callback.mouseCallback = MouseEventCallback;
1866 callback.touchCallback = TouchEventCallback;
1867 callback.axisCallback = AxisEventCallback;
1868 Input_InterceptorOptions *option = nullptr;
1869 retResult = OH_Input_AddInputEventInterceptor(&callback, option);
1870 EXPECT_EQ(retResult, INPUT_SUCCESS);
1871 retResult = OH_Input_RemoveInputEventInterceptor();
1872 EXPECT_EQ(retResult, INPUT_SUCCESS);
1873 }
1874
1875 /**
1876 * @tc.name: InputNativeTest_GetIntervalSinceLastInput_001
1877 * @tc.desc: Verify the Get Interval Since Last Input
1878 * @tc.type: FUNC
1879 * @tc.require:
1880 */
1881 HWTEST_F(InputNativeTest, InputNativeTest_GetIntervalSinceLastInput_001, TestSize.Level1)
1882 {
1883 int64_t intervalSinceLastInput = 5;
1884 int32_t retResult = OH_Input_GetIntervalSinceLastInput(&intervalSinceLastInput);
1885
1886 EXPECT_EQ(retResult, INPUT_SUCCESS);
1887 }
1888
1889 /**
1890 * @tc.name: InputNativeTest_OH_Input_GetAllSystemHotkeys_001
1891 * @tc.desc: Verify the InputNativeTest_OH_Input_GetAllSystemHotkeys
1892 * @tc.type: FUNC
1893 * @tc.require:
1894 */
1895 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAllSystemHotkey_001, TestSize.Level1)
1896 {
1897 int32_t count = 1;
1898 Input_Result ret = OH_Input_GetAllSystemHotkeys(nullptr, &count);
1899 EXPECT_EQ(ret, INPUT_SUCCESS);
1900 Input_Hotkey **hotkey = OH_Input_CreateAllSystemHotkeys(count);
1901 ASSERT_NE(hotkey, nullptr);
1902 ret = OH_Input_GetAllSystemHotkeys(hotkey, &count);
1903 EXPECT_EQ(ret, INPUT_SUCCESS);
1904 OH_Input_DestroyAllSystemHotkeys(hotkey, count);
1905 }
1906
1907 /**
1908 * @tc.name: InputNativeTest_OH_Input_GetAllSystemHotkeys_002
1909 * @tc.desc: Verify the InputNativeTest_OH_Input_GetAllSystemHotkeys
1910 * @tc.type: FUNC
1911 * @tc.require:
1912 */
1913 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAllSystemHotkey_002, TestSize.Level1)
1914 {
1915 Input_Hotkey *hotkey { nullptr };
1916 Input_Result ret = OH_Input_GetAllSystemHotkeys(&hotkey, nullptr);
1917 ASSERT_NE(ret, INPUT_SUCCESS);
1918 }
1919
1920 /**
1921 * @tc.name: InputNativeTest_OH_Input_CreateAllSystemHotkeys_001
1922 * @tc.desc: Verify the InputNativeTest_OH_Input_CreateAllSystemHotkeys
1923 * @tc.type: FUNC
1924 * @tc.require:
1925 */
1926 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_CreateAllSystemHotkeys_001, TestSize.Level1)
1927 {
1928 int32_t count = 100;
1929 Input_Hotkey **hotkey = OH_Input_CreateAllSystemHotkeys(count);
1930 EXPECT_EQ(hotkey, nullptr);
1931 }
1932
1933 /**
1934 * @tc.name: InputNativeTest_OH_Input_GetAllSystemHotkeys_003
1935 * @tc.desc: Verify the InputNativeTest_OH_Input_GetAllSystemHotkeys
1936 * @tc.type: FUNC
1937 * @tc.require:
1938 */
1939 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAllSystemHotkey_003, TestSize.Level1)
1940 {
1941 int32_t count = -2;
1942 Input_Hotkey **hotkey = OH_Input_CreateAllSystemHotkeys(count);
1943 Input_Result ret = OH_Input_GetAllSystemHotkeys(hotkey, &count);
1944 ASSERT_EQ(ret, INPUT_SUCCESS);
1945 OH_Input_DestroyAllSystemHotkeys(hotkey, count);
1946 ret = OH_Input_GetAllSystemHotkeys(nullptr, nullptr);
1947 ASSERT_EQ(ret, INPUT_PARAMETER_ERROR);
1948 }
1949
1950 /**
1951 * @tc.name: InputNativeTest_OH_Input_GetAllSystemHotkeys_003
1952 * @tc.desc: Verify the InputNativeTest_OH_Input_GetAllSystemHotkeys
1953 * @tc.type: FUNC
1954 * @tc.require:
1955 */
1956 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAllSystemHotkey_004, TestSize.Level1)
1957 {
1958 int32_t count = -1;
1959 Input_Hotkey* hotkeys = nullptr;
1960 Input_Result ret = OH_Input_GetAllSystemHotkeys(&hotkeys, &count);
1961 EXPECT_EQ(ret, INPUT_PARAMETER_ERROR);
1962 }
1963 } // namespace MMI
1964 } // namespace OHOS
1965