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