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