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