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 <unistd.h>
19 #include <gtest/gtest.h>
20 extern "C" {
21 #include "usb_raw_sdk_if_test.h"
22 #include "hdf_base.h"
23 #include "hdf_log.h"
24 #include "osal_mem.h"
25 #include "osal_time.h"
26 #include "securec.h"
27 #include "hdf_usb_pnp_manage.h"
28 }
29
30 using namespace std;
31 using namespace testing::ext;
32
33 namespace {
34 class UsbRawSdkIfTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp();
39 void TearDown();
40 };
41
42 #define USB_RAW_IO_SLEEP_MS_TIME 500
43 #define USB_IO_THREAD_STACK_SIZE 8192
44
45 static struct UsbSession *g_session = NULL;
46 static struct AcmDevice *g_acm = NULL;
47 static struct AcmDevice g_deviceService;
48 static UsbRawHandle *g_devHandle = NULL;
49 static UsbRawDevice *g_dev = NULL;
50 static int32_t g_activeConfig;
51 static bool g_stopIoThreadFlag = false;
52
UsbIoThread(void * data)53 static int32_t UsbIoThread(void *data)
54 {
55 int32_t ret;
56 struct AcmDevice *acm = (struct AcmDevice *)data;
57
58 for (;;) {
59 if (acm == NULL) {
60 printf("%s:%d acm is NULL\n", __func__, __LINE__);
61 OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME);
62 continue;
63 }
64
65 if (acm->devHandle == NULL) {
66 printf("%s:%d acm->devHandle is NULL!\n", __func__, __LINE__);
67 OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME);
68 continue;
69 }
70
71 ret = UsbRawHandleRequests(acm->devHandle);
72 if (ret < 0) {
73 printf("%s:%d UsbRawHandleRequests faile, ret=%d \n", __func__, __LINE__, ret);
74 if (ret == HDF_DEV_ERR_NO_DEVICE) {
75 printf("%s:%d, ret=%d\n", __func__, __LINE__, ret);
76 OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME);
77 }
78 }
79
80 if (g_stopIoThreadFlag == true) {
81 printf("%s:%d\n", __func__, __LINE__);
82 g_stopIoThreadFlag = false;
83 break;
84 }
85 }
86
87 return HDF_SUCCESS;
88 }
89
90
UsbStartIo(struct AcmDevice * acm)91 static int32_t UsbStartIo(struct AcmDevice *acm)
92 {
93 struct OsalThreadParam threadCfg;
94 int32_t ret;
95
96 printf("%s start\n", __func__);
97
98 /* creat Io thread */
99 (void)memset_s(&threadCfg, sizeof(threadCfg), 0, sizeof(threadCfg));
100 threadCfg.name = (char *)("usb io thread");
101 threadCfg.priority = OSAL_THREAD_PRI_LOW;
102 threadCfg.stackSize = USB_IO_THREAD_STACK_SIZE;
103
104 ret = OsalThreadCreate(&acm->ioThread, \
105 (OsalThreadEntry)UsbIoThread, (void *)acm);
106 if (ret != HDF_SUCCESS) {
107 printf("%s:%d OsalThreadCreate faile, ret=%d \n", __func__, __LINE__, ret);
108 return ret;
109 }
110
111 ret = OsalThreadStart(&acm->ioThread, &threadCfg);
112 if (ret != HDF_SUCCESS) {
113 printf("%s:%d OsalThreadStart faile, ret=%d \n", __func__, __LINE__, ret);
114 return ret;
115 }
116
117 return HDF_SUCCESS;
118 }
119
UsbStopIo(struct AcmDevice * acm)120 static int32_t UsbStopIo(struct AcmDevice *acm)
121 {
122 int32_t ret;
123
124 HDF_LOGD("%{public}s:%{public}d", __func__, __LINE__);
125 if (g_stopIoThreadFlag == false) {
126 HDF_LOGD("%{public}s:%{public}d", __func__, __LINE__);
127 g_stopIoThreadFlag = true;
128 }
129 ret = OsalThreadDestroy(&acm->ioThread);
130 if (ret != HDF_SUCCESS) {
131 HDF_LOGE("%{public}s:%{public}d OsalThreadDestroy faile, ret=%{public}d ", __func__, __LINE__, ret);
132 return ret;
133 }
134
135 return HDF_SUCCESS;
136 }
137
SetUpTestCase()138 void UsbRawSdkIfTest::SetUpTestCase()
139 {
140 g_acm = &g_deviceService;
141 UsbStartIo(g_acm);
142 }
143
TearDownTestCase()144 void UsbRawSdkIfTest::TearDownTestCase()
145 {
146 g_acm = &g_deviceService;
147 if (UsbStopIo(g_acm) != HDF_SUCCESS) {
148 HDF_LOGW("%s:%d UsbStopIo error!", __func__, __LINE__);
149 }
150 }
151
SetUp()152 void UsbRawSdkIfTest::SetUp()
153 {
154 }
155
TearDown()156 void UsbRawSdkIfTest::TearDown()
157 {
158 }
159
AcmWriteBulkCallback(const void * requestArg)160 static void AcmWriteBulkCallback(const void *requestArg)
161 {
162 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
163
164 printf("%s:%d entry!", __func__, __LINE__);
165
166 if (req == NULL) {
167 printf("%s:%d req is NULL!", __func__, __LINE__);
168 return;
169 }
170 struct AcmWb *wb = (struct AcmWb *)req->userData;
171 if (wb == NULL) {
172 printf("%s:%d userData(wb) is NULL!", __func__, __LINE__);
173 return;
174 }
175
176 if (req->status != USB_REQUEST_COMPLETED) {
177 printf("%s: write req failed, status=%d", __func__, req->status);
178 }
179
180 wb->use = 0;
181 }
182
AcmReadBulkCallback(const void * requestArg)183 static void AcmReadBulkCallback(const void *requestArg)
184 {
185 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
186
187 printf("%s:%d entry!", __func__, __LINE__);
188
189 if (req == NULL) {
190 printf("%s:%d req is NULL!", __func__, __LINE__);
191 return;
192 }
193 struct AcmDevice *acm = (struct AcmDevice *)req->userData;
194 if (acm == NULL) {
195 printf("%s:%d userData(acm) is NULL!", __func__, __LINE__);
196 return;
197 }
198 size_t size = req->actualLength;
199
200 switch (req->status) {
201 case USB_REQUEST_COMPLETED:
202 HDF_LOGD("Bulk status: %{public}d+size:%{public}zu\n", req->status, size);
203 if (size) {
204 uint8_t *data = req->buffer;
205 uint32_t count;
206
207 OsalMutexLock(&acm->readLock);
208 if (DataFifoIsFull(&acm->port->readFifo)) {
209 DataFifoSkip(&acm->port->readFifo, size);
210 }
211 count = DataFifoWrite(&acm->port->readFifo, data, size);
212 if (count != size) {
213 printf("%s: write %u less than expected %zu", __func__, count, size);
214 }
215 OsalMutexUnlock(&acm->readLock);
216 }
217 break;
218 case USB_REQUEST_CANCELLED:
219 printf("%s: the request is cancelled", __func__);
220 break;
221 default:
222 printf("%s: the request is failed", __func__);
223 break;
224 }
225 }
226
AcmProcessNotification(struct AcmDevice * acm,unsigned char * buf)227 static void AcmProcessNotification(struct AcmDevice *acm, unsigned char *buf)
228 {
229 struct UsbCdcNotification *dr = (struct UsbCdcNotification *)buf;
230
231 printf("%s:%d entry!", __func__, __LINE__);
232
233 switch (dr->bNotificationType) {
234 case USB_DDK_CDC_NOTIFY_NETWORK_CONNECTION:
235 printf("%s - network connection: %d\n", __func__, dr->wValue);
236 break;
237 case USB_DDK_CDC_NOTIFY_SERIAL_STATE:
238 printf("the serial State change\n");
239 break;
240 default:
241 printf("%s-%d received: index %d len %d\n", __func__, dr->bNotificationType, dr->wIndex, dr->wLength);
242 }
243 }
244
AcmNotifyReqCallback(const void * requestArg)245 static void AcmNotifyReqCallback(const void *requestArg)
246 {
247 struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg;
248 if (req == NULL) {
249 return;
250 }
251 struct AcmDevice *acm = (struct AcmDevice *)req->userData;
252 if (acm == NULL) {
253 return;
254 }
255 struct UsbCdcNotification *dr = (struct UsbCdcNotification *)req->buffer;
256 if (dr == NULL) {
257 return;
258 }
259 unsigned int currentSize = req->actualLength;
260 unsigned int expectedSize, copySize, allocSize;
261 int32_t ret;
262 if (req->status != USB_REQUEST_COMPLETED)
263 goto EXIT;
264 if (acm->nbIndex)
265 dr = (struct UsbCdcNotification *)acm->notificationBuffer;
266 expectedSize = sizeof(struct UsbCdcNotification) + Le16ToCpu(dr->wLength);
267 if (currentSize < expectedSize) {
268 if (acm->nbSize < expectedSize) {
269 if (acm->nbSize) {
270 OsalMemFree(acm->notificationBuffer);
271 acm->nbSize = 0;
272 }
273 allocSize = expectedSize;
274 acm->notificationBuffer = (uint8_t *)OsalMemCalloc(allocSize);
275 if (!acm->notificationBuffer)
276 goto EXIT;
277 acm->nbSize = allocSize;
278 }
279 copySize = MIN(currentSize, expectedSize - acm->nbIndex);
280 ret = memcpy_s(&acm->notificationBuffer[acm->nbIndex], acm->nbSize - acm->nbIndex,
281 req->buffer, copySize);
282 if (ret) {
283 printf("memcpy_s fail\n");
284 }
285 acm->nbIndex += copySize;
286 currentSize = acm->nbIndex;
287 }
288 if (currentSize >= expectedSize) {
289 AcmProcessNotification(acm, (unsigned char *)dr);
290 acm->nbIndex = 0;
291 }
292 if (UsbRawSubmitRequest(req))
293 printf("%s - UsbRawSubmitRequest failed", __func__);
294 EXIT:
295 printf("%s:%d exit", __func__, __LINE__);
296 }
297
AcmWriteBufAlloc(struct AcmDevice * acm)298 static int32_t AcmWriteBufAlloc(struct AcmDevice *acm)
299 {
300 struct AcmWb *wb = &acm->wb[0];
301 int32_t i;
302
303 for (i = 0; i < ACM_NW; i++, wb++) {
304 wb->buf = (uint8_t *)OsalMemCalloc(acm->dataOutEp->maxPacketSize);
305 if (!wb->buf) {
306 while (i != 0) {
307 --i;
308 --wb;
309 OsalMemFree(wb->buf);
310 wb->buf = NULL;
311 }
312 return -HDF_ERR_MALLOC_FAIL;
313 }
314 }
315 return HDF_SUCCESS;
316 }
317
AcmCtrlReqCallback(const void * requestArg)318 static void AcmCtrlReqCallback(const void *requestArg)
319 {
320 printf("%s:%d entry!", __func__, __LINE__);
321 }
322
UsbParseConfigDescriptor(struct AcmDevice * acm,struct UsbRawConfigDescriptor * config)323 static int32_t UsbParseConfigDescriptor(struct AcmDevice *acm, struct UsbRawConfigDescriptor *config)
324 {
325 uint8_t numInterfaces;
326 uint8_t i;
327 uint8_t j;
328 int32_t ret;
329 uint8_t ifaceClass;
330 uint8_t numEndpoints;
331 const struct UsbRawInterface *interface = NULL;
332
333 numInterfaces = config->configDescriptor.bNumInterfaces;
334 printf("------numInterfaces = [%d]------\n", numInterfaces);
335 for (i = 0; i < numInterfaces; i++) {
336 interface = config->interface[i];
337 ifaceClass = interface->altsetting->interfaceDescriptor.bInterfaceClass;
338 numEndpoints = interface->altsetting->interfaceDescriptor.bNumEndpoints;
339
340 ret = UsbRawClaimInterface(acm->devHandle, i);
341 if (ret) {
342 printf("%s:%d claim interface %u failed\n", __func__, __LINE__, i);
343 continue;
344 }
345
346 switch (ifaceClass) {
347 case USB_DDK_CLASS_COMM:
348 acm->ctrlIface = i;
349 acm->notifyEp = (UsbEndpoint *)OsalMemAlloc(sizeof(struct UsbEndpoint));
350 if (acm->notifyEp == NULL) {
351 printf("%s:%d allocate endpoint failed\n", __func__, __LINE__);
352 return;
353 }
354 /* get the first endpoint by default */
355 acm->notifyEp->addr = interface->altsetting->endPoint[0].endpointDescriptor.bEndpointAddress;
356 acm->notifyEp->interval = interface->altsetting->endPoint[0].endpointDescriptor.bInterval;
357 acm->notifyEp->maxPacketSize = interface->altsetting->endPoint[0].endpointDescriptor.wMaxPacketSize;
358 break;
359 case USB_DDK_CLASS_CDC_DATA:
360 acm->dataIface = i;
361 for (j = 0; j < numEndpoints; j++) {
362 const struct UsbRawEndpointDescriptor *endPoint = &interface->altsetting->endPoint[j];
363
364 /* get bulk in endpoint */
365 if ((endPoint->endpointDescriptor.bEndpointAddress \
366 & USB_DDK_ENDPOINT_DIR_MASK) == USB_DDK_DIR_IN) {
367 acm->dataInEp = (UsbEndpoint *)OsalMemAlloc(sizeof(struct UsbEndpoint));
368 if (acm->dataInEp == NULL) {
369 printf("%s:%d allocate dataInEp failed\n", __func__, __LINE__);
370 break;
371 }
372 acm->dataInEp->addr = endPoint->endpointDescriptor.bEndpointAddress;
373 acm->dataInEp->interval = endPoint->endpointDescriptor.bInterval;
374 acm->dataInEp->maxPacketSize = endPoint->endpointDescriptor.wMaxPacketSize;
375 } else { /* get bulk out endpoint */
376 acm->dataOutEp = (UsbEndpoint *)OsalMemAlloc(sizeof(struct UsbEndpoint));
377 if (acm->dataOutEp == NULL) {
378 printf("%s:%d allocate dataOutEp failed\n", __func__, __LINE__);
379 break;
380 }
381 acm->dataOutEp->addr = endPoint->endpointDescriptor.bEndpointAddress;
382 acm->dataOutEp->interval = endPoint->endpointDescriptor.bInterval;
383 acm->dataOutEp->maxPacketSize = endPoint->endpointDescriptor.wMaxPacketSize;
384 }
385 }
386 break;
387 default:
388 printf("%s:%d wrong descriptor type\n", __func__, __LINE__);
389 break;
390 }
391 }
392
393 return HDF_SUCCESS;
394 }
395
396 /**
397 * @tc.number : CheckRawSdkIfInit001
398 * @tc.name :
399 * @tc.type : PERF
400 * @tc.level : Level 1
401 */
402 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfInit001, TestSize.Level1)
403 {
404 int32_t ret;
405
406 ret = UsbRawInit(&g_session);
407 EXPECT_EQ(HDF_SUCCESS, ret);
408 g_acm->session = g_session;
409 }
410
411 /**
412 * @tc.number : CheckRawSdkIfExit001
413 * @tc.name :
414 * @tc.type : PERF
415 * @tc.level : Level 1
416 */
417 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfExit001, TestSize.Level1)
418 {
419 int32_t ret;
420
421 ret = UsbRawExit(g_acm->session);
422 EXPECT_EQ(HDF_SUCCESS, ret);
423 }
424
425 /**
426 * @tc.number : CheckRawSdkIfInit002
427 * @tc.name :
428 * @tc.type : PERF
429 * @tc.level : Level 1
430 */
431 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfInit002, TestSize.Level1)
432 {
433 int32_t ret;
434
435 ret = UsbRawInit(NULL);
436 EXPECT_EQ(HDF_SUCCESS, ret);
437 g_acm->session = g_session;
438 }
439
440 /**
441 * @tc.number : CheckRawSdkIfExit002
442 * @tc.name :
443 * @tc.type : PERF
444 * @tc.level : Level 1
445 */
446 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfExit002, TestSize.Level1)
447 {
448 int32_t ret;
449
450 ret = UsbRawExit(NULL);
451 EXPECT_EQ(HDF_SUCCESS, ret);
452 }
453
454 /**
455 * @tc.number : CheckRawSdkIfInit003
456 * @tc.name :
457 * @tc.type : PERF
458 * @tc.level : Level 1
459 */
460 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfInit003, TestSize.Level1)
461 {
462 int32_t ret;
463 int32_t i;
464
465 for (i = 0; i < 100; i++)
466 {
467 ret = UsbRawInit(&g_session);
468 EXPECT_EQ(HDF_SUCCESS, ret);
469 g_acm->session = g_session;
470 ret = UsbRawExit(g_acm->session);
471 EXPECT_EQ(HDF_SUCCESS, ret);
472 }
473 }
474
475 /**
476 * @tc.number : CheckRawSdkIfInit004
477 * @tc.name :
478 * @tc.type : PERF
479 * @tc.level : Level 1
480 */
481 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfInit004, TestSize.Level1)
482 {
483 int32_t ret;
484 int32_t i;
485
486 for (i = 0; i < 100; i++)
487 {
488 ret = UsbRawInit(NULL);
489 EXPECT_EQ(HDF_SUCCESS, ret);
490 ret = UsbRawExit(NULL);
491 EXPECT_EQ(HDF_SUCCESS, ret);
492 }
493 }
494
495 /**
496 * @tc.number : CheckRawSdkIfInit005
497 * @tc.name :
498 * @tc.type : PERF
499 * @tc.level : Level 1
500 */
501 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfInit005, TestSize.Level1)
502 {
503 int32_t ret;
504
505 ret = UsbRawInit(&g_session);
506 EXPECT_EQ(HDF_SUCCESS, ret);
507 g_acm->session = g_session;
508 }
509
510 /**
511 * @tc.number : CheckRawSdkIfOpenDevice001
512 * @tc.name :
513 * @tc.type : PERF
514 * @tc.level : Level 1
515 */
516 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfOpenDevice001, TestSize.Level1)
517 {
518 g_acm->busNum = 1U;
519 g_acm->devAddr = 2U;
520
521 g_devHandle = UsbRawOpenDevice(NULL, g_acm->busNum, g_acm->devAddr);
522 EXPECT_EQ(nullptr, g_devHandle);
523 g_acm->devHandle = g_devHandle;
524 }
525
526 /**
527 * @tc.number : CheckRawSdkIfOpenDevice002
528 * @tc.name :
529 * @tc.type : PERF
530 * @tc.level : Level 1
531 */
532 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfOpenDevice002, TestSize.Level1)
533 {
534 g_acm->busNum = 1U;
535 g_acm->devAddr = 100U;
536
537 g_devHandle = UsbRawOpenDevice(g_acm->session, g_acm->busNum, g_acm->devAddr);
538 EXPECT_EQ(nullptr, g_devHandle);
539 g_acm->devHandle = g_devHandle;
540 }
541
542 /**
543 * @tc.number : CheckRawSdkIfOpenDevice003
544 * @tc.name :
545 * @tc.type : PERF
546 * @tc.level : Level 1
547 */
548 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfOpenDevice003, TestSize.Level1)
549 {
550 g_acm->busNum = 1U;
551 g_acm->devAddr = 255U;
552
553 g_devHandle = UsbRawOpenDevice(g_acm->session, g_acm->busNum, g_acm->devAddr);
554 EXPECT_EQ(nullptr, g_devHandle);
555 g_acm->devHandle = g_devHandle;
556 }
557
558 /**
559 * @tc.number : CheckRawSdkIfOpenDevice004
560 * @tc.name :
561 * @tc.type : PERF
562 * @tc.level : Level 1
563 */
564 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfOpenDevice004, TestSize.Level1)
565 {
566 g_acm->busNum = 100U;
567 g_acm->devAddr = 2U;
568
569 g_devHandle = UsbRawOpenDevice(g_acm->session, g_acm->busNum, g_acm->devAddr);
570 EXPECT_EQ(nullptr, g_devHandle);
571 g_acm->devHandle = g_devHandle;
572 }
573
574 /**
575 * @tc.number : CheckRawSdkIfOpenDevice005
576 * @tc.name :
577 * @tc.type : PERF
578 * @tc.level : Level 1
579 */
580 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfOpenDevice005, TestSize.Level1)
581 {
582 g_acm->busNum = 255U;
583 g_acm->devAddr = 2U;
584
585 g_devHandle = UsbRawOpenDevice(g_acm->session, g_acm->busNum, g_acm->devAddr);
586 EXPECT_EQ(nullptr, g_devHandle);
587 g_acm->devHandle = g_devHandle;
588 }
589
590 /**
591 * @tc.number : CheckRawSdkIfOpenDevice006
592 * @tc.name :
593 * @tc.type : PERF
594 * @tc.level : Level 1
595 */
596 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfOpenDevice006, TestSize.Level1)
597 {
598 g_acm->busNum = 1U;
599 g_acm->devAddr = 2U;
600
601 g_devHandle = UsbRawOpenDevice(g_acm->session, g_acm->busNum, g_acm->devAddr);
602 EXPECT_NE(nullptr, g_devHandle);
603 g_acm->devHandle = g_devHandle;
604 }
605
606 /**
607 * @tc.number : CheckRawSdkIfResetDevice001
608 * @tc.name :
609 * @tc.type : PERF
610 * @tc.level : Level 1
611 */
612 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfResetDevice001, TestSize.Level1)
613 {
614 int32_t ret;
615
616 ret = UsbRawResetDevice(NULL);
617 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
618 }
619
620 /**
621 * @tc.number : CheckRawSdkIfResetDevice002
622 * @tc.name :
623 * @tc.type : PERF
624 * @tc.level : Level 1
625 */
626 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfResetDevice002, TestSize.Level1)
627 {
628 int32_t ret;
629
630 ret = UsbRawResetDevice(g_acm->devHandle);
631 EXPECT_EQ(HDF_SUCCESS, ret);
632 }
633
634 /**
635 * @tc.number : CheckRawSdkIfCloseDevice001
636 * @tc.name :
637 * @tc.type : PERF
638 * @tc.level : Level 1
639 */
640 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfCloseDevice001, TestSize.Level1)
641 {
642 int32_t ret;
643
644 ret = UsbRawCloseDevice(NULL);
645 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
646 }
647
648 /**
649 * @tc.number : CheckRawSdkIfCloseDevice002
650 * @tc.name :
651 * @tc.type : PERF
652 * @tc.level : Level 1
653 */
654 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfCloseDevice002, TestSize.Level1)
655 {
656 int32_t ret;
657
658 ret = UsbRawCloseDevice(g_acm->devHandle);
659 EXPECT_EQ(HDF_SUCCESS, ret);
660 }
661
662 /**
663 * @tc.number : CheckRawSdkIfOpenDevice007
664 * @tc.name :
665 * @tc.type : PERF
666 * @tc.level : Level 1
667 */
668 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfOpenDevice007, TestSize.Level1)
669 {
670 g_acm->busNum = 1U;
671 g_acm->devAddr = 2U;
672
673 g_devHandle = UsbRawOpenDevice(g_session, g_acm->busNum, g_acm->devAddr);
674 EXPECT_NE(nullptr, g_devHandle);
675 g_acm->devHandle = g_devHandle;
676 }
677
678 /**
679 * @tc.number : CheckRawSdkIfGetConfiguration001
680 * @tc.name :
681 * @tc.type : PERF
682 * @tc.level : Level 1
683 */
684 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetConfiguration001, TestSize.Level1)
685 {
686 int32_t ret;
687
688 ret = UsbRawGetConfiguration(NULL, &g_activeConfig);
689 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
690 }
691
692 /**
693 * @tc.number : CheckRawSdkIfGetConfiguration002
694 * @tc.name :
695 * @tc.type : PERF
696 * @tc.level : Level 1
697 */
698 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetConfiguration002, TestSize.Level1)
699 {
700 int32_t ret;
701
702 ret = UsbRawGetConfiguration(g_acm->devHandle, NULL);
703 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
704 }
705
706 /**
707 * @tc.number : CheckRawSdkIfGetConfiguration003
708 * @tc.name :
709 * @tc.type : PERF
710 * @tc.level : Level 1
711 */
712 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetConfiguration003, TestSize.Level1)
713 {
714 int32_t ret;
715
716 ret = UsbRawGetConfiguration(NULL, NULL);
717 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
718 }
719
720 /**
721 * @tc.number : CheckRawSdkIfGetConfiguration004
722 * @tc.name :
723 * @tc.type : PERF
724 * @tc.level : Level 1
725 */
726 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetConfiguration004, TestSize.Level1)
727 {
728 int32_t ret;
729
730 ret = UsbRawGetConfiguration(g_acm->devHandle, &g_activeConfig);
731 printf("------activeConfig = [%d]------\n", g_activeConfig);
732 EXPECT_EQ(HDF_SUCCESS, ret);
733 }
734
735
736 /**
737 * @tc.number : CheckRawSdkIfGetDevice001
738 * @tc.name :
739 * @tc.type : PERF
740 * @tc.level : Level 1
741 */
742 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDevice001, TestSize.Level1)
743 {
744 g_dev = UsbRawGetDevice(NULL);
745 EXPECT_EQ(nullptr, g_dev);
746 }
747
748 /**
749 * @tc.number : CheckRawSdkIfGetDevice002
750 * @tc.name :
751 * @tc.type : PERF
752 * @tc.level : Level 1
753 */
754 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDevice002, TestSize.Level1)
755 {
756 g_dev = UsbRawGetDevice(g_acm->devHandle);
757 EXPECT_NE(nullptr, g_dev);
758 }
759
760 /**
761 * @tc.number : CheckRawSdkIfGetConfigDescriptor001
762 * @tc.name :
763 * @tc.type : PERF
764 * @tc.level : Level 1
765 */
766 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetConfigDescriptor001, TestSize.Level1)
767 {
768 int32_t ret;
769
770 ret = UsbRawGetConfigDescriptor(NULL, g_activeConfig, &g_acm->config);
771 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
772 }
773
774 /**
775 * @tc.number : CheckRawSdkIfGetConfigDescriptor002
776 * @tc.name :
777 * @tc.type : PERF
778 * @tc.level : Level 1
779 */
780 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetConfigDescriptor002, TestSize.Level1)
781 {
782 int32_t ret;
783
784 ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, NULL);
785 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
786 }
787
788 /**
789 * @tc.number : CheckRawSdkIfGetConfigDescriptor003
790 * @tc.name :
791 * @tc.type : PERF
792 * @tc.level : Level 1
793 */
794 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetConfigDescriptor003, TestSize.Level1)
795 {
796 int32_t ret;
797
798 ret = UsbRawGetConfigDescriptor(NULL, g_activeConfig, NULL);
799 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
800 }
801
802 /**
803 * @tc.number : CheckRawSdkIfGetConfigDescriptor004
804 * @tc.name :
805 * @tc.type : PERF
806 * @tc.level : Level 1
807 */
808 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetConfigDescriptor004, TestSize.Level1)
809 {
810 int32_t ret;
811
812 printf("------activeConfig = [%d]------\n", g_activeConfig);
813 ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, &g_acm->config);
814 EXPECT_EQ(HDF_SUCCESS, ret);
815 }
816
817 /**
818 * @tc.number : CheckRawSdkIfSetConfiguration001
819 * @tc.name :
820 * @tc.type : PERF
821 * @tc.level : Level 1
822 */
823 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfSetConfiguration001, TestSize.Level1)
824 {
825 int32_t ret;
826 int32_t config = 0;
827
828 ret = UsbRawSetConfiguration(NULL, config);
829 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
830 }
831
832 /**
833 * @tc.number : CheckRawSdkIfSetConfiguration002
834 * @tc.name :
835 * @tc.type : PERF
836 * @tc.level : Level 1
837 */
838 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfSetConfiguration002, TestSize.Level1)
839 {
840 int32_t ret;
841 int32_t config = 0;
842
843 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
844 EXPECT_EQ(HDF_SUCCESS, ret);
845 }
846
847 /**
848 * @tc.number : CheckRawSdkIfSetConfiguration003
849 * @tc.name :
850 * @tc.type : PERF
851 * @tc.level : Level 1
852 */
853 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfSetConfiguration003, TestSize.Level1)
854 {
855 int32_t ret;
856 int32_t config = 1;
857
858 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
859 EXPECT_EQ(HDF_SUCCESS, ret);
860 }
861
862 /**
863 * @tc.number : CheckRawSdkIfSetConfiguration004
864 * @tc.name :
865 * @tc.type : PERF
866 * @tc.level : Level 1
867 */
868 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfSetConfiguration004, TestSize.Level1)
869 {
870 int32_t ret;
871 int32_t config = 10;
872
873 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
874 EXPECT_EQ(HDF_FAILURE, ret);
875 }
876
877 /**
878 * @tc.number : CheckRawSdkIfSetConfiguration005
879 * @tc.name :
880 * @tc.type : PERF
881 * @tc.level : Level 1
882 */
883 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfSetConfiguration005, TestSize.Level1)
884 {
885 int32_t ret;
886 int32_t config = 100;
887
888 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
889 EXPECT_EQ(HDF_FAILURE, ret);
890 }
891
892 /**
893 * @tc.number : CheckRawSdkIfSetConfiguration006
894 * @tc.name :
895 * @tc.type : PERF
896 * @tc.level : Level 1
897 */
898 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfSetConfiguration006, TestSize.Level1)
899 {
900 int32_t ret;
901 int32_t config = 200;
902
903 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
904 EXPECT_EQ(HDF_FAILURE, ret);
905 }
906
907 /**
908 * @tc.number : CheckRawSdkIfSetConfiguration007
909 * @tc.name :
910 * @tc.type : PERF
911 * @tc.level : Level 1
912 */
913 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfSetConfiguration007, TestSize.Level1)
914 {
915 int32_t ret;
916 int32_t config = 255;
917
918 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
919 EXPECT_EQ(HDF_FAILURE, ret);
920 }
921
922 /**
923 * @tc.number : CheckRawSdkIfSetConfiguration008
924 * @tc.name :
925 * @tc.type : PERF
926 * @tc.level : Level 1
927 */
928 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfSetConfiguration008, TestSize.Level1)
929 {
930 int32_t ret;
931 int32_t config = 1;
932
933 ret = UsbRawSetConfiguration(g_acm->devHandle, config);
934 EXPECT_EQ(HDF_SUCCESS, ret);
935 }
936
937 /**
938 * @tc.number : CheckRawSdkIfGetDeviceDescriptor001
939 * @tc.name :
940 * @tc.type : PERF
941 * @tc.level : Level 1
942 */
943 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDeviceDescriptor001, TestSize.Level1)
944 {
945 struct UsbDeviceDescriptor desc;
946 int32_t ret;
947
948 ret = UsbRawGetDeviceDescriptor(NULL, &desc);
949 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
950 }
951
952 /**
953 * @tc.number : CheckRawSdkIfGetDeviceDescriptor002
954 * @tc.name :
955 * @tc.type : PERF
956 * @tc.level : Level 1
957 */
958 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDeviceDescriptor002, TestSize.Level1)
959 {
960 int32_t ret;
961
962 ret = UsbRawGetDeviceDescriptor(g_dev, NULL);
963 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
964 }
965
966 /**
967 * @tc.number : CheckRawSdkIfGetDeviceDescriptor003
968 * @tc.name :
969 * @tc.type : PERF
970 * @tc.level : Level 1
971 */
972 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDeviceDescriptor003, TestSize.Level1)
973 {
974 int32_t ret;
975
976 ret = UsbRawGetDeviceDescriptor(NULL, NULL);
977 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
978 }
979
980 /**
981 * @tc.number : CheckRawSdkIfGetDeviceDescriptor004
982 * @tc.name :
983 * @tc.type : PERF
984 * @tc.level : Level 1
985 */
986 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDeviceDescriptor004, TestSize.Level1)
987 {
988 struct UsbDeviceDescriptor desc;
989 int32_t ret;
990
991 ret = UsbRawGetDeviceDescriptor(g_dev, &desc);
992 EXPECT_EQ(HDF_SUCCESS, ret);
993 }
994
995 /**
996 * @tc.number : CheckRawSdkIfGetConfigDescriptor005
997 * @tc.name :
998 * @tc.type : PERF
999 * @tc.level : Level 1
1000 */
1001 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetConfigDescriptor005, TestSize.Level1)
1002 {
1003 int32_t ret;
1004
1005 printf("------activeConfig = [%d]------\n", g_activeConfig);
1006 ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, &g_acm->config);
1007 EXPECT_EQ(HDF_SUCCESS, ret);
1008 }
1009
1010 /**
1011 * @tc.number : CheckRawSdkIfGetDeviceDescriptor005
1012 * @tc.name :
1013 * @tc.type : PERF
1014 * @tc.level : Level 1
1015 */
1016 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDeviceDescriptor005, TestSize.Level1)
1017 {
1018 struct UsbDeviceDescriptor desc;
1019 int32_t ret;
1020
1021 ret = UsbRawGetDeviceDescriptor(g_dev, &desc);
1022 EXPECT_EQ(HDF_SUCCESS, ret);
1023 }
1024
1025 /**
1026 * @tc.number : CheckRawSdkIfClaimInterface001
1027 * @tc.name :
1028 * @tc.type : PERFs
1029 * @tc.level : Level 1
1030 */
1031 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfClaimInterface001, TestSize.Level1)
1032 {
1033 int32_t ret;
1034 int32_t interfaceNumber = 1;
1035
1036 ret = UsbRawClaimInterface(NULL, interfaceNumber);
1037 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1038 }
1039
1040 /**
1041 * @tc.number : CheckRawSdkIfClaimInterface002
1042 * @tc.name :
1043 * @tc.type : PERFs
1044 * @tc.level : Level 1
1045 */
1046 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfClaimInterface002, TestSize.Level1)
1047 {
1048 int32_t ret;
1049 int32_t interfaceNumber = 1;
1050
1051 ret = UsbRawClaimInterface(g_devHandle, interfaceNumber);
1052 EXPECT_EQ(HDF_SUCCESS, ret);
1053 }
1054
1055 /**
1056 * @tc.number : CheckRawSdkIfClaimInterface003
1057 * @tc.name :
1058 * @tc.type : PERFs
1059 * @tc.level : Level 1
1060 */
1061 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfClaimInterface003, TestSize.Level1)
1062 {
1063 int32_t ret;
1064 int32_t interfaceNumber = 0;
1065
1066 ret = UsbRawClaimInterface(g_devHandle, interfaceNumber);
1067 EXPECT_EQ(HDF_SUCCESS, ret);
1068 }
1069
1070 /**
1071 * @tc.number : CheckRawSdkIfClaimInterface004
1072 * @tc.name :
1073 * @tc.type : PERFs
1074 * @tc.level : Level 1
1075 */
1076 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfClaimInterface004, TestSize.Level1)
1077 {
1078 int32_t ret;
1079 int32_t interfaceNumber = 255;
1080
1081 ret = UsbRawClaimInterface(g_devHandle, interfaceNumber);
1082 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1083 }
1084
1085 /**
1086 * @tc.number : CheckRawSdkIfClaimInterface005
1087 * @tc.name :
1088 * @tc.type : PERFs
1089 * @tc.level : Level 1
1090 */
1091 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfClaimInterface005, TestSize.Level1)
1092 {
1093 int32_t ret;
1094
1095 ret = UsbParseConfigDescriptor(g_acm, g_acm->config);
1096 EXPECT_EQ(HDF_SUCCESS, ret);
1097 }
1098
1099 /**
1100 * @tc.number : CheckRawSdkIfReleaseInterface001
1101 * @tc.name :
1102 * @tc.type : PERFs
1103 * @tc.level : Level 1
1104 */
1105 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfReleaseInterface001, TestSize.Level1)
1106 {
1107 int32_t ret;
1108
1109 ret = UsbRawReleaseInterface(NULL, g_acm->ctrlIface);
1110 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1111 }
1112
1113 /**
1114 * @tc.number : CheckRawSdkIfReleaseInterface002
1115 * @tc.name :
1116 * @tc.type : PERFs
1117 * @tc.level : Level 1
1118 */
1119 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfReleaseInterface002, TestSize.Level1)
1120 {
1121 int32_t ret;
1122
1123 ret = UsbRawReleaseInterface(g_acm->devHandle, g_acm->ctrlIface);
1124 EXPECT_EQ(HDF_SUCCESS, ret);
1125 }
1126
1127 /**
1128 * @tc.number : CheckRawSdkIfReleaseInterface003
1129 * @tc.name :
1130 * @tc.type : PERFs
1131 * @tc.level : Level 1
1132 */
1133 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfReleaseInterface003, TestSize.Level1)
1134 {
1135 int32_t ret;
1136
1137 ret = UsbRawReleaseInterface(NULL, g_acm->dataIface);
1138 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1139 }
1140
1141 /**
1142 * @tc.number : CheckRawSdkIfReleaseInterface004
1143 * @tc.name :
1144 * @tc.type : PERFs
1145 * @tc.level : Level 1
1146 */
1147 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfReleaseInterface004, TestSize.Level1)
1148 {
1149 int32_t ret;
1150
1151 ret = UsbRawReleaseInterface(g_acm->devHandle, g_acm->dataIface);
1152 EXPECT_EQ(HDF_SUCCESS, ret);
1153 }
1154
1155 /**
1156 * @tc.number : CheckRawSdkIfClaimInterface006
1157 * @tc.name :
1158 * @tc.type : PERFs
1159 * @tc.level : Level 1
1160 */
1161 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfClaimInterface006, TestSize.Level1)
1162 {
1163 int32_t ret;
1164
1165 ret = UsbParseConfigDescriptor(g_acm, g_acm->config);
1166 EXPECT_EQ(HDF_SUCCESS, ret);
1167 }
1168
1169 /**
1170 * @tc.number : CheckRawSdkIfAllocRequest001
1171 * @tc.name :
1172 * @tc.type : PERFs
1173 * @tc.level : Level 1
1174 */
1175 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfAllocRequest001, TestSize.Level1)
1176 {
1177 int32_t i;
1178 int32_t ret;
1179
1180 ret = AcmWriteBufAlloc(g_acm);
1181 EXPECT_EQ(HDF_SUCCESS, ret);
1182
1183 for (i = 0; i < ACM_NW; i++) {
1184 g_acm->wb[i].request = UsbRawAllocRequest(NULL, 0, g_acm->dataOutEp->maxPacketSize);
1185 g_acm->wb[i].instance = g_acm;
1186 EXPECT_EQ(nullptr, g_acm->wb[i].request);
1187 }
1188 }
1189
1190 /**
1191 * @tc.number : CheckRawSdkIfAllocRequest002
1192 * @tc.name :
1193 * @tc.type : PERFs
1194 * @tc.level : Level 1
1195 */
1196 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfAllocRequest002, TestSize.Level1)
1197 {
1198 int32_t i;
1199 int32_t ret;
1200
1201 ret = AcmWriteBufAlloc(g_acm);
1202 EXPECT_EQ(HDF_SUCCESS, ret);
1203
1204 for (i = 0; i < ACM_NW; i++) {
1205 g_acm->wb[i].request = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataOutEp->maxPacketSize);
1206 g_acm->wb[i].instance = g_acm;
1207 ((struct UsbHostRequest *)(g_acm->wb[i].request))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
1208 EXPECT_NE(nullptr, g_acm->wb[i].request);
1209 }
1210 }
1211
1212 /**
1213 * @tc.number : CheckRawSdkIfAllocRequest003
1214 * @tc.name :
1215 * @tc.type : PERFs
1216 * @tc.level : Level 1
1217 */
1218 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfAllocRequest003, TestSize.Level1)
1219 {
1220 int32_t i;
1221
1222 for (i = 0; i < ACM_NR; i++) {
1223 g_acm->readReq[i] = UsbRawAllocRequest(NULL, 0, g_acm->dataInEp->maxPacketSize);
1224 EXPECT_EQ(nullptr, g_acm->readReq[i]);
1225 }
1226 }
1227
1228 /**
1229 * @tc.number : CheckRawSdkIfAllocRequest004
1230 * @tc.name :
1231 * @tc.type : PERFs
1232 * @tc.level : Level 1
1233 */
1234 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfAllocRequest004, TestSize.Level1)
1235 {
1236 int32_t i;
1237
1238 for (i = 0; i < ACM_NR; i++) {
1239 g_acm->readReq[i] = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataInEp->maxPacketSize);
1240 ((struct UsbHostRequest *)(g_acm->readReq[i]))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
1241 EXPECT_NE(nullptr, g_acm->readReq[i]);
1242 }
1243 }
1244
1245 /**
1246 * @tc.number : CheckRawSdkIfAllocRequest005
1247 * @tc.name :
1248 * @tc.type : PERFs
1249 * @tc.level : Level 1
1250 */
1251 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfAllocRequest005, TestSize.Level1)
1252 {
1253 g_acm->ctrlReq = UsbRawAllocRequest(NULL, 0, USB_CTRL_REQ_SIZE);
1254 EXPECT_EQ(nullptr, g_acm->ctrlReq);
1255 }
1256
1257 /**
1258 * @tc.number : CheckRawSdkIfAllocRequest006
1259 * @tc.name :
1260 * @tc.type : PERFs
1261 * @tc.level : Level 1
1262 */
1263 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfAllocRequest006, TestSize.Level1)
1264 {
1265 g_acm->ctrlReq = UsbRawAllocRequest(g_acm->devHandle, 0, USB_CTRL_REQ_SIZE);
1266 ((struct UsbHostRequest *)(g_acm->ctrlReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
1267 EXPECT_NE(nullptr, g_acm->ctrlReq);
1268 }
1269
1270 /**
1271 * @tc.number : CheckRawSdkIfAllocRequest007
1272 * @tc.name :
1273 * @tc.type : PERFs
1274 * @tc.level : Level 1
1275 */
1276 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfAllocRequest007, TestSize.Level1)
1277 {
1278 g_acm->notifyReq = UsbRawAllocRequest(NULL, 0, g_acm->notifyEp->maxPacketSize);
1279 EXPECT_EQ(nullptr, g_acm->notifyReq);
1280 }
1281
1282 /**
1283 * @tc.number : CheckRawSdkIfAllocRequest008
1284 * @tc.name :
1285 * @tc.type : PERFs
1286 * @tc.level : Level 1
1287 */
1288 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfAllocRequest008, TestSize.Level1)
1289 {
1290 g_acm->notifyReq = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->notifyEp->maxPacketSize);
1291 ((struct UsbHostRequest *)(g_acm->notifyReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle;
1292 EXPECT_NE(nullptr, g_acm->notifyReq);
1293 }
1294
1295 /**
1296 * @tc.number : CheckRawSdkIfFreeRequest001
1297 * @tc.name :
1298 * @tc.type : PERFs
1299 * @tc.level : Level 1
1300 */
1301 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFreeRequest001, TestSize.Level1)
1302 {
1303 int32_t ret;
1304 int32_t i;
1305
1306 for (i = 0; i < ACM_NW; i++) {
1307 ret = UsbRawFreeRequest(g_acm->wb[i].request);
1308 EXPECT_EQ(HDF_SUCCESS, ret);
1309 }
1310 }
1311
1312 /**
1313 * @tc.number : CheckRawSdkIfFreeRequest002
1314 * @tc.name :
1315 * @tc.type : PERFs
1316 * @tc.level : Level 1
1317 */
1318 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFreeRequest002, TestSize.Level1)
1319 {
1320 int32_t ret;
1321 int32_t i;
1322
1323 for (i = 0; i < ACM_NW; i++) {
1324 ret = UsbRawFreeRequest(g_acm->readReq[i]);
1325 EXPECT_EQ(HDF_SUCCESS, ret);
1326 }
1327 }
1328
1329 /**
1330 * @tc.number : CheckRawSdkIfFreeRequest003
1331 * @tc.name :
1332 * @tc.type : PERFs
1333 * @tc.level : Level 1
1334 */
1335 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFreeRequest003, TestSize.Level1)
1336 {
1337 int32_t ret;
1338
1339 ret = UsbRawFreeRequest(g_acm->ctrlReq);
1340 EXPECT_EQ(HDF_SUCCESS, ret);
1341 }
1342
1343 /**
1344 * @tc.number : CheckRawSdkIfFreeRequest004
1345 * @tc.name :
1346 * @tc.type : PERFs
1347 * @tc.level : Level 1
1348 */
1349 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFreeRequest004, TestSize.Level1)
1350 {
1351 int32_t ret;
1352
1353 ret = UsbRawFreeRequest(g_acm->notifyReq);
1354 EXPECT_EQ(HDF_SUCCESS, ret);
1355 }
1356
1357 /**
1358 * @tc.number : CheckRawSdkIfFreeRequest005
1359 * @tc.name :
1360 * @tc.type : PERFs
1361 * @tc.level : Level 1
1362 */
1363 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFreeRequest005, TestSize.Level1)
1364 {
1365 int32_t ret;
1366
1367 ret = UsbRawFreeRequest(NULL);
1368 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1369 }
1370
1371 /**
1372 * @tc.number : CheckRawSdkIfAllocRequest009
1373 * @tc.name :
1374 * @tc.type : PERFs
1375 * @tc.level : Level 1
1376 */
1377 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfAllocRequest009, TestSize.Level1)
1378 {
1379 int32_t i;
1380
1381 for (i = 0; i < ACM_NW; i++) {
1382 g_acm->wb[i].request = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataOutEp->maxPacketSize);
1383 g_acm->wb[i].instance = g_acm;
1384 EXPECT_NE(nullptr, g_acm->wb[i].request);
1385 }
1386
1387 for (i = 0; i < ACM_NR; i++) {
1388 g_acm->readReq[i] = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataInEp->maxPacketSize);
1389 EXPECT_NE(nullptr, g_acm->readReq[i]);
1390 }
1391
1392 g_acm->ctrlReq = UsbRawAllocRequest(g_acm->devHandle, 0, USB_CTRL_REQ_SIZE);
1393 EXPECT_NE(nullptr, g_acm->ctrlReq);
1394
1395 g_acm->notifyReq = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->notifyEp->maxPacketSize);
1396 EXPECT_NE(nullptr, g_acm->notifyReq);
1397 }
1398
1399 /**
1400 * @tc.number : CheckRawSdkIfGetDescriptor001
1401 * @tc.name :
1402 * @tc.type : PERF
1403 * @tc.level : Level 1
1404 */
1405 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor001, TestSize.Level1)
1406 {
1407 UsbRawDescriptorParam param;
1408 unsigned char data[100];
1409 int32_t ret;
1410
1411 ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, ¶m, data);
1412 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1413 }
1414
1415 /**
1416 * @tc.number : CheckRawSdkIfGetDescriptor002
1417 * @tc.name :
1418 * @tc.type : PERF
1419 * @tc.level : Level 1
1420 */
1421 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor002, TestSize.Level1)
1422 {
1423 UsbRawDescriptorParam param;
1424 unsigned char data[100];
1425 int32_t ret;
1426
1427 ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, ¶m, data);
1428 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1429 }
1430
1431 /**
1432 * @tc.number : CheckRawSdkIfGetDescriptor003
1433 * @tc.name :
1434 * @tc.type : PERF
1435 * @tc.level : Level 1
1436 */
1437 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor003, TestSize.Level1)
1438 {
1439 UsbRawDescriptorParam param;
1440 unsigned char data[100];
1441 int32_t ret;
1442
1443 ret = UsbRawGetDescriptor(NULL, NULL, ¶m, data);
1444 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1445 }
1446
1447 /**
1448 * @tc.number : CheckRawSdkIfGetDescriptor004
1449 * @tc.name :
1450 * @tc.type : PERF
1451 * @tc.level : Level 1
1452 */
1453 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor004, TestSize.Level1)
1454 {
1455 unsigned char data[100];
1456 int32_t ret;
1457
1458 ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, NULL, data);
1459 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1460 }
1461
1462 /**
1463 * @tc.number : CheckRawSdkIfGetDescriptor005
1464 * @tc.name :
1465 * @tc.type : PERF
1466 * @tc.level : Level 1
1467 */
1468 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor005, TestSize.Level1)
1469 {
1470 UsbRawDescriptorParam param;
1471 int32_t ret;
1472
1473 ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, ¶m, NULL);
1474 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1475 }
1476
1477 /**
1478 * @tc.number : CheckRawSdkIfGetDescriptor006
1479 * @tc.name :
1480 * @tc.type : PERF
1481 * @tc.level : Level 1
1482 */
1483 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor006, TestSize.Level1)
1484 {
1485 UsbRawDescriptorParam param;
1486 unsigned char data[100];
1487 int32_t ret;
1488
1489 param.descType = 0;
1490 param.descIndex = 0;
1491 param.length = sizeof(data);
1492
1493 ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, ¶m, data);
1494 EXPECT_EQ(HDF_ERR_IO, ret);
1495 }
1496
1497 /**
1498 * @tc.number : CheckRawSdkIfGetDescriptor007
1499 * @tc.name :
1500 * @tc.type : PERF
1501 * @tc.level : Level 1
1502 */
1503 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor007, TestSize.Level1)
1504 {
1505 unsigned char data[100];
1506 int32_t ret;
1507
1508 ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, NULL, data);
1509 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1510 }
1511
1512 /**
1513 * @tc.number : CheckRawSdkIfGetDescriptor008
1514 * @tc.name :
1515 * @tc.type : PERF
1516 * @tc.level : Level 1
1517 */
1518 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor008, TestSize.Level1)
1519 {
1520 int32_t ret;
1521
1522 ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, NULL, NULL);
1523 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1524 }
1525
1526 /**
1527 * @tc.number : CheckRawSdkIfGetDescriptor009
1528 * @tc.name :
1529 * @tc.type : PERF
1530 * @tc.level : Level 1
1531 */
1532 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor009, TestSize.Level1)
1533 {
1534 unsigned char data[100];
1535 int32_t ret;
1536
1537 ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, NULL, data);
1538 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1539 }
1540
1541 /**
1542 * @tc.number : CheckRawSdkIfGetDescriptor010
1543 * @tc.name :
1544 * @tc.type : PERF
1545 * @tc.level : Level 1
1546 */
1547 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor010, TestSize.Level1)
1548 {
1549 UsbRawDescriptorParam param;
1550 unsigned char data[100];
1551 int32_t ret;
1552
1553 param.descType = 0;
1554 param.descIndex = 0;
1555 param.length = sizeof(data);
1556
1557 ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, ¶m, NULL);
1558 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1559 }
1560
1561 /**
1562 * @tc.number : CheckRawSdkIfGetDescriptor011
1563 * @tc.name :
1564 * @tc.type : PERF
1565 * @tc.level : Level 1
1566 */
1567 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor011, TestSize.Level1)
1568 {
1569 UsbRawDescriptorParam param;
1570 unsigned char data[100];
1571 int32_t ret;
1572
1573 param.descType = 0;
1574 param.descIndex = 0;
1575 param.length = sizeof(data);
1576
1577 ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, ¶m, NULL);
1578 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1579 }
1580
1581 /**
1582 * @tc.number : CheckRawSdkIfGetDescriptor012
1583 * @tc.name :
1584 * @tc.type : PERF
1585 * @tc.level : Level 1
1586 */
1587 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor012, TestSize.Level1)
1588 {
1589 unsigned char data[100];
1590 int32_t ret;
1591
1592 ret = UsbRawGetDescriptor(NULL, NULL, NULL, data);
1593 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1594 }
1595
1596 /**
1597 * @tc.number : CheckRawSdkIfGetDescriptor013
1598 * @tc.name :
1599 * @tc.type : PERF
1600 * @tc.level : Level 1
1601 */
1602 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor013, TestSize.Level1)
1603 {
1604 UsbRawDescriptorParam param;
1605 unsigned char data[100];
1606 int32_t ret;
1607
1608 param.descType = 0;
1609 param.descIndex = 0;
1610 param.length = sizeof(data);
1611
1612 ret = UsbRawGetDescriptor(NULL, NULL, ¶m, NULL);
1613 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1614 }
1615
1616 /**
1617 * @tc.number : CheckRawSdkIfGetDescriptor014
1618 * @tc.name :
1619 * @tc.type : PERF
1620 * @tc.level : Level 1
1621 */
1622 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor014, TestSize.Level1)
1623 {
1624 int32_t ret;
1625
1626 ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, NULL, NULL);
1627 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1628 }
1629
1630 /**
1631 * @tc.number : CheckRawSdkIfGetDescriptor015
1632 * @tc.name :
1633 * @tc.type : PERF
1634 * @tc.level : Level 1
1635 */
1636 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor015, TestSize.Level1)
1637 {
1638 int32_t ret;
1639
1640 ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, NULL, NULL);
1641 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1642 }
1643
1644 /**
1645 * @tc.number : CheckRawSdkIfGetDescriptor016
1646 * @tc.name :
1647 * @tc.type : PERF
1648 * @tc.level : Level 1
1649 */
1650 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfGetDescriptor016, TestSize.Level1)
1651 {
1652 int32_t ret;
1653
1654 ret = UsbRawGetDescriptor(NULL, NULL, NULL, NULL);
1655 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1656 }
1657
1658
1659
1660
1661
1662 /**
1663 * @tc.number : CheckRawSdkIfFillBulkRequest001
1664 * @tc.name :
1665 * @tc.type : PERFs
1666 * @tc.level : Level 1
1667 */
1668 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillBulkRequest001, TestSize.Level1)
1669 {
1670 struct UsbRawFillRequestData reqData;
1671 int32_t ret;
1672 int32_t i;
1673 uint32_t size;
1674 char sendData[] = {"abcde\0"};
1675
1676 size = strlen(sendData) + 1;
1677
1678 size = (size > g_acm->dataOutEp->maxPacketSize) ? g_acm->dataOutEp->maxPacketSize : size;
1679
1680 for (i = 0; i < 1; i++) {
1681 AcmWb *snd = &g_acm->wb[i];
1682 snd->len = size;
1683 ret = memcpy_s(snd->buf, g_acm->dataOutEp->maxPacketSize, sendData, size);
1684 if (ret) {
1685 printf("memcpy_s fial");
1686 }
1687 g_acm->transmitting++;
1688
1689 reqData.endPoint = g_acm->dataOutEp->addr;
1690 reqData.numIsoPackets = 0;
1691 reqData.callback = AcmWriteBulkCallback;
1692 reqData.userData = (void *)snd;
1693 reqData.timeout = USB_CTRL_SET_TIMEOUT;
1694 reqData.buffer = snd->buf;
1695 reqData.length = snd->len;
1696
1697 ret = UsbRawFillBulkRequest(snd->request, g_acm->devHandle, &reqData);
1698 EXPECT_EQ(HDF_SUCCESS, ret);
1699 }
1700 }
1701
1702 /**
1703 * @tc.number : CheckRawSdkIfFillBulkRequest002
1704 * @tc.name :
1705 * @tc.type : PERFs
1706 * @tc.level : Level 1
1707 */
1708 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillBulkRequest002, TestSize.Level1)
1709 {
1710 struct UsbRawFillRequestData reqData;
1711 int32_t ret;
1712 int32_t i;
1713 uint32_t size = g_acm->dataInEp->maxPacketSize;
1714
1715 for (i = 0; i < 1; i++) {
1716 reqData.endPoint = g_acm->dataInEp->addr;
1717 reqData.numIsoPackets = 0;
1718 reqData.callback = AcmReadBulkCallback;
1719 reqData.userData = (void *)g_acm;
1720 reqData.timeout = USB_CTRL_SET_TIMEOUT;
1721 reqData.length = size;
1722
1723 ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData);
1724 EXPECT_EQ(HDF_SUCCESS, ret);
1725 }
1726 }
1727
1728 /**
1729 * @tc.number : CheckRawSdkIfFillInterruptRequest001
1730 * @tc.name :
1731 * @tc.type : PERFs
1732 * @tc.level : Level 1
1733 */
1734 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillInterruptRequest001, TestSize.Level1)
1735 {
1736 struct UsbRawFillRequestData fillRequestData;
1737 int32_t ret;
1738 uint32_t size = g_acm->notifyEp->maxPacketSize;
1739
1740 fillRequestData.endPoint = g_acm->notifyEp->addr;
1741 fillRequestData.length = size;
1742 fillRequestData.numIsoPackets = 0;
1743 fillRequestData.callback = AcmNotifyReqCallback;
1744 fillRequestData.userData = (void *)g_acm;
1745 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1746
1747 ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData);
1748 EXPECT_EQ(HDF_SUCCESS, ret);
1749 }
1750
1751 /**
1752 * @tc.number : CheckRawSdkIfFillInterruptRequest002
1753 * @tc.name :
1754 * @tc.type : PERFs
1755 * @tc.level : Level 1
1756 */
1757 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillInterruptRequest002, TestSize.Level1)
1758 {
1759 struct UsbRawFillRequestData fillRequestData;
1760 int32_t ret;
1761 uint32_t size = g_acm->notifyEp->maxPacketSize;
1762
1763 fillRequestData.endPoint = g_acm->notifyEp->addr;
1764 fillRequestData.length = size;
1765 fillRequestData.numIsoPackets = 0;
1766 fillRequestData.callback = AcmNotifyReqCallback;
1767 fillRequestData.userData = (void *)g_acm;
1768 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1769
1770 ret = UsbRawFillInterruptRequest(NULL, g_acm->devHandle, &fillRequestData);
1771 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1772 }
1773
1774 /**
1775 * @tc.number : CheckRawSdkIfFillInterruptRequest003
1776 * @tc.name :
1777 * @tc.type : PERFs
1778 * @tc.level : Level 1
1779 */
1780 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillInterruptRequest003, TestSize.Level1)
1781 {
1782 struct UsbRawFillRequestData fillRequestData;
1783 int32_t ret;
1784 uint32_t size = g_acm->notifyEp->maxPacketSize;
1785
1786 fillRequestData.endPoint = g_acm->notifyEp->addr;
1787 fillRequestData.length = size;
1788 fillRequestData.numIsoPackets = 0;
1789 fillRequestData.callback = AcmNotifyReqCallback;
1790 fillRequestData.userData = (void *)g_acm;
1791 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1792
1793 ret = UsbRawFillInterruptRequest(g_acm->notifyReq, NULL, &fillRequestData);
1794 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1795 }
1796
1797 /**
1798 * @tc.number : CheckRawSdkIfFillInterruptRequest004
1799 * @tc.name :
1800 * @tc.type : PERFs
1801 * @tc.level : Level 1
1802 */
1803 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillInterruptRequest004, TestSize.Level1)
1804 {
1805 struct UsbRawFillRequestData fillRequestData;
1806 int32_t ret;
1807 uint32_t size = g_acm->notifyEp->maxPacketSize;
1808
1809 fillRequestData.endPoint = g_acm->notifyEp->addr;
1810 fillRequestData.length = size;
1811 fillRequestData.numIsoPackets = 0;
1812 fillRequestData.callback = AcmNotifyReqCallback;
1813 fillRequestData.userData = (void *)g_acm;
1814 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1815
1816 ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, NULL);
1817 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1818 }
1819
1820
1821 /**
1822 * @tc.number : CheckRawSdkIfFillControlRequest001
1823 * @tc.name :
1824 * @tc.type : PERFs
1825 * @tc.level : Level 1
1826 */
1827 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlRequest001, TestSize.Level1)
1828 {
1829 struct UsbRawFillRequestData fillRequestData;
1830 int32_t ret;
1831 int32_t completed = 0;
1832
1833 fillRequestData.callback = AcmCtrlReqCallback;
1834 fillRequestData.userData = &completed;
1835 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1836
1837 ret = UsbRawFillControlRequest(g_acm->ctrlReq, g_acm->devHandle, &fillRequestData);
1838 EXPECT_EQ(HDF_SUCCESS, ret);
1839 }
1840
1841 /**
1842 * @tc.number : CheckRawSdkIfFillControlRequest002
1843 * @tc.name :
1844 * @tc.type : PERFs
1845 * @tc.level : Level 1
1846 */
1847 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlRequest002, TestSize.Level1)
1848 {
1849 struct UsbRawFillRequestData fillRequestData;
1850 int32_t ret;
1851 int32_t completed = 0;
1852
1853 fillRequestData.callback = AcmCtrlReqCallback;
1854 fillRequestData.userData = &completed;
1855 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1856
1857 ret = UsbRawFillControlRequest(NULL, g_acm->devHandle, &fillRequestData);
1858 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1859 }
1860
1861 /**
1862 * @tc.number : CheckRawSdkIfFillControlRequest003
1863 * @tc.name :
1864 * @tc.type : PERFs
1865 * @tc.level : Level 1
1866 */
1867 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlRequest003, TestSize.Level1)
1868 {
1869 struct UsbRawFillRequestData fillRequestData;
1870 int32_t ret;
1871 int32_t completed = 0;
1872
1873 fillRequestData.callback = AcmCtrlReqCallback;
1874 fillRequestData.userData = &completed;
1875 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1876
1877 ret = UsbRawFillControlRequest(g_acm->ctrlReq, NULL, &fillRequestData);
1878 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1879 }
1880
1881 /**
1882 * @tc.number : CheckRawSdkIfFillControlRequest004
1883 * @tc.name :
1884 * @tc.type : PERFs
1885 * @tc.level : Level 1
1886 */
1887 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlRequest004, TestSize.Level1)
1888 {
1889 struct UsbRawFillRequestData fillRequestData;
1890 int32_t ret;
1891 int32_t completed = 0;
1892
1893 fillRequestData.callback = AcmCtrlReqCallback;
1894 fillRequestData.userData = &completed;
1895 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1896
1897 ret = UsbRawFillControlRequest(g_acm->ctrlReq, g_acm->devHandle, NULL);
1898 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1899 }
1900
1901 /**
1902 * @tc.number : CheckRawSdkIfFillControlRequest005
1903 * @tc.name :
1904 * @tc.type : PERFs
1905 * @tc.level : Level 1
1906 */
1907 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlRequest005, TestSize.Level1)
1908 {
1909 struct UsbRawFillRequestData fillRequestData;
1910 int32_t ret;
1911 int32_t completed = 0;
1912
1913 fillRequestData.callback = AcmCtrlReqCallback;
1914 fillRequestData.userData = &completed;
1915 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1916
1917 ret = UsbRawFillControlRequest(NULL, g_acm->devHandle, NULL);
1918 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1919 }
1920
1921 /**
1922 * @tc.number : CheckRawSdkIfFillControlRequest006
1923 * @tc.name :
1924 * @tc.type : PERFs
1925 * @tc.level : Level 1
1926 */
1927 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlRequest006, TestSize.Level1)
1928 {
1929 struct UsbRawFillRequestData fillRequestData;
1930 int32_t ret;
1931 int32_t completed = 0;
1932
1933 fillRequestData.callback = AcmCtrlReqCallback;
1934 fillRequestData.userData = &completed;
1935 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1936
1937 ret = UsbRawFillControlRequest(g_acm->ctrlReq, NULL, NULL);
1938 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1939 }
1940
1941 /**
1942 * @tc.number : CheckRawSdkIfFillControlRequest007
1943 * @tc.name :
1944 * @tc.type : PERFs
1945 * @tc.level : Level 1
1946 */
1947 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlRequest007, TestSize.Level1)
1948 {
1949 struct UsbRawFillRequestData fillRequestData;
1950 int32_t ret;
1951 int32_t completed = 0;
1952
1953 fillRequestData.callback = AcmCtrlReqCallback;
1954 fillRequestData.userData = &completed;
1955 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1956
1957 ret = UsbRawFillControlRequest(NULL, NULL, NULL);
1958 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1959 }
1960
1961 /**
1962 * @tc.number : CheckRawSdkIfFillControlRequest008
1963 * @tc.name :
1964 * @tc.type : PERFs
1965 * @tc.level : Level 1
1966 */
1967 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlRequest008, TestSize.Level1)
1968 {
1969 struct UsbRawFillRequestData fillRequestData;
1970 int32_t ret;
1971 int32_t completed = 0;
1972
1973 fillRequestData.callback = AcmCtrlReqCallback;
1974 fillRequestData.userData = &completed;
1975 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
1976
1977 ret = UsbRawFillControlRequest(NULL, NULL, &fillRequestData);
1978 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
1979 }
1980
1981 /**
1982 * @tc.number : CheckRawSdkIfFillIsoRequest001
1983 * @tc.name :
1984 * @tc.type : PERFs
1985 * @tc.level : Level 1
1986 */
1987 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillIsoRequest001, TestSize.Level1)
1988 {
1989
1990 }
1991
1992 /**
1993 * @tc.number : CheckRawSdkIfFillControlSetup001
1994 * @tc.name :
1995 * @tc.type : PERFs
1996 * @tc.level : Level 1
1997 */
1998 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlSetup001, TestSize.Level1)
1999 {
2000 struct UsbControlRequestData ctrlReq;
2001 int32_t ret;
2002
2003 g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
2004 g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
2005 g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
2006 g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
2007
2008 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
2009 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
2010 ctrlReq.value = CpuToLe16(0);
2011 ctrlReq.index = 0;
2012 ctrlReq.data = (unsigned char *)&g_acm->lineCoding;
2013 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
2014 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
2015
2016 ret = UsbRawFillControlSetup(NULL, &ctrlReq);
2017 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2018 }
2019
2020 /**
2021 * @tc.number : CheckRawSdkIfFillControlSetup002
2022 * @tc.name :
2023 * @tc.type : PERFs
2024 * @tc.level : Level 1
2025 */
2026 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlSetup002, TestSize.Level1)
2027 {
2028 unsigned char setup[100] = {0};
2029 int32_t ret;
2030
2031 ret = UsbRawFillControlSetup(setup, NULL);
2032 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2033 }
2034
2035 /**
2036 * @tc.number : CheckRawSdkIfFillControlSetup003
2037 * @tc.name :
2038 * @tc.type : PERFs
2039 * @tc.level : Level 1
2040 */
2041 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlSetup003, TestSize.Level1)
2042 {
2043 int32_t ret;
2044
2045 ret = UsbRawFillControlSetup(NULL, NULL);
2046 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2047 }
2048
2049 /**
2050 * @tc.number : CheckRawSdkIfFillControlSetup004
2051 * @tc.name :
2052 * @tc.type : PERFs
2053 * @tc.level : Level 1
2054 */
2055 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillControlSetup004, TestSize.Level1)
2056 {
2057 struct UsbControlRequestData ctrlReq;
2058 unsigned char setup[100] = {0};
2059 int32_t ret;
2060
2061 g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE);
2062 g_acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
2063 g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
2064 g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
2065
2066 ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
2067 ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING;
2068 ctrlReq.value = CpuToLe16(0);
2069 ctrlReq.index = 0;
2070 ctrlReq.data = (unsigned char *)&g_acm->lineCoding;
2071 ctrlReq.length = sizeof(struct UsbCdcLineCoding);
2072 ctrlReq.timeout = USB_CTRL_SET_TIMEOUT;
2073
2074 ret = UsbRawFillControlSetup(setup, &ctrlReq);
2075 EXPECT_EQ(HDF_SUCCESS, ret);
2076 }
2077
2078 /**
2079 * @tc.number : CheckRawSdkIfFillBulkRequest004
2080 * @tc.name :
2081 * @tc.type : PERFs
2082 * @tc.level : Level 1
2083 */
2084 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillBulkRequest004, TestSize.Level1)
2085 {
2086 struct UsbRawFillRequestData reqData;
2087 int32_t ret;
2088 int32_t i;
2089 uint32_t size = g_acm->dataInEp->maxPacketSize;
2090
2091 for (i = 0; i < ACM_NW; i++) {
2092 reqData.endPoint = g_acm->dataInEp->addr;
2093 reqData.numIsoPackets = 0;
2094 reqData.callback = AcmReadBulkCallback;
2095 reqData.userData = (void *)g_acm;
2096 reqData.timeout = USB_CTRL_SET_TIMEOUT;
2097 reqData.length = size;
2098
2099 ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData);
2100 EXPECT_EQ(HDF_SUCCESS, ret);
2101 }
2102 }
2103
2104 /**
2105 * @tc.number : CheckRawSdkIfFillInterruptRequest005
2106 * @tc.name :
2107 * @tc.type : PERFs
2108 * @tc.level : Level 1
2109 */
2110 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFillInterruptRequest005, TestSize.Level1)
2111 {
2112 struct UsbRawFillRequestData fillRequestData;
2113 int32_t ret;
2114 uint32_t size = g_acm->notifyEp->maxPacketSize;
2115
2116 fillRequestData.endPoint = g_acm->notifyEp->addr;
2117 fillRequestData.length = size;
2118 fillRequestData.numIsoPackets = 0;
2119 fillRequestData.callback = AcmNotifyReqCallback;
2120 fillRequestData.userData = (void *)g_acm;
2121 fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
2122
2123 ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData);
2124 EXPECT_EQ(HDF_SUCCESS, ret);
2125 }
2126
2127 /**
2128 * @tc.number : CheckRawSdkIfFreeConfigDescriptor001
2129 * @tc.name :
2130 * @tc.type : PERF
2131 * @tc.level : Level 1
2132 */
2133 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFreeConfigDescriptor001, TestSize.Level1)
2134 {
2135 UsbRawFreeConfigDescriptor(NULL);
2136 }
2137
2138 /**
2139 * @tc.number : CheckRawSdkIfFreeConfigDescriptor002
2140 * @tc.name :
2141 * @tc.type : PERF
2142 * @tc.level : Level 1
2143 */
2144 HWTEST_F(UsbRawSdkIfTest, CheckRawSdkIfFreeConfigDescriptor002, TestSize.Level1)
2145 {
2146 UsbRawFreeConfigDescriptor(g_acm->config);
2147 g_acm->config = nullptr;
2148 }
2149 }
2150