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