• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021 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 <cstdio>
17 #include <cstring>
18 #include <gtest/gtest.h>
19 extern "C" {
20 #include "usb_device_cdcacm_test.h"
21 }
22 
23 using namespace std;
24 using namespace testing::ext;
25 namespace {
26 #ifdef AUTO_NO_SKIP
27 static struct AcmDevice *g_acmDevice = nullptr;
28 #endif
29 class UsbDeviceSdkIfTest : public testing::Test {
30 public:
31     static void SetUpTestCase();
32     static void TearDownTestCase();
33     void SetUp();
34     void TearDown();
35 };
36 
SetUpTestCase()37 void UsbDeviceSdkIfTest::SetUpTestCase()
38 {
39 }
40 
TearDownTestCase()41 void UsbDeviceSdkIfTest::TearDownTestCase()
42 {
43 }
44 
SetUp()45 void UsbDeviceSdkIfTest::SetUp()
46 {
47 }
48 
TearDown()49 void UsbDeviceSdkIfTest::TearDown()
50 {
51 }
52 
53 #ifdef AUTO_NO_SKIP
54 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCreateDevice001, TestSize.Level1)
55 {
56     g_acmDevice = SetUpAcmDevice();
57     EXPECT_NE(nullptr, g_acmDevice);
58     EXPECT_NE(nullptr, g_acmDevice->fnDev);
59 }
60 #endif
61 
62 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCreateDevice002, TestSize.Level1)
63 {
64     struct UsbFnDevice *fnDev = nullptr;
65     struct UsbFnDescriptorData descData;
66     descData.type = USBFN_DESC_DATA_TYPE_DESC;
67     descData.descriptor = nullptr;
68     fnDev = (struct UsbFnDevice *)UsbFnCreateDevice("100e0000.hidwc3_0", &descData);
69     EXPECT_EQ(nullptr, fnDev);
70 }
71 
72 #ifdef AUTO_NO_SKIP
73 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCreateDevice003, TestSize.Level1)
74 {
75     struct UsbFnDevice *fnDev = nullptr;
76     struct UsbFnDescriptorData descData;
77     descData.type = USBFN_DESC_DATA_TYPE_DESC;
78     descData.descriptor = &g_acmFnDevice;
79     fnDev = (struct UsbFnDevice *)UsbFnCreateDevice("100e0000.hidwc3_1", &descData);
80     EXPECT_EQ(nullptr, fnDev);
81 }
82 #endif
83 
84 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCreateDevice004, TestSize.Level1)
85 {
86     struct UsbFnDevice *fnDev = nullptr;
87     struct UsbFnDescriptorData descData;
88     descData.type = USBFN_DESC_DATA_TYPE_PROP;
89     descData.property = nullptr;
90     fnDev = (struct UsbFnDevice *)UsbFnCreateDevice("100e0000.hidwc3_0", &descData);
91     EXPECT_EQ(nullptr, fnDev);
92 }
93 
94 #ifdef AUTO_NO_SKIP
95 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCreateDevice005, TestSize.Level1)
96 {
97     struct UsbFnDevice *fnDev = nullptr;
98     struct UsbFnDescriptorData descData;
99     descData.type = USBFN_DESC_DATA_TYPE_DESC;
100     descData.descriptor = &g_acmFnDevice;
101     fnDev = (struct UsbFnDevice *)UsbFnCreateDevice("100e0000.hidwc3_0", &descData);
102     EXPECT_EQ(nullptr, fnDev);
103 }
104 #endif
105 
106 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCreateDevice006, TestSize.Level1)
107 {
108     struct UsbFnDevice *fnDev = nullptr;
109     struct UsbFnDescriptorData descData;
110     const char *udcName = NULL;
111     descData.type = USBFN_DESC_DATA_TYPE_DESC;
112     descData.descriptor = &g_acmFnDevice;
113     fnDev = (struct UsbFnDevice *)UsbFnCreateDevice(udcName, &descData);
114     EXPECT_EQ(nullptr, fnDev);
115 }
116 
117 #ifdef AUTO_NO_SKIP
118 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfDeviceStatus001, TestSize.Level1)
119 {
120     int32_t ret;
121     UsbFnDeviceState devState;
122     EXPECT_NE(nullptr, g_acmDevice);
123     EXPECT_NE(nullptr, g_acmDevice->fnDev);
124     ret = UsbFnGetDeviceState(g_acmDevice->fnDev, &devState);
125     EXPECT_EQ(HDF_SUCCESS, ret);
126     EXPECT_TRUE((devState >= USBFN_STATE_BIND && devState <= USBFN_STATE_RESUME));
127 }
128 #endif
129 
130 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfDeviceStatus002, TestSize.Level1)
131 {
132     int32_t ret;
133     UsbFnDeviceState devState;
134     ret = UsbFnGetDeviceState(nullptr, &devState);
135     EXPECT_NE(HDF_SUCCESS, ret);
136 }
137 
138 #ifdef AUTO_NO_SKIP
139 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfDeviceStatus003, TestSize.Level1)
140 {
141     int32_t ret;
142     int32_t count = 0;
143     UsbFnDeviceState devState;
144     EXPECT_NE(nullptr, g_acmDevice);
145     EXPECT_NE(nullptr, g_acmDevice->fnDev);
146     for (count = 0; count < TEST_TIMES; count++) {
147         ret = UsbFnGetDeviceState(g_acmDevice->fnDev, &devState);
148         EXPECT_EQ(HDF_SUCCESS, ret);
149         EXPECT_TRUE((devState >= USBFN_STATE_BIND && devState <= USBFN_STATE_RESUME));
150     }
151 }
152 #endif
153 
154 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfDeviceStatus004, TestSize.Level1)
155 {
156     int32_t ret;
157     ret = UsbFnGetDeviceState(nullptr, nullptr);
158     EXPECT_NE(HDF_SUCCESS, ret);
159 }
160 
161 #ifdef AUTO_NO_SKIP
162 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfDeviceStatus005, TestSize.Level1)
163 {
164     int32_t ret;
165     UsbFnDeviceState *devState = NULL;
166     EXPECT_NE(nullptr, g_acmDevice);
167     EXPECT_NE(nullptr, g_acmDevice->fnDev);
168     ret = UsbFnGetDeviceState(g_acmDevice->fnDev, devState);
169     EXPECT_NE(HDF_SUCCESS, ret);
170 }
171 
172 
173 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetDevice001, TestSize.Level1)
174 {
175     const struct UsbFnDevice *device = nullptr;
176     const char *udcName = "100e0000.hidwc3_0";
177     device = UsbFnGetDevice(udcName);
178     EXPECT_NE(nullptr, device);
179 }
180 #endif
181 
182 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetDevice002, TestSize.Level1)
183 {
184     const struct UsbFnDevice *device = nullptr;
185     const char *udcName = "100e0000.hidwc3_1";
186     device = UsbFnGetDevice(udcName);
187     EXPECT_EQ(nullptr, device);
188 }
189 
190 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetDevice003, TestSize.Level1)
191 {
192     struct UsbFnDevice *device = nullptr;
193     device = (struct UsbFnDevice *)UsbFnGetDevice(nullptr);
194     EXPECT_EQ(nullptr, device);
195 }
196 
197 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetDevice004, TestSize.Level1)
198 {
199     const struct UsbFnDevice *device = nullptr;
200     const char *udcName = " 100e0000.hidwc3_0";
201     device = UsbFnGetDevice(udcName);
202     EXPECT_EQ(nullptr, device);
203 }
204 
205 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetDevice005, TestSize.Level1)
206 {
207     const struct UsbFnDevice *device = nullptr;
208     const char *udcName = "100e0000.hidwc3_0 ";
209     device = UsbFnGetDevice(udcName);
210     EXPECT_EQ(nullptr, device);
211 }
212 
213 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetDevice006, TestSize.Level1)
214 {
215     const struct UsbFnDevice *device = nullptr;
216     const char *udcName = "100e0000.hidwc3_0\0100e0000.hidwc3_0";
217     device = UsbFnGetDevice(udcName);
218     EXPECT_EQ(nullptr, device);
219 }
220 
221 #ifdef AUTO_NO_SKIP
222 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetInterface001, TestSize.Level1)
223 {
224     struct UsbFnInterface *fnInterface = nullptr;
225     EXPECT_NE(nullptr, g_acmDevice);
226     EXPECT_NE(nullptr, g_acmDevice->fnDev);
227     fnInterface = (struct UsbFnInterface *)UsbFnGetInterface(g_acmDevice->fnDev, 0);
228     EXPECT_NE(nullptr, fnInterface);
229 }
230 
231 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetInterface002, TestSize.Level1)
232 {
233     struct UsbFnInterface *fnInterface = nullptr;
234     EXPECT_NE(nullptr, g_acmDevice);
235     EXPECT_NE(nullptr, g_acmDevice->fnDev);
236     fnInterface = (struct UsbFnInterface *)UsbFnGetInterface(g_acmDevice->fnDev, 0x1);
237     EXPECT_NE(nullptr, fnInterface);
238 }
239 
240 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetInterface003, TestSize.Level1)
241 {
242     struct UsbFnInterface *fnInterface = nullptr;
243     EXPECT_NE(nullptr, g_acmDevice);
244     EXPECT_NE(nullptr, g_acmDevice->fnDev);
245     fnInterface = (struct UsbFnInterface *)UsbFnGetInterface(g_acmDevice->fnDev, 0xA);
246     EXPECT_EQ(nullptr, fnInterface);
247 }
248 
249 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetInterface004, TestSize.Level1)
250 {
251     struct UsbFnInterface *fnInterface = nullptr;
252     EXPECT_NE(nullptr, g_acmDevice);
253     EXPECT_NE(nullptr, g_acmDevice->fnDev);
254     fnInterface = (struct UsbFnInterface *)UsbFnGetInterface(g_acmDevice->fnDev, 0x20);
255     EXPECT_EQ(nullptr, fnInterface);
256 }
257 #endif
258 
259 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetInterface005, TestSize.Level1)
260 {
261     struct UsbFnInterface *fnInterface = nullptr;
262     fnInterface = (struct UsbFnInterface *)UsbFnGetInterface(nullptr, 0);
263     EXPECT_EQ(nullptr, fnInterface);
264 }
265 
266 #ifdef AUTO_NO_SKIP
267 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetInterface006, TestSize.Level1)
268 {
269     struct UsbFnInterface *fnInterface = nullptr;
270     int32_t cnt;
271     EXPECT_NE(nullptr, g_acmDevice);
272     EXPECT_NE(nullptr, g_acmDevice->fnDev);
273     for (cnt = 0; cnt < 0x2; cnt++) {
274         fnInterface = (struct UsbFnInterface *)UsbFnGetInterface(g_acmDevice->fnDev, cnt);
275         EXPECT_NE(nullptr, fnInterface);
276     }
277 }
278 
279 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetpipeInfo001, TestSize.Level1)
280 {
281     int32_t ret;
282     struct UsbFnPipeInfo info;
283     EXPECT_TRUE((nullptr != g_acmDevice));
284     EXPECT_TRUE(nullptr != g_acmDevice->dataIface.fn);
285     ret = UsbFnGetInterfacePipeInfo(g_acmDevice->dataIface.fn, 0, &info);
286     EXPECT_TRUE(HDF_SUCCESS == ret);
287     EXPECT_TRUE(0 == info.id);
288 }
289 
290 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetpipeInfo002, TestSize.Level1)
291 {
292     int32_t ret;
293     struct UsbFnPipeInfo info;
294     EXPECT_NE(nullptr, g_acmDevice);
295     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
296     ret = UsbFnGetInterfacePipeInfo(g_acmDevice->dataIface.fn, 1, &info);
297     EXPECT_TRUE(HDF_SUCCESS == ret);
298     EXPECT_TRUE(1 == info.id);
299 }
300 
301 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetpipeInfo003, TestSize.Level1)
302 {
303     int32_t ret;
304     struct UsbFnPipeInfo info;
305     EXPECT_NE(nullptr, g_acmDevice);
306     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
307     ret = UsbFnGetInterfacePipeInfo(g_acmDevice->dataIface.fn, 0xF, &info);
308     EXPECT_TRUE(HDF_SUCCESS != ret);
309 }
310 
311 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetpipeInfo004, TestSize.Level1)
312 {
313     int32_t ret;
314     EXPECT_NE(nullptr, g_acmDevice);
315     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
316     ret = UsbFnGetInterfacePipeInfo(g_acmDevice->dataIface.fn, 0, nullptr);
317     EXPECT_TRUE(HDF_SUCCESS != ret);
318 }
319 #endif
320 
321 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetpipeInfo005, TestSize.Level1)
322 {
323     int32_t ret;
324     struct UsbFnPipeInfo info;
325     ret = UsbFnGetInterfacePipeInfo(nullptr, 1, &info);
326     EXPECT_TRUE(HDF_SUCCESS != ret);
327 }
328 
329 #ifdef AUTO_NO_SKIP
330 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetpipeInfo006, TestSize.Level1)
331 {
332     int32_t ret;
333     struct UsbFnPipeInfo info;
334     EXPECT_TRUE((nullptr != g_acmDevice));
335     EXPECT_TRUE(nullptr != g_acmDevice->ctrlIface.fn);
336     ret = UsbFnGetInterfacePipeInfo(g_acmDevice->ctrlIface.fn, 0, &info);
337     EXPECT_TRUE(HDF_SUCCESS == ret);
338     EXPECT_TRUE(0 == info.id);
339 }
340 #endif
341 
PropCallBack(const struct UsbFnInterface * intf,const char * name,const char * value)342 int32_t PropCallBack(const struct UsbFnInterface *intf, const char *name, const char *value)
343 {
344     if (intf == nullptr || name == nullptr || value == nullptr) {
345         return HDF_FAILURE;
346     }
347     return HDF_SUCCESS;
348 }
349 
350 #ifdef AUTO_NO_SKIP
351 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRegistProp001, TestSize.Level1)
352 {
353     int32_t ret;
354     struct UsbFnRegistInfo info;
355     EXPECT_NE(nullptr, g_acmDevice);
356     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
357     info.name = "name_test";
358     info.value = "test_value";
359     info.getProp  = PropCallBack;
360     info.setProp  = PropCallBack;
361     ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info);
362     EXPECT_TRUE(HDF_SUCCESS == ret);
363 }
364 
365 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRegistProp002, TestSize.Level1)
366 {
367     int32_t ret;
368     struct UsbFnRegistInfo info;
369     EXPECT_NE(nullptr, g_acmDevice);
370     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
371     info.name = "name_test";
372     info.value = "test_value";
373     info.getProp  = PropCallBack;
374     info.setProp  = PropCallBack;
375     ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info);
376     EXPECT_TRUE(HDF_SUCCESS != ret);
377 }
378 
379 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRegistProp003, TestSize.Level1)
380 {
381     int32_t ret;
382     struct UsbFnRegistInfo info;
383     EXPECT_NE(nullptr, g_acmDevice);
384     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
385     info.name = nullptr;
386     info.value = "test_value";
387     info.getProp  = PropCallBack;
388     info.setProp  = PropCallBack;
389     ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info);
390     EXPECT_TRUE(HDF_SUCCESS != ret);
391 }
392 
393 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRegistProp004, TestSize.Level1)
394 {
395     int32_t ret;
396     struct UsbFnRegistInfo info;
397     EXPECT_NE(nullptr, g_acmDevice);
398     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
399     info.name = "name_test4";
400     info.value = nullptr;
401     info.getProp  = PropCallBack;
402     info.setProp  = PropCallBack;
403     ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info);
404     EXPECT_TRUE(HDF_SUCCESS == ret);
405 }
406 
407 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRegistProp005, TestSize.Level1)
408 {
409     int32_t ret;
410     struct UsbFnRegistInfo info;
411     EXPECT_NE(nullptr, g_acmDevice);
412     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
413     info.name = "name_test5";
414     info.value = "test_value";
415     info.getProp  = nullptr;
416     info.setProp  = PropCallBack;
417     ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info);
418     EXPECT_TRUE(HDF_SUCCESS == ret);
419 }
420 #endif
421 
422 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRegistProp006, TestSize.Level1)
423 {
424     int32_t ret;
425     struct UsbFnRegistInfo info;
426     info.name = "name_test5";
427     info.value = "test_value";
428     info.getProp  = PropCallBack;
429     info.setProp  = PropCallBack;
430     ret = UsbFnRegistInterfaceProp(nullptr, &info);
431     EXPECT_TRUE(HDF_SUCCESS != ret);
432 }
433 
434 #ifdef AUTO_NO_SKIP
435 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRegistProp007, TestSize.Level1)
436 {
437     int32_t ret;
438     struct UsbFnRegistInfo info;
439     EXPECT_NE(nullptr, g_acmDevice);
440     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
441     info.name = "name_test";
442     info.value = "test_value";
443     info.getProp  = PropCallBack;
444     info.setProp  = PropCallBack;
445     ret = UsbFnRegistInterfaceProp(g_acmDevice->dataIface.fn, &info);
446     EXPECT_TRUE(HDF_SUCCESS == ret);
447 }
448 
449 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRegistProp008, TestSize.Level1)
450 {
451     int32_t ret;
452     struct UsbFnRegistInfo info;
453     EXPECT_NE(nullptr, g_acmDevice);
454     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
455     info.name = "name_test";
456     info.value = "test_value";
457     info.getProp  = PropCallBack;
458     info.setProp  = PropCallBack;
459     ret = UsbFnRegistInterfaceProp(g_acmDevice->dataIface.fn, &info);
460     EXPECT_TRUE(HDF_SUCCESS != ret);
461 }
462 
463 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetProp001, TestSize.Level1)
464 {
465     int32_t ret;
466     char buffer[BUFFER_LEN] = {0};
467     EXPECT_NE(nullptr, g_acmDevice);
468     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
469     ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "name_test", buffer);
470     EXPECT_TRUE(HDF_SUCCESS == ret);
471     EXPECT_TRUE(strcmp(buffer, "test_value") == 0);
472 }
473 
474 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetProp002, TestSize.Level1)
475 {
476     int32_t ret;
477     char buffer[BUFFER_LEN] = {0};
478     EXPECT_NE(nullptr, g_acmDevice);
479     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
480     ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "unknown", buffer);
481     EXPECT_TRUE(HDF_SUCCESS != ret);
482 }
483 
484 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetProp003, TestSize.Level1)
485 {
486     int32_t ret;
487     char buffer[BUFFER_LEN] = {0};
488     EXPECT_NE(nullptr, g_acmDevice);
489     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
490     ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "idProduct", buffer);
491     EXPECT_TRUE(HDF_SUCCESS == ret);
492 }
493 
494 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetProp004, TestSize.Level1)
495 {
496     int32_t ret;
497     char buffer[BUFFER_LEN] = {0};
498     EXPECT_NE(nullptr, g_acmDevice);
499     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
500     ret = UsbFnGetInterfaceProp(nullptr, "idProduct", buffer);
501     EXPECT_TRUE(HDF_SUCCESS != ret);
502 }
503 
504 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetProp005, TestSize.Level1)
505 {
506     int32_t ret;
507     EXPECT_NE(nullptr, g_acmDevice);
508     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
509     ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "idProduct", nullptr);
510     EXPECT_TRUE(HDF_SUCCESS == ret);
511 }
512 #endif
513 
514 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetProp006, TestSize.Level1)
515 {
516     int32_t ret;
517     char buffer[BUFFER_LEN] = {0};
518     ret = UsbFnGetInterfaceProp(nullptr, "idProduct", buffer);
519     EXPECT_TRUE(HDF_SUCCESS != ret);
520 }
521 
522 #ifdef AUTO_NO_SKIP
523 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetProp007, TestSize.Level1)
524 {
525     int32_t ret;
526     char buffer[BUFFER_LEN] = {0};
527     EXPECT_NE(nullptr, g_acmDevice);
528     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
529     ret = UsbFnGetInterfaceProp(g_acmDevice->dataIface.fn, "name_test", buffer);
530     EXPECT_TRUE(HDF_SUCCESS == ret);
531     EXPECT_TRUE(strcmp(buffer, "test_value") == 0);
532 }
533 
534 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfGetProp008, TestSize.Level1)
535 {
536     int32_t ret;
537     char buffer[BUFFER_LEN] = {0};
538     EXPECT_NE(nullptr, g_acmDevice);
539     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
540     ret = UsbFnGetInterfaceProp(g_acmDevice->dataIface.fn, "idProduct", buffer);
541     EXPECT_TRUE(HDF_SUCCESS == ret);
542 }
543 
544 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfSetProp001, TestSize.Level1)
545 {
546     int32_t ret;
547     EXPECT_NE(nullptr, g_acmDevice);
548     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
549     ret = UsbFnSetInterfaceProp(g_acmDevice->ctrlIface.fn, "name_test", "hello");
550     EXPECT_TRUE(HDF_SUCCESS == ret);
551 }
552 
553 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfSetProp002, TestSize.Level1)
554 {
555     int32_t ret;
556     EXPECT_NE(nullptr, g_acmDevice);
557     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
558     ret = UsbFnSetInterfaceProp(g_acmDevice->ctrlIface.fn, "unknown", "hello");
559     EXPECT_TRUE(HDF_SUCCESS != ret);
560 }
561 
562 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfSetProp003, TestSize.Level1)
563 {
564     int32_t ret;
565     EXPECT_NE(nullptr, g_acmDevice);
566     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
567     ret = UsbFnSetInterfaceProp(nullptr, "name_test", "hello");
568     EXPECT_TRUE(HDF_SUCCESS != ret);
569 }
570 
571 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfSetProp004, TestSize.Level1)
572 {
573     int32_t ret;
574     EXPECT_NE(nullptr, g_acmDevice);
575     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
576     ret = UsbFnSetInterfaceProp(g_acmDevice->ctrlIface.fn, nullptr, "hello");
577     EXPECT_TRUE(HDF_SUCCESS != ret);
578 }
579 
580 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfSetProp005, TestSize.Level1)
581 {
582     int32_t ret;
583     EXPECT_NE(nullptr, g_acmDevice);
584     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
585     ret = UsbFnSetInterfaceProp(g_acmDevice->ctrlIface.fn, "idVendor", "0x625");
586     EXPECT_TRUE(HDF_SUCCESS == ret);
587 }
588 
589 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfSetProp006, TestSize.Level1)
590 {
591     int32_t ret;
592     EXPECT_NE(nullptr, g_acmDevice);
593     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
594     ret = UsbFnSetInterfaceProp(g_acmDevice->ctrlIface.fn, "bLength", "0x14");
595     EXPECT_TRUE(HDF_SUCCESS != ret);
596 }
597 
598 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfSetProp007, TestSize.Level1)
599 {
600     int32_t ret;
601     EXPECT_NE(nullptr, g_acmDevice);
602     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
603     ret = UsbFnSetInterfaceProp(g_acmDevice->dataIface.fn, "name_test", "hello");
604     EXPECT_TRUE(HDF_SUCCESS == ret);
605 }
606 
607 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocCtrlRequest001, TestSize.Level1)
608 {
609     int32_t ret;
610     struct UsbFnRequest *req = nullptr;
611     EXPECT_NE(nullptr, g_acmDevice);
612     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
613     req = UsbFnAllocCtrlRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.maxPacketSize);
614     EXPECT_TRUE(nullptr != req);
615     ret = UsbFnFreeRequest(req);
616     EXPECT_TRUE(HDF_SUCCESS == ret);
617 }
618 
619 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocCtrlRequest002, TestSize.Level1)
620 {
621     int32_t ret;
622     struct UsbFnRequest *req = nullptr;
623     EXPECT_NE(nullptr, g_acmDevice);
624     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
625     req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle,
626            sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
627     EXPECT_TRUE(nullptr != req);
628     ret = UsbFnFreeRequest(req);
629     EXPECT_TRUE(HDF_SUCCESS == ret);
630 }
631 
632 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocCtrlRequest003, TestSize.Level1)
633 {
634     struct UsbFnRequest *req = nullptr;
635     EXPECT_NE(nullptr, g_acmDevice);
636     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
637     req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, 0);
638     EXPECT_TRUE(nullptr == req);
639 }
640 
641 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocCtrlRequest004, TestSize.Level1)
642 {
643     int32_t ret;
644     struct UsbFnRequest *req = nullptr;
645     EXPECT_NE(nullptr, g_acmDevice);
646     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
647     req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, 0x800);
648     EXPECT_TRUE(nullptr != req);
649     ret = UsbFnFreeRequest(req);
650     EXPECT_TRUE(HDF_SUCCESS == ret);
651 }
652 
653 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocCtrlRequest005, TestSize.Level1)
654 {
655     struct UsbFnRequest *req = nullptr;
656     EXPECT_NE(nullptr, g_acmDevice);
657     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
658     req = UsbFnAllocCtrlRequest(nullptr, g_acmDevice->notifyPipe.maxPacketSize);
659     EXPECT_TRUE(nullptr == req);
660 }
661 
662 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocCtrlRequest006, TestSize.Level1)
663 {
664     struct UsbFnRequest *req = nullptr;
665     EXPECT_NE(nullptr, g_acmDevice);
666     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
667     req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, 0x801);
668     EXPECT_TRUE(nullptr == req);
669 }
670 
671 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocCtrlRequest007, TestSize.Level1)
672 {
673     struct UsbFnRequest *req = nullptr;
674     EXPECT_NE(nullptr, g_acmDevice);
675     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
676     req = UsbFnAllocCtrlRequest(g_acmDevice->dataIface.handle, 0);
677     EXPECT_TRUE(nullptr == req);
678 }
679 
680 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocCtrlRequest008, TestSize.Level1)
681 {
682     struct UsbFnRequest *req = nullptr;
683     EXPECT_NE(nullptr, g_acmDevice);
684     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
685     req = UsbFnAllocCtrlRequest(g_acmDevice->dataIface.handle, 0x801);
686     EXPECT_TRUE(nullptr == req);
687 }
688 #endif
689 
690 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocCtrlRequest009, TestSize.Level1)
691 {
692     struct UsbFnRequest *req = nullptr;
693     UsbFnInterfaceHandle handle = NULL;
694     req = UsbFnAllocCtrlRequest(handle, 0);
695     EXPECT_TRUE(nullptr == req);
696 }
697 
698 #ifdef AUTO_NO_SKIP
699 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest001, TestSize.Level1)
700 {
701     int32_t ret;
702     struct UsbFnRequest *req = nullptr;
703     EXPECT_NE(nullptr, g_acmDevice);
704     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
705     req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id,
706         sizeof(struct UsbCdcNotification));
707     EXPECT_TRUE(nullptr != req);
708     ret = UsbFnFreeRequest(req);
709     EXPECT_TRUE(HDF_SUCCESS == ret);
710 }
711 
712 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest002, TestSize.Level1)
713 {
714     struct UsbFnRequest *req = nullptr;
715     EXPECT_NE(nullptr, g_acmDevice);
716     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
717     req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, 0);
718     EXPECT_TRUE(nullptr == req);
719 }
720 
721 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest003, TestSize.Level1)
722 {
723     int32_t ret;
724     struct UsbFnRequest *req = nullptr;
725     EXPECT_NE(nullptr, g_acmDevice);
726     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
727     req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, 0x800);
728     EXPECT_TRUE(nullptr != req);
729     ret = UsbFnFreeRequest(req);
730     EXPECT_TRUE(HDF_SUCCESS == ret);
731 }
732 
733 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest004, TestSize.Level1)
734 {
735     struct UsbFnRequest *req = nullptr;
736     EXPECT_NE(nullptr, g_acmDevice);
737     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
738     req = UsbFnAllocRequest(nullptr, g_acmDevice->notifyPipe.id, 0x800);
739     EXPECT_TRUE(nullptr == req);
740 }
741 
742 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest005, TestSize.Level1)
743 {
744     struct UsbFnRequest *req = nullptr;
745     EXPECT_NE(nullptr, g_acmDevice);
746     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
747     req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, 0x20, 0x800);
748     EXPECT_TRUE(nullptr == req);
749 }
750 
751 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest006, TestSize.Level1)
752 {
753     struct UsbFnRequest *req = nullptr;
754     EXPECT_NE(nullptr, g_acmDevice);
755     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
756     req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, 0, 0x801);
757     EXPECT_TRUE(nullptr == req);
758 }
759 
760 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest007, TestSize.Level1)
761 {
762     int32_t ret;
763     struct UsbFnRequest *req = nullptr;
764     EXPECT_NE(nullptr, g_acmDevice);
765     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
766     req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id,
767         g_acmDevice->dataOutPipe.maxPacketSize);
768     EXPECT_TRUE(nullptr != req);
769     ret = UsbFnFreeRequest(req);
770     EXPECT_TRUE(HDF_SUCCESS == ret);
771 }
772 
773 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest008, TestSize.Level1)
774 {
775     struct UsbFnRequest *req = nullptr;
776     EXPECT_NE(nullptr, g_acmDevice);
777     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
778     req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, 0);
779     EXPECT_TRUE(nullptr == req);
780 }
781 
782 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest009, TestSize.Level1)
783 {
784     struct UsbFnRequest *req = nullptr;
785     EXPECT_NE(nullptr, g_acmDevice);
786     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
787     req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, 0x801);
788     EXPECT_TRUE(nullptr == req);
789 }
790 
791 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfAllocRequest010, TestSize.Level1)
792 {
793     struct UsbFnRequest *req = nullptr;
794     EXPECT_NE(nullptr, g_acmDevice);
795     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
796     req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, 0xf, 0x801);
797     EXPECT_TRUE(nullptr == req);
798 }
799 
800 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfFreeRequest001, TestSize.Level1)
801 {
802     int32_t ret;
803     struct UsbFnRequest *req = nullptr;
804     EXPECT_NE(nullptr, g_acmDevice);
805     req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id,
806         g_acmDevice->dataInPipe.maxPacketSize);
807     EXPECT_TRUE(req != nullptr);
808     ret = UsbFnFreeRequest(req);
809     EXPECT_TRUE(ret == HDF_SUCCESS);
810 }
811 
812 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfFreeRequest002, TestSize.Level1)
813 {
814     int32_t ret;
815     struct UsbFnRequest *req = nullptr;
816     EXPECT_NE(nullptr, g_acmDevice);
817     req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id,
818         g_acmDevice->dataOutPipe.maxPacketSize);
819     EXPECT_TRUE(req != nullptr);
820     ret = UsbFnFreeRequest(req);
821     EXPECT_TRUE(ret == HDF_SUCCESS);
822 }
823 
824 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfFreeRequest003, TestSize.Level1)
825 {
826     int32_t ret;
827     struct UsbFnRequest *req = nullptr;
828     EXPECT_NE(nullptr, g_acmDevice);
829     req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id,
830         g_acmDevice->notifyPipe.maxPacketSize);
831     EXPECT_TRUE(req != nullptr);
832     ret = UsbFnFreeRequest(req);
833     EXPECT_TRUE(ret == HDF_SUCCESS);
834 }
835 
836 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfFreeRequest004, TestSize.Level1)
837 {
838     int32_t ret;
839     struct UsbFnRequest *req = nullptr;
840     EXPECT_NE(nullptr, g_acmDevice);
841     req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.maxPacketSize);
842     EXPECT_TRUE(req != nullptr);
843     ret = UsbFnFreeRequest(req);
844     EXPECT_TRUE(ret == HDF_SUCCESS);
845 }
846 
847 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfFreeRequest005, TestSize.Level1)
848 {
849     int32_t ret;
850     int32_t count;
851     struct UsbFnRequest *req = nullptr;
852     EXPECT_NE(nullptr, g_acmDevice);
853     for (count = 0; count < TEST_TIMES; count++) {
854         req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.maxPacketSize);
855         EXPECT_TRUE(req != nullptr);
856         ret = UsbFnFreeRequest(req);
857         EXPECT_TRUE(ret == HDF_SUCCESS);
858     }
859 }
860 #endif
861 
862 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfFreeRequest006, TestSize.Level1)
863 {
864     int32_t ret;
865     ret = UsbFnFreeRequest(nullptr);
866     EXPECT_TRUE(ret != HDF_SUCCESS);
867 }
868 
869 #ifdef AUTO_NO_SKIP
eventCallback(struct UsbFnEvent * event)870 static void eventCallback(struct UsbFnEvent *event)
871 {
872     (void)event;
873 }
874 
875 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStartRecvEvent001, TestSize.Level1)
876 {
877     int32_t ret;
878     EXPECT_NE(nullptr, g_acmDevice);
879     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
880     ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0xff, nullptr, g_acmDevice);
881     EXPECT_NE(HDF_SUCCESS, ret);
882 }
883 
884 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStartRecvEvent002, TestSize.Level1)
885 {
886     int32_t ret;
887     EXPECT_NE(nullptr, g_acmDevice);
888     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
889     ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0x0, eventCallback, g_acmDevice);
890     EXPECT_NE(HDF_SUCCESS, ret);
891 }
892 
893 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStartRecvEvent003, TestSize.Level1)
894 {
895     int32_t ret;
896     EXPECT_NE(nullptr, g_acmDevice);
897     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
898     ret = UsbFnStartRecvInterfaceEvent(nullptr, 0xff, eventCallback, g_acmDevice);
899     EXPECT_NE(HDF_SUCCESS, ret);
900 }
901 
902 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStartRecvEvent004, TestSize.Level1)
903 {
904     int32_t ret;
905     EXPECT_NE(nullptr, g_acmDevice);
906     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
907     ret = UsbFnStopRecvInterfaceEvent(g_acmDevice->ctrlIface.fn);
908     EXPECT_TRUE(HDF_SUCCESS == ret);
909     ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0xff, eventCallback, g_acmDevice);
910     EXPECT_TRUE(HDF_SUCCESS == ret);
911 }
912 
913 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStartRecvEvent005, TestSize.Level1)
914 {
915     int32_t ret;
916     int32_t count = 0;
917     EXPECT_NE(nullptr, g_acmDevice);
918     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
919     for (count = 0; count < TEST_TIMES; count++) {
920         ret = UsbFnStopRecvInterfaceEvent(g_acmDevice->ctrlIface.fn);
921         EXPECT_TRUE(HDF_SUCCESS == ret);
922         ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0xff, eventCallback, g_acmDevice);
923         EXPECT_TRUE(HDF_SUCCESS == ret);
924     }
925 }
926 
927 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStartRecvEvent006, TestSize.Level1)
928 {
929     int32_t ret;
930     EXPECT_NE(nullptr, g_acmDevice);
931     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
932     ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0xff, eventCallback, g_acmDevice);
933     EXPECT_NE(HDF_SUCCESS, ret);
934 }
935 
936 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStartRecvEvent007, TestSize.Level1)
937 {
938     int32_t ret;
939     EXPECT_NE(nullptr, g_acmDevice);
940     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
941     ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->dataIface.fn, 0xff, eventCallback, g_acmDevice);
942     EXPECT_NE(HDF_SUCCESS, ret);
943 }
944 
945 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStopRecvEvent001, TestSize.Level1)
946 {
947     int32_t ret;
948     EXPECT_NE(nullptr, g_acmDevice);
949     ret = UsbFnStopRecvInterfaceEvent(nullptr);
950     EXPECT_TRUE(HDF_SUCCESS != ret);
951 }
952 
953 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStopRecvEvent002, TestSize.Level1)
954 {
955     int32_t ret;
956     EXPECT_NE(nullptr, g_acmDevice);
957     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
958     ret = UsbFnStopRecvInterfaceEvent(g_acmDevice->ctrlIface.fn);
959     EXPECT_TRUE(HDF_SUCCESS == ret);
960 }
961 
962 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStopRecvEvent003, TestSize.Level1)
963 {
964     int32_t ret;
965     EXPECT_NE(nullptr, g_acmDevice);
966     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
967     ret = UsbFnStopRecvInterfaceEvent(g_acmDevice->ctrlIface.fn);
968     EXPECT_TRUE(HDF_SUCCESS != ret);
969 }
970 
971 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfStopRecvEvent004, TestSize.Level1)
972 {
973     int32_t ret;
974     EXPECT_NE(nullptr, g_acmDevice);
975     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
976     ret = UsbFnStopRecvInterfaceEvent(g_acmDevice->dataIface.fn);
977     EXPECT_TRUE(HDF_SUCCESS != ret);
978 }
979 
980 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCloseInterface001, TestSize.Level1)
981 {
982     int32_t ret;
983     EXPECT_NE(nullptr, g_acmDevice);
984     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
985     ret = UsbFnCloseInterface(g_acmDevice->ctrlIface.handle);
986     EXPECT_TRUE(HDF_SUCCESS == ret);
987     g_acmDevice->ctrlIface.handle = NULL;
988 }
989 
990 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCloseInterface002, TestSize.Level1)
991 {
992     int32_t ret;
993     EXPECT_NE(nullptr, g_acmDevice);
994     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
995     ret = UsbFnCloseInterface(g_acmDevice->dataIface.handle);
996     EXPECT_TRUE(HDF_SUCCESS == ret);
997     g_acmDevice->dataIface.handle = NULL;
998 }
999 
1000 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCloseInterface003, TestSize.Level1)
1001 {
1002     int32_t ret;
1003     EXPECT_NE(nullptr, g_acmDevice);
1004     ret = UsbFnCloseInterface(g_acmDevice->ctrlIface.handle);
1005     EXPECT_TRUE(HDF_SUCCESS != ret);
1006 }
1007 
1008 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfCloseInterface004, TestSize.Level1)
1009 {
1010     int32_t ret;
1011     EXPECT_NE(nullptr, g_acmDevice);
1012     ret = UsbFnCloseInterface(g_acmDevice->dataIface.handle);
1013     EXPECT_TRUE(HDF_SUCCESS != ret);
1014 }
1015 
1016 
1017 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfOpenInterface001, TestSize.Level1)
1018 {
1019     UsbFnInterfaceHandle handle;
1020     EXPECT_NE(nullptr, g_acmDevice);
1021     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
1022     handle = UsbFnOpenInterface(g_acmDevice->ctrlIface.fn);
1023     EXPECT_TRUE(nullptr != handle);
1024     g_acmDevice->ctrlIface.handle = handle;
1025 }
1026 
1027 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfOpenInterface002, TestSize.Level1)
1028 {
1029     UsbFnInterfaceHandle handle;
1030     EXPECT_NE(nullptr, g_acmDevice);
1031     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
1032     handle = UsbFnOpenInterface(g_acmDevice->dataIface.fn);
1033     EXPECT_TRUE(nullptr != handle);
1034     g_acmDevice->dataIface.handle = handle;
1035 }
1036 
1037 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfOpenInterface003, TestSize.Level1)
1038 {
1039     UsbFnInterfaceHandle handle;
1040     EXPECT_NE(nullptr, g_acmDevice);
1041     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.fn);
1042     handle = UsbFnOpenInterface(g_acmDevice->ctrlIface.fn);
1043     EXPECT_TRUE(handle == nullptr);
1044 }
1045 
1046 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfOpenInterface004, TestSize.Level1)
1047 {
1048     UsbFnInterfaceHandle handle;
1049     EXPECT_NE(nullptr, g_acmDevice);
1050     EXPECT_NE(nullptr, g_acmDevice->dataIface.fn);
1051     handle = UsbFnOpenInterface(g_acmDevice->dataIface.fn);
1052     EXPECT_TRUE(handle == nullptr);
1053 }
1054 #endif
1055 
1056 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfOpenInterface005, TestSize.Level1)
1057 {
1058     struct UsbFnInterface *fn = nullptr;
1059     UsbFnInterfaceHandle handle;
1060     handle = UsbFnOpenInterface(fn);
1061     EXPECT_TRUE(handle == nullptr);
1062 }
1063 
1064 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRemoveDevice001, TestSize.Level1)
1065 {
1066     int32_t ret;
1067     ret = UsbFnRemoveDevice(nullptr);
1068     EXPECT_TRUE(HDF_SUCCESS != ret);
1069 }
1070 
1071 #ifdef AUTO_NO_SKIP
1072 HWTEST_F(UsbDeviceSdkIfTest, CheckDeviceSdkIfRemoveDevice002, TestSize.Level1)
1073 {
1074     int32_t ret;
1075 
1076     EXPECT_NE(nullptr, g_acmDevice);
1077     ReleaseAcmDevice(g_acmDevice);
1078     EXPECT_NE(nullptr, g_acmDevice->fnDev);
1079     ret = UsbFnRemoveDevice(g_acmDevice->fnDev);
1080     EXPECT_EQ(HDF_SUCCESS, ret);
1081     OsalMemFree(g_acmDevice);
1082 }
1083 #endif
1084 }
1085