1 /*
2  * Copyright (c) 2023-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 <cmath>
17 #include <cstdio>
18 #include <unistd.h>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 #include <hdf_base.h>
22 #include <hdf_log.h>
23 #include "osal_time.h"
24 #include "v1_0/iinput_interfaces.h"
25 #include "input_type.h"
26 #include "input_callback_impl.h"
27 
28 using namespace OHOS::HDI::Input::V1_0;
29 using namespace testing::ext;
30 
31 namespace {
32 sptr<IInputInterfaces> g_inputInterfaces = nullptr;
33 sptr<IInputCallback> g_callback = nullptr;
34 sptr<IInputCallback> g_hotplugCb = nullptr;
35 constexpr int32_t TOUCH_INDEX = 1;
36 constexpr int32_t MAX_DEVICES = 33;
37 constexpr int32_t INIT_DEFAULT_VALUE = 255;
38 constexpr int32_t TEST_RESULT_LEN = 32;
39 std::vector<DevDesc> g_sta;
40 } // namespace
41 
42 class HdfInputHdiTestAdditional : public testing::Test {
43 public:
44     static void SetUpTestCase();
45     static void TearDownTestCase();
46     void SetUp();
47     void TearDown();
48 };
49 
SetUpTestCase()50 void HdfInputHdiTestAdditional::SetUpTestCase()
51 {
52     g_inputInterfaces = IInputInterfaces::Get(true);
53     if (g_inputInterfaces != nullptr) {
54         g_callback = new InputCallbackImpl(g_inputInterfaces, nullptr);
55         g_hotplugCb = new InputCallbackImpl(g_inputInterfaces, g_callback);
56         g_inputInterfaces->ScanInputDevice(g_sta);
57     }
58 }
59 
TearDownTestCase()60 void HdfInputHdiTestAdditional::TearDownTestCase() {}
61 
SetUp()62 void HdfInputHdiTestAdditional::SetUp() {}
63 
TearDown()64 void HdfInputHdiTestAdditional::TearDown() {}
65 
IsOnlineDev(uint32_t devIndex)66 static bool IsOnlineDev(uint32_t devIndex)
67 {
68     bool ret = false;
69     int32_t i = 0;
70     for (i = 0; i < g_sta.size(); i++) {
71         if (g_sta[i].devIndex == devIndex) {
72             ret = true;
73             break;
74         }
75     }
76     return ret;
77 }
78 
79 /**
80  * @tc.number : SUB_Driver_Input_ScanInputDevice_0200
81  * @tc.name   : testScanInputDevice001
82  * @tc.desc   : Reliability of function(ScanInputDevice)
83  */
84 HWTEST_F(HdfInputHdiTestAdditional, testScanInputDevice001, Function | MediumTest | Level1)
85 {
86     std::vector<DevDesc> sta;
87     int32_t ret = 0;
88     int i = 0;
89     for (i = 0; i < 1000; i++) {
90         ret |= g_inputInterfaces->ScanInputDevice(sta);
91     }
92     EXPECT_EQ(ret, INPUT_SUCCESS);
93 }
94 
95 /**
96  * @tc.number : SUB_Driver_Input_OpenInputDevice_0300
97  * @tc.name   : testOpenInputDevice001
98  * @tc.desc   : Reliability of function(OpenInputDevice)
99  */
100 HWTEST_F(HdfInputHdiTestAdditional, testOpenInputDevice001, Function | MediumTest | Level1)
101 {
102     int32_t ret = 0;
103     int i = 0;
104     for (i = 0; i < 1000; i++) {
105         ret |= g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
106         g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
107     }
108     EXPECT_EQ(ret, INPUT_SUCCESS);
109 }
110 
111 /**
112  * @tc.number : SUB_Driver_Input_OpenInputDevice_0400
113  * @tc.name   : testOpenInputDevice002
114  * @tc.desc   : Test parameters(devIndex::0) with abnormal input
115  */
116 HWTEST_F(HdfInputHdiTestAdditional, testOpenInputDevice002, Function | MediumTest | Level2)
117 {
118     int32_t ret = 0;
119     uint32_t devIndex = 0;
120     ret = g_inputInterfaces->OpenInputDevice(devIndex);
121     EXPECT_NE(ret, INPUT_SUCCESS);
122 }
123 
124 /**
125  * @tc.number : SUB_Driver_Input_OpenInputDevice_0500
126  * @tc.name   : testOpenInputDevice003
127  * @tc.desc   : Test input param(devIndex::1~32)
128  */
129 HWTEST_F(HdfInputHdiTestAdditional, testOpenInputDevice003, Function | MediumTest | Level1)
130 {
131     int32_t ret = 0;
132     uint32_t devIndex = TOUCH_INDEX;
133     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
134         if (IsOnlineDev(devIndex)) {
135             ret = g_inputInterfaces->OpenInputDevice(devIndex);
136             g_inputInterfaces->CloseInputDevice(devIndex);
137             EXPECT_EQ(ret, INPUT_SUCCESS);
138         } else {
139             ret = g_inputInterfaces->OpenInputDevice(devIndex);
140             EXPECT_NE(ret, INPUT_SUCCESS);
141         }
142     }
143 }
144 
145 /**
146  * @tc.number : SUB_Driver_Input_OpenInputDevice_0600
147  * @tc.name   : testOpenInputDevice004
148  * @tc.desc   : Test parameters(devIndex::33) with abnormal input
149  */
150 HWTEST_F(HdfInputHdiTestAdditional, testOpenInputDevice004, Function | MediumTest | Level2)
151 {
152     int32_t ret = g_inputInterfaces->OpenInputDevice(MAX_DEVICES);
153     g_inputInterfaces->CloseInputDevice(MAX_DEVICES);
154     EXPECT_NE(ret, INPUT_SUCCESS);
155 }
156 
157 /**
158  * @tc.number : SUB_Driver_Input_CloseInputDevice_0300
159  * @tc.name   : testCloseInputDevice001
160  * @tc.desc   : Reliability of function(CloseInputDevice)
161  */
162 HWTEST_F(HdfInputHdiTestAdditional, testCloseInputDevice001, Function | MediumTest | Level1)
163 {
164     int32_t ret = 0;
165     int i = 0;
166     for (i = 0; i < 1000; i++) {
167         ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
168         if (ret != INPUT_SUCCESS) {
169             break;
170         }
171         ret |= g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
172     }
173     EXPECT_EQ(ret, INPUT_SUCCESS);
174 }
175 
176 /**
177  * @tc.number : SUB_Driver_Input_CloseInputDevice_0400
178  * @tc.name   : testCloseInputDevice002
179  * @tc.desc   : Test parameters(devIndex::0) with abnormal input
180  */
181 HWTEST_F(HdfInputHdiTestAdditional, testCloseInputDevice002, Function | MediumTest | Level2)
182 {
183     int32_t ret = 0;
184     uint32_t devIndex = 0;
185     ret = g_inputInterfaces->CloseInputDevice(devIndex);
186     EXPECT_NE(ret, INPUT_SUCCESS);
187 }
188 
189 /**
190  * @tc.number : SUB_Driver_Input_CloseInputDevice_0500
191  * @tc.name   : testCloseInputDevice003
192  * @tc.desc   : Test input param(devIndex::1~32)
193  */
194 HWTEST_F(HdfInputHdiTestAdditional, testCloseInputDevice003, Function | MediumTest | Level1)
195 {
196     int32_t ret = 0;
197     uint32_t devIndex = TOUCH_INDEX;
198     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
199         if (IsOnlineDev(devIndex)) {
200             ret = g_inputInterfaces->OpenInputDevice(devIndex);
201             EXPECT_EQ(ret, INPUT_SUCCESS);
202             ret = g_inputInterfaces->CloseInputDevice(devIndex);
203             EXPECT_EQ(ret, INPUT_SUCCESS);
204         } else {
205             ret = g_inputInterfaces->CloseInputDevice(devIndex);
206             EXPECT_NE(ret, INPUT_SUCCESS);
207         }
208     }
209 }
210 
211 /**
212  * @tc.number : SUB_Driver_Input_CloseInputDevice_0600
213  * @tc.name   : testCloseInputDevice004
214  * @tc.desc   : Test parameters(devIndex::33) with abnormal input
215  */
216 HWTEST_F(HdfInputHdiTestAdditional, testCloseInputDevice004, Function | MediumTest | Level2)
217 {
218     int32_t ret = 0;
219     ret = g_inputInterfaces->CloseInputDevice(MAX_DEVICES);
220     EXPECT_NE(ret, INPUT_SUCCESS);
221 }
222 
223 /**
224  * @tc.number : SUB_Driver_Input_GetInputDevice_0300
225  * @tc.name   : testGetInputDevice001
226  * @tc.desc   : Reliability of function(GetInputDevice)
227  */
228 HWTEST_F(HdfInputHdiTestAdditional, testGetInputDevice001, Function | MediumTest | Level1)
229 {
230     struct DeviceInfo devInfo;
231     int32_t ret = 0;
232     int i = 0;
233     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
234     EXPECT_EQ(ret, INPUT_SUCCESS);
235     for (i = 0; i < 1000; i++) {
236         ret |= g_inputInterfaces->GetInputDevice(TOUCH_INDEX, devInfo);
237     }
238     g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
239     EXPECT_EQ(ret, INPUT_SUCCESS);
240 }
241 
242 /**
243  * @tc.number : SUB_Driver_Input_GetInputDevice_0400
244  * @tc.name   : testGetInputDevice002
245  * @tc.desc   : Test parameters(devIndex::0) with abnormal input
246  */
247 HWTEST_F(HdfInputHdiTestAdditional, testGetInputDevice002, Function | MediumTest | Level2)
248 {
249     struct DeviceInfo devInfo;
250     int32_t ret = 0;
251     uint32_t devIndex = 0;
252     ret = g_inputInterfaces->GetInputDevice(devIndex, devInfo);
253     EXPECT_NE(ret, INPUT_SUCCESS);
254 }
255 
256 /**
257  * @tc.number : SUB_Driver_Input_GetInputDevice_0500
258  * @tc.name   : testGetInputDevice003
259  * @tc.desc   : Test input param(devIndex::1~32)
260  */
261 HWTEST_F(HdfInputHdiTestAdditional, testGetInputDevice003, Function | MediumTest | Level1)
262 {
263     struct DeviceInfo devInfo;
264     int32_t ret = 0;
265     uint32_t devIndex = TOUCH_INDEX;
266     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
267         if (IsOnlineDev(devIndex)) {
268             ret = g_inputInterfaces->OpenInputDevice(devIndex);
269             EXPECT_EQ(ret, INPUT_SUCCESS);
270             ret = g_inputInterfaces->GetInputDevice(devIndex, devInfo);
271             EXPECT_EQ(ret, INPUT_SUCCESS);
272             g_inputInterfaces->CloseInputDevice(devIndex);
273         } else {
274             ret = g_inputInterfaces->GetInputDevice(devIndex, devInfo);
275             EXPECT_NE(ret, INPUT_SUCCESS);
276         }
277     }
278 }
279 
280 /**
281  * @tc.number : SUB_Driver_Input_GetInputDevice_0600
282  * @tc.name   : testGetInputDevice004
283  * @tc.desc   : Test parameters(devIndex::33) with abnormal input
284  */
285 HWTEST_F(HdfInputHdiTestAdditional, testGetInputDevice004, Function | MediumTest | Level2)
286 {
287     struct DeviceInfo devInfo;
288     int32_t ret = g_inputInterfaces->GetInputDevice(MAX_DEVICES, devInfo);
289     EXPECT_NE(ret, INPUT_SUCCESS);
290 }
291 
292 /**
293  * @tc.number : SUB_Driver_Input_GetInputDeviceList_0200
294  * @tc.name   : testGetInputDeviceList001
295  * @tc.desc   : Reliability of function(GetInputDeviceList)
296  */
297 HWTEST_F(HdfInputHdiTestAdditional, testGetInputDeviceList001, Function | MediumTest | Level1)
298 {
299     int32_t ret = 0;
300     int i = 0;
301     uint32_t num = 0;
302     std::vector<DeviceInfo> dev;
303     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
304     EXPECT_EQ(ret, INPUT_SUCCESS);
305     for (i = 0; i < 1000; i++) {
306         g_inputInterfaces->GetInputDeviceList(num, dev, MAX_INPUT_DEV_NUM);
307     }
308     g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
309     EXPECT_EQ(ret, INPUT_SUCCESS);
310 }
311 
312 /**
313  *
314  * @tc.number : SUB_Driver_Input_SetPowerStatus_0500
315  * @tc.name   : testSetPowerStatus001
316  * @tc.desc   : Reliability of function(SetPowerStatus)
317  */
318 HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus001, Function | MediumTest | Level1)
319 {
320     int32_t ret = 0;
321     int i = 0;
322     uint32_t setStatus = INPUT_SUSPEND;
323     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
324     EXPECT_EQ(ret, INPUT_SUCCESS);
325     for (i = 0; i < 1000; i++) {
326         ret = g_inputInterfaces->SetPowerStatus(TOUCH_INDEX, setStatus);
327     }
328     g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
329     EXPECT_EQ(ret, INPUT_SUCCESS);
330 }
331 
332 /**
333  * @tc.number : SUB_Driver_Input_SetPowerStatus_0600
334  * @tc.name   : testSetPowerStatus002
335  * @tc.desc   : Test parameters(devIndex::0) with abnormal input
336  */
337 HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus002, Function | MediumTest | Level2)
338 {
339     int32_t ret = 0;
340     uint32_t devIndex = 0;
341     uint32_t setStatus = INPUT_SUSPEND;
342     ret = g_inputInterfaces->SetPowerStatus(devIndex, setStatus);
343     EXPECT_NE(ret, INPUT_SUCCESS);
344 }
345 
346 /**
347  * @tc.number : SUB_Driver_Input_SetPowerStatus_0700
348  * @tc.name   : testSetPowerStatus003
349  * @tc.desc   : Test input param(devIndex::1~32)
350  */
351 HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus003, Function | MediumTest | Level1)
352 {
353     int32_t ret = 0;
354     uint32_t devIndex = TOUCH_INDEX;
355     uint32_t setStatus = INPUT_SUSPEND;
356     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
357         if (IsOnlineDev(devIndex)) {
358             ret = g_inputInterfaces->OpenInputDevice(devIndex);
359             EXPECT_EQ(ret, INPUT_SUCCESS);
360             ret = g_inputInterfaces->SetPowerStatus(devIndex, setStatus);
361             EXPECT_EQ(ret, INPUT_SUCCESS);
362             g_inputInterfaces->CloseInputDevice(devIndex);
363         } else {
364             ret = g_inputInterfaces->SetPowerStatus(devIndex, setStatus);
365             EXPECT_NE(ret, INPUT_SUCCESS);
366         }
367     }
368 }
369 
370 /**
371  * @tc.number : SUB_Driver_Input_SetPowerStatus_0800
372  * @tc.name   : testSetPowerStatus004
373  * @tc.desc   : Test parameters(devIndex::33) with abnormal input
374  */
375 HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus004, Function | MediumTest | Level2)
376 {
377     int32_t ret = 0;
378     uint32_t setStatus = INPUT_SUSPEND;
379     ret = g_inputInterfaces->SetPowerStatus(MAX_DEVICES, setStatus);
380     EXPECT_NE(ret, INPUT_SUCCESS);
381 }
382 
383 /**
384  * @tc.number : SUB_Driver_Input_SetPowerStatus_0900
385  * @tc.name   : testSetPowerStatus005
386  * @tc.desc   : Test parameters(devIndex::1,setStatus::INPUT_POWER_STATUS_UNKNOWN) with abnormal input
387  */
388 HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus005, Function | MediumTest | Level2)
389 {
390     int32_t ret = 0;
391     uint32_t setStatus = INPUT_POWER_STATUS_UNKNOWN;
392     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
393     EXPECT_EQ(ret, INPUT_SUCCESS);
394     ret = g_inputInterfaces->SetPowerStatus(TOUCH_INDEX, setStatus);
395     g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
396     EXPECT_NE(ret, INPUT_SUCCESS);
397 }
398 
399 /**
400  * @tc.number : SUB_Driver_Input_SetPowerStatus_1000
401  * @tc.name   : testSetPowerStatus006
402  * @tc.desc   : Test parameters(devIndex::33) with abnormal input
403  */
404 HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus006, Function | MediumTest | Level2)
405 {
406     int32_t ret = 0;
407     uint32_t setStatus = INPUT_POWER_STATUS_UNKNOWN;
408     ret = g_inputInterfaces->SetPowerStatus(MAX_DEVICES, setStatus);
409     EXPECT_NE(ret, INPUT_SUCCESS);
410 }
411 
412 /**
413  * @tc.number : SUB_Driver_Input_SetPowerStatus_1100
414  * @tc.name   : testSetPowerStatus007
415  * @tc.desc   : Test parameters(devIndex::1,setStatus::5) with abnormal input
416  */
417 HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus007, Function | MediumTest | Level2)
418 {
419     int32_t ret = 0;
420     uint32_t setStatus = 5;
421     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
422     EXPECT_EQ(ret, INPUT_SUCCESS);
423     ret = g_inputInterfaces->SetPowerStatus(TOUCH_INDEX, setStatus);
424     g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
425     EXPECT_NE(ret, INPUT_SUCCESS);
426 }
427 
428 /**
429  * @tc.number : SUB_Driver_Input_SetPowerStatus_1200
430  * @tc.name   : testSetPowerStatus008
431  * @tc.desc   : Test parameters(devIndex::1,setStatus::0x7fffffff) with abnormal input
432  */
433 HWTEST_F(HdfInputHdiTestAdditional, testSetPowerStatus008, Function | MediumTest | Level2)
434 {
435     int32_t ret = 0;
436     uint32_t setStatus = 0x7fffffff;
437     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
438     EXPECT_EQ(ret, INPUT_SUCCESS);
439     ret = g_inputInterfaces->SetPowerStatus(TOUCH_INDEX, setStatus);
440     g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
441     EXPECT_NE(ret, INPUT_SUCCESS);
442 }
443 
444 /**
445  * @tc.number : SUB_Driver_Input_GetPowerStatus_0300
446  * @tc.name   : testGetPowerStatus001
447  * @tc.desc   : Reliability of function(GetPowerStatus)
448  */
449 HWTEST_F(HdfInputHdiTestAdditional, testGetPowerStatus001, Function | MediumTest | Level1)
450 {
451     int32_t ret = 0;
452     int i = 0;
453     uint32_t getStatus = 0;
454     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
455     EXPECT_EQ(ret, INPUT_SUCCESS);
456     for (i = 0; i < 1000; i++) {
457         ret = g_inputInterfaces->GetPowerStatus(TOUCH_INDEX, getStatus);
458     }
459     g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
460     EXPECT_EQ(ret, INPUT_SUCCESS);
461 }
462 
463 /**
464  * @tc.number : SUB_Driver_Input_GetPowerStatus_0400
465  * @tc.name   : testGetPowerStatus002
466  * @tc.desc   : Test parameters(devIndex::0) with abnormal input
467  */
468 HWTEST_F(HdfInputHdiTestAdditional, testGetPowerStatus002, Function | MediumTest | Level2)
469 {
470     int32_t ret = 0;
471     uint32_t devIndex = 0;
472     uint32_t getStatus = 0;
473     ret = g_inputInterfaces->GetPowerStatus(devIndex, getStatus);
474     EXPECT_NE(ret, INPUT_SUCCESS);
475 }
476 
477 /**
478  * @tc.number : SUB_Driver_Input_GetPowerStatus_0600
479  * @tc.name   : testGetPowerStatus004
480  * @tc.desc   : Test input param(devIndex::3~32)
481  */
482 HWTEST_F(HdfInputHdiTestAdditional, testGetPowerStatus004, Function | MediumTest | Level1)
483 {
484     int32_t ret = 0;
485     uint32_t devIndex = 3;
486     uint32_t getStatus = 0;
487     for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) {
488         if (IsOnlineDev(devIndex)) {
489             ret = g_inputInterfaces->OpenInputDevice(devIndex);
490             EXPECT_EQ(ret, INPUT_SUCCESS);
491             ret = g_inputInterfaces->GetPowerStatus(devIndex, getStatus);
492             g_inputInterfaces->CloseInputDevice(devIndex);
493             EXPECT_EQ(ret, INPUT_SUCCESS);
494         } else {
495             ret = g_inputInterfaces->GetPowerStatus(devIndex, getStatus);
496             EXPECT_NE(ret, INPUT_SUCCESS);
497         }
498     }
499 }
500 
501 /**
502  * @tc.number : SUB_Driver_Input_GetPowerStatus_0700
503  * @tc.name   : testGetPowerStatus005
504  * @tc.desc   : Test parameters(devIndex::33) with abnormal input
505  */
506 HWTEST_F(HdfInputHdiTestAdditional, testGetPowerStatus005, Function | MediumTest | Level2)
507 {
508     int32_t ret = 0;
509     uint32_t getStatus = 0;
510     ret = g_inputInterfaces->GetPowerStatus(MAX_DEVICES, getStatus);
511     EXPECT_NE(ret, INPUT_SUCCESS);
512 }
513 
514 /**
515  * @tc.number : SUB_Driver_Input_GetDeviceType_0300
516  * @tc.name   : testGetDeviceType001
517  * @tc.desc   : Reliability of function(GetDeviceType)
518  */
519 HWTEST_F(HdfInputHdiTestAdditional, testGetDeviceType001, Function | MediumTest | Level1)
520 {
521     int32_t ret = 0;
522     int i = 0;
523     uint32_t devType = INIT_DEFAULT_VALUE;
524     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
525     EXPECT_EQ(ret, INPUT_SUCCESS);
526     for (i = 0; i < 1000; i++) {
527         ret = g_inputInterfaces->GetDeviceType(TOUCH_INDEX, devType);
528     }
529     g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
530     EXPECT_EQ(ret, INPUT_SUCCESS);
531 }
532 
533 /**
534  * @tc.number : SUB_Driver_Input_GetDeviceType_0400
535  * @tc.name   : testGetDeviceType002
536  * @tc.desc   : Test parameters(devIndex::0) with abnormal input
537  */
538 HWTEST_F(HdfInputHdiTestAdditional, testGetDeviceType002, Function | MediumTest | Level2)
539 {
540     int32_t ret = 0;
541     uint32_t devIndex = 0;
542     uint32_t devType = INIT_DEFAULT_VALUE;
543     ret = g_inputInterfaces->GetDeviceType(devIndex, devType);
544     EXPECT_NE(ret, INPUT_SUCCESS);
545 }
546 
547 /**
548  * @tc.number : SUB_Driver_Input_GetDeviceType_0500
549  * @tc.name   : testGetDeviceType003
550  * @tc.desc   : Test input param(devIndex::1~32)
551  */
552 HWTEST_F(HdfInputHdiTestAdditional, testGetDeviceType003, Function | MediumTest | Level1)
553 {
554     int32_t ret = 0;
555     uint32_t devIndex = TOUCH_INDEX;
556     uint32_t devType = INIT_DEFAULT_VALUE;
557     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
558         if (IsOnlineDev(devIndex)) {
559             ret = g_inputInterfaces->OpenInputDevice(devIndex);
560             EXPECT_EQ(ret, INPUT_SUCCESS);
561             ret = g_inputInterfaces->GetDeviceType(devIndex, devType);
562             g_inputInterfaces->CloseInputDevice(devIndex);
563             EXPECT_EQ(ret, INPUT_SUCCESS);
564         } else {
565             ret = g_inputInterfaces->GetDeviceType(devIndex, devType);
566             EXPECT_NE(ret, INPUT_SUCCESS);
567         }
568     }
569 }
570 
571 /**
572  * @tc.number : SUB_Driver_Input_GetDeviceType_0600
573  * @tc.name   : testGetDeviceType004
574  * @tc.desc   : Test parameters(devIndex::33) with abnormal input
575  */
576 HWTEST_F(HdfInputHdiTestAdditional, testGetDeviceType004, Function | MediumTest | Level2)
577 {
578     int32_t ret = 0;
579     uint32_t devType = INIT_DEFAULT_VALUE;
580     ret = g_inputInterfaces->GetDeviceType(MAX_DEVICES, devType);
581     EXPECT_NE(ret, INPUT_SUCCESS);
582 }
583 
584 /**
585  * @tc.number : SUB_Driver_Input_SetGestureMode_0300
586  * @tc.name   : testSetGestureMode001
587  * @tc.desc   : Reliability of function(SetGestureMode)
588  */
589 HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode001, Function | MediumTest | Level1)
590 {
591     int32_t ret = 0;
592     uint32_t gestureMode = 1;
593     int i = 0;
594     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
595     EXPECT_EQ(ret, INPUT_SUCCESS);
596     for (i = 0; i < 1000; i++) {
597         ret = g_inputInterfaces->SetGestureMode(TOUCH_INDEX, gestureMode);
598     }
599     g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
600     EXPECT_EQ(ret, INPUT_SUCCESS);
601 }
602 
603 /**
604  * @tc.number : SUB_Driver_Input_SetGestureMode_0400
605  * @tc.name   : testSetGestureMode002
606  * @tc.desc   : Test parameters(devIndex::0) with abnormal input
607  */
608 HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode002, Function | MediumTest | Level2)
609 {
610     int32_t ret = 0;
611     uint32_t devIndex = 0;
612     uint32_t gestureMode = 1;
613     ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode);
614     EXPECT_NE(ret, INPUT_SUCCESS);
615 }
616 
617 /**
618  * @tc.number : SUB_Driver_Input_SetGestureMode_0500
619  * @tc.name   : testSetGestureMode003
620  * @tc.desc   : Test input param(devIndex::1~32)
621  */
622 HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode003, Function | MediumTest | Level1)
623 {
624     int32_t ret = 0;
625     uint32_t devIndex = TOUCH_INDEX;
626     uint32_t gestureMode = 1;
627     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
628         if (IsOnlineDev(devIndex)) {
629             ret = g_inputInterfaces->OpenInputDevice(devIndex);
630             EXPECT_EQ(ret, INPUT_SUCCESS);
631             ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode);
632             g_inputInterfaces->CloseInputDevice(devIndex);
633             EXPECT_EQ(ret, INPUT_SUCCESS);
634         } else {
635             ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode);
636             EXPECT_NE(ret, INPUT_SUCCESS);
637         }
638     }
639 }
640 
641 /**
642  * @tc.number : SUB_Driver_Input_SetGestureMode_0600
643  * @tc.name   : testSetGestureMode004
644  * @tc.desc   : Test parameters(devIndex::33) with abnormal input
645  */
646 HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode004, Function | MediumTest | Level2)
647 {
648     int32_t ret = 0;
649     uint32_t gestureMode = 1;
650     ret = g_inputInterfaces->SetGestureMode(MAX_DEVICES, gestureMode);
651     EXPECT_NE(ret, INPUT_SUCCESS);
652 }
653 
654 /**
655  * @tc.number : SUB_Driver_Input_SetGestureMode_0700
656  * @tc.name   : testSetGestureMode005
657  * @tc.desc   : Test input param(devIndex::1,gestureMode::0)
658  */
659 HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode005, Function | MediumTest | Level1)
660 {
661     int32_t ret = 0;
662     uint32_t devIndex = TOUCH_INDEX;
663     uint32_t gestureMode = 0;
664     g_inputInterfaces->OpenInputDevice(devIndex);
665     ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode);
666     g_inputInterfaces->CloseInputDevice(devIndex);
667     EXPECT_EQ(ret, INPUT_SUCCESS);
668 }
669 
670 /**
671  * @tc.number : SUB_Driver_Input_SetGestureMode_0800
672  * @tc.name   : testSetGestureMode006
673  * @tc.desc   : Test input param(devIndex::1,gestureMode::0x7fffffff)
674  */
675 HWTEST_F(HdfInputHdiTestAdditional, testSetGestureMode006, Function | MediumTest | Level1)
676 {
677     int32_t ret = 0;
678     uint32_t devIndex = TOUCH_INDEX;
679     uint32_t gestureMode = 0x7fffffff;
680     g_inputInterfaces->OpenInputDevice(devIndex);
681     ret = g_inputInterfaces->SetGestureMode(devIndex, gestureMode);
682     g_inputInterfaces->CloseInputDevice(devIndex);
683     EXPECT_EQ(ret, INPUT_SUCCESS);
684 }
685 
686 /**
687  * @tc.number : SUB_Driver_Input_GetChipInfo_0300
688  * @tc.name   : testGetChipInfo001
689  * @tc.desc   : GetChipInfo, stability test
690  */
691 HWTEST_F(HdfInputHdiTestAdditional, testGetChipInfo001, Function | MediumTest | Level1)
692 {
693     int32_t ret;
694 
695     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
696     EXPECT_EQ(ret, INPUT_SUCCESS);
697 
698     std::string chipInfo;
699 
700     for (int i = 0; i < 1000; i++) {
701         ret = g_inputInterfaces->GetChipInfo(TOUCH_INDEX, chipInfo);
702         EXPECT_EQ(ret, INPUT_SUCCESS);
703     }
704 
705     ret = g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
706     EXPECT_EQ(ret, INPUT_SUCCESS);
707 }
708 
709 /**
710  * @tc.number : SUB_Driver_Input_GetChipInfo_0400
711  * @tc.name   : testGetChipInfo002
712  * @tc.desc   : GetChipInfo, Test input param, devIndex = 0
713  */
714 HWTEST_F(HdfInputHdiTestAdditional, testGetChipInfo002, Function | MediumTest | Level2)
715 {
716     int32_t ret = 0;
717     uint32_t devIndex = 0;
718     std::string chipInfo;
719 
720     ret = g_inputInterfaces->GetChipInfo(devIndex, chipInfo);
721     EXPECT_NE(ret, INPUT_SUCCESS);
722 }
723 
724 /**
725  * @tc.number : SUB_Driver_Input_GetChipInfo_0500
726  * @tc.name   : testGetChipInfo003
727  * @tc.desc   : GetChipInfo, Test input param
728  */
729 HWTEST_F(HdfInputHdiTestAdditional, testGetChipInfo003, Function | MediumTest | Level1)
730 {
731     int32_t ret = 0;
732     uint32_t devIndex = TOUCH_INDEX;
733     std::string chipInfo;
734 
735     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
736         if (IsOnlineDev(devIndex)) {
737             ret = g_inputInterfaces->OpenInputDevice(devIndex);
738             EXPECT_EQ(ret, INPUT_SUCCESS);
739             ret = g_inputInterfaces->GetChipInfo(devIndex, chipInfo);
740             EXPECT_EQ(ret, INPUT_SUCCESS);
741             ret = g_inputInterfaces->CloseInputDevice(devIndex);
742             EXPECT_EQ(ret, INPUT_SUCCESS);
743         } else {
744             ret = g_inputInterfaces->GetChipInfo(devIndex, chipInfo);
745             EXPECT_NE(ret, INPUT_SUCCESS);
746         }
747     }
748 }
749 
750 /**
751  * @tc.number : SUB_Driver_Input_GetChipInfo_0600
752  * @tc.name   : testGetChipInfo004
753  * @tc.desc   : GetChipInfo, Test input param, devIndex = 32
754  */
755 HWTEST_F(HdfInputHdiTestAdditional, testGetChipInfo004, Function | MediumTest | Level2)
756 {
757     int32_t ret = 0;
758     uint32_t devIndex = MAX_DEVICES;
759     std::string chipInfo;
760 
761     ret = g_inputInterfaces->GetChipInfo(devIndex, chipInfo);
762     EXPECT_NE(ret, INPUT_SUCCESS);
763 }
764 
765 /**
766  * @tc.number : SUB_Driver_Input_GetVendorName_0300
767  * @tc.name   : testGetVendorName001
768  * @tc.desc   : GetVendorName, stability test
769  */
770 HWTEST_F(HdfInputHdiTestAdditional, testGetVendorName001, Function | MediumTest | Level1)
771 {
772     int32_t ret;
773 
774     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
775     EXPECT_EQ(ret, INPUT_SUCCESS);
776 
777     std::string vendorName;
778 
779     for (int i = 0; i < 1000; i++) {
780         ret = g_inputInterfaces->GetVendorName(TOUCH_INDEX, vendorName);
781         EXPECT_EQ(ret, INPUT_SUCCESS);
782     }
783 
784     ret = g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
785     EXPECT_EQ(ret, INPUT_SUCCESS);
786 }
787 
788 /**
789  * @tc.number : SUB_Driver_Input_GetVendorName_0400
790  * @tc.name   : testGetVendorName002
791  * @tc.desc   : GetVendorName, Test input param, devIndex = 0
792  */
793 HWTEST_F(HdfInputHdiTestAdditional, testGetVendorName002, Function | MediumTest | Level2)
794 {
795     int32_t ret = 0;
796     uint32_t devIndex = 0;
797     std::string vendorName;
798 
799     ret = g_inputInterfaces->GetVendorName(devIndex, vendorName);
800     EXPECT_NE(ret, INPUT_SUCCESS);
801 }
802 
803 /**
804  * @tc.number : SUB_Driver_Input_GetVendorName_0500
805  * @tc.name   : testGetVendorName003
806  * @tc.desc   : GetVendorName, Test input param, devIndex = 2
807  */
808 HWTEST_F(HdfInputHdiTestAdditional, testGetVendorName003, Function | MediumTest | Level1)
809 {
810     int32_t ret = 0;
811     uint32_t devIndex = TOUCH_INDEX;
812     std::string vendorName;
813 
814     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
815         if (IsOnlineDev(devIndex)) {
816             ret = g_inputInterfaces->OpenInputDevice(devIndex);
817             EXPECT_EQ(ret, INPUT_SUCCESS);
818             ret = g_inputInterfaces->GetVendorName(devIndex, vendorName);
819             EXPECT_EQ(ret, INPUT_SUCCESS);
820             ret = g_inputInterfaces->CloseInputDevice(devIndex);
821             EXPECT_EQ(ret, INPUT_SUCCESS);
822         } else {
823             ret = g_inputInterfaces->GetVendorName(devIndex, vendorName);
824             EXPECT_NE(ret, INPUT_SUCCESS);
825         }
826     }
827 }
828 
829 /**
830  * @tc.number : SUB_Driver_Input_GetVendorName_0600
831  * @tc.name   : testGetVendorName004
832  * @tc.desc   : GetVendorName, Test input param, devIndex = 32
833  */
834 HWTEST_F(HdfInputHdiTestAdditional, testGetVendorName004, Function | MediumTest | Level2)
835 {
836     int32_t ret = 0;
837     uint32_t devIndex = MAX_DEVICES;
838     std::string vendorName;
839 
840     ret = g_inputInterfaces->GetVendorName(devIndex, vendorName);
841     EXPECT_NE(ret, INPUT_SUCCESS);
842 }
843 
844 /**
845  * @tc.number : SUB_Driver_Input_GetChipName_0300
846  * @tc.name   : testGetChipName001
847  * @tc.desc   : GetChipName, stability test
848  */
849 HWTEST_F(HdfInputHdiTestAdditional, testGetChipName001, Function | MediumTest | Level1)
850 {
851     int32_t ret;
852 
853     ret = g_inputInterfaces->OpenInputDevice(TOUCH_INDEX);
854     EXPECT_EQ(ret, INPUT_SUCCESS);
855 
856     std::string chipName;
857 
858     for (int i = 0; i < 1000; i++) {
859         ret = g_inputInterfaces->GetChipName(TOUCH_INDEX, chipName);
860         EXPECT_EQ(ret, INPUT_SUCCESS);
861     }
862 
863     ret = g_inputInterfaces->CloseInputDevice(TOUCH_INDEX);
864     EXPECT_EQ(ret, INPUT_SUCCESS);
865 }
866 
867 /**
868  * @tc.number : SUB_Driver_Input_GetChipName_0400
869  * @tc.name   : testGetChipName002
870  * @tc.desc   : GetChipName, Test input param, devIndex = 0
871  */
872 HWTEST_F(HdfInputHdiTestAdditional, testGetChipName002, Function | MediumTest | Level2)
873 {
874     int32_t ret = 0;
875     uint32_t devIndex = 0;
876     std::string chipName;
877 
878     ret = g_inputInterfaces->GetChipName(devIndex, chipName);
879     EXPECT_NE(ret, INPUT_SUCCESS);
880 }
881 
882 /**
883  * @tc.number : SUB_Driver_Input_GetChipName_0500
884  * @tc.name   : testGetChipName003
885  * @tc.desc   : GetChipName, Test input param, devIndex = 2
886  */
887 HWTEST_F(HdfInputHdiTestAdditional, testGetChipName003, Function | MediumTest | Level1)
888 {
889     int32_t ret = 0;
890     uint32_t devIndex = TOUCH_INDEX;
891     std::string chipName;
892 
893     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
894         if (IsOnlineDev(devIndex)) {
895             ret = g_inputInterfaces->OpenInputDevice(devIndex);
896             EXPECT_EQ(ret, INPUT_SUCCESS);
897             ret = g_inputInterfaces->GetChipName(devIndex, chipName);
898             EXPECT_EQ(ret, INPUT_SUCCESS);
899             ret = g_inputInterfaces->CloseInputDevice(devIndex);
900             EXPECT_EQ(ret, INPUT_SUCCESS);
901         } else {
902             ret = g_inputInterfaces->GetChipName(devIndex, chipName);
903             EXPECT_NE(ret, INPUT_SUCCESS);
904         }
905     }
906 }
907 
908 /**
909  * @tc.number : SUB_Driver_Input_GetChipName_0600
910  * @tc.name   : testGetChipName004
911  * @tc.desc   : GetChipName, Test input param, devIndex = 32
912  */
913 HWTEST_F(HdfInputHdiTestAdditional, testGetChipName004, Function | MediumTest | Level2)
914 {
915     int32_t ret = 0;
916     uint32_t devIndex = MAX_DEVICES;
917     std::string chipName;
918 
919     ret = g_inputInterfaces->GetChipName(devIndex, chipName);
920     EXPECT_NE(ret, INPUT_SUCCESS);
921 }
922 
923 /**
924  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_0600
925  * @tc.name   : testRunCapacitanceTest001
926  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 0 and testType is BASE_TEST.
927  */
928 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest001, Function | MediumTest | Level2)
929 {
930     int32_t ret = INPUT_SUCCESS;
931     uint32_t devIndex = 0;
932     uint32_t testType = BASE_TEST;
933     std::string result;
934     ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
935     EXPECT_NE(ret, INPUT_SUCCESS);
936 }
937 
938 /**
939  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_0700
940  * @tc.name   : testRunCapacitanceTest002
941  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 3-31 and testType is
942  * BASE_TEST.
943  */
944 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest002, Function | MediumTest | Level1)
945 {
946     int32_t ret = INPUT_SUCCESS;
947     uint32_t devIndex = TOUCH_INDEX;
948     uint32_t testType = BASE_TEST;
949     std::string result;
950     for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) {
951         if (IsOnlineDev(devIndex)) {
952             ret = g_inputInterfaces->OpenInputDevice(devIndex);
953             EXPECT_EQ(ret, INPUT_SUCCESS);
954             ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
955             EXPECT_EQ(ret, INPUT_SUCCESS);
956             ret = g_inputInterfaces->CloseInputDevice(devIndex);
957             EXPECT_EQ(ret, INPUT_SUCCESS);
958         } else {
959             ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
960             EXPECT_NE(ret, INPUT_SUCCESS);
961         }
962     }
963 }
964 
965 /**
966  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_0800
967  * @tc.name   : testRunCapacitanceTest003
968  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 32 and testType is BASE_TEST.
969  */
970 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest003, Function | MediumTest | Level2)
971 {
972     int32_t ret = INPUT_SUCCESS;
973     uint32_t devIndex = MAX_DEVICES;
974     uint32_t testType = BASE_TEST;
975     std::string result;
976     ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
977     EXPECT_NE(ret, INPUT_SUCCESS);
978 }
979 
980 /**
981  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_0900
982  * @tc.name   : testRunCapacitanceTest004
983  * @tc.desc   : Verify the stability of the RunCapacitanceTest function when devIndex is 1 and testType is BASE_TEST.
984  */
985 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest004, Function | MediumTest | Level1)
986 {
987     int32_t ret = INPUT_SUCCESS;
988     uint32_t devIndex = TOUCH_INDEX;
989     uint32_t testType = BASE_TEST;
990     std::string result;
991     for (int32_t i = 0; i < 1000; i++) {
992         ret = g_inputInterfaces->OpenInputDevice(devIndex);
993         EXPECT_EQ(ret, INPUT_SUCCESS);
994         ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
995         EXPECT_EQ(ret, INPUT_SUCCESS);
996         ret = g_inputInterfaces->CloseInputDevice(devIndex);
997         EXPECT_EQ(ret, INPUT_SUCCESS);
998     }
999 }
1000 
1001 /**
1002  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1000
1003  * @tc.name   : testRunCapacitanceTest005
1004  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 0 and testType is FULL_TEST.
1005  */
1006 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest005, Function | MediumTest | Level2)
1007 {
1008     int32_t ret = INPUT_SUCCESS;
1009     uint32_t devIndex = 0;
1010     uint32_t testType = FULL_TEST;
1011     std::string result;
1012     ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1013     EXPECT_NE(ret, INPUT_SUCCESS);
1014 }
1015 
1016 /**
1017  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1100
1018  * @tc.name   : testRunCapacitanceTest006
1019  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 3-31 and testType is
1020  * FULL_TEST.
1021  */
1022 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest006, Function | MediumTest | Level1)
1023 {
1024     int32_t ret = INPUT_SUCCESS;
1025     uint32_t devIndex = TOUCH_INDEX;
1026     uint32_t testType = FULL_TEST;
1027     std::string result;
1028     for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) {
1029         if (IsOnlineDev(devIndex)) {
1030             ret = g_inputInterfaces->OpenInputDevice(devIndex);
1031             EXPECT_EQ(ret, INPUT_SUCCESS);
1032             ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1033             EXPECT_EQ(ret, INPUT_SUCCESS);
1034             ret = g_inputInterfaces->CloseInputDevice(devIndex);
1035             EXPECT_EQ(ret, INPUT_SUCCESS);
1036         } else {
1037             ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1038             EXPECT_NE(ret, INPUT_SUCCESS);
1039         }
1040     }
1041 }
1042 
1043 /**
1044  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1200
1045  * @tc.name   : testRunCapacitanceTest007
1046  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 32 and testType is FULL_TEST.
1047  */
1048 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest007, Function | MediumTest | Level2)
1049 {
1050     int32_t ret = INPUT_SUCCESS;
1051     uint32_t devIndex = MAX_DEVICES;
1052     uint32_t testType = FULL_TEST;
1053     std::string result;
1054     ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1055     EXPECT_NE(ret, INPUT_SUCCESS);
1056 }
1057 
1058 /**
1059  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1300
1060  * @tc.name   : testRunCapacitanceTest008
1061  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 0 and testType is MMI_TEST.
1062  */
1063 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest008, Function | MediumTest | Level2)
1064 {
1065     int32_t ret = INPUT_SUCCESS;
1066     uint32_t devIndex = 0;
1067     uint32_t testType = MMI_TEST;
1068     std::string result;
1069     ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1070     EXPECT_NE(ret, INPUT_SUCCESS);
1071 }
1072 
1073 /**
1074  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1400
1075  * @tc.name   : testRunCapacitanceTest009
1076  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 3-31 and testType is
1077  * MMI_TEST.
1078  */
1079 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest009, Function | MediumTest | Level1)
1080 {
1081     int32_t ret = INPUT_SUCCESS;
1082     uint32_t devIndex = TOUCH_INDEX;
1083     uint32_t testType = MMI_TEST;
1084     std::string result;
1085     for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) {
1086         if (IsOnlineDev(devIndex)) {
1087             ret = g_inputInterfaces->OpenInputDevice(devIndex);
1088             EXPECT_EQ(ret, INPUT_SUCCESS);
1089             ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1090             EXPECT_EQ(ret, INPUT_SUCCESS);
1091             ret = g_inputInterfaces->CloseInputDevice(devIndex);
1092             EXPECT_EQ(ret, INPUT_SUCCESS);
1093         } else {
1094             ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1095             EXPECT_NE(ret, INPUT_SUCCESS);
1096         }
1097     }
1098 }
1099 
1100 /**
1101  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1500
1102  * @tc.name   : testRunCapacitanceTest010
1103  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 32 and testType is MMI_TEST.
1104  */
1105 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest010, Function | MediumTest | Level2)
1106 {
1107     int32_t ret = INPUT_SUCCESS;
1108     uint32_t devIndex = MAX_DEVICES;
1109     uint32_t testType = MMI_TEST;
1110     std::string result;
1111     ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1112     EXPECT_NE(ret, INPUT_SUCCESS);
1113 }
1114 
1115 /**
1116  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1600
1117  * @tc.name   : testRunCapacitanceTest011
1118  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 0 and testType is
1119  * RUNNING_TEST.
1120  */
1121 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest011, Function | MediumTest | Level2)
1122 {
1123     int32_t ret = INPUT_SUCCESS;
1124     uint32_t devIndex = 0;
1125     uint32_t testType = RUNNING_TEST;
1126     std::string result;
1127     ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1128     EXPECT_NE(ret, INPUT_SUCCESS);
1129 }
1130 
1131 /**
1132  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1700
1133  * @tc.name   : testRunCapacitanceTest012
1134  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 3-31 and testType is
1135  * RUNNING_TEST.
1136  */
1137 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest012, Function | MediumTest | Level1)
1138 {
1139     int32_t ret = INPUT_SUCCESS;
1140     uint32_t devIndex = TOUCH_INDEX;
1141     uint32_t testType = RUNNING_TEST;
1142     std::string result;
1143     for (devIndex = 3; devIndex < MAX_DEVICES; devIndex++) {
1144         if (IsOnlineDev(devIndex)) {
1145             ret = g_inputInterfaces->OpenInputDevice(devIndex);
1146             EXPECT_EQ(ret, INPUT_SUCCESS);
1147             ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1148             EXPECT_EQ(ret, INPUT_SUCCESS);
1149             ret = g_inputInterfaces->CloseInputDevice(devIndex);
1150             EXPECT_EQ(ret, INPUT_SUCCESS);
1151         } else {
1152             ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1153             EXPECT_NE(ret, INPUT_SUCCESS);
1154         }
1155     }
1156 }
1157 
1158 /**
1159  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1800
1160  * @tc.name   : testRunCapacitanceTest013
1161  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 32 and testType is
1162  * RUNNING_TEST.
1163  */
1164 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest013, Function | MediumTest | Level2)
1165 {
1166     int32_t ret = INPUT_SUCCESS;
1167     uint32_t devIndex = MAX_DEVICES;
1168     uint32_t testType = RUNNING_TEST;
1169     std::string result;
1170     ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1171     EXPECT_NE(ret, INPUT_SUCCESS);
1172 }
1173 
1174 /**
1175  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_1900
1176  * @tc.name   : testRunCapacitanceTest014
1177  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 1 and testType is
1178  * BASE_TEST.
1179  */
1180 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest014, Function | MediumTest | Level1)
1181 {
1182     int32_t ret = INPUT_SUCCESS;
1183     uint32_t devIndex = TOUCH_INDEX;
1184     uint32_t testType = BASE_TEST;
1185     std::string result;
1186     if (IsOnlineDev(devIndex)) {
1187         ret = g_inputInterfaces->OpenInputDevice(devIndex);
1188         EXPECT_EQ(ret, INPUT_SUCCESS);
1189         ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1190         EXPECT_EQ(ret, INPUT_SUCCESS);
1191         ret = g_inputInterfaces->CloseInputDevice(devIndex);
1192         EXPECT_EQ(ret, INPUT_SUCCESS);
1193     } else {
1194         ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1195         EXPECT_NE(ret, INPUT_SUCCESS);
1196     }
1197 }
1198 
1199 /**
1200  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_2100
1201  * @tc.name   : testRunCapacitanceTest016
1202  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 1 and testType is
1203  * FULL_TEST.
1204  */
1205 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest016, Function | MediumTest | Level1)
1206 {
1207     int32_t ret = INPUT_SUCCESS;
1208     uint32_t devIndex = TOUCH_INDEX;
1209     uint32_t testType = FULL_TEST;
1210     std::string result;
1211     if (IsOnlineDev(devIndex)) {
1212         ret = g_inputInterfaces->OpenInputDevice(devIndex);
1213         EXPECT_EQ(ret, INPUT_SUCCESS);
1214         ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1215         EXPECT_EQ(ret, INPUT_SUCCESS);
1216         ret = g_inputInterfaces->CloseInputDevice(devIndex);
1217         EXPECT_EQ(ret, INPUT_SUCCESS);
1218     } else {
1219         ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1220         EXPECT_NE(ret, INPUT_SUCCESS);
1221     }
1222 }
1223 
1224 /**
1225  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_2300
1226  * @tc.name   : testRunCapacitanceTest018
1227  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 1 and testType is
1228  * MMI_TEST.
1229  */
1230 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest018, Function | MediumTest | Level1)
1231 {
1232     int32_t ret = INPUT_SUCCESS;
1233     uint32_t devIndex = TOUCH_INDEX;
1234     uint32_t testType = MMI_TEST;
1235     std::string result;
1236     if (IsOnlineDev(devIndex)) {
1237         ret = g_inputInterfaces->OpenInputDevice(devIndex);
1238         EXPECT_EQ(ret, INPUT_SUCCESS);
1239         ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1240         EXPECT_EQ(ret, INPUT_SUCCESS);
1241         ret = g_inputInterfaces->CloseInputDevice(devIndex);
1242         EXPECT_EQ(ret, INPUT_SUCCESS);
1243     } else {
1244         ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1245         EXPECT_NE(ret, INPUT_SUCCESS);
1246     }
1247 }
1248 
1249 /**
1250  * @tc.number : SUB_Driver_Input_RunCapacitanceTest_2500
1251  * @tc.name   : testRunCapacitanceTest020
1252  * @tc.desc   : Verify the reliability of the RunCapacitanceTest function when devIndex is 1 and testType is
1253  * RUNNING_TEST.
1254  */
1255 HWTEST_F(HdfInputHdiTestAdditional, testRunCapacitanceTest020, Function | MediumTest | Level1)
1256 {
1257     int32_t ret = INPUT_SUCCESS;
1258     uint32_t devIndex = TOUCH_INDEX;
1259     uint32_t testType = RUNNING_TEST;
1260     std::string result;
1261     if (IsOnlineDev(devIndex)) {
1262         ret = g_inputInterfaces->OpenInputDevice(devIndex);
1263         EXPECT_EQ(ret, INPUT_SUCCESS);
1264         ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1265         EXPECT_EQ(ret, INPUT_SUCCESS);
1266         ret = g_inputInterfaces->CloseInputDevice(devIndex);
1267         EXPECT_EQ(ret, INPUT_SUCCESS);
1268     } else {
1269         ret = g_inputInterfaces->RunCapacitanceTest(devIndex, testType, result, TEST_RESULT_LEN);
1270         EXPECT_NE(ret, INPUT_SUCCESS);
1271     }
1272 }
1273 
1274 /**
1275  * @tc.number : SUB_Driver_Input_RunExtraCommand_0300
1276  * @tc.name   : testRunExtraCommand001
1277  * @tc.desc   : Verify the reliability of the RunExtraCommand function when devIndex is 0.
1278  */
1279 HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand001, Function | MediumTest | Level2)
1280 {
1281     int32_t ret = INPUT_SUCCESS;
1282     uint32_t devIndex = 0;
1283     struct ExtraCmd extraCmd;
1284     extraCmd.cmdCode = "WakeUpMode";
1285     extraCmd.cmdValue = "Enable";
1286     ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd);
1287     EXPECT_NE(ret, INPUT_SUCCESS);
1288 }
1289 
1290 /**
1291  * @tc.number : SUB_Driver_Input_RunExtraCommand_0400
1292  * @tc.name   : testRunExtraCommand002
1293  * @tc.desc   : Verify the reliability of the RunExtraCommand function when devIndex is 2.
1294  */
1295 HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand002, Function | MediumTest | Level1)
1296 {
1297     int32_t ret = INPUT_SUCCESS;
1298     uint32_t devIndex = TOUCH_INDEX;
1299     struct ExtraCmd extraCmd;
1300     extraCmd.cmdCode = "WakeUpMode";
1301     extraCmd.cmdValue = "Enable";
1302     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
1303         if (IsOnlineDev(devIndex)) {
1304             ret = g_inputInterfaces->OpenInputDevice(devIndex);
1305             EXPECT_EQ(ret, INPUT_SUCCESS);
1306             ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd);
1307             EXPECT_EQ(ret, INPUT_SUCCESS);
1308             ret = g_inputInterfaces->CloseInputDevice(devIndex);
1309             EXPECT_EQ(ret, INPUT_SUCCESS);
1310         } else {
1311             ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd);
1312             EXPECT_NE(ret, INPUT_SUCCESS);
1313         }
1314     }
1315 }
1316 
1317 /**
1318  * @tc.number : SUB_Driver_Input_RunExtraCommand_0500
1319  * @tc.name   : testRunExtraCommand003
1320  * @tc.desc   : Verify the reliability of the RunExtraCommand function when devIndex is 32.
1321  */
1322 HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand003, Function | MediumTest | Level2)
1323 {
1324     int32_t ret = INPUT_SUCCESS;
1325     uint32_t devIndex = MAX_DEVICES;
1326     struct ExtraCmd extraCmd;
1327     extraCmd.cmdCode = "WakeUpMode";
1328     extraCmd.cmdValue = "Enable";
1329     ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd);
1330     EXPECT_NE(ret, INPUT_SUCCESS);
1331 }
1332 
1333 /**
1334  * @tc.number : SUB_Driver_Input_RunExtraCommand_0600
1335  * @tc.name   : testRunExtraCommand004
1336  * @tc.desc   : Verify the stability of the RunExtraCommand function when devIndex is 1.
1337  */
1338 HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand004, Function | MediumTest | Level1)
1339 {
1340     int32_t ret = INPUT_SUCCESS;
1341     uint32_t devIndex = TOUCH_INDEX;
1342     struct ExtraCmd extraCmd;
1343     extraCmd.cmdCode = "WakeUpMode";
1344     extraCmd.cmdValue = "Enable";
1345     for (int32_t i = 0; i < 1000; i++) {
1346         ret = g_inputInterfaces->OpenInputDevice(devIndex);
1347         EXPECT_EQ(ret, INPUT_SUCCESS);
1348         ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd);
1349         EXPECT_EQ(ret, INPUT_SUCCESS);
1350         ret = g_inputInterfaces->CloseInputDevice(devIndex);
1351         EXPECT_EQ(ret, INPUT_SUCCESS);
1352     }
1353 }
1354 
1355 /**
1356  * @tc.number : SUB_Driver_Input_RunExtraCommand_0700
1357  * @tc.name   : testRunExtraCommand005
1358  * @tc.desc   : Verify the reliability of the RunExtraCommand function when devIndex is 1.
1359  */
1360 HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand005, Function | MediumTest | Level1)
1361 {
1362     int32_t ret = INPUT_SUCCESS;
1363     uint32_t devIndex = TOUCH_INDEX;
1364     struct ExtraCmd extraCmd;
1365     extraCmd.cmdCode = "";
1366     extraCmd.cmdValue = "";
1367     ret = g_inputInterfaces->OpenInputDevice(devIndex);
1368     EXPECT_EQ(ret, INPUT_SUCCESS);
1369     ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd);
1370     EXPECT_EQ(ret, INPUT_SUCCESS);
1371     ret = g_inputInterfaces->CloseInputDevice(devIndex);
1372     EXPECT_EQ(ret, INPUT_SUCCESS);
1373 }
1374 
1375 /**
1376  * @tc.number : SUB_Driver_Input_RunExtraCommand_0800
1377  * @tc.name   : testRunExtraCommand006
1378  * @tc.desc   : Verify the reliability of the RunExtraCommand function when devIndex is 1.
1379  */
1380 HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand006, Function | MediumTest | Level1)
1381 {
1382     int32_t ret = INPUT_SUCCESS;
1383     uint32_t devIndex = TOUCH_INDEX;
1384     struct ExtraCmd extraCmd;
1385     extraCmd.cmdCode = "";
1386     extraCmd.cmdValue = "Enable";
1387     ret = g_inputInterfaces->OpenInputDevice(devIndex);
1388     EXPECT_EQ(ret, INPUT_SUCCESS);
1389     ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd);
1390     EXPECT_EQ(ret, INPUT_SUCCESS);
1391     ret = g_inputInterfaces->CloseInputDevice(devIndex);
1392     EXPECT_EQ(ret, INPUT_SUCCESS);
1393 }
1394 
1395 /**
1396  * @tc.number : SUB_Driver_Input_RunExtraCommand_0900
1397  * @tc.name   : testRunExtraCommand007
1398  * @tc.desc   : Verify the reliability of the RunExtraCommand function when devIndex is 1.
1399  */
1400 HWTEST_F(HdfInputHdiTestAdditional, testRunExtraCommand007, Function | MediumTest | Level1)
1401 {
1402     int32_t ret = INPUT_SUCCESS;
1403     uint32_t devIndex = TOUCH_INDEX;
1404     struct ExtraCmd extraCmd;
1405     extraCmd.cmdCode = "WakeUpMode";
1406     extraCmd.cmdValue = "";
1407     ret = g_inputInterfaces->OpenInputDevice(devIndex);
1408     EXPECT_EQ(ret, INPUT_SUCCESS);
1409     ret = g_inputInterfaces->RunExtraCommand(devIndex, extraCmd);
1410     EXPECT_EQ(ret, INPUT_SUCCESS);
1411     ret = g_inputInterfaces->CloseInputDevice(devIndex);
1412     EXPECT_EQ(ret, INPUT_SUCCESS);
1413 }
1414 
1415 /**
1416  * @tc.number : SUB_Driver_Input_RegisterReportCallback_0300
1417  * @tc.name   : testRegisterReportCallback001
1418  * @tc.desc   : Verify the reliability of the RegisterReportCallback function when devIndex is 0.
1419  */
1420 HWTEST_F(HdfInputHdiTestAdditional, testRegisterReportCallback001, Function | MediumTest | Level2)
1421 {
1422     int32_t ret = INPUT_SUCCESS;
1423     uint32_t devIndex = 0;
1424     ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback);
1425     EXPECT_NE(ret, INPUT_SUCCESS);
1426 }
1427 
1428 /**
1429  * @tc.number : SUB_Driver_Input_RegisterReportCallback_0400
1430  * @tc.name   : testRegisterReportCallback002
1431  * @tc.desc   : Verify the reliability of the RegisterReportCallback function when devIndex is 1-31.
1432  */
1433 HWTEST_F(HdfInputHdiTestAdditional, testRegisterReportCallback002, Function | MediumTest | Level1)
1434 {
1435     int32_t ret = INPUT_SUCCESS;
1436     uint32_t devIndex = TOUCH_INDEX;
1437     for (devIndex = TOUCH_INDEX; devIndex < MAX_DEVICES; devIndex++) {
1438         if (IsOnlineDev(devIndex)) {
1439             ret = g_inputInterfaces->OpenInputDevice(devIndex);
1440             EXPECT_EQ(ret, INPUT_SUCCESS);
1441             ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback);
1442             EXPECT_EQ(ret, INPUT_SUCCESS);
1443             ret = g_inputInterfaces->UnregisterReportCallback(devIndex);
1444             EXPECT_EQ(ret, INPUT_SUCCESS);
1445             ret = g_inputInterfaces->CloseInputDevice(devIndex);
1446             EXPECT_EQ(ret, INPUT_SUCCESS);
1447         } else {
1448             ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback);
1449             EXPECT_NE(ret, INPUT_SUCCESS);
1450         }
1451     }
1452 }
1453 
1454 /**
1455  * @tc.number : SUB_Driver_Input_RegisterReportCallback_0500
1456  * @tc.name   : testRegisterReportCallback003
1457  * @tc.desc   : Verify the reliability of the RegisterReportCallback function when devIndex is 32.
1458  */
1459 HWTEST_F(HdfInputHdiTestAdditional, testRegisterReportCallback003, Function | MediumTest | Level2)
1460 {
1461     int32_t ret = INPUT_SUCCESS;
1462     uint32_t devIndex = MAX_DEVICES;
1463     ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback);
1464     EXPECT_NE(ret, INPUT_SUCCESS);
1465 }
1466 
1467 /**
1468  * @tc.number : SUB_Driver_Input_RegisterReportCallback_0600
1469  * @tc.name   : testRegisterReportCallback004
1470  * @tc.desc   : Verify the stability of the RegisterReportCallback function when devIndex is 1.
1471  */
1472 HWTEST_F(HdfInputHdiTestAdditional, testRegisterReportCallback004, Function | MediumTest | Level1)
1473 {
1474     int32_t ret = INPUT_SUCCESS;
1475     uint32_t devIndex = TOUCH_INDEX;
1476     for (int32_t i = 0; i < 1000; i++) {
1477         ret = g_inputInterfaces->OpenInputDevice(devIndex);
1478         EXPECT_EQ(ret, INPUT_SUCCESS);
1479         ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback);
1480         EXPECT_EQ(ret, INPUT_SUCCESS);
1481         ret = g_inputInterfaces->UnregisterReportCallback(devIndex);
1482         EXPECT_EQ(ret, INPUT_SUCCESS);
1483         ret = g_inputInterfaces->CloseInputDevice(devIndex);
1484         EXPECT_EQ(ret, INPUT_SUCCESS);
1485     }
1486 }
1487 
1488 /**
1489  * @tc.number : SUB_Driver_Input_UnregisterReportCallback_0200
1490  * @tc.name   : testUnregisterReportCallback001
1491  * @tc.desc   : Verify the reliability of the UnregisterReportCallback function when devIndex is 1.
1492  */
1493 HWTEST_F(HdfInputHdiTestAdditional, testUnregisterReportCallback001, Function | MediumTest | Level1)
1494 {
1495     int32_t ret = INPUT_SUCCESS;
1496     uint32_t devIndex = TOUCH_INDEX;
1497     if (IsOnlineDev(devIndex)) {
1498         ret = g_inputInterfaces->OpenInputDevice(devIndex);
1499         EXPECT_EQ(ret, INPUT_SUCCESS);
1500         ret = g_inputInterfaces->RegisterReportCallback(devIndex, g_callback);
1501         EXPECT_EQ(ret, INPUT_SUCCESS);
1502         ret = g_inputInterfaces->UnregisterReportCallback(devIndex);
1503         EXPECT_EQ(ret, INPUT_SUCCESS);
1504         ret = g_inputInterfaces->CloseInputDevice(devIndex);
1505         EXPECT_EQ(ret, INPUT_SUCCESS);
1506     } else {
1507         ret = g_inputInterfaces->UnregisterReportCallback(devIndex);
1508         EXPECT_NE(ret, INPUT_SUCCESS);
1509     }
1510 }
1511 
1512 /**
1513  * @tc.number : SUB_Driver_Input_RegisterHotPlugCallback_0100
1514  * @tc.name   : testRegisterHotPlugCallback001
1515  * @tc.desc   : Validation function RegisterHotPlugCallback results in success.
1516  * when the hotPlugCallback parameter is g_callback
1517  */
1518 HWTEST_F(HdfInputHdiTestAdditional, testRegisterHotPlugCallback001, Function | MediumTest | Level1)
1519 {
1520     int32_t ret = INPUT_SUCCESS;
1521     ret = g_inputInterfaces->RegisterHotPlugCallback(g_callback);
1522     EXPECT_EQ(ret, INPUT_SUCCESS);
1523     ret = g_inputInterfaces->UnregisterHotPlugCallback();
1524     EXPECT_EQ(ret, INPUT_SUCCESS);
1525 }
1526 
1527 /**
1528  * @tc.number : SUB_Driver_Input_RegisterHotPlugCallback_0200
1529  * @tc.name   : testRegisterHotPlugCallback002
1530  * @tc.desc   : Validation function RegisterHotPlugCallback results in success.
1531  * when the hotPlugCallback parameter is nullptr
1532  */
1533 HWTEST_F(HdfInputHdiTestAdditional, testRegisterHotPlugCallback002, Function | MediumTest | Level2)
1534 {
1535     int32_t ret = INPUT_SUCCESS;
1536     ret = g_inputInterfaces->RegisterHotPlugCallback(nullptr);
1537     EXPECT_NE(ret, INPUT_SUCCESS);
1538 }
1539 
1540 /**
1541  * @tc.number : SUB_Driver_Input_UnregisterHotPlugCallback_0100
1542  * @tc.name   : testUnregisterHotPlugCallback001
1543  * @tc.desc   : Verify the reliability of UnregisterHotPlugCallback function and functional
1544  */
1545 HWTEST_F(HdfInputHdiTestAdditional, testUnregisterHotPlugCallback001, Function | MediumTest | Level1)
1546 {
1547     int32_t ret = INPUT_SUCCESS;
1548     ret = g_inputInterfaces->UnregisterHotPlugCallback();
1549     EXPECT_EQ(ret, INPUT_SUCCESS);
1550 }
1551