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 UsbDeviceSdkIoTest : public testing::Test {};
28 
29 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfCreateDevice001, TestSize.Level1)
30 {
31     g_acmDevice = SetUpAcmDevice();
32     EXPECT_NE(nullptr, g_acmDevice);
33     EXPECT_NE(nullptr, g_acmDevice->fnDev);
34 }
35 
36 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestAsync001, TestSize.Level1)
37 {
38     int32_t ret;
39     ret = UsbFnSubmitRequestAsync(nullptr);
40     EXPECT_TRUE(ret != HDF_SUCCESS);
41 }
42 
ReadComplete(uint8_t pipe,struct UsbFnRequest * req)43 static void ReadComplete(uint8_t pipe, struct UsbFnRequest *req)
44 {
45     EXPECT_NE(nullptr, req);
46     if (req->actual) {
47         uint8_t *data = (uint8_t *)req->buf;
48         data[req->actual] = '\0';
49         printf("receive [%d] bytes data: %s\n", req->actual, data);
50         if (strcmp((const char *)data, "q") == 0 || strcmp((const char *)data, "q\n") == 0) {
51             g_acmDevice->submitExit = 1;
52         }
53     }
54     g_acmDevice->submit = 1;
55 }
56 
57 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestAsync002, TestSize.Level1)
58 {
59     struct UsbFnRequest *req = nullptr;
60     int32_t ret;
61     int32_t waitMs = 1000;
62     EXPECT_NE(nullptr, g_acmDevice);
63     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
64     printf("wait receiving data form host, please connect\n");
65     req = UsbFnAllocRequest(
66         g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
67     EXPECT_NE(nullptr, req);
68     req->complete = ReadComplete;
69     req->context = g_acmDevice;
70     g_acmDevice->submit = 0;
71     while (1) {
72         ret = UsbFnSubmitRequestAsync(req);
73         if (ret != HDF_SUCCESS) {
74             continue;
75         }
76         while (g_acmDevice->submit == 0) {
77             OsalMSleep(waitMs);
78         }
79         EXPECT_TRUE(ret == HDF_SUCCESS);
80         EXPECT_EQ(1, g_acmDevice->submit);
81         g_acmDevice->submit = 0;
82         if (req->actual > 0) {
83             break;
84         }
85     }
86     ret = UsbFnFreeRequest(req);
87     EXPECT_TRUE(ret == HDF_SUCCESS);
88 }
89 
90 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestAsync003, TestSize.Level1)
91 {
92     struct UsbFnRequest *req = nullptr;
93     int32_t ret;
94     int32_t waitMs = WAIT_10MS;
95     EXPECT_NE(nullptr, g_acmDevice);
96     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
97     printf("recv data until 'q' exit\n");
98     g_acmDevice->submitExit = 0;
99     while (g_acmDevice->submitExit == 0) {
100         req = UsbFnAllocRequest(
101             g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
102         EXPECT_NE(nullptr, req);
103         req->complete = ReadComplete;
104         req->context = g_acmDevice;
105         g_acmDevice->submit = 0;
106         ret = UsbFnSubmitRequestAsync(req);
107         EXPECT_TRUE(ret == HDF_SUCCESS);
108         EXPECT_EQ(0, g_acmDevice->submit);
109         while (g_acmDevice->submit == 0) {
110             OsalMSleep(waitMs);
111         }
112         g_acmDevice->submit = 0;
113         ret = UsbFnFreeRequest(req);
114         EXPECT_TRUE(ret == HDF_SUCCESS);
115     }
116 }
117 
WriteComplete(uint8_t pipe,struct UsbFnRequest * req)118 static void WriteComplete(uint8_t pipe, struct UsbFnRequest *req)
119 {
120     EXPECT_EQ(0, req->status);
121     printf("write data ok\n");
122     g_acmDevice->submit = 1;
123 }
124 
125 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestAsync004, TestSize.Level1)
126 {
127     int32_t ret;
128     struct UsbFnRequest *req = nullptr;
129     EXPECT_NE(nullptr, g_acmDevice);
130     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
131     req = UsbFnAllocRequest(
132         g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, g_acmDevice->dataInPipe.maxPacketSize);
133     EXPECT_NE(nullptr, req);
134     req->complete = WriteComplete;
135     req->context = g_acmDevice;
136     g_acmDevice->submit = 0;
137     printf("------send \"abc\" to host------\n");
138     memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc"));
139     req->length = strlen("abc");
140     ret = UsbFnSubmitRequestAsync(req);
141     EXPECT_TRUE(ret == HDF_SUCCESS);
142     while (g_acmDevice->submit == 0) {
143         OsalMSleep(1);
144     }
145     g_acmDevice->submit = 0;
146     ret = UsbFnFreeRequest(req);
147     EXPECT_TRUE(ret == HDF_SUCCESS);
148 }
149 
150 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestAsync005, TestSize.Level1)
151 {
152     int32_t ret;
153     int32_t loopTime = TEST_TIMES;
154     struct UsbFnRequest *req = nullptr;
155     EXPECT_NE(nullptr, g_acmDevice);
156     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
157     printf("------send \"xyz\" 10 times to host------\n");
158     while (loopTime > 0) {
159         req = UsbFnAllocRequest(
160             g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, g_acmDevice->dataInPipe.maxPacketSize);
161         EXPECT_NE(nullptr, req);
162         req->complete = WriteComplete;
163         req->context = g_acmDevice;
164         g_acmDevice->submit = 0;
165         memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "xyz", strlen("xyz"));
166         req->length = strlen("xyz");
167         ret = UsbFnSubmitRequestAsync(req);
168         EXPECT_TRUE(ret == HDF_SUCCESS);
169         while (g_acmDevice->submit == 0) {
170             OsalMSleep(1);
171         }
172         g_acmDevice->submit = 0;
173         ret = UsbFnFreeRequest(req);
174         EXPECT_TRUE(ret == HDF_SUCCESS);
175         loopTime--;
176     }
177 }
178 
179 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestSync001, TestSize.Level1)
180 {
181     int32_t ret;
182     ret = UsbFnSubmitRequestSync(nullptr, 0);
183     EXPECT_TRUE(ret != HDF_SUCCESS);
184 }
185 
186 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestSync002, TestSize.Level1)
187 {
188     struct UsbFnRequest *req = nullptr;
189     int32_t ret;
190     uint8_t *data = nullptr;
191     EXPECT_NE(nullptr, g_acmDevice);
192     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
193     printf("wait receiving data form host:\n");
194     req = UsbFnAllocRequest(
195         g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
196     EXPECT_NE(nullptr, req);
197     ret = UsbFnSubmitRequestSync(req, 0);
198     EXPECT_TRUE(ret == 0);
199     EXPECT_TRUE(req->actual > 0);
200     EXPECT_TRUE(req->status == USB_REQUEST_COMPLETED);
201     data = (uint8_t *)req->buf;
202     data[req->actual] = '\0';
203     ret = UsbFnFreeRequest(req);
204     EXPECT_TRUE(ret == HDF_SUCCESS);
205 }
206 
207 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestSync003, TestSize.Level1)
208 {
209     struct UsbFnRequest *req = nullptr;
210     int32_t ret;
211     int32_t submitExit = 0;
212     uint8_t *data;
213     EXPECT_NE(nullptr, g_acmDevice);
214     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
215     printf("receive data until 'q' exit\n");
216     while (submitExit == 0) {
217         req = UsbFnAllocRequest(
218             g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
219         EXPECT_NE(nullptr, req);
220         ret = UsbFnSubmitRequestSync(req, 0);
221         EXPECT_TRUE(ret == 0);
222         EXPECT_TRUE(req->actual > 0);
223         EXPECT_TRUE(req->status == USB_REQUEST_COMPLETED);
224         data = (uint8_t *)req->buf;
225         data[req->actual] = '\0';
226         if (strcmp((const char *)data, "q") == 0 || strcmp((const char *)data, "q\n") == 0) {
227             submitExit = 1;
228         }
229         printf("receive data from host: %s------\n", data);
230         ret = UsbFnFreeRequest(req);
231         EXPECT_TRUE(ret == HDF_SUCCESS);
232     }
233 }
234 
235 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestSync004, TestSize.Level1)
236 {
237     int32_t ret;
238     struct UsbFnRequest *req = nullptr;
239     EXPECT_NE(nullptr, g_acmDevice);
240     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
241     req = UsbFnAllocRequest(
242         g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, g_acmDevice->dataInPipe.maxPacketSize);
243     EXPECT_NE(nullptr, req);
244     printf("------send \"abc\" to host------\n");
245     memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc"));
246     req->length = strlen("abc");
247     ret = UsbFnSubmitRequestSync(req, 0);
248     EXPECT_TRUE(ret == 0);
249     EXPECT_TRUE(req->actual == strlen("abc"));
250     EXPECT_TRUE(req->status == USB_REQUEST_COMPLETED);
251     ret = UsbFnFreeRequest(req);
252     EXPECT_TRUE(ret == HDF_SUCCESS);
253 }
254 
255 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestSync005, TestSize.Level1)
256 {
257     int32_t ret;
258     int32_t loopTime = TEST_TIMES;
259     struct UsbFnRequest *req = nullptr;
260     EXPECT_NE(nullptr, g_acmDevice);
261     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
262     printf("------send \"abcdefg\" 10 times to host------\n");
263     while (loopTime > 0) {
264         req = UsbFnAllocRequest(
265             g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, g_acmDevice->dataInPipe.maxPacketSize);
266         EXPECT_NE(nullptr, req);
267         memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abcdefg", strlen("abcdefg"));
268         req->length = strlen("abcdefg");
269         ret = UsbFnSubmitRequestSync(req, 0);
270         EXPECT_TRUE(ret == 0);
271         EXPECT_TRUE(req->actual == strlen("abcdefg"));
272         EXPECT_TRUE(req->status == USB_REQUEST_COMPLETED);
273         ret = UsbFnFreeRequest(req);
274         EXPECT_TRUE(ret == HDF_SUCCESS);
275         loopTime--;
276     }
277 }
278 
279 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestSync006, TestSize.Level1)
280 {
281     struct UsbFnRequest *req = nullptr;
282     int32_t ret;
283     EXPECT_NE(nullptr, g_acmDevice);
284     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
285     printf("test sync timeout 5s:\n");
286     req = UsbFnAllocRequest(
287         g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
288     EXPECT_NE(nullptr, req);
289     ret = UsbFnSubmitRequestSync(req, SYNC_5000MS);
290     EXPECT_TRUE(ret != 0);
291     ret = UsbFnFreeRequest(req);
292     EXPECT_TRUE(ret == HDF_SUCCESS);
293 }
294 
295 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRequestSync007, TestSize.Level1)
296 {
297     struct UsbFnRequest *req = nullptr;
298     int32_t ret;
299     ret = UsbFnSubmitRequestSync(req, SYNC_5000MS);
300     EXPECT_TRUE(ret != 0);
301 }
302 
303 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfGetReqStatus001, TestSize.Level1)
304 {
305     int32_t ret;
306     UsbRequestStatus status;
307     struct UsbFnRequest *notifyReq = nullptr;
308     EXPECT_NE(nullptr, g_acmDevice);
309     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
310     notifyReq =
311         UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, sizeof(struct UsbCdcNotification));
312     EXPECT_TRUE(notifyReq != nullptr);
313     ret = UsbFnGetRequestStatus(notifyReq, &status);
314     EXPECT_TRUE(ret == HDF_SUCCESS);
315     EXPECT_TRUE(status >= USB_REQUEST_COMPLETED && status <= USB_REQUEST_OVERFLOW);
316     ret = UsbFnFreeRequest(notifyReq);
317     EXPECT_TRUE(ret == HDF_SUCCESS);
318 }
319 
320 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfGetReqStatus002, TestSize.Level1)
321 {
322     int32_t ret;
323     UsbRequestStatus status;
324     struct UsbFnRequest *notifyReq = nullptr;
325     EXPECT_NE(nullptr, g_acmDevice);
326     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
327     notifyReq = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, sizeof(struct UsbCdcNotification));
328     EXPECT_TRUE(notifyReq != nullptr);
329     ret = UsbFnGetRequestStatus(notifyReq, &status);
330     EXPECT_TRUE(ret == HDF_SUCCESS);
331     EXPECT_TRUE(status >= USB_REQUEST_COMPLETED && status <= USB_REQUEST_OVERFLOW);
332     ret = UsbFnFreeRequest(notifyReq);
333     EXPECT_TRUE(ret == HDF_SUCCESS);
334 }
335 
336 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfGetReqStatus003, TestSize.Level1)
337 {
338     int32_t ret;
339     struct UsbFnRequest *notifyReq = nullptr;
340     EXPECT_NE(nullptr, g_acmDevice);
341     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
342     notifyReq = UsbFnAllocRequest(
343         g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
344     EXPECT_TRUE(notifyReq != nullptr);
345     ret = UsbFnGetRequestStatus(notifyReq, nullptr);
346     EXPECT_TRUE(ret != HDF_SUCCESS);
347     ret = UsbFnFreeRequest(notifyReq);
348     EXPECT_TRUE(ret == HDF_SUCCESS);
349 }
350 
351 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfGetReqStatus004, TestSize.Level1)
352 {
353     int32_t ret;
354     UsbRequestStatus status;
355     struct UsbFnRequest *notifyReq = nullptr;
356     EXPECT_NE(nullptr, g_acmDevice);
357     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
358     notifyReq = UsbFnAllocRequest(
359         g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
360     EXPECT_TRUE(notifyReq != nullptr);
361     ret = UsbFnSubmitRequestAsync(notifyReq);
362     EXPECT_TRUE(ret == HDF_SUCCESS);
363     ret = UsbFnCancelRequest(notifyReq);
364     EXPECT_TRUE(ret == HDF_SUCCESS);
365     ret = UsbFnGetRequestStatus(notifyReq, &status);
366     EXPECT_TRUE(ret == HDF_SUCCESS);
367     EXPECT_TRUE(status >= USB_REQUEST_COMPLETED && status <= USB_REQUEST_OVERFLOW);
368     ret = UsbFnFreeRequest(notifyReq);
369     EXPECT_TRUE(ret == HDF_SUCCESS);
370 }
371 
372 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfGetReqStatus005, TestSize.Level1)
373 {
374     int32_t ret;
375     UsbRequestStatus status;
376     EXPECT_NE(nullptr, g_acmDevice);
377     ret = UsbFnGetRequestStatus(nullptr, &status);
378     EXPECT_TRUE(ret != HDF_SUCCESS);
379 }
380 
381 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfCancelReq001, TestSize.Level1)
382 {
383     int32_t ret;
384     EXPECT_NE(nullptr, g_acmDevice);
385     ret = UsbFnCancelRequest(nullptr);
386     EXPECT_TRUE(ret != HDF_SUCCESS);
387 }
388 
389 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfCancelReq002, TestSize.Level1)
390 {
391     int32_t ret;
392     struct UsbFnRequest *notifyReq = nullptr;
393     EXPECT_NE(nullptr, g_acmDevice);
394     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
395     notifyReq =
396         UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, sizeof(struct UsbCdcNotification));
397     EXPECT_TRUE(notifyReq != nullptr);
398     ret = UsbFnSubmitRequestAsync(notifyReq);
399     EXPECT_TRUE(ret == HDF_SUCCESS);
400     ret = UsbFnCancelRequest(notifyReq);
401     EXPECT_TRUE(ret == HDF_SUCCESS);
402     ret = UsbFnFreeRequest(notifyReq);
403     EXPECT_TRUE(ret == HDF_SUCCESS);
404 }
405 
406 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfCancelReq003, TestSize.Level1)
407 {
408     int32_t ret;
409     struct UsbFnRequest *req = nullptr;
410     EXPECT_NE(nullptr, g_acmDevice);
411     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
412     req = UsbFnAllocRequest(
413         g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, g_acmDevice->dataInPipe.maxPacketSize);
414     EXPECT_NE(nullptr, req);
415     req->complete = WriteComplete;
416     req->context = g_acmDevice;
417     g_acmDevice->submit = 0;
418     printf("------send \"abcdef\" to host------\n");
419     memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abcdef", strlen("abcdef"));
420     req->length = strlen("abcdef");
421     ret = UsbFnSubmitRequestAsync(req);
422     EXPECT_TRUE(ret == HDF_SUCCESS);
423     while (g_acmDevice->submit == 0) {
424         OsalMSleep(1);
425     }
426     g_acmDevice->submit = 0;
427     ret = UsbFnCancelRequest(req);
428     EXPECT_TRUE(ret != HDF_SUCCESS);
429     ret = UsbFnFreeRequest(req);
430     EXPECT_TRUE(ret == HDF_SUCCESS);
431 }
432 
433 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfCancelReq004, TestSize.Level1)
434 {
435     int32_t ret;
436     struct UsbFnRequest *req = nullptr;
437     EXPECT_NE(nullptr, g_acmDevice);
438     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
439     req = UsbFnAllocRequest(
440         g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
441     EXPECT_TRUE(req != nullptr);
442     ret = UsbFnSubmitRequestAsync(req);
443     EXPECT_TRUE(ret == HDF_SUCCESS);
444     ret = UsbFnCancelRequest(req);
445     EXPECT_TRUE(ret == HDF_SUCCESS);
446     ret = UsbFnFreeRequest(req);
447     EXPECT_TRUE(ret == HDF_SUCCESS);
448 }
449 
450 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfCancelReq005, TestSize.Level1)
451 {
452     int32_t ret;
453     struct UsbFnRequest *req = nullptr;
454     EXPECT_NE(nullptr, g_acmDevice);
455     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
456     req = UsbFnAllocRequest(
457         g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, g_acmDevice->dataInPipe.maxPacketSize);
458     EXPECT_TRUE(req != nullptr);
459     ret = UsbFnCancelRequest(req);
460     EXPECT_TRUE(ret != HDF_SUCCESS);
461     ret = UsbFnFreeRequest(req);
462     EXPECT_TRUE(ret == HDF_SUCCESS);
463 }
464 
465 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfCancelReq006, TestSize.Level1)
466 {
467     int32_t ret;
468     struct UsbFnRequest *req = nullptr;
469     EXPECT_NE(nullptr, g_acmDevice);
470     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
471     req = UsbFnAllocRequest(
472         g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
473     EXPECT_TRUE(req != nullptr);
474     ret = UsbFnCancelRequest(req);
475     EXPECT_TRUE(ret != HDF_SUCCESS);
476     ret = UsbFnFreeRequest(req);
477     EXPECT_TRUE(ret == HDF_SUCCESS);
478 }
479 
480 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfCancelReq007, TestSize.Level1)
481 {
482     int32_t ret;
483     struct UsbFnRequest *ctrlReq = nullptr;
484     EXPECT_NE(nullptr, g_acmDevice);
485     EXPECT_NE(nullptr, g_acmDevice->ctrlIface.handle);
486     ctrlReq = UsbFnAllocCtrlRequest(
487         g_acmDevice->ctrlIface.handle, sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
488     EXPECT_TRUE(ctrlReq != nullptr);
489     ret = UsbFnCancelRequest(ctrlReq);
490     EXPECT_TRUE(ret != HDF_SUCCESS);
491     ret = UsbFnFreeRequest(ctrlReq);
492     EXPECT_TRUE(ret == HDF_SUCCESS);
493 }
494 
495 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfCancelReq008, TestSize.Level1)
496 {
497     int32_t ret;
498     int32_t count = 0;
499     struct UsbFnRequest *req = nullptr;
500     EXPECT_NE(nullptr, g_acmDevice);
501     EXPECT_NE(nullptr, g_acmDevice->dataIface.handle);
502     for (count = 0; count < TEST_TIMES; count++) {
503         req = UsbFnAllocRequest(
504             g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize);
505         EXPECT_TRUE(req != nullptr);
506         ret = UsbFnSubmitRequestAsync(req);
507         EXPECT_TRUE(ret == HDF_SUCCESS);
508         ret = UsbFnCancelRequest(req);
509         EXPECT_TRUE(ret == HDF_SUCCESS);
510         ret = UsbFnFreeRequest(req);
511         EXPECT_TRUE(ret == HDF_SUCCESS);
512     }
513 }
514 
515 HWTEST_F(UsbDeviceSdkIoTest, CheckDeviceSdkIfRemoveDevice002, TestSize.Level1)
516 {
517     int32_t ret;
518 
519     EXPECT_NE(nullptr, g_acmDevice);
520     ReleaseAcmDevice(g_acmDevice);
521     EXPECT_NE(nullptr, g_acmDevice->fnDev);
522     ret = UsbFnRemoveDevice(g_acmDevice->fnDev);
523     EXPECT_EQ(HDF_SUCCESS, ret);
524     OsalMemFree(g_acmDevice);
525 }
526 } // namespace
527