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_InjectMouseEvent_001
213 * @tc.desc: Verify the InjectMouseEvent
214 * @tc.type: FUNC
215 * @tc.require:
216 */
217 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_001, TestSize.Level1)
218 {
219 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
220 ASSERT_NE(mouseEvent, nullptr);
221 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_MOVE);
222 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
223 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
224 OH_Input_SetMouseEventButton(mouseEvent, -2);
225 OH_Input_SetMouseEventActionTime(mouseEvent, -1);
226 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
227 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
228 OH_Input_DestroyMouseEvent(&mouseEvent);
229 EXPECT_EQ(mouseEvent, nullptr);
230 }
231
232 /**
233 * @tc.name: InputNativeTest_InjectMouseEvent_002
234 * @tc.desc: Verify the InjectMouseEvent
235 * @tc.type: FUNC
236 * @tc.require:
237 */
238 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_002, TestSize.Level1)
239 {
240 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
241 ASSERT_NE(mouseEvent, nullptr);
242 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
243 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
244 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
245 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
246 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
247 OH_Input_SetMouseEventButton(mouseEvent, -2);
248 OH_Input_SetMouseEventActionTime(mouseEvent, -1);
249 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
250 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
251 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_END);
252 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
253 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
254 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
255 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
256 OH_Input_SetMouseEventButton(mouseEvent, -2);
257 OH_Input_SetMouseEventActionTime(mouseEvent, -1);
258 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_MouseEventAction_001
266 * @tc.desc: Verify the set and get of mouseEvent action
267 * @tc.type: FUNC
268 * @tc.require:
269 */
270 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventAction_001, TestSize.Level1)
271 {
272 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
273 ASSERT_NE(mouseEvent, nullptr);
274 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_BUTTON_DOWN);
275 int32_t action = OH_Input_GetMouseEventAction(mouseEvent);
276 EXPECT_EQ(action, MOUSE_ACTION_BUTTON_DOWN);
277 OH_Input_DestroyMouseEvent(&mouseEvent);
278 EXPECT_EQ(mouseEvent, nullptr);
279 }
280
281 /**
282 * @tc.name: InputNativeTest_MouseEventDisplayX_001
283 * @tc.desc: Verify the set and get of mouseEvent displayX
284 * @tc.type: FUNC
285 * @tc.require:
286 */
287 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventDisplayX_001, TestSize.Level1)
288 {
289 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
290 ASSERT_NE(mouseEvent, nullptr);
291 OH_Input_SetMouseEventDisplayX(mouseEvent, 100);
292 int32_t displayX = OH_Input_GetMouseEventDisplayX(mouseEvent);
293 EXPECT_EQ(displayX, 100);
294 OH_Input_DestroyMouseEvent(&mouseEvent);
295 EXPECT_EQ(mouseEvent, nullptr);
296 }
297
298 /**
299 * @tc.name: InputNativeTest_MouseEventDisplayY_001
300 * @tc.desc: Verify the set and get of mouseEvent displayY
301 * @tc.type: FUNC
302 * @tc.require:
303 */
304 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventDisplayY_001, TestSize.Level1)
305 {
306 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
307 ASSERT_NE(mouseEvent, nullptr);
308 OH_Input_SetMouseEventDisplayY(mouseEvent, 100);
309 int32_t displayY = OH_Input_GetMouseEventDisplayY(mouseEvent);
310 EXPECT_EQ(displayY, 100);
311 OH_Input_DestroyMouseEvent(&mouseEvent);
312 EXPECT_EQ(mouseEvent, nullptr);
313 }
314
315 /**
316 * @tc.name: InputNativeTest_MouseEventButton_001
317 * @tc.desc: Verify the set and get of mouseEvent button
318 * @tc.type: FUNC
319 * @tc.require:
320 */
321 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventButton_001, TestSize.Level1)
322 {
323 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
324 ASSERT_NE(mouseEvent, nullptr);
325 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_LEFT);
326 int32_t button = OH_Input_GetMouseEventButton(mouseEvent);
327 EXPECT_EQ(button, MOUSE_BUTTON_LEFT);
328 OH_Input_DestroyMouseEvent(&mouseEvent);
329 EXPECT_EQ(mouseEvent, nullptr);
330 }
331
332 /**
333 * @tc.name: InputNativeTest_MouseEventAxisType_001
334 * @tc.desc: Verify the set and get of mouseEvent axisType
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventAxisType_001, TestSize.Level1)
339 {
340 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
341 ASSERT_NE(mouseEvent, nullptr);
342 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
343 int32_t axisType = OH_Input_GetMouseEventAxisType(mouseEvent);
344 EXPECT_EQ(axisType, MOUSE_BUTTON_LEFT);
345 OH_Input_DestroyMouseEvent(&mouseEvent);
346 EXPECT_EQ(mouseEvent, nullptr);
347 }
348
349 /**
350 * @tc.name: InputNativeTest_MouseEventAxisValue_001
351 * @tc.desc: Verify the set and get of mouseEvent axisValue
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventAxisValue_001, TestSize.Level1)
356 {
357 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
358 ASSERT_NE(mouseEvent, nullptr);
359 OH_Input_SetMouseEventAxisValue(mouseEvent, 15.0);
360 float axisValue = OH_Input_GetMouseEventAxisValue(mouseEvent);
361 EXPECT_EQ(axisValue, 15.0);
362 OH_Input_DestroyMouseEvent(&mouseEvent);
363 EXPECT_EQ(mouseEvent, nullptr);
364 }
365
366 /**
367 * @tc.name: InputNativeTest_MouseEventActionTime_001
368 * @tc.desc: Verify the set and get of mouseEvent actionTime
369 * @tc.type: FUNC
370 * @tc.require:
371 */
372 HWTEST_F(InputNativeTest, InputNativeTest_MouseEventActionTime_001, TestSize.Level1)
373 {
374 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
375 ASSERT_NE(mouseEvent, nullptr);
376 OH_Input_SetMouseEventActionTime(mouseEvent, 200);
377 int64_t actionTime = OH_Input_GetMouseEventActionTime(mouseEvent);
378 EXPECT_EQ(actionTime, 200);
379 OH_Input_DestroyMouseEvent(&mouseEvent);
380 EXPECT_EQ(mouseEvent, nullptr);
381 }
382
383 /**
384 * @tc.name: InputNativeTest_InjectTouchEvent_001
385 * @tc.desc: Verify the InjectTouchEvent
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_001, TestSize.Level1)
390 {
391 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
392 ASSERT_NE(touchEvent, nullptr);
393 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
394 OH_Input_SetTouchEventFingerId(touchEvent, 0);
395 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
396 OH_Input_SetTouchEventDisplayY(touchEvent, -10);
397 OH_Input_SetTouchEventActionTime(touchEvent, -1);
398 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
399 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
400 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_UP);
401 OH_Input_SetTouchEventFingerId(touchEvent, 0);
402 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
403 OH_Input_SetTouchEventDisplayY(touchEvent, -10);
404 OH_Input_SetTouchEventActionTime(touchEvent, -1);
405 retResult = OH_Input_InjectTouchEvent(touchEvent);
406 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
407 OH_Input_DestroyTouchEvent(&touchEvent);
408 EXPECT_EQ(touchEvent, nullptr);
409 }
410
411 /**
412 * @tc.name: InputNativeTest_TouchEventAction_001
413 * @tc.desc: Verify the set and get of touchEvent action
414 * @tc.type: FUNC
415 * @tc.require:
416 */
417 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventAction_001, TestSize.Level1)
418 {
419 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
420 ASSERT_NE(touchEvent, nullptr);
421 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
422 int32_t action = OH_Input_GetTouchEventAction(touchEvent);
423 EXPECT_EQ(action, TOUCH_ACTION_DOWN);
424 OH_Input_DestroyTouchEvent(&touchEvent);
425 EXPECT_EQ(touchEvent, nullptr);
426 }
427
428 /**
429 * @tc.name: InputNativeTest_TouchEventFingerId_001
430 * @tc.desc: Verify the set and get of touchEvent id
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventFingerId_001, TestSize.Level1)
435 {
436 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
437 ASSERT_NE(touchEvent, nullptr);
438 OH_Input_SetTouchEventFingerId(touchEvent, 0);
439 int32_t id = OH_Input_GetTouchEventFingerId(touchEvent);
440 EXPECT_EQ(id, 0);
441 OH_Input_DestroyTouchEvent(&touchEvent);
442 EXPECT_EQ(touchEvent, nullptr);
443 }
444
445 /**
446 * @tc.name: InputNativeTest_TouchEventDisplayX_001
447 * @tc.desc: Verify the set and get of touchEvent displayX
448 * @tc.type: FUNC
449 * @tc.require:
450 */
451 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventDisplayX_001, TestSize.Level1)
452 {
453 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
454 ASSERT_NE(touchEvent, nullptr);
455 OH_Input_SetTouchEventDisplayX(touchEvent, 100);
456 int32_t displayX = OH_Input_GetTouchEventDisplayX(touchEvent);
457 EXPECT_EQ(displayX, 100);
458 OH_Input_DestroyTouchEvent(&touchEvent);
459 EXPECT_EQ(touchEvent, nullptr);
460 }
461
462 /**
463 * @tc.name: InputNativeTest_TouchEventDisplayY_001
464 * @tc.desc: Verify the set and get of touchEvent displayY
465 * @tc.type: FUNC
466 * @tc.require:
467 */
468 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventDisplayY_001, TestSize.Level1)
469 {
470 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
471 ASSERT_NE(touchEvent, nullptr);
472 OH_Input_SetTouchEventDisplayY(touchEvent, 100);
473 int32_t displayY = OH_Input_GetTouchEventDisplayY(touchEvent);
474 EXPECT_EQ(displayY, 100);
475 OH_Input_DestroyTouchEvent(&touchEvent);
476 EXPECT_EQ(touchEvent, nullptr);
477 }
478
479 /**
480 * @tc.name: InputNativeTest_TouchEventActionTime_001
481 * @tc.desc: Verify the set and get of touchEvent actionTime
482 * @tc.type: FUNC
483 * @tc.require:
484 */
485 HWTEST_F(InputNativeTest, InputNativeTest_TouchEventActionTime_001, TestSize.Level1)
486 {
487 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
488 ASSERT_NE(touchEvent, nullptr);
489 OH_Input_SetTouchEventActionTime(touchEvent, 200);
490 int64_t actionTime = OH_Input_GetTouchEventActionTime(touchEvent);
491 EXPECT_EQ(actionTime, 200);
492 OH_Input_DestroyTouchEvent(&touchEvent);
493 EXPECT_EQ(touchEvent, nullptr);
494 }
495
496 /**
497 * @tc.name: InputNativeTest_InjectKeyEvent_002
498 * @tc.desc: Verify the InjectKeyEvent
499 * @tc.type: FUNC
500 * @tc.require:
501 */
502 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_002, TestSize.Level1)
503 {
504 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
505 ASSERT_NE(keyEvent, nullptr);
506 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
507 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
508 g_keyEvent->SetAction(OHOS::MMI::KeyEvent::KEY_ACTION_UP);
509 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
510 EXPECT_EQ(retResult, INPUT_SUCCESS);
511 }
512
513 /**
514 * @tc.name: InputNativeTest_InjectKeyEvent_003
515 * @tc.desc: Verify the InjectKeyEvent
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_003, TestSize.Level1)
520 {
521 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
522 ASSERT_NE(keyEvent, nullptr);
523 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
524 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
525 g_keyEvent->SetAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
526 OH_Input_SetKeyEventActionTime(keyEvent, -1);
527 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
528 EXPECT_EQ(retResult, INPUT_SUCCESS);
529 }
530
531 /**
532 * @tc.name: InputNativeTest_InjectKeyEvent_004
533 * @tc.desc: Verify the InjectKeyEvent
534 * @tc.type: FUNC
535 * @tc.require:
536 */
537 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_004, TestSize.Level1)
538 {
539 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
540 ASSERT_NE(keyEvent, nullptr);
541 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
542 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
543 g_keyEvent->SetAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
544 OH_Input_SetKeyEventActionTime(keyEvent, 2);
545 OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_DOWN);
546 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
547 EXPECT_EQ(retResult, INPUT_SUCCESS);
548 }
549
550 /**
551 * @tc.name: InputNativeTest_InjectKeyEvent_005
552 * @tc.desc: Verify the InjectKeyEvent
553 * @tc.type: FUNC
554 * @tc.require:
555 */
556 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_005, TestSize.Level1)
557 {
558 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
559 ASSERT_NE(keyEvent, nullptr);
560 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
561 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
562 g_keyEvent->SetAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
563 OH_Input_SetKeyEventActionTime(keyEvent, 2);
564 OH_Input_SetKeyEventAction(keyEvent, KEY_ACTION_UP);
565 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
566 EXPECT_EQ(retResult, INPUT_SUCCESS);
567 }
568
569 /**
570 * @tc.name: InputNativeTest_InjectKeyEvent_006
571 * @tc.desc: Verify the InjectKeyEvent
572 * @tc.type: FUNC
573 * @tc.require:
574 */
575 HWTEST_F(InputNativeTest, InputNativeTest_InjectKeyEvent_006, TestSize.Level1)
576 {
577 Input_KeyEvent* keyEvent = OH_Input_CreateKeyEvent();
578 ASSERT_NE(keyEvent, nullptr);
579 OH_Input_SetKeyEventKeyCode(keyEvent, KEYCODE_VOLUME_DOWN);
580 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
581 g_keyEvent->SetAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
582 OH_Input_SetKeyEventActionTime(keyEvent, 2);
583 OH_Input_SetKeyEventAction(keyEvent, KeyEvent::KEY_ACTION_UNKNOWN);
584 int32_t retResult = OH_Input_InjectKeyEvent(keyEvent);
585 EXPECT_EQ(retResult, INPUT_SUCCESS);
586 }
587
588 /**
589 * @tc.name: InputNativeTest_InjectMouseEvent_003
590 * @tc.desc: Verify the InjectMouseEvent
591 * @tc.type: FUNC
592 * @tc.require:
593 */
594 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_003, TestSize.Level1)
595 {
596 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
597 ASSERT_NE(mouseEvent, nullptr);
598 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
599 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
600 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
601 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
602 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
603 OH_Input_SetMouseEventButton(mouseEvent, 3);
604 OH_Input_SetMouseEventActionTime(mouseEvent, -1);
605 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
606 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
607 }
608
609 /**
610 * @tc.name: InputNativeTest_InjectTouchEvent_002
611 * @tc.desc: Verify the InjectTouchEvent
612 * @tc.type: FUNC
613 * @tc.require:
614 */
615 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_002, TestSize.Level1)
616 {
617 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
618 ASSERT_NE(touchEvent, nullptr);
619 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_UP);
620 OH_Input_SetTouchEventFingerId(touchEvent, 0);
621 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
622 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
623 OH_Input_SetTouchEventActionTime(touchEvent, -1);
624 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
625 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
626 }
627
628 /**
629 * @tc.name: InputNativeTest_InjectTouchEvent_003
630 * @tc.desc: Verify the InjectTouchEvent
631 * @tc.type: FUNC
632 * @tc.require:
633 */
634 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_003, TestSize.Level1)
635 {
636 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
637 ASSERT_NE(touchEvent, nullptr);
638 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
639 OH_Input_SetTouchEventFingerId(touchEvent, 0);
640 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
641 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
642 OH_Input_SetTouchEventActionTime(touchEvent, -1);
643 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
644 EXPECT_EQ(retResult, INPUT_SUCCESS);
645 }
646
647 /**
648 * @tc.name: InputNativeTest_InjectMouseEvent_004
649 * @tc.desc: Verify the InjectMouseEvent
650 * @tc.type: FUNC
651 * @tc.require:
652 */
653 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_004, TestSize.Level1)
654 {
655 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
656 ASSERT_NE(mouseEvent, nullptr);
657 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_CANCEL);
658 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
659 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
660 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
661 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
662 OH_Input_SetMouseEventActionTime(mouseEvent, 2);
663 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
664 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
665 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_MOVE);
666 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_NONE);
667 retResult = OH_Input_InjectMouseEvent(mouseEvent);
668 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
669 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_BUTTON_DOWN);
670 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_LEFT);
671 retResult = OH_Input_InjectMouseEvent(mouseEvent);
672 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
673 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_BUTTON_UP);
674 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_MIDDLE);
675 retResult = OH_Input_InjectMouseEvent(mouseEvent);
676 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
677 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
678 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_RIGHT);
679 retResult = OH_Input_InjectMouseEvent(mouseEvent);
680 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
681 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_UPDATE);
682 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_FORWARD);
683 retResult = OH_Input_InjectMouseEvent(mouseEvent);
684 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
685 }
686
687 /**
688 * @tc.name: InputNativeTest_InjectMouseEvent_005
689 * @tc.desc: Verify the InjectMouseEvent
690 * @tc.type: FUNC
691 * @tc.require:
692 */
693 HWTEST_F(InputNativeTest, InputNativeTest_InjectMouseEvent_005, TestSize.Level1)
694 {
695 Input_MouseEvent* mouseEvent = OH_Input_CreateMouseEvent();
696 ASSERT_NE(mouseEvent, nullptr);
697 OH_Input_SetMouseEventDisplayX(mouseEvent, 350);
698 OH_Input_SetMouseEventDisplayY(mouseEvent, 350);
699 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
700 OH_Input_SetMouseEventAxisValue(mouseEvent, 1.1);
701 OH_Input_SetMouseEventActionTime(mouseEvent, 2);
702 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_END);
703 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_BACK);
704 int32_t retResult = OH_Input_InjectMouseEvent(mouseEvent);
705 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_END);
706 OH_Input_SetMouseEventButton(mouseEvent, 7);
707 retResult = OH_Input_InjectMouseEvent(mouseEvent);
708 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
709 OH_Input_SetMouseEventAction(mouseEvent, 10);
710 retResult = OH_Input_InjectMouseEvent(mouseEvent);
711 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
712 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_HORIZONTAL);
713 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
714 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_BACK);
715 retResult = OH_Input_InjectMouseEvent(mouseEvent);
716 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
717 OH_Input_SetMouseEventAxisType(mouseEvent, 5);
718 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
719 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_BACK);
720 retResult = OH_Input_InjectMouseEvent(mouseEvent);
721 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
722 OH_Input_SetMouseEventAxisType(mouseEvent, MOUSE_AXIS_SCROLL_VERTICAL);
723 OH_Input_SetMouseEventAction(mouseEvent, MOUSE_ACTION_AXIS_BEGIN);
724 OH_Input_SetMouseEventButton(mouseEvent, MOUSE_BUTTON_BACK);
725 retResult = OH_Input_InjectMouseEvent(mouseEvent);
726 EXPECT_EQ(retResult, INPUT_PERMISSION_DENIED);
727 }
728
729 /**
730 * @tc.name: InputNativeTest_InjectTouchEvent_004
731 * @tc.desc: Verify the InjectTouchEvent
732 * @tc.type: FUNC
733 * @tc.require:
734 */
735 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_004, TestSize.Level1)
736 {
737 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
738 ASSERT_NE(touchEvent, nullptr);
739 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
740 ASSERT_NE(g_keyEvent, nullptr);
741 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_CANCEL);
742 OH_Input_SetTouchEventFingerId(touchEvent, 0);
743 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
744 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
745 OH_Input_SetTouchEventActionTime(touchEvent, 2);
746 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
747 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
748 OH_Input_SetTouchEventActionTime(touchEvent, 2);
749 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
750 retResult = OH_Input_InjectTouchEvent(touchEvent);
751 EXPECT_EQ(retResult, INPUT_SUCCESS);
752 OH_Input_SetTouchEventActionTime(touchEvent, 2);
753 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_MOVE);
754 retResult = OH_Input_InjectTouchEvent(touchEvent);
755 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
756 OH_Input_SetTouchEventActionTime(touchEvent, 2);
757 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_UP);
758 retResult = OH_Input_InjectTouchEvent(touchEvent);
759 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
760 OH_Input_SetTouchEventActionTime(touchEvent, 2);
761 OH_Input_SetTouchEventAction(touchEvent, 10);
762 retResult = OH_Input_InjectTouchEvent(touchEvent);
763 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
764 }
765
766 /**
767 * @tc.name: InputNativeTest_InjectTouchEvent_005
768 * @tc.desc: Verify the InjectTouchEvent
769 * @tc.type: FUNC
770 * @tc.require:
771 */
772 HWTEST_F(InputNativeTest, InputNativeTest_InjectTouchEvent_005, TestSize.Level1)
773 {
774 Input_TouchEvent* touchEvent = OH_Input_CreateTouchEvent();
775 ASSERT_NE(touchEvent, nullptr);
776 std::shared_ptr<OHOS::MMI::KeyEvent> g_keyEvent = OHOS::MMI::KeyEvent::Create();
777 ASSERT_NE(g_keyEvent, nullptr);
778 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_CANCEL);
779 OH_Input_SetTouchEventFingerId(touchEvent, 0);
780 OH_Input_SetTouchEventDisplayX(touchEvent, -10);
781 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
782 OH_Input_SetTouchEventActionTime(touchEvent, 2);
783 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
784 int32_t retResult = OH_Input_InjectTouchEvent(touchEvent);
785 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
786 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
787 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
788 OH_Input_SetTouchEventActionTime(touchEvent, 2);
789 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_DOWN);
790 retResult = OH_Input_InjectTouchEvent(touchEvent);
791 EXPECT_EQ(retResult, INPUT_SUCCESS);
792 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
793 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
794 OH_Input_SetTouchEventActionTime(touchEvent, 2);
795 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_MOVE);
796 retResult = OH_Input_InjectTouchEvent(touchEvent);
797 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
798 OH_Input_SetTouchEventDisplayX(touchEvent, 671);
799 OH_Input_SetTouchEventDisplayY(touchEvent, 10);
800 OH_Input_SetTouchEventActionTime(touchEvent, 2);
801 OH_Input_SetTouchEventAction(touchEvent, TOUCH_ACTION_CANCEL);
802 retResult = OH_Input_InjectTouchEvent(touchEvent);
803 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
804 }
805
806 /**
807 * @tc.name: InputNativeTest_OH_Input_CreateAxisEvent_001
808 * @tc.desc: Verify the OH_Input_CreateAxisEvent
809 * @tc.type: FUNC
810 * @tc.require:
811 */
812 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_CreateAxisEvent_001, TestSize.Level1)
813 {
814 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
815 EXPECT_NE(axisEvent, nullptr);
816
817 InputEvent_AxisAction action = AXIS_ACTION_BEGIN;
818 Input_Result result = OH_Input_SetAxisEventAction(axisEvent, action);
819 EXPECT_EQ(result, INPUT_SUCCESS);
820 action = AXIS_ACTION_UPDATE;
821 result = OH_Input_GetAxisEventAction(axisEvent, &action);
822 EXPECT_EQ(result, INPUT_SUCCESS);
823 EXPECT_EQ(action, AXIS_ACTION_BEGIN);
824
825 float displayX = DISPLAY_X;
826 result = OH_Input_SetAxisEventDisplayX(axisEvent, displayX);
827 EXPECT_EQ(result, INPUT_SUCCESS);
828 displayX = DISPLAY_Y;
829 result = OH_Input_GetAxisEventDisplayX(axisEvent, &displayX);
830 EXPECT_EQ(result, INPUT_SUCCESS);
831 EXPECT_FLOAT_EQ(displayX, DISPLAY_X);
832
833 float displayY = DISPLAY_Y;
834 result = OH_Input_SetAxisEventDisplayY(axisEvent, displayY);
835 EXPECT_EQ(result, INPUT_SUCCESS);
836 displayY = DISPLAY_X;
837 result = OH_Input_GetAxisEventDisplayY(axisEvent, &displayY);
838 EXPECT_EQ(result, INPUT_SUCCESS);
839 EXPECT_FLOAT_EQ(displayY, DISPLAY_Y);
840
841 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
842 double axisValue = DEFAULT_AXIS_VALUE;
843 result = OH_Input_SetAxisEventAxisValue(axisEvent, axisType, axisValue);
844 EXPECT_EQ(result, INPUT_SUCCESS);
845 axisValue = AXIS_VALUE;
846 result = OH_Input_GetAxisEventAxisValue(axisEvent, axisType, &axisValue);
847 EXPECT_EQ(result, INPUT_SUCCESS);
848 EXPECT_DOUBLE_EQ(axisValue, DEFAULT_AXIS_VALUE);
849
850 int64_t actionTime = DEFAULT_ACTIONE_TIME;
851 result = OH_Input_SetAxisEventActionTime(axisEvent, actionTime);
852 EXPECT_EQ(result, INPUT_SUCCESS);
853 actionTime = ACTIONE_TIME;
854 result = OH_Input_GetAxisEventActionTime(axisEvent, &actionTime);
855 EXPECT_EQ(result, INPUT_SUCCESS);
856 EXPECT_EQ(actionTime, DEFAULT_ACTIONE_TIME);
857
858 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
859 result = OH_Input_SetAxisEventType(axisEvent, axisEventType);
860 EXPECT_EQ(result, INPUT_SUCCESS);
861 axisEventType = AXIS_EVENT_TYPE_SCROLL;
862 result = OH_Input_GetAxisEventType(axisEvent, &axisEventType);
863 EXPECT_EQ(result, INPUT_SUCCESS);
864 EXPECT_EQ(axisEventType, AXIS_EVENT_TYPE_PINCH);
865
866 InputEvent_SourceType sourceType = SOURCE_TYPE_MOUSE;
867 result = OH_Input_SetAxisEventSourceType(axisEvent, sourceType);
868 EXPECT_EQ(result, INPUT_SUCCESS);
869 sourceType = SOURCE_TYPE_TOUCHSCREEN;
870 result = OH_Input_GetAxisEventSourceType(axisEvent, &sourceType);
871 EXPECT_EQ(result, INPUT_SUCCESS);
872 EXPECT_EQ(sourceType, SOURCE_TYPE_MOUSE);
873
874 result = OH_Input_DestroyAxisEvent(&axisEvent);
875 EXPECT_EQ(result, INPUT_SUCCESS);
876 }
877
878 /**
879 * @tc.name: InputNativeTest_OH_Input_DestroyAxisEvent_001
880 * @tc.desc: Verify the OH_Input_DestroyAxisEvent
881 * @tc.type: FUNC
882 * @tc.require:
883 */
884 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_DestroyAxisEvent_001, TestSize.Level1)
885 {
886 Input_Result result = OH_Input_DestroyAxisEvent(nullptr);
887 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
888 }
889
890 /**
891 * @tc.name: InputNativeTest_OH_Input_SetAxisEventAction_001
892 * @tc.desc: Verify the OH_Input_SetAxisEventAction
893 * @tc.type: FUNC
894 * @tc.require:
895 */
896 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventAction_001, TestSize.Level1)
897 {
898 InputEvent_AxisAction action = AXIS_ACTION_BEGIN;
899 Input_Result result = OH_Input_SetAxisEventAction(nullptr, action);
900 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
901 }
902
903 /**
904 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAction_001
905 * @tc.desc: Verify the OH_Input_GetAxisEventAction
906 * @tc.type: FUNC
907 * @tc.require:
908 */
909 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAction_001, TestSize.Level1)
910 {
911 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
912 EXPECT_NE(axisEvent, nullptr);
913 Input_Result result = OH_Input_GetAxisEventAction(axisEvent, nullptr);
914 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
915 result = OH_Input_DestroyAxisEvent(&axisEvent);
916 EXPECT_EQ(result, INPUT_SUCCESS);
917 }
918
919 /**
920 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAction_002
921 * @tc.desc: Verify the OH_Input_GetAxisEventAction
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAction_002, TestSize.Level1)
926 {
927 InputEvent_AxisAction action = AXIS_ACTION_END;
928 Input_Result result = OH_Input_GetAxisEventAction(nullptr, &action);
929 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
930 }
931
932 /**
933 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAction_003
934 * @tc.desc: Verify the OH_Input_GetAxisEventAction
935 * @tc.type: FUNC
936 * @tc.require:
937 */
938 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAction_003, TestSize.Level1)
939 {
940 Input_Result result = OH_Input_GetAxisEventAction(nullptr, nullptr);
941 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
942 }
943
944 /**
945 * @tc.name: InputNativeTest_OH_Input_SetAxisEventDisplayX_001
946 * @tc.desc: Verify the OH_Input_SetAxisEventDisplayX
947 * @tc.type: FUNC
948 * @tc.require:
949 */
950 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventDisplayX_001, TestSize.Level1)
951 {
952 float displayX = DISPLAY_X;
953 Input_Result result = OH_Input_SetAxisEventDisplayX(nullptr, displayX);
954 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
955 }
956
957 /**
958 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayX_001
959 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayX
960 * @tc.type: FUNC
961 * @tc.require:
962 */
963 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayX_001, TestSize.Level1)
964 {
965 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
966 EXPECT_NE(axisEvent, nullptr);
967 Input_Result result = OH_Input_GetAxisEventDisplayX(axisEvent, nullptr);
968 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
969 result = OH_Input_DestroyAxisEvent(&axisEvent);
970 EXPECT_EQ(result, INPUT_SUCCESS);
971 }
972
973 /**
974 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayX_002
975 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayX
976 * @tc.type: FUNC
977 * @tc.require:
978 */
979 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayX_002, TestSize.Level1)
980 {
981 float displayX = DISPLAY_X;
982 Input_Result result = OH_Input_GetAxisEventDisplayX(nullptr, &displayX);
983 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
984 }
985
986 /**
987 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayX_003
988 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayX
989 * @tc.type: FUNC
990 * @tc.require:
991 */
992 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayX_003, TestSize.Level1)
993 {
994 Input_Result result = OH_Input_GetAxisEventDisplayX(nullptr, nullptr);
995 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
996 }
997
998 /**
999 * @tc.name: InputNativeTest_OH_Input_SetAxisEventDisplayY_001
1000 * @tc.desc: Verify the OH_Input_SetAxisEventDisplayY
1001 * @tc.type: FUNC
1002 * @tc.require:
1003 */
1004 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventDisplayY_001, TestSize.Level1)
1005 {
1006 float displayY = DISPLAY_Y;
1007 Input_Result result = OH_Input_SetAxisEventDisplayY(nullptr, displayY);
1008 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1009 }
1010
1011 /**
1012 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayY_001
1013 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayY
1014 * @tc.type: FUNC
1015 * @tc.require:
1016 */
1017 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayY_001, TestSize.Level1)
1018 {
1019 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1020 EXPECT_NE(axisEvent, nullptr);
1021 Input_Result result = OH_Input_GetAxisEventDisplayY(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_GetAxisEventDisplayY_002
1029 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayY
1030 * @tc.type: FUNC
1031 * @tc.require:
1032 */
1033 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayY_002, TestSize.Level1)
1034 {
1035 float displayY = DISPLAY_Y;
1036 Input_Result result = OH_Input_GetAxisEventDisplayY(nullptr, &displayY);
1037 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1038 }
1039
1040 /**
1041 * @tc.name: InputNativeTest_OH_Input_GetAxisEventDisplayY_003
1042 * @tc.desc: Verify the OH_Input_GetAxisEventDisplayY
1043 * @tc.type: FUNC
1044 * @tc.require:
1045 */
1046 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventDisplayY_003, TestSize.Level1)
1047 {
1048 Input_Result result = OH_Input_GetAxisEventDisplayY(nullptr, nullptr);
1049 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1050 }
1051
1052 /**
1053 * @tc.name: InputNativeTest_OH_Input_SetAxisEventAxisValue_001
1054 * @tc.desc: Verify the OH_Input_SetAxisEventAxisValue
1055 * @tc.type: FUNC
1056 * @tc.require:
1057 */
1058 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventAxisValue_001, TestSize.Level1)
1059 {
1060 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1061 double axisValue = DEFAULT_AXIS_VALUE;
1062 Input_Result result = OH_Input_SetAxisEventAxisValue(nullptr, axisType, axisValue);
1063 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1064 }
1065
1066 /**
1067 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAxisValue_001
1068 * @tc.desc: Verify the OH_Input_GetAxisEventAxisValue
1069 * @tc.type: FUNC
1070 * @tc.require:
1071 */
1072 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAxisValue_001, TestSize.Level1)
1073 {
1074 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1075 EXPECT_NE(axisEvent, nullptr);
1076 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1077 Input_Result result = OH_Input_GetAxisEventAxisValue(axisEvent, axisType, nullptr);
1078 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1079 result = OH_Input_DestroyAxisEvent(&axisEvent);
1080 EXPECT_EQ(result, INPUT_SUCCESS);
1081 }
1082
1083 /**
1084 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAxisValue_002
1085 * @tc.desc: Verify the OH_Input_GetAxisEventAxisValue
1086 * @tc.type: FUNC
1087 * @tc.require:
1088 */
1089 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAxisValue_002, TestSize.Level1)
1090 {
1091 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1092 double axisValue = DEFAULT_AXIS_VALUE;
1093 Input_Result result = OH_Input_GetAxisEventAxisValue(nullptr, axisType, &axisValue);
1094 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1095 }
1096
1097 /**
1098 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAxisValue_003
1099 * @tc.desc: Verify the OH_Input_GetAxisEventAxisValue
1100 * @tc.type: FUNC
1101 * @tc.require:
1102 */
1103 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAxisValue_003, TestSize.Level1)
1104 {
1105 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1106 Input_Result result = OH_Input_GetAxisEventAxisValue(nullptr, axisType, nullptr);
1107 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1108 }
1109
1110 /**
1111 * @tc.name: InputNativeTest_OH_Input_GetAxisEventAxisValue_004
1112 * @tc.desc: Verify the OH_Input_GetAxisEventAxisValue
1113 * @tc.type: FUNC
1114 * @tc.require:
1115 */
1116 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventAxisValue_004, TestSize.Level1)
1117 {
1118 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1119 EXPECT_NE(axisEvent, nullptr);
1120 InputEvent_AxisType axisType = AXIS_TYPE_SCROLL_VERTICAL;
1121 double axisValue = DEFAULT_AXIS_VALUE;
1122 Input_Result result = OH_Input_GetAxisEventAxisValue(axisEvent, axisType, &axisValue);
1123 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1124 result = OH_Input_DestroyAxisEvent(&axisEvent);
1125 EXPECT_EQ(result, INPUT_SUCCESS);
1126 }
1127
1128 /**
1129 * @tc.name: InputNativeTest_OH_Input_SetAxisEventActionTime_001
1130 * @tc.desc: Verify the OH_Input_SetAxisEventActionTime
1131 * @tc.type: FUNC
1132 * @tc.require:
1133 */
1134 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventActionTime_001, TestSize.Level1)
1135 {
1136 int64_t actionTime = DEFAULT_ACTIONE_TIME;
1137 Input_Result result = OH_Input_SetAxisEventActionTime(nullptr, actionTime);
1138 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1139 }
1140
1141 /**
1142 * @tc.name: InputNativeTest_OH_Input_GetAxisEventActionTime_001
1143 * @tc.desc: Verify the OH_Input_GetAxisEventActionTime
1144 * @tc.type: FUNC
1145 * @tc.require:
1146 */
1147 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventActionTime_001, TestSize.Level1)
1148 {
1149 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1150 EXPECT_NE(axisEvent, nullptr);
1151 Input_Result result = OH_Input_GetAxisEventActionTime(axisEvent, nullptr);
1152 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1153 result = OH_Input_DestroyAxisEvent(&axisEvent);
1154 EXPECT_EQ(result, INPUT_SUCCESS);
1155 }
1156
1157 /**
1158 * @tc.name: InputNativeTest_OH_Input_GetAxisEventActionTime_002
1159 * @tc.desc: Verify the OH_Input_GetAxisEventActionTime
1160 * @tc.type: FUNC
1161 * @tc.require:
1162 */
1163 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventActionTime_002, TestSize.Level1)
1164 {
1165 int64_t actionTime = DEFAULT_ACTIONE_TIME;
1166 Input_Result result = OH_Input_GetAxisEventActionTime(nullptr, &actionTime);
1167 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1168 }
1169
1170 /**
1171 * @tc.name: InputNativeTest_OH_Input_GetAxisEventActionTime_003
1172 * @tc.desc: Verify the OH_Input_GetAxisEventActionTime
1173 * @tc.type: FUNC
1174 * @tc.require:
1175 */
1176 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventActionTime_003, TestSize.Level1)
1177 {
1178 Input_Result result = OH_Input_GetAxisEventActionTime(nullptr, nullptr);
1179 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1180 }
1181
1182 /**
1183 * @tc.name: InputNativeTest_OH_Input_SetAxisEventType_001
1184 * @tc.desc: Verify the OH_Input_SetAxisEventType
1185 * @tc.type: FUNC
1186 * @tc.require:
1187 */
1188 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventType_001, TestSize.Level1)
1189 {
1190 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1191 Input_Result result = OH_Input_SetAxisEventType(nullptr, axisEventType);
1192 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1193 }
1194
1195 /**
1196 * @tc.name: InputNativeTest_OH_Input_GetAxisEventType_001
1197 * @tc.desc: Verify the OH_Input_GetAxisEventType
1198 * @tc.type: FUNC
1199 * @tc.require:
1200 */
1201 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventType_001, TestSize.Level1)
1202 {
1203 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1204 EXPECT_NE(axisEvent, nullptr);
1205 Input_Result result = OH_Input_GetAxisEventType(axisEvent, nullptr);
1206 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1207 result = OH_Input_DestroyAxisEvent(&axisEvent);
1208 EXPECT_EQ(result, INPUT_SUCCESS);
1209 }
1210
1211 /**
1212 * @tc.name: InputNativeTest_OH_Input_GetAxisEventType_002
1213 * @tc.desc: Verify the OH_Input_GetAxisEventType
1214 * @tc.type: FUNC
1215 * @tc.require:
1216 */
1217 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventType_002, TestSize.Level1)
1218 {
1219 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1220 Input_Result result = OH_Input_GetAxisEventType(nullptr, &axisEventType);
1221 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1222 }
1223
1224 /**
1225 * @tc.name: InputNativeTest_OH_Input_GetAxisEventType_003
1226 * @tc.desc: Verify the OH_Input_GetAxisEventType
1227 * @tc.type: FUNC
1228 * @tc.require:
1229 */
1230 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventType_003, TestSize.Level1)
1231 {
1232 Input_Result result = OH_Input_GetAxisEventType(nullptr, nullptr);
1233 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1234 }
1235
1236 /**
1237 * @tc.name: InputNativeTest_OH_Input_SetAxisEventSourceType_001
1238 * @tc.desc: Verify the OH_Input_SetAxisEventSourceType
1239 * @tc.type: FUNC
1240 * @tc.require:
1241 */
1242 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_SetAxisEventSourceType_001, TestSize.Level1)
1243 {
1244 InputEvent_SourceType sourceType = SOURCE_TYPE_MOUSE;
1245 Input_Result result = OH_Input_SetAxisEventSourceType(nullptr, sourceType);
1246 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1247 }
1248
1249 /**
1250 * @tc.name: InputNativeTest_OH_Input_GetAxisEventSourceType_001
1251 * @tc.desc: Verify the OH_Input_GetAxisEventSourceType
1252 * @tc.type: FUNC
1253 * @tc.require:
1254 */
1255 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventSourceType_001, TestSize.Level1)
1256 {
1257 Input_AxisEvent* axisEvent = OH_Input_CreateAxisEvent();
1258 EXPECT_NE(axisEvent, nullptr);
1259 Input_Result result = OH_Input_GetAxisEventSourceType(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_GetAxisEventSourceType_002
1267 * @tc.desc: Verify the OH_Input_GetAxisEventSourceType
1268 * @tc.type: FUNC
1269 * @tc.require:
1270 */
1271 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventSourceType_002, TestSize.Level1)
1272 {
1273 InputEvent_SourceType sourceType = SOURCE_TYPE_MOUSE;
1274 Input_Result result = OH_Input_GetAxisEventSourceType(nullptr, &sourceType);
1275 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1276 }
1277
1278 /**
1279 * @tc.name: InputNativeTest_OH_Input_GetAxisEventSourceType_003
1280 * @tc.desc: Verify the OH_Input_GetAxisEventSourceType
1281 * @tc.type: FUNC
1282 * @tc.require:
1283 */
1284 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_GetAxisEventSourceType_003, TestSize.Level1)
1285 {
1286 Input_Result result = OH_Input_GetAxisEventSourceType(nullptr, nullptr);
1287 EXPECT_EQ(result, INPUT_PARAMETER_ERROR);
1288 }
1289
KeyEventCallback(const struct Input_KeyEvent * keyEvent)1290 static void KeyEventCallback(const struct Input_KeyEvent* keyEvent)
1291 {
1292 EXPECT_NE(keyEvent, nullptr);
1293 int32_t action = OH_Input_GetKeyEventAction(keyEvent);
1294 int32_t keyCode = OH_Input_GetKeyEventKeyCode(keyEvent);
1295 MMI_HILOGI("KeyEventCallback, action:%{public}d, keyCode:%{public}d,", action, keyCode);
1296 }
1297
MouseEventCallback(const struct Input_MouseEvent * mouseEvent)1298 static void MouseEventCallback(const struct Input_MouseEvent* mouseEvent)
1299 {
1300 EXPECT_NE(mouseEvent, nullptr);
1301 int32_t action = OH_Input_GetMouseEventAction(mouseEvent);
1302 int32_t displayX = OH_Input_GetMouseEventDisplayX(mouseEvent);
1303 int32_t displayY = OH_Input_GetMouseEventDisplayY(mouseEvent);
1304 MMI_HILOGI("MouseEventCallback, action:%{public}d, displayX:%{public}d, displayY:%{public}d",
1305 action, displayX, displayY);
1306 }
1307
TouchEventCallback(const struct Input_TouchEvent * touchEvent)1308 static void TouchEventCallback(const struct Input_TouchEvent* touchEvent)
1309 {
1310 EXPECT_NE(touchEvent, nullptr);
1311 int32_t action = OH_Input_GetTouchEventAction(touchEvent);
1312 int32_t id = OH_Input_GetTouchEventFingerId(touchEvent);
1313 MMI_HILOGI("TouchEventCallback, action:%{public}d, id:%{public}d", action, id);
1314 }
1315
AxisEventCallbackAll(const struct Input_AxisEvent * axisEvent)1316 static void AxisEventCallbackAll(const struct Input_AxisEvent* axisEvent)
1317 {
1318 EXPECT_NE(axisEvent, nullptr);
1319 InputEvent_AxisAction axisAction = AXIS_ACTION_BEGIN;
1320 OH_Input_GetAxisEventAction(axisEvent, &axisAction);
1321 InputEvent_AxisEventType sourceType = AXIS_EVENT_TYPE_PINCH;
1322 OH_Input_GetAxisEventType(axisEvent, &sourceType);
1323 InputEvent_SourceType axisEventType = SOURCE_TYPE_MOUSE;
1324 OH_Input_GetAxisEventSourceType(axisEvent, &axisEventType);
1325 MMI_HILOGI("AxisEventCallbackAll, axisAction:%{public}d, sourceType:%{public}d, axisEventType:%{public}d",
1326 axisAction, sourceType, axisEventType);
1327 }
1328
AxisEventCallback(const struct Input_AxisEvent * axisEvent)1329 static void AxisEventCallback(const struct Input_AxisEvent* axisEvent)
1330 {
1331 EXPECT_NE(axisEvent, nullptr);
1332 InputEvent_AxisAction axisAction = AXIS_ACTION_BEGIN;
1333 OH_Input_GetAxisEventAction(axisEvent, &axisAction);
1334 InputEvent_AxisEventType sourceType = AXIS_EVENT_TYPE_PINCH;
1335 OH_Input_GetAxisEventType(axisEvent, &sourceType);
1336 InputEvent_SourceType axisEventType = SOURCE_TYPE_MOUSE;
1337 OH_Input_GetAxisEventSourceType(axisEvent, &axisEventType);
1338 MMI_HILOGI("AxisEventCallback, axisAction:%{public}d, sourceType:%{public}d, axisEventType:%{public}d",
1339 axisAction, sourceType, axisEventType);
1340 }
1341
1342 /**
1343 * @tc.name: InputNativeTest_OH_Input_AddKeyEventMonitor_001
1344 * @tc.desc: Verify the OH_Input_AddKeyEventMonitor
1345 * @tc.type: FUNC
1346 * @tc.require:
1347 */
1348 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddKeyEventMonitor_001, TestSize.Level1)
1349 {
1350 Input_Result retResult = OH_Input_AddKeyEventMonitor(KeyEventCallback);
1351 EXPECT_EQ(retResult, INPUT_SUCCESS);
1352 retResult = OH_Input_RemoveKeyEventMonitor(KeyEventCallback);
1353 EXPECT_EQ(retResult, INPUT_SUCCESS);
1354 }
1355
1356 /**
1357 * @tc.name: InputNativeTest_OH_Input_AddKeyEventMonitor_002
1358 * @tc.desc: Verify the OH_Input_AddKeyEventMonitor
1359 * @tc.type: FUNC
1360 * @tc.require:
1361 */
1362 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddKeyEventMonitor_002, TestSize.Level1)
1363 {
1364 Input_Result retResult = OH_Input_AddKeyEventMonitor(nullptr);
1365 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1366 }
1367
1368 /**
1369 * @tc.name: InputNativeTest_OH_Input_RemoveKeyEventMonitor_001
1370 * @tc.desc: Verify the OH_Input_RemoveKeyEventMonitor
1371 * @tc.type: FUNC
1372 * @tc.require:
1373 */
1374 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveKeyEventMonitor_001, TestSize.Level1)
1375 {
1376 Input_Result retResult = OH_Input_RemoveKeyEventMonitor(nullptr);
1377 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1378 }
1379
1380 /**
1381 * @tc.name: InputNativeTest_OH_Input_RemoveKeyEventMonitor_002
1382 * @tc.desc: Verify the OH_Input_RemoveKeyEventMonitor
1383 * @tc.type: FUNC
1384 * @tc.require:
1385 */
1386 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveKeyEventMonitor_002, TestSize.Level1)
1387 {
1388 Input_Result retResult = OH_Input_RemoveKeyEventMonitor(KeyEventCallback);
1389 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1390 retResult = OH_Input_AddKeyEventMonitor(KeyEventCallback);
1391 EXPECT_EQ(retResult, INPUT_SUCCESS);
1392 retResult = OH_Input_RemoveKeyEventMonitor(KeyEventCallback);
1393 EXPECT_EQ(retResult, INPUT_SUCCESS);
1394 }
1395
1396
1397 /**
1398 * @tc.name: InputNativeTest_OH_Input_AddMouseEventMonitor_001
1399 * @tc.desc: Verify the OH_Input_AddMouseEventMonitor
1400 * @tc.type: FUNC
1401 * @tc.require:
1402 */
1403 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddMouseEventMonitor_001, TestSize.Level1)
1404 {
1405 Input_Result retResult = OH_Input_AddMouseEventMonitor(MouseEventCallback);
1406 EXPECT_EQ(retResult, INPUT_SUCCESS);
1407 retResult = OH_Input_RemoveMouseEventMonitor(MouseEventCallback);
1408 EXPECT_EQ(retResult, INPUT_SUCCESS);
1409 }
1410
1411 /**
1412 * @tc.name: InputNativeTest_OH_Input_AddMouseEventMonitor_002
1413 * @tc.desc: Verify the OH_Input_AddMouseEventMonitor
1414 * @tc.type: FUNC
1415 * @tc.require:
1416 */
1417 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddMouseEventMonitor_002, TestSize.Level1)
1418 {
1419 Input_Result retResult = OH_Input_AddMouseEventMonitor(nullptr);
1420 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1421 }
1422
1423 /**
1424 * @tc.name: InputNativeTest_OH_Input_RemoveMouseEventMonitor_001
1425 * @tc.desc: Verify the OH_Input_RemoveMouseEventMonitor
1426 * @tc.type: FUNC
1427 * @tc.require:
1428 */
1429 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveMouseEventMonitor_001, TestSize.Level1)
1430 {
1431 Input_Result retResult = OH_Input_RemoveMouseEventMonitor(nullptr);
1432 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1433 }
1434
1435 /**
1436 * @tc.name: InputNativeTest_OH_Input_RemoveMouseEventMonitor_002
1437 * @tc.desc: Verify the OH_Input_RemoveMouseEventMonitor
1438 * @tc.type: FUNC
1439 * @tc.require:
1440 */
1441 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveMouseEventMonitor_002, TestSize.Level1)
1442 {
1443 Input_Result retResult = OH_Input_RemoveMouseEventMonitor(MouseEventCallback);
1444 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1445 retResult = OH_Input_AddMouseEventMonitor(MouseEventCallback);
1446 EXPECT_EQ(retResult, INPUT_SUCCESS);
1447 retResult = OH_Input_RemoveMouseEventMonitor(MouseEventCallback);
1448 EXPECT_EQ(retResult, INPUT_SUCCESS);
1449 }
1450
1451 /**
1452 * @tc.name: InputNativeTest_OH_Input_AddTouchEventMonitor_001
1453 * @tc.desc: Verify the OH_Input_AddTouchEventMonitor
1454 * @tc.type: FUNC
1455 * @tc.require:
1456 */
1457 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddTouchEventMonitor_001, TestSize.Level1)
1458 {
1459 Input_Result retResult = OH_Input_AddTouchEventMonitor(TouchEventCallback);
1460 EXPECT_EQ(retResult, INPUT_SUCCESS);
1461 retResult = OH_Input_RemoveTouchEventMonitor(TouchEventCallback);
1462 EXPECT_EQ(retResult, INPUT_SUCCESS);
1463 }
1464
1465 /**
1466 * @tc.name: InputNativeTest_OH_Input_AddTouchEventMonitor_002
1467 * @tc.desc: Verify the OH_Input_AddTouchEventMonitor
1468 * @tc.type: FUNC
1469 * @tc.require:
1470 */
1471 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddTouchEventMonitor_002, TestSize.Level1)
1472 {
1473 Input_Result retResult = OH_Input_AddTouchEventMonitor(nullptr);
1474 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1475 }
1476
1477 /**
1478 * @tc.name: InputNativeTest_OH_Input_RemoveTouchEventMonitor_001
1479 * @tc.desc: Verify the OH_Input_RemoveTouchEventMonitor
1480 * @tc.type: FUNC
1481 * @tc.require:
1482 */
1483 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveTouchEventMonitor_001, TestSize.Level1)
1484 {
1485 Input_Result retResult = OH_Input_RemoveTouchEventMonitor(nullptr);
1486 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1487 }
1488
1489 /**
1490 * @tc.name: InputNativeTest_OH_Input_RemoveTouchEventMonitor_002
1491 * @tc.desc: Verify the OH_Input_RemoveTouchEventMonitor
1492 * @tc.type: FUNC
1493 * @tc.require:
1494 */
1495 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveTouchEventMonitor_002, TestSize.Level1)
1496 {
1497 Input_Result retResult = OH_Input_RemoveTouchEventMonitor(TouchEventCallback);
1498 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1499 retResult = OH_Input_AddTouchEventMonitor(TouchEventCallback);
1500 EXPECT_EQ(retResult, INPUT_SUCCESS);
1501 retResult = OH_Input_RemoveTouchEventMonitor(TouchEventCallback);
1502 EXPECT_EQ(retResult, INPUT_SUCCESS);
1503 }
1504
1505
1506 /**
1507 * @tc.name: InputNativeTest_OH_Input_AddAxisEventMonitorForAll_001
1508 * @tc.desc: Verify the OH_Input_AddAxisEventMonitorForAll
1509 * @tc.type: FUNC
1510 * @tc.require:
1511 */
1512 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddAxisEventMonitorForAll_001, TestSize.Level1)
1513 {
1514 Input_Result retResult = OH_Input_AddAxisEventMonitorForAll(AxisEventCallbackAll);
1515 EXPECT_EQ(retResult, INPUT_SUCCESS);
1516 retResult = OH_Input_RemoveAxisEventMonitorForAll(AxisEventCallbackAll);
1517 EXPECT_EQ(retResult, INPUT_SUCCESS);
1518 }
1519
1520 /**
1521 * @tc.name: InputNativeTest_OH_Input_AddAxisEventMonitorForAll_002
1522 * @tc.desc: Verify the OH_Input_AddAxisEventMonitorForAll
1523 * @tc.type: FUNC
1524 * @tc.require:
1525 */
1526 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddAxisEventMonitorForAll_002, TestSize.Level1)
1527 {
1528 Input_Result retResult = OH_Input_AddAxisEventMonitorForAll(nullptr);
1529 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1530 }
1531
1532 /**
1533 * @tc.name: InputNativeTest_OH_Input_RemoveAxisEventMonitorForAll_001
1534 * @tc.desc: Verify the OH_Input_RemoveAxisEventMonitorForAll
1535 * @tc.type: FUNC
1536 * @tc.require:
1537 */
1538 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveAxisEventMonitorForAll_001, TestSize.Level1)
1539 {
1540 Input_Result retResult = OH_Input_RemoveAxisEventMonitorForAll(nullptr);
1541 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1542 }
1543
1544 /**
1545 * @tc.name: InputNativeTest_OH_Input_RemoveAxisEventMonitorForAll_002
1546 * @tc.desc: Verify the OH_Input_RemoveAxisEventMonitorForAll
1547 * @tc.type: FUNC
1548 * @tc.require:
1549 */
1550 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveAxisEventMonitorForAll_002, TestSize.Level1)
1551 {
1552 Input_Result retResult = OH_Input_RemoveAxisEventMonitorForAll(AxisEventCallbackAll);
1553 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1554 retResult = OH_Input_AddAxisEventMonitorForAll(AxisEventCallbackAll);
1555 EXPECT_EQ(retResult, INPUT_SUCCESS);
1556 retResult = OH_Input_RemoveAxisEventMonitorForAll(AxisEventCallbackAll);
1557 EXPECT_EQ(retResult, INPUT_SUCCESS);
1558 }
1559
1560 /**
1561 * @tc.name: InputNativeTest_OH_Input_AddAxisEventMonitor_001
1562 * @tc.desc: Verify the OH_Input_AddAxisEventMonitor
1563 * @tc.type: FUNC
1564 * @tc.require:
1565 */
1566 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddAxisEventMonitor_001, TestSize.Level1)
1567 {
1568 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1569 Input_Result retResult = OH_Input_AddAxisEventMonitor(axisEventType, AxisEventCallback);
1570 EXPECT_EQ(retResult, INPUT_SUCCESS);
1571 retResult = OH_Input_RemoveAxisEventMonitor(axisEventType, AxisEventCallback);
1572 EXPECT_EQ(retResult, INPUT_SUCCESS);
1573 }
1574
1575 /**
1576 * @tc.name: InputNativeTest_OH_Input_AddAxisEventMonitor_002
1577 * @tc.desc: Verify the OH_Input_AddAxisEventMonitor
1578 * @tc.type: FUNC
1579 * @tc.require:
1580 */
1581 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddAxisEventMonitor_002, TestSize.Level1)
1582 {
1583 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1584 Input_Result retResult = OH_Input_AddAxisEventMonitor(axisEventType, nullptr);
1585 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1586 }
1587
1588 /**
1589 * @tc.name: InputNativeTest_OH_Input_RemoveAxisEventMonitor_001
1590 * @tc.desc: Verify the OH_Input_RemoveAxisEventMonitor
1591 * @tc.type: FUNC
1592 * @tc.require:
1593 */
1594 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveAxisEventMonitor_001, TestSize.Level1)
1595 {
1596 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1597 Input_Result retResult = OH_Input_RemoveAxisEventMonitor(axisEventType, nullptr);
1598 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1599 }
1600
1601 /**
1602 * @tc.name: InputNativeTest_OH_Input_RemoveAxisEventMonitor_002
1603 * @tc.desc: Verify the OH_Input_RemoveAxisEventMonitor
1604 * @tc.type: FUNC
1605 * @tc.require:
1606 */
1607 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveAxisEventMonitor_002, TestSize.Level1)
1608 {
1609 InputEvent_AxisEventType axisEventType = AXIS_EVENT_TYPE_PINCH;
1610 Input_Result retResult = OH_Input_RemoveAxisEventMonitor(axisEventType, AxisEventCallback);
1611 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1612 retResult = OH_Input_AddAxisEventMonitor(axisEventType, AxisEventCallback);
1613 EXPECT_EQ(retResult, INPUT_SUCCESS);
1614 retResult = OH_Input_RemoveAxisEventMonitor(AXIS_EVENT_TYPE_SCROLL, AxisEventCallback);
1615 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1616 retResult = OH_Input_RemoveAxisEventMonitor(axisEventType, AxisEventCallback);
1617 EXPECT_EQ(retResult, INPUT_SUCCESS);
1618 }
1619
1620 /**
1621 * @tc.name: InputNativeTest_OH_Input_AddKeyEventInterceptor_001
1622 * @tc.desc: Verify the OH_Input_AddKeyEventInterceptor
1623 * @tc.type: FUNC
1624 * @tc.require:
1625 */
1626 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddKeyEventInterceptor_001, TestSize.Level1)
1627 {
1628 Input_Result retResult = OH_Input_AddKeyEventInterceptor(nullptr, nullptr);
1629 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1630 }
1631
1632 /**
1633 * @tc.name: InputNativeTest_OH_Input_AddKeyEventInterceptor_002
1634 * @tc.desc: Verify the OH_Input_AddKeyEventInterceptor
1635 * @tc.type: FUNC
1636 * @tc.require:
1637 */
1638 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddKeyEventInterceptor_002, TestSize.Level1)
1639 {
1640 Input_Result retResult = OH_Input_AddKeyEventInterceptor(KeyEventCallback, nullptr);
1641 EXPECT_EQ(retResult, INPUT_SUCCESS);
1642 retResult = OH_Input_AddKeyEventInterceptor(KeyEventCallback, nullptr);
1643 EXPECT_EQ(retResult, INPUT_REPEAT_INTERCEPTOR);
1644 retResult = OH_Input_RemoveKeyEventInterceptor();
1645 EXPECT_EQ(retResult, INPUT_SUCCESS);
1646 }
1647
1648 /**
1649 * @tc.name: InputNativeTest_OH_Input_RemoveKeyEventInterceptor_001
1650 * @tc.desc: Verify the OH_Input_RemoveKeyEventInterceptor
1651 * @tc.type: FUNC
1652 * @tc.require:
1653 */
1654 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveKeyEventInterceptor_001, TestSize.Level1)
1655 {
1656 Input_Result retResult = OH_Input_RemoveKeyEventInterceptor();
1657 EXPECT_EQ(retResult, INPUT_SERVICE_EXCEPTION);
1658 retResult = OH_Input_AddKeyEventInterceptor(KeyEventCallback, nullptr);
1659 EXPECT_EQ(retResult, INPUT_SUCCESS);
1660 retResult = OH_Input_RemoveKeyEventInterceptor();
1661 EXPECT_EQ(retResult, INPUT_SUCCESS);
1662 }
1663
1664 /**
1665 * @tc.name: InputNativeTest_OH_Input_AddInputEventInterceptor_001
1666 * @tc.desc: Verify the OH_Input_AddInputEventInterceptor
1667 * @tc.type: FUNC
1668 * @tc.require:
1669 */
1670 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddInputEventInterceptor_001, TestSize.Level1)
1671 {
1672 Input_InterceptorOptions *option = nullptr;
1673 Input_Result retResult = OH_Input_AddInputEventInterceptor(nullptr, option);
1674 EXPECT_EQ(retResult, INPUT_PARAMETER_ERROR);
1675 }
1676
1677 /**
1678 * @tc.name: InputNativeTest_OH_Input_AddInputEventInterceptor_002
1679 * @tc.desc: Verify the OH_Input_AddInputEventInterceptor
1680 * @tc.type: FUNC
1681 * @tc.require:
1682 */
1683 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_AddInputEventInterceptor_002, TestSize.Level1)
1684 {
1685 Input_InterceptorEventCallback callback;
1686 callback.mouseCallback = MouseEventCallback;
1687 callback.touchCallback = TouchEventCallback;
1688 callback.axisCallback = AxisEventCallback;
1689 Input_InterceptorOptions *option = nullptr;
1690 Input_Result retResult = OH_Input_AddInputEventInterceptor(&callback, option);
1691 EXPECT_EQ(retResult, INPUT_SUCCESS);
1692 retResult = OH_Input_AddInputEventInterceptor(&callback, option);
1693 EXPECT_EQ(retResult, INPUT_REPEAT_INTERCEPTOR);
1694 retResult = OH_Input_RemoveInputEventInterceptor();
1695 EXPECT_EQ(retResult, INPUT_SUCCESS);
1696 }
1697
1698 /**
1699 * @tc.name: InputNativeTest_OH_Input_RemoveInputEventInterceptor_001
1700 * @tc.desc: Verify the OH_Input_RemoveInputEventInterceptor
1701 * @tc.type: FUNC
1702 * @tc.require:
1703 */
1704 HWTEST_F(InputNativeTest, InputNativeTest_OH_Input_RemoveInputEventInterceptor_001, TestSize.Level1)
1705 {
1706 Input_Result retResult = OH_Input_RemoveInputEventInterceptor();
1707 EXPECT_EQ(retResult, INPUT_SERVICE_EXCEPTION);
1708 Input_InterceptorEventCallback callback;
1709 callback.mouseCallback = MouseEventCallback;
1710 callback.touchCallback = TouchEventCallback;
1711 callback.axisCallback = AxisEventCallback;
1712 Input_InterceptorOptions *option = nullptr;
1713 retResult = OH_Input_AddInputEventInterceptor(&callback, option);
1714 EXPECT_EQ(retResult, INPUT_SUCCESS);
1715 retResult = OH_Input_RemoveInputEventInterceptor();
1716 EXPECT_EQ(retResult, INPUT_SUCCESS);
1717 }
1718
1719 /**
1720 * @tc.name: InputNativeTest_GetIntervalSinceLastInput_001
1721 * @tc.desc: Verify the Get Interval Since Last Input
1722 * @tc.type: FUNC
1723 * @tc.require:
1724 */
1725 HWTEST_F(InputNativeTest, InputNativeTest_GetIntervalSinceLastInput_001, TestSize.Level1)
1726 {
1727 int64_t *intervalSinceLastInput = static_cast<int64_t *>(malloc(sizeof(int64_t)));
1728 int32_t retResult = OH_Input_GetIntervalSinceLastInput(intervalSinceLastInput);
1729 free(intervalSinceLastInput);
1730 EXPECT_EQ(retResult, INPUT_SUCCESS);
1731 }
1732 } // namespace MMI
1733 } // namespace OHOS
1734