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