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