1/*
2 * Copyright (c) 2021-2023 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 "usbd_request_test.h"
17
18#include <iostream>
19#include <vector>
20
21#include "UsbSubscriberTest.h"
22#include "hdf_log.h"
23#include "usbd_type.h"
24#include "v1_1/iusb_interface.h"
25#include "v1_1/usb_types.h"
26
27const int SLEEP_TIME = 3;
28const uint8_t INDEX_1 = 1;
29const uint8_t INDEX_INVALID = 255;
30const uint8_t CONFIG_ID_0 = 0;
31const uint8_t CONFIG_ID_INVALID = 222;
32const uint8_t BUS_NUM_INVALID = 255;
33const uint8_t DEV_ADDR_INVALID = 255;
34const uint8_t STRING_ID_INVALID = 233;
35const uint32_t MAX_BUFFER_LENGTH = 255;
36const int TAG_NUM_10 = 10;
37const uint8_t INTERFACEID_OK = 1;
38const uint8_t INTERFACEID_INVALID = 255;
39const uint8_t POINTID_INVALID = 158;
40// data interface have 2 point : 1->bulk_out 2->bulk_in
41const uint8_t POINTID_DIR_IN = USB_ENDPOINT_DIR_IN | 2;
42const uint8_t POINTID_DIR_OUT = USB_ENDPOINT_DIR_OUT | 1;
43const uint8_t INVALID_NUM = 222;
44const uint32_t TIME_WAIT = 10000;
45
46using namespace testing::ext;
47using namespace OHOS;
48using namespace OHOS::USB;
49using namespace std;
50using namespace OHOS::HDI::Usb::V1_0;
51using namespace OHOS::HDI::Usb::V1_1;
52
53UsbDev UsbdRequestTest::dev_ = {0, 0};
54sptr<UsbSubscriberTest> UsbdRequestTest::subscriber_ = nullptr;
55namespace {
56sptr<OHOS::HDI::Usb::V1_1::IUsbInterface> g_usbInterface = nullptr;
57
58int32_t SwitchErrCode(int32_t ret)
59{
60    return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
61}
62
63void UsbdRequestTest::SetUpTestCase(void)
64{
65    g_usbInterface = OHOS::HDI::Usb::V1_1::IUsbInterface::Get();
66    if (g_usbInterface == nullptr) {
67        HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
68        exit(0);
69    }
70    auto ret = g_usbInterface->SetPortRole(1, 1, 1);
71    sleep(SLEEP_TIME);
72    HDF_LOGI("UsbdRequestTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
73    ret = SwitchErrCode(ret);
74    ASSERT_EQ(0, ret);
75    if (ret != 0) {
76        exit(0);
77    }
78
79    subscriber_ = new UsbSubscriberTest();
80    if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
81        HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
82        exit(0);
83    }
84
85    std::cout << "please connect device, press enter to continue" << std::endl;
86    int c;
87    while ((c = getchar()) != '\n' && c != EOF) {}
88    dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
89
90    ret = g_usbInterface->OpenDevice(dev_);
91    HDF_LOGI("UsbdRequestTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
92    ASSERT_EQ(0, ret);
93}
94
95void UsbdRequestTest::TearDownTestCase(void)
96{
97    g_usbInterface->UnbindUsbdSubscriber(subscriber_);
98    dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
99    auto ret = g_usbInterface->CloseDevice(dev_);
100    HDF_LOGI("UsbdRequestTest:: %{public}d Close=%{public}d", __LINE__, ret);
101    ASSERT_EQ(0, ret);
102}
103
104void UsbdRequestTest::SetUp(void) {}
105
106void UsbdRequestTest::TearDown(void) {}
107
108/**
109 * @tc.name: UsbdConfig001
110 * @tc.desc: Test functions to SetConfig
111 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
112 * @tc.desc: Positive test: parameters correctly
113 * @tc.type: FUNC
114 */
115HWTEST_F(UsbdRequestTest, UsbdSetConfig001, TestSize.Level1)
116{
117    uint8_t configIndex = INDEX_1;
118    struct UsbDev dev = dev_;
119    auto ret = g_usbInterface->SetConfig(dev, configIndex);
120    HDF_LOGI("UsbdRequestTest::UsbdSetConfigConfig001 %{public}d SetConfig=%{public}d", __LINE__, ret);
121    EXPECT_EQ(0, ret);
122}
123
124/**
125 * @tc.name: UsbdConfig002
126 * @tc.desc: Test functions to SetConfig
127 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
128 * @tc.desc: Negative test: parameters exception, busNum error
129 * @tc.type: FUNC
130 */
131HWTEST_F(UsbdRequestTest, UsbdSetConfig002, TestSize.Level1)
132{
133    uint8_t configIndex = INDEX_1;
134    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
135    auto ret = g_usbInterface->SetConfig(dev, configIndex);
136    HDF_LOGI("UsbdRequestTest::UsbdSetConfig002 %{public}d SetConfig=%{public}d", __LINE__, ret);
137    EXPECT_NE(ret, 0);
138}
139
140/**
141 * @tc.name: UsbdConfig003
142 * @tc.desc: Test functions to SetConfig
143 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
144 * @tc.desc: Negative test: parameters exception, devAddr error
145 * @tc.type: FUNC
146 */
147HWTEST_F(UsbdRequestTest, UsbdSetConfig003, TestSize.Level1)
148{
149    uint8_t configIndex = INDEX_1;
150    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
151    auto ret = g_usbInterface->SetConfig(dev, configIndex);
152    HDF_LOGI("UsbdRequestTest::UsbdSetConfig003 %{public}d SetConfig=%{public}d", __LINE__, ret);
153    EXPECT_NE(ret, 0);
154}
155
156/**
157 * @tc.name: UsbdConfig004
158 * @tc.desc: Test functions to SetConfig
159 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
160 * @tc.desc: Negative test: parameters exception, configIndex error
161 * @tc.type: FUNC
162 */
163HWTEST_F(UsbdRequestTest, UsbdSetConfig004, TestSize.Level1)
164{
165    uint8_t configIndex = INDEX_INVALID;
166    struct UsbDev dev = dev_;
167    auto ret = g_usbInterface->SetConfig(dev, configIndex);
168    EXPECT_NE(ret, 0);
169    configIndex = INDEX_1;
170    ret = g_usbInterface->SetConfig(dev, configIndex);
171    HDF_LOGI("UsbdRequestTest::UsbdSetConfig004 %{public}d SetConfig=%{public}d", __LINE__, ret);
172    EXPECT_EQ(0, ret);
173}
174
175/**
176 * @tc.name: UsbdConfig005
177 * @tc.desc: Test functions to SetConfig
178 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
179 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
180 * @tc.type: FUNC
181 */
182HWTEST_F(UsbdRequestTest, UsbdSetConfig005, TestSize.Level1)
183{
184    uint8_t configIndex = INDEX_1;
185    struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
186    auto ret = g_usbInterface->SetConfig(dev, configIndex);
187    HDF_LOGI("UsbdRequestTest::UsbdSetConfig005 %{public}d SetConfig=%{public}d", __LINE__, ret);
188    EXPECT_NE(ret, 0);
189}
190
191/**
192 * @tc.name: UsbdConfig006
193 * @tc.desc: Test functions to SetConfig
194 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
195 * @tc.desc: Negative test: parameters exception, busNum && configIndex error
196 * @tc.type: FUNC
197 */
198HWTEST_F(UsbdRequestTest, UsbdSetConfig006, TestSize.Level1)
199{
200    uint8_t configIndex = INDEX_INVALID;
201    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
202    auto ret = g_usbInterface->SetConfig(dev, configIndex);
203    HDF_LOGI("UsbdRequestTest::UsbdSetConfig006 %{public}d SetConfig=%{public}d", __LINE__, ret);
204    EXPECT_NE(ret, 0);
205}
206
207/**
208 * @tc.name: UsbdConfig007
209 * @tc.desc: Test functions to SetConfig
210 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
211 * @tc.desc: Negative test: parameters exception, devAddr && configIndex error
212 * @tc.type: FUNC
213 */
214HWTEST_F(UsbdRequestTest, UsbdSetConfig007, TestSize.Level1)
215{
216    uint8_t configIndex = INDEX_INVALID;
217    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
218    auto ret = g_usbInterface->SetConfig(dev, configIndex);
219    HDF_LOGI("UsbdRequestTest::UsbdSetConfig007 %{public}d SetConfig=%{public}d", __LINE__, ret);
220    EXPECT_NE(ret, 0);
221}
222
223/**
224 * @tc.name: UsbdConfig008
225 * @tc.desc: Test functions to SetConfig
226 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
227 * @tc.desc: Negative test: parameters exception, busNum && devAddr && configIndex error
228 * @tc.type: FUNC
229 */
230HWTEST_F(UsbdRequestTest, UsbdSetConfig008, TestSize.Level1)
231{
232    uint8_t configIndex = INDEX_INVALID;
233    struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
234    auto ret = g_usbInterface->SetConfig(dev, configIndex);
235    HDF_LOGI("UsbdRequestTest::UsbdSetConfig008 %{public}d SetConfig=%{public}d", __LINE__, ret);
236    EXPECT_NE(ret, 0);
237}
238
239/**********************************************************************************************************/
240
241/**
242 * @tc.name: UsbdConfig001
243 * @tc.desc: Test functions to GetConfig
244 * @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
245 * @tc.desc: Positive test: parameters correctly
246 * @tc.type: FUNC
247 */
248HWTEST_F(UsbdRequestTest, UsbdGetConfig001, TestSize.Level1)
249{
250    uint8_t configIndex = INDEX_1;
251    struct UsbDev dev = dev_;
252    auto ret = g_usbInterface->GetConfig(dev, configIndex);
253    HDF_LOGI("UsbdRequestTest::UsbdGetConfig001 %{public}d GetConfig=%{public}d", __LINE__, ret);
254    EXPECT_EQ(0, ret);
255}
256
257/**
258 * @tc.name: UsbdConfig002
259 * @tc.desc: Test functions to GetConfig
260 * @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
261 * @tc.desc: Negative test: parameters exception, busNum error
262 * @tc.type: FUNC
263 */
264HWTEST_F(UsbdRequestTest, UsbdGetConfig002, TestSize.Level1)
265{
266    uint8_t configIndex = INDEX_1;
267    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
268    auto ret = g_usbInterface->GetConfig(dev, configIndex);
269    HDF_LOGI("UsbdRequestTest::UsbdGetConfig002 %{public}d GetConfig=%{public}d", __LINE__, ret);
270    EXPECT_NE(ret, 0);
271}
272
273/**
274 * @tc.name: UsbdConfig003
275 * @tc.desc: Test functions to GetConfig
276 * @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
277 * @tc.desc: Negative test: parameters exception, devAddr error
278 * @tc.type: FUNC
279 */
280HWTEST_F(UsbdRequestTest, UsbdGetConfig003, TestSize.Level1)
281{
282    uint8_t configIndex = INDEX_1;
283    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
284    auto ret = g_usbInterface->GetConfig(dev, configIndex);
285    HDF_LOGI("UsbdRequestTest::UsbdGetConfig003 %{public}d GetConfig=%{public}d", __LINE__, ret);
286    EXPECT_NE(ret, 0);
287}
288
289/**
290 * @tc.name: UsbdConfig004
291 * @tc.desc: Test functions to GetConfig
292 * @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
293 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
294 * @tc.type: FUNC
295 */
296HWTEST_F(UsbdRequestTest, UsbdGetConfig004, TestSize.Level1)
297{
298    uint8_t configIndex = INDEX_1;
299    struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
300    auto ret = g_usbInterface->GetConfig(dev, configIndex);
301    HDF_LOGI("UsbdRequestTest::UsbdGetConfig004 %{public}d GetConfig=%{public}d", __LINE__, ret);
302    EXPECT_NE(ret, 0);
303}
304
305/**
306 * @tc.name: UsbdClaimInterface001
307 * @tc.desc: Test functions to ClaimInterface
308 * @tc.desc: int32_t  ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
309 * @tc.desc: Positive test: parameters correctly
310 * @tc.type: FUNC
311 */
312HWTEST_F(UsbdRequestTest, UsbdClaimInterface001, TestSize.Level1)
313{
314    uint8_t interfaceId = INTERFACEID_OK;
315    struct UsbDev dev = dev_;
316    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
317    HDF_LOGI("UsbdRequestTest::UsbdClaimInterface001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
318    EXPECT_EQ(0, ret);
319}
320
321/**
322 * @tc.name: UsbdClaimInterface002
323 * @tc.desc: Test functions to ClaimInterface
324 * @tc.desc: int32_t  ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
325 * @tc.desc: Negative test: parameters exception, busNum error
326 * @tc.type: FUNC
327 */
328HWTEST_F(UsbdRequestTest, UsbdClaimInterface002, TestSize.Level1)
329{
330    uint8_t interfaceId = INTERFACEID_OK;
331    struct UsbDev dev = dev_;
332    dev.busNum = BUS_NUM_INVALID;
333    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
334    HDF_LOGI("UsbdRequestTest::UsbdClaimInterface002 %{public}d ret=%{public}d", __LINE__, ret);
335    EXPECT_NE(ret, 0);
336}
337
338/**
339 * @tc.name: UsbdClaimInterface003
340 * @tc.desc: Test functions to ClaimInterface
341 * @tc.desc: int32_t  ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
342 * @tc.desc: Negative test: parameters exception, devAddr error
343 * @tc.type: FUNC
344 */
345HWTEST_F(UsbdRequestTest, UsbdClaimInterface003, TestSize.Level1)
346{
347    uint8_t interfaceId = INTERFACEID_OK;
348    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
349    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
350    HDF_LOGI("UsbdRequestTest::UsbdClaimInterface003 %{public}d ret=%{public}d", __LINE__, ret);
351    EXPECT_NE(ret, 0);
352}
353
354/**
355 * @tc.name: UsbdClaimInterface004
356 * @tc.desc: Test functions to ClaimInterface
357 * @tc.desc: int32_t  ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
358 * @tc.desc: Negative test: parameters exception, interfaceid error
359 * @tc.type: FUNC
360 */
361HWTEST_F(UsbdRequestTest, UsbdClaimInterface004, TestSize.Level1)
362{
363    uint8_t interfaceId = INTERFACEID_OK;
364    struct UsbDev dev = dev_;
365    interfaceId = INTERFACEID_INVALID;
366    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
367    HDF_LOGI("UsbdRequestTest::UsbdClaimInterface004 %{public}d ret=%{public}d", __LINE__, ret);
368    EXPECT_NE(ret, 0);
369}
370
371/**
372 * @tc.name: UsbdClaimInterface005
373 * @tc.desc: Test functions to ClaimInterface
374 * @tc.desc: int32_t  ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
375 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
376 * @tc.type: FUNC
377 */
378HWTEST_F(UsbdRequestTest, UsbdClaimInterface005, TestSize.Level1)
379{
380    uint8_t interfaceId = INTERFACEID_OK;
381    struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
382    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
383    HDF_LOGI("UsbdRequestTest::UsbdClaimInterface005 %{public}d ret=%{public}d", __LINE__, ret);
384    EXPECT_NE(ret, 0);
385}
386
387/**
388 * @tc.name: UsbdClaimInterface006
389 * @tc.desc: Test functions to ClaimInterface
390 * @tc.desc: int32_t  ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
391 * @tc.desc: Negative test: parameters exception, busNum && interfaceid error
392 * @tc.type: FUNC
393 */
394HWTEST_F(UsbdRequestTest, UsbdClaimInterface006, TestSize.Level1)
395{
396    uint8_t interfaceId = INTERFACEID_INVALID;
397    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
398    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
399    HDF_LOGI("UsbdRequestTest::UsbdClaimInterface006 %{public}d ret=%{public}d", __LINE__, ret);
400    EXPECT_NE(ret, 0);
401}
402
403/**
404 * @tc.name: UsbdClaimInterface007
405 * @tc.desc: Test functions to ClaimInterface
406 * @tc.desc: int32_t  ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
407 * @tc.desc: Negative test: parameters exception, devAddr && interfaceid error
408 * @tc.type: FUNC
409 */
410HWTEST_F(UsbdRequestTest, UsbdClaimInterface007, TestSize.Level1)
411{
412    uint8_t interfaceId = INTERFACEID_INVALID;
413    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
414    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
415    HDF_LOGI("UsbdRequestTest::UsbdClaimInterface007 %{public}d ret=%{public}d", __LINE__, ret);
416    EXPECT_NE(ret, 0);
417}
418
419/**
420 * @tc.name: UsbdClaimInterface008
421 * @tc.desc: Test functions to ClaimInterface
422 * @tc.desc: int32_t  ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
423 * @tc.desc: Negative test: parameters exception, busNum && devAddr && interfaceid error
424 * @tc.type: FUNC
425 */
426HWTEST_F(UsbdRequestTest, UsbdClaimInterface008, TestSize.Level1)
427{
428    uint8_t interfaceId = INTERFACEID_INVALID;
429    struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
430    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
431    HDF_LOGI("UsbdRequestTest::UsbdClaimInterface008 %{public}d ret=%{public}d", __LINE__, ret);
432    EXPECT_NE(ret, 0);
433}
434
435/**********************************************************************************************************/
436
437/**
438 * @tc.name: UsbdDescriptor001
439 * @tc.desc: Test functions to GetDeviceDescriptor
440 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
441 * @tc.desc: Positive test: parameters correctly
442 * @tc.type: FUNC
443 */
444HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor001, TestSize.Level1)
445{
446    struct UsbDev dev = dev_;
447    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
448    auto ret = g_usbInterface->GetDeviceDescriptor(dev, devData);
449    HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor001 length=%{public}zu buffer=%{public}zu ret=%{public}d",
450        devData.size(), sizeof(devData), ret);
451    EXPECT_EQ(0, ret);
452}
453
454/**
455 * @tc.name: UsbdDescriptor002
456 * @tc.desc: Test functions to GetDeviceDescriptor
457 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
458 * @tc.desc: Negative test: parameters exception, busNum error
459 * @tc.type: FUNC
460 */
461HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor002, TestSize.Level1)
462{
463    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
464    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
465    auto ret = g_usbInterface->GetDeviceDescriptor(dev, devData);
466    HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor002 length=%{public}zu buffer=%{public}zu ret=%{public}d",
467        devData.size(), sizeof(devData), ret);
468    EXPECT_NE(ret, 0);
469}
470
471/**
472 * @tc.name: UsbdDescriptor003
473 * @tc.desc: Test functions to GetDeviceDescriptor
474 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
475 * @tc.desc: Negative test: parameters exception, devAddr error
476 * @tc.type: FUNC
477 */
478HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor003, TestSize.Level1)
479{
480    uint8_t devAddr = DEV_ADDR_INVALID;
481    struct UsbDev dev = {dev_.busNum, devAddr};
482    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
483    auto ret = g_usbInterface->GetDeviceDescriptor(dev, devData);
484    HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor003 length=%{public}zu buffer=%{public}zu ret=%{public}d",
485        devData.size(), sizeof(devData), ret);
486    EXPECT_NE(ret, 0);
487}
488
489/**
490 * @tc.name: UsbdDescriptor004
491 * @tc.desc: Test functions to GetDeviceDescriptor
492 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
493 * @tc.desc: Negative test: parameters exception, length error
494 * @tc.type: FUNC
495 */
496HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor004, TestSize.Level1)
497{
498    struct UsbDev dev = dev_;
499    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
500    auto ret = g_usbInterface->GetDeviceDescriptor(dev, devData);
501    HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor004 length=%{public}zu buffer=%{public}zu ret=%{public}d",
502        devData.size(), sizeof(devData), ret);
503    EXPECT_EQ(0, ret);
504}
505
506/**
507 * @tc.name: UsbdDescriptor005
508 * @tc.desc: Test functions to GetDeviceDescriptor
509 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
510 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
511 * @tc.type: FUNC
512 */
513HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor005, TestSize.Level1)
514{
515    uint8_t busNum = BUS_NUM_INVALID;
516    uint8_t devAddr = DEV_ADDR_INVALID;
517    struct UsbDev dev = {busNum, devAddr};
518    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
519    auto ret = g_usbInterface->GetDeviceDescriptor(dev, devData);
520    HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor005 length=%{public}zu buffer=%{public}zu ret=%{public}d",
521        devData.size(), sizeof(devData), ret);
522    EXPECT_NE(ret, 0);
523}
524
525/**
526 * @tc.name: UsbdDescriptor006
527 * @tc.desc: Test functions to GetDeviceDescriptor
528 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
529 * @tc.desc: Negative test: parameters exception, busNum && length error
530 * @tc.type: FUNC
531 */
532HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor006, TestSize.Level1)
533{
534    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
535    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
536    auto ret = g_usbInterface->GetDeviceDescriptor(dev, devData);
537    HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor006 length=%{public}zu buffer=%{public}zu ret=%{public}d",
538        devData.size(), sizeof(devData), ret);
539    EXPECT_NE(ret, 0);
540}
541
542/**
543 * @tc.name: UsbdDescriptor007
544 * @tc.desc: Test functions to GetDeviceDescriptor
545 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
546 * @tc.desc: Negative test: parameters exception, devAddr && length error
547 * @tc.type: FUNC
548 */
549HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor007, TestSize.Level1)
550{
551    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
552    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
553    auto ret = g_usbInterface->GetDeviceDescriptor(dev, devData);
554    HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor007 length=%{public}zu buffer=%{public}zu ret=%{public}d",
555        devData.size(), sizeof(devData), ret);
556    EXPECT_NE(ret, 0);
557}
558
559/**
560 * @tc.name: UsbdDescriptor008
561 * @tc.desc: Test functions to GetDeviceDescriptor
562 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
563 * @tc.desc: Negative test: parameters exception, busNum && devAddr && length error
564 * @tc.type: FUNC
565 */
566HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor008, TestSize.Level1)
567{
568    uint8_t busNum = BUS_NUM_INVALID;
569    uint8_t devAddr = DEV_ADDR_INVALID;
570    struct UsbDev dev = {busNum, devAddr};
571    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
572    auto ret = g_usbInterface->GetDeviceDescriptor(dev, devData);
573    HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor008 length=%{public}zu buffer=%{public}zu ret=%{public}d",
574        devData.size(), sizeof(devData), ret);
575    EXPECT_NE(ret, 0);
576}
577
578/**********************************************************************************************************/
579
580/**
581 * @tc.name: UsbdDescriptor001
582 * @tc.desc: Test functions to GetStringDescriptor
583 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
584 * @tc.desc: Positive test: parameters correctly
585 * @tc.type: FUNC
586 */
587HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor001, TestSize.Level1)
588{
589    uint8_t stringId = 0;
590    struct UsbDev dev = dev_;
591    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
592    auto ret = g_usbInterface->GetStringDescriptor(dev, stringId, devData);
593    HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor001 length=%{public}zu buffer=%{public}zu ret=%{public}d",
594        devData.size(), sizeof(devData), ret);
595    EXPECT_EQ(0, ret);
596}
597
598/**
599 * @tc.name: UsbdDescriptor002
600 * @tc.desc: Test functions to GetStringDescriptor
601 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
602 * @tc.desc: Negative test: parameters exception, busNum error
603 * @tc.type: FUNC
604 */
605HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor002, TestSize.Level1)
606{
607    uint8_t stringId = 1;
608    struct UsbDev dev = dev_;
609    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
610    auto ret = g_usbInterface->GetStringDescriptor(dev, stringId, devData);
611    HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor002 length=%{public}zu buffer=%{public}zu ret=%{public}d",
612        devData.size(), sizeof(devData), ret);
613    EXPECT_EQ(0, ret);
614}
615
616/**
617 * @tc.name: UsbdDescriptor003
618 * @tc.desc: Test functions to GetStringDescriptor
619 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
620 * @tc.desc: Negative test: parameters exception, stringId error
621 * @tc.type: FUNC
622 */
623HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor003, TestSize.Level1)
624{
625    uint8_t stringId = INVALID_NUM;
626    struct UsbDev dev = dev_;
627    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
628    auto ret = g_usbInterface->GetStringDescriptor(dev, stringId, devData);
629    HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor003 length=%{public}zu buffer=%{public}zu ret=%{public}d",
630        devData.size(), sizeof(devData), ret);
631    EXPECT_EQ(0, ret);
632}
633
634/**
635 * @tc.name: UsbdDescriptor004
636 * @tc.desc: Test functions to GetStringDescriptor
637 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
638 * @tc.desc: Negative test: parameters exception, devAddr error
639 * @tc.type: FUNC
640 */
641HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor004, TestSize.Level1)
642{
643    uint8_t stringId = 0;
644    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
645    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
646    auto ret = g_usbInterface->GetStringDescriptor(dev, stringId, devData);
647    HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor004 length=%{public}zu buffer=%{public}zu ret=%{public}d",
648        devData.size(), sizeof(devData), ret);
649    EXPECT_NE(ret, 0);
650}
651
652/**
653 * @tc.name: UsbdDescriptor005
654 * @tc.desc: Test functions to GetStringDescriptor
655 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
656 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
657 * @tc.type: FUNC
658 */
659HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor005, TestSize.Level1)
660{
661    uint8_t stringId = 0;
662    struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
663    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
664    auto ret = g_usbInterface->GetStringDescriptor(dev, stringId, devData);
665    HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor005 length=%{public}zu buffer=%{public}zu ret=%{public}d",
666        devData.size(), sizeof(devData), ret);
667    EXPECT_NE(ret, 0);
668}
669
670/**
671 * @tc.name: UsbdDescriptor006
672 * @tc.desc: Test functions to GetStringDescriptor
673 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
674 * @tc.desc: Negative test: parameters exception, busNum error
675 * @tc.type: FUNC
676 */
677HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor006, TestSize.Level1)
678{
679    uint8_t stringId = 0;
680    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
681    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
682    auto ret = g_usbInterface->GetStringDescriptor(dev, stringId, devData);
683    HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor006 length=%{public}zu buffer=%{public}zu ret=%{public}d",
684        devData.size(), sizeof(devData), ret);
685    EXPECT_NE(ret, 0);
686}
687
688/**
689 * @tc.name: UsbdDescriptor007
690 * @tc.desc: Test functions to GetStringDescriptor
691 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
692 * @tc.desc: Negative test: parameters exception, devAddr && stringID error
693 * @tc.type: FUNC
694 */
695HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor007, TestSize.Level1)
696{
697    uint8_t stringId = STRING_ID_INVALID;
698    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
699    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
700    auto ret = g_usbInterface->GetStringDescriptor(dev, stringId, devData);
701    HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor007 length=%{public}zu buffer=%{public}zu ret=%{public}d",
702        devData.size(), sizeof(devData), ret);
703    EXPECT_NE(ret, 0);
704}
705
706/**
707 * @tc.name: UsbdDescriptor008
708 * @tc.desc: Test functions to GetStringDescriptor
709 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
710 * @tc.desc: Negative test: parameters exception, busNum && devAddr && stringID error
711 * @tc.type: FUNC
712 */
713HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor008, TestSize.Level1)
714{
715    uint8_t stringId = STRING_ID_INVALID;
716    struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
717    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
718    auto ret = g_usbInterface->GetStringDescriptor(dev, stringId, devData);
719    HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor008 length=%{public}zu buffer=%{public}zu ret=%{public}d",
720        devData.size(), sizeof(devData), ret);
721    EXPECT_NE(ret, 0);
722}
723
724/**********************************************************************************************************/
725
726/**
727 * @tc.name: UsbdDescriptor001
728 * @tc.desc: Test functions to GetConfigDescriptor
729 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
730 * @tc.desc: Positive test: parameters correctly
731 * @tc.type: FUNC
732 */
733HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor001, TestSize.Level1)
734{
735    uint8_t configId = CONFIG_ID_0;
736    struct UsbDev dev = dev_;
737    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
738    auto ret = g_usbInterface->GetConfigDescriptor(dev, configId, devData);
739    HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor001 length=%{public}zu buffer=%{public}zu ret=%{public}d",
740        devData.size(), sizeof(devData), ret);
741    EXPECT_EQ(0, ret);
742}
743
744/**
745 * @tc.name: UsbdDescriptor002
746 * @tc.desc: Test functions to GetConfigDescriptor
747 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
748 * @tc.desc: Negative test: parameters exception, busNum error
749 * @tc.type: FUNC
750 */
751HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor002, TestSize.Level1)
752{
753    uint8_t configId = CONFIG_ID_0;
754    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
755    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
756    auto ret = g_usbInterface->GetConfigDescriptor(dev, configId, devData);
757    HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor002 length=%{public}zu buffer=%{public}zu ret=%{public}d",
758        devData.size(), sizeof(devData), ret);
759    EXPECT_NE(ret, 0);
760}
761
762/**
763 * @tc.name: UsbdDescriptor003
764 * @tc.desc: Test functions to GetConfigDescriptor
765 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
766 * @tc.desc: Negative test: parameters exception, devAddr error
767 * @tc.type: FUNC
768 */
769HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor003, TestSize.Level1)
770{
771    uint8_t configId = CONFIG_ID_0;
772    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
773    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
774    auto ret = g_usbInterface->GetConfigDescriptor(dev, configId, devData);
775    HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor003 length=%{public}zu buffer=%{public}zu ret=%{public}d",
776        devData.size(), sizeof(devData), ret);
777    EXPECT_NE(ret, 0);
778}
779
780/**
781 * @tc.name: UsbdDescriptor004
782 * @tc.desc: Test functions to GetConfigDescriptor
783 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
784 * @tc.desc: Negative test: parameters exception, configId error
785 * @tc.type: FUNC
786 */
787HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor004, TestSize.Level1)
788{
789    uint8_t configId = CONFIG_ID_0;
790    struct UsbDev dev = dev_;
791    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
792    auto ret = g_usbInterface->GetConfigDescriptor(dev, configId, devData);
793    HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor004 length=%{public}zu buffer=%{public}zu ret=%{public}d",
794        devData.size(), sizeof(devData), ret);
795    EXPECT_EQ(0, ret);
796}
797
798/**
799 * @tc.name: UsbdDescriptor005
800 * @tc.desc: Test functions to GetConfigDescriptor
801 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
802 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
803 * @tc.type: FUNC
804 */
805HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor005, TestSize.Level1)
806{
807    uint8_t configId = CONFIG_ID_0;
808    struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
809    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
810    auto ret = g_usbInterface->GetConfigDescriptor(dev, configId, devData);
811    HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor005 length=%{public}zu buffer=%{public}zu ret=%{public}d",
812        devData.size(), sizeof(devData), ret);
813    EXPECT_NE(ret, 0);
814}
815
816/**
817 * @tc.name: UsbdDescriptor006
818 * @tc.desc: Test functions to GetConfigDescriptor
819 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
820 * @tc.desc: Negative test: parameters exception, busNum && configId error
821 * @tc.type: FUNC
822 */
823HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor006, TestSize.Level1)
824{
825    uint8_t configId = CONFIG_ID_INVALID;
826    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
827    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
828    auto ret = g_usbInterface->GetConfigDescriptor(dev, configId, devData);
829    HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor006 length=%{public}zu buffer=%{public}zu ret=%{public}d",
830        devData.size(), sizeof(devData), ret);
831    EXPECT_NE(ret, 0);
832}
833
834/**
835 * @tc.name: UsbdDescriptor007
836 * @tc.desc: Test functions to GetConfigDescriptor
837 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
838 * @tc.desc: Negative test: parameters exception, devAddr && configId error
839 * @tc.type: FUNC
840 */
841HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor007, TestSize.Level1)
842{
843    uint8_t configId = CONFIG_ID_INVALID;
844    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
845    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
846    auto ret = g_usbInterface->GetConfigDescriptor(dev, configId, devData);
847    HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor007 length=%{public}zu buffer=%{public}zu ret=%{public}d",
848        devData.size(), sizeof(devData), ret);
849    EXPECT_NE(ret, 0);
850}
851
852/**
853 * @tc.name: UsbdDescriptor008
854 * @tc.desc: Test functions to GetConfigDescriptor
855 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor);
856 * @tc.desc: Negative test: parameters exception, busNum && devAddr && configId error
857 * @tc.type: FUNC
858 */
859HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor008, TestSize.Level1)
860{
861    uint8_t configId = CONFIG_ID_INVALID;
862    struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
863    std::vector<uint8_t> devData(MAX_BUFFER_LENGTH);
864    auto ret = g_usbInterface->GetConfigDescriptor(dev, configId, devData);
865    HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor008 length=%{public}zu buffer=%{public}zu ret=%{public}d",
866        devData.size(), sizeof(devData), ret);
867    EXPECT_NE(ret, 0);
868}
869
870/**
871 * @tc.name: UsbdGetRawDescriptor001
872 * @tc.desc: Test functions to GetRawDescriptor
873 * @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
874 * @tc.desc: Positive test: parameters correctly
875 * @tc.type: FUNC
876 */
877HWTEST_F(UsbdRequestTest, UsbdGetRawDescriptor001, TestSize.Level1)
878{
879    struct UsbDev dev = dev_;
880    std::vector<uint8_t> rawData;
881    auto ret = g_usbInterface->GetRawDescriptor(dev, rawData);
882    HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor001 length=%{public}zu buffer=%{public}zu ret=%{public}d",
883        rawData.size(), sizeof(rawData), ret);
884    EXPECT_EQ(0, ret);
885}
886
887/**
888 * @tc.name: UsbdGetRawDescriptor002
889 * @tc.desc: Test functions to GetRawDescriptor
890 * @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
891 * @tc.desc: Negative test: parameters exception, busNum error
892 * @tc.type: FUNC
893 */
894HWTEST_F(UsbdRequestTest, UsbdGetRawDescriptor002, TestSize.Level1)
895{
896    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
897    std::vector<uint8_t> rawData;
898    auto ret = g_usbInterface->GetRawDescriptor(dev, rawData);
899    HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor002 length=%{public}zu buffer=%{public}zu ret=%{public}d",
900        rawData.size(), sizeof(rawData), ret);
901    EXPECT_NE(ret, 0);
902}
903
904/**
905 * @tc.name: UsbdGetRawDescriptor003
906 * @tc.desc: Test functions to GetRawDescriptor
907 * @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor);
908 * @tc.desc: Negative test: parameters exception, devAddr error
909 * @tc.type: FUNC
910 */
911HWTEST_F(UsbdRequestTest, UsbdGetRawDescriptor003, TestSize.Level1)
912{
913    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
914    std::vector<uint8_t> rawData;
915    auto ret = g_usbInterface->GetRawDescriptor(dev, rawData);
916    HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor003 length=%{public}zu buffer=%{public}zu ret=%{public}d",
917        rawData.size(), sizeof(rawData), ret);
918    EXPECT_NE(ret, 0);
919}
920
921/**
922 * @tc.name: GetFileDescriptor001
923 * @tc.desc: Test functions to GetFileDescriptor
924 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
925 * @tc.desc: Positive test: parameters correctly
926 * @tc.type: FUNC
927 */
928HWTEST_F(UsbdRequestTest, GetFileDescriptor001, TestSize.Level1)
929{
930    struct UsbDev dev = dev_;
931    int32_t fd = 0;
932    auto ret = g_usbInterface->GetFileDescriptor(dev, fd);
933    HDF_LOGI("UsbdRequestTest::GetFileDescriptor001 %{public}d fd=%{public}d ret=%{public}d", __LINE__, fd, ret);
934    EXPECT_EQ(0, ret);
935}
936
937/**
938 * @tc.name: GetFileDescriptor002
939 * @tc.desc: Test functions to GetFileDescriptor
940 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
941 * @tc.desc: Negative test: parameters exception, busNum error
942 * @tc.type: FUNC
943 */
944HWTEST_F(UsbdRequestTest, GetFileDescriptor002, TestSize.Level1)
945{
946    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
947    int32_t fd = 0;
948    auto ret = g_usbInterface->GetFileDescriptor(dev, fd);
949    HDF_LOGI("UsbdRequestTest::GetFileDescriptor002 %{public}d fd=%{public}d ret=%{public}d", __LINE__, fd, ret);
950    EXPECT_NE(ret, 0);
951}
952
953/**
954 * @tc.name: GetFileDescriptor003
955 * @tc.desc: Test functions to GetFileDescriptor
956 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
957 * @tc.desc: Negative test: parameters exception, devAddr error
958 * @tc.type: FUNC
959 */
960HWTEST_F(UsbdRequestTest, GetFileDescriptor003, TestSize.Level1)
961{
962    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
963    int32_t fd = 0;
964    auto ret = g_usbInterface->GetFileDescriptor(dev, fd);
965    HDF_LOGI("UsbdRequestTest::GetFileDescriptor003 %{public}d fd=%{public}d ret=%{public}d", __LINE__, fd, ret);
966    EXPECT_NE(ret, 0);
967}
968
969/**
970 * @tc.name: GetFileDescriptor004
971 * @tc.desc: Test functions to GetFileDescriptor
972 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
973 * @tc.desc: Negative test: parameters exception, fd error
974 * @tc.type: FUNC
975 */
976HWTEST_F(UsbdRequestTest, GetFileDescriptor004, TestSize.Level1)
977{
978    struct UsbDev dev = dev_;
979    int32_t fd = MAX_BUFFER_LENGTH;
980    auto ret = g_usbInterface->GetFileDescriptor(dev, fd);
981    HDF_LOGI("UsbdRequestTest::GetFileDescriptor004 %{public}d fd=%{public}d ret=%{public}d", __LINE__, fd, ret);
982    EXPECT_EQ(0, ret);
983}
984
985/**
986 * @tc.name: GetDeviceFileDescriptor001
987 * @tc.desc: Test functions to GetDeviceFileDescriptor
988 * @tc.desc: int32_t GetDeviceFileDescriptor(const UsbDev &dev, int32_t &fd);
989 * @tc.desc: Positive test: parameters correctly
990 * @tc.type: FUNC
991 */
992HWTEST_F(UsbdRequestTest, GetDeviceFileDescriptor001, TestSize.Level1)
993{
994    struct UsbDev dev = dev_;
995    int32_t fd = 0;
996    auto ret = g_usbInterface->GetDeviceFileDescriptor(dev, fd);
997    HDF_LOGI("UsbdRequestTest::GetDeviceFileDescriptor001 %{public}d fd=%{public}d ret=%{public}d", __LINE__, fd, ret);
998    EXPECT_EQ(0, ret);
999}
1000
1001/**
1002 * @tc.name: GetDeviceFileDescriptor002
1003 * @tc.desc: Test functions to GetDeviceFileDescriptor
1004 * @tc.desc: int32_t GetDeviceFileDescriptor(const UsbDev &dev, int32_t &fd);
1005 * @tc.desc: Negative test: parameters exception, busNum error
1006 * @tc.type: FUNC
1007 */
1008HWTEST_F(UsbdRequestTest, GetDeviceFileDescriptor002, TestSize.Level1)
1009{
1010    struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
1011    int32_t fd = 0;
1012    auto ret = g_usbInterface->GetDeviceFileDescriptor(dev, fd);
1013    HDF_LOGI("UsbdRequestTest::GetDeviceFileDescriptor002 %{public}d fd=%{public}d ret=%{public}d", __LINE__, fd, ret);
1014    EXPECT_NE(ret, 0);
1015}
1016
1017/**
1018 * @tc.name: GetDeviceFileDescriptor003
1019 * @tc.desc: Test functions to GetDeviceFileDescriptor
1020 * @tc.desc: int32_t GetDeviceFileDescriptor(const UsbDev &dev, int32_t &fd);
1021 * @tc.desc: Negative test: parameters exception, devAddr error
1022 * @tc.type: FUNC
1023 */
1024HWTEST_F(UsbdRequestTest, GetDeviceFileDescriptor003, TestSize.Level1)
1025{
1026    struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
1027    int32_t fd = 0;
1028    auto ret = g_usbInterface->GetDeviceFileDescriptor(dev, fd);
1029    HDF_LOGI("UsbdRequestTest::GetDeviceFileDescriptor003 %{public}d fd=%{public}d ret=%{public}d", __LINE__, fd, ret);
1030    EXPECT_NE(ret, 0);
1031}
1032
1033/**
1034 * @tc.name: GetDeviceFileDescriptor004
1035 * @tc.desc: Test functions to GetDeviceFileDescriptor
1036 * @tc.desc: int32_t GetDeviceFileDescriptor(const UsbDev &dev, int32_t &fd);
1037 * @tc.desc: Negative test: parameters exception, fd error
1038 * @tc.type: FUNC
1039 */
1040HWTEST_F(UsbdRequestTest, GetDeviceFileDescriptor004, TestSize.Level1)
1041{
1042    struct UsbDev dev = dev_;
1043    int32_t fd = MAX_BUFFER_LENGTH;
1044    auto ret = g_usbInterface->GetDeviceFileDescriptor(dev, fd);
1045    HDF_LOGI("UsbdRequestTest::GetDeviceFileDescriptor004 %{public}d fd=%{public}d ret=%{public}d", __LINE__, fd, ret);
1046    EXPECT_EQ(0, ret);
1047}
1048
1049/**
1050 * @tc.name: UsbdRequest001
1051 * @tc.desc: Test functions to RequestQueue
1052 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData
1053        std::vector<uint8_t> &buffer);
1054 * @tc.desc: Positive test: parameters correctly
1055 * @tc.type: FUNC
1056 */
1057HWTEST_F(UsbdRequestTest, UsbdRequestQueue001, TestSize.Level1)
1058{
1059    struct UsbDev dev = dev_;
1060    uint8_t interfaceId = INTERFACEID_OK;
1061    uint8_t pointId = POINTID_DIR_IN;
1062    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1063    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1064    ASSERT_EQ(0, ret);
1065    struct UsbPipe pipe = {interfaceId, pointId};
1066    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1067    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1068    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1069    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue001 interfaceId=%{public}d pointId=%{public}d ret=%{public}d",
1070        interfaceId, pointId, ret);
1071    EXPECT_EQ(0, ret);
1072}
1073
1074/**
1075 * @tc.name: UsbdRequest002
1076 * @tc.desc: Test functions to RequestQueue
1077 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData
1078        std::vector<uint8_t> &buffer);
1079 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
1080 * @tc.type: FUNC
1081 */
1082HWTEST_F(UsbdRequestTest, UsbdRequestQueue002, TestSize.Level1)
1083{
1084    struct UsbDev dev = dev_;
1085    uint8_t pointId = POINTID_DIR_IN;
1086    uint8_t interfaceId = INTERFACEID_OK;
1087    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1088    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1089    ASSERT_EQ(0, ret);
1090    dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
1091    struct UsbPipe pipe = {interfaceId, pointId};
1092    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1093    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1094    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1095    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue002 interfaceId=%{public}d pointId=%{public}d ret=%{public}d",
1096        interfaceId, pointId, ret);
1097    EXPECT_NE(ret, 0);
1098}
1099
1100/**
1101 * @tc.name: UsbdRequest003
1102 * @tc.desc: Test functions to RequestQueue
1103 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData
1104        std::vector<uint8_t> &buffer);
1105 * @tc.desc: Negative test: parameters exception, devAddr error
1106 * @tc.type: FUNC
1107 */
1108HWTEST_F(UsbdRequestTest, UsbdRequestQueue003, TestSize.Level1)
1109{
1110    uint8_t pointId = POINTID_DIR_IN;
1111    uint8_t interfaceId = INTERFACEID_OK;
1112    struct UsbDev dev = dev_;
1113    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1114    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1115    ASSERT_EQ(0, ret);
1116    dev.devAddr = DEV_ADDR_INVALID;
1117    struct UsbPipe pipe = {interfaceId, pointId};
1118    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1119    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1120    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1121    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue003 interfaceId=%{public}d pointId=%{public}d ret=%{public}d",
1122        interfaceId, pointId, ret);
1123    EXPECT_NE(ret, 0);
1124}
1125
1126/**
1127 * @tc.name: UsbdRequest004
1128 * @tc.desc: Test functions to RequestQueue
1129 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uin        t8_t> &clientData
1130        std::vector<uint8_t> &buffer);
1131 * @tc.desc: Negative test: parameters exception, busNum && configIndex error
1132 * @tc.type: FUNC
1133 */
1134HWTEST_F(UsbdRequestTest, UsbdRequestQueue004, TestSize.Level1)
1135{
1136    struct UsbDev dev = dev_;
1137    uint8_t pointId = POINTID_DIR_IN;
1138    uint8_t interfaceId = INTERFACEID_OK;
1139    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1140    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1141    ASSERT_EQ(0, ret);
1142    interfaceId = INVALID_NUM;
1143    dev.busNum = BUS_NUM_INVALID;
1144    struct UsbPipe pipe = {interfaceId, pointId};
1145    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1146    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1147    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1148    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue004 interfaceId=%{public}d pointId=%{public}d ret=%{public}d",
1149        interfaceId, pointId, ret);
1150    EXPECT_NE(ret, 0);
1151}
1152
1153/**
1154 * @tc.name: UsbdRequest005
1155 * @tc.desc: Test functions to RequestQueue
1156 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData
1157        std::vector<uint8_t> &buffer);
1158 * @tc.desc: Negative test: parameters exception, busNum error
1159 * @tc.type: FUNC
1160 */
1161HWTEST_F(UsbdRequestTest, UsbdRequestQueue005, TestSize.Level1)
1162{
1163    struct UsbDev dev = dev_;
1164    uint8_t pointId = POINTID_DIR_IN;
1165    uint8_t interfaceId = INTERFACEID_OK;
1166    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1167    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1168    ASSERT_EQ(0, ret);
1169    dev.busNum = BUS_NUM_INVALID;
1170    struct UsbPipe pipe = {interfaceId, pointId};
1171    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1172    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1173    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1174    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue005 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1175    EXPECT_NE(ret, 0);
1176}
1177
1178/**
1179 * @tc.name: UsbdRequest006
1180 * @tc.desc: Test functions to RequestQueue
1181 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
1182        std::vector<uint8_t> &buffer);
1183 * @tc.desc: Negative test: parameters exception, busNum && interfaceId && pointId error
1184 * @tc.type: FUNC
1185 */
1186HWTEST_F(UsbdRequestTest, UsbdRequestQueue006, TestSize.Level1)
1187{
1188    struct UsbDev dev = dev_;
1189    uint8_t pointId = POINTID_DIR_IN;
1190    uint8_t interfaceId = INTERFACEID_OK;
1191    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1192    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1193    ASSERT_EQ(0, ret);
1194    dev.busNum = BUS_NUM_INVALID;
1195    interfaceId = INVALID_NUM;
1196    pointId = INVALID_NUM;
1197    struct UsbPipe pipe = {interfaceId, pointId};
1198    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1199    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1200    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1201    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue006 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1202    EXPECT_NE(ret, 0);
1203}
1204
1205/**
1206 * @tc.name: UsbdRequest007
1207 * @tc.desc: Test functions to RequestQueue
1208 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData
1209        std::vector<uint8_t> &buffer);
1210 * @tc.desc: Positive test: parameters correctly
1211 * @tc.type: FUNC
1212 */
1213HWTEST_F(UsbdRequestTest, UsbdRequestQueue007, TestSize.Level1)
1214{
1215    struct UsbDev dev = dev_;
1216    uint8_t pointId = POINTID_DIR_OUT;
1217    uint8_t interfaceId = INTERFACEID_OK;
1218    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1219    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1220    ASSERT_EQ(0, ret);
1221    struct UsbPipe pipe = {interfaceId, pointId};
1222    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'w', 'r', 'i', 't', 'e'};
1223    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '7'};
1224    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1225    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue007 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1226    EXPECT_EQ(0, ret);
1227}
1228
1229/**
1230 * @tc.name: UsbdRequest008
1231 * @tc.desc: Test functions to RequestQueue
1232 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData
1233        std::vector<uint8_t> &buffer);
1234 * @tc.desc: Negative test: parameters exception, interfaceId error
1235 * @tc.type: FUNC
1236 */
1237HWTEST_F(UsbdRequestTest, UsbdRequestQueue008, TestSize.Level1)
1238{
1239    struct UsbDev dev = dev_;
1240    uint8_t pointId = POINTID_DIR_OUT;
1241    uint8_t interfaceId = INTERFACEID_OK;
1242    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1243    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1244    ASSERT_EQ(0, ret);
1245    interfaceId = INVALID_NUM;
1246    struct UsbPipe pipe = {interfaceId, pointId};
1247    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'w', 'r', 'i', 't', 'e'};
1248    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '8'};
1249    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1250    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue008 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1251    EXPECT_NE(ret, 0);
1252}
1253
1254/**
1255 * @tc.name: UsbdRequest009
1256 * @tc.desc: Test functions to RequestQueue
1257 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData
1258        std::vector<uint8_t> &buffer);
1259 * @tc.desc: Negative test: parameters exception, interfaceId && pointId error
1260 * @tc.type: FUNC
1261 */
1262HWTEST_F(UsbdRequestTest, UsbdRequestQueue009, TestSize.Level1)
1263{
1264    struct UsbDev dev = dev_;
1265    uint8_t pointId = POINTID_DIR_OUT;
1266    uint8_t interfaceId = INTERFACEID_OK;
1267    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1268    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue009 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1269    ASSERT_EQ(0, ret);
1270    interfaceId = INVALID_NUM;
1271    pointId = INVALID_NUM;
1272    struct UsbPipe pipe = {interfaceId, pointId};
1273    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'w', 'r', 'i', 't', 'e'};
1274    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '9'};
1275    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1276    HDF_LOGI("UsbdRequestTest::UsbdRequestQueue009 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1277    EXPECT_NE(ret, 0);
1278}
1279
1280/**********************************************************************************************************/
1281
1282/**
1283 * @tc.name: UsbdRequest001
1284 * @tc.desc: Test functions to RequestWait
1285 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
1286 * int32_t timeout);
1287 * @tc.desc: Positive test: parameters correctly
1288 * @tc.type: FUNC
1289 */
1290HWTEST_F(UsbdRequestTest, UsbdRequestWait001, TestSize.Level1)
1291{
1292    struct UsbDev dev = dev_;
1293    uint8_t pointId = POINTID_DIR_IN;
1294    uint8_t interfaceId = INTERFACEID_OK;
1295    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1296    HDF_LOGI("UsbdRequestTest::UsbdRequestWait001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1297    ASSERT_EQ(0, ret);
1298    struct UsbPipe pipe = {interfaceId, pointId};
1299    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1300    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1301    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1302    HDF_LOGI("UsbdRequestTest::UsbdRequestWait001 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1303    ASSERT_EQ(0, ret);
1304    std::vector<uint8_t> waitData(TAG_NUM_10);
1305    ret = g_usbInterface->RequestWait(dev, waitData, bufferData, TIME_WAIT);
1306    HDF_LOGI("UsbdRequestTest::UsbdRequestWait001 %{public}d RequestWait=%{public}d", __LINE__, ret);
1307    EXPECT_EQ(0, ret);
1308}
1309
1310/**
1311 * @tc.name: UsbdRequest002
1312 * @tc.desc: Test functions to RequestWait
1313 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData std::vector<uint8_t> &buffer,
1314 * int32_t timeout);
1315 * @tc.desc: Negative test: parameters exception, busNum error
1316 * @tc.type: FUNC
1317 */
1318HWTEST_F(UsbdRequestTest, UsbdRequestWait002, TestSize.Level1)
1319{
1320    uint8_t pointId = POINTID_DIR_IN;
1321    uint8_t interfaceId = INTERFACEID_OK;
1322    struct UsbDev dev = dev_;
1323    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1324    HDF_LOGI("UsbdRequestTest::UsbdRequestWait002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1325    ASSERT_EQ(0, ret);
1326    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1327    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1328    struct UsbPipe pipe = {interfaceId, pointId};
1329    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1330    HDF_LOGI("UsbdRequestTest::UsbdRequestWait002 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1331    ASSERT_EQ(0, ret);
1332    dev.busNum = BUS_NUM_INVALID;
1333    std::vector<uint8_t> waitData(TAG_NUM_10);
1334    ret = g_usbInterface->RequestWait(dev, waitData, bufferData, TIME_WAIT);
1335    HDF_LOGI("UsbdRequestTest::UsbdRequestWait002 %{public}d RequestWait=%{public}d", __LINE__, ret);
1336    EXPECT_NE(ret, 0);
1337}
1338
1339/**
1340 * @tc.name: UsbdRequest003
1341 * @tc.desc: Test functions to RequestWait
1342 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData std::vector<uint8_t> &buffer,
1343 * int32_t timeout);
1344 * @tc.desc: Negative test: parameters exception, devAddr error
1345 * @tc.type: FUNC
1346 */
1347HWTEST_F(UsbdRequestTest, UsbdRequestWait003, TestSize.Level1)
1348{
1349    uint8_t pointId = POINTID_DIR_IN;
1350    uint8_t interfaceId = INTERFACEID_OK;
1351    struct UsbDev dev = dev_;
1352    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1353    HDF_LOGI("UsbdRequestTest::UsbdRequestWait003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1354    ASSERT_EQ(0, ret);
1355    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1356    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1357    struct UsbPipe pipe = {interfaceId, pointId};
1358    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1359    HDF_LOGI("UsbdRequestTest::UsbdRequestWait003 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1360    ASSERT_EQ(0, ret);
1361    dev.devAddr = DEV_ADDR_INVALID;
1362    std::vector<uint8_t> waitData(TAG_NUM_10);
1363    ret = g_usbInterface->RequestWait(dev, waitData, bufferData, TIME_WAIT);
1364    HDF_LOGI("UsbdRequestTest::UsbdRequestWait003 %{public}d RequestWait=%{public}d", __LINE__, ret);
1365    EXPECT_NE(ret, 0);
1366}
1367
1368/**
1369 * @tc.name: UsbdRequest004
1370 * @tc.desc: Test functions to RequestWait
1371 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData std::vector<uint8_t> &buffer,
1372 * int32_t timeout);
1373 * @tc.desc: Negative test: parameters exception, timeout error
1374 * @tc.type: FUNC
1375 */
1376HWTEST_F(UsbdRequestTest, UsbdRequestWait004, TestSize.Level1)
1377{
1378    uint8_t pointId = POINTID_DIR_IN;
1379    uint8_t interfaceId = INTERFACEID_OK;
1380    struct UsbDev dev = dev_;
1381    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1382    HDF_LOGI("UsbdRequestTest::UsbdRequestWait004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1383    ASSERT_EQ(0, ret);
1384    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1385    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1386    struct UsbPipe pipe = {interfaceId, pointId};
1387    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1388    HDF_LOGI("UsbdRequestTest::UsbdRequestWait004 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1389    ASSERT_EQ(0, ret);
1390    std::vector<uint8_t> waitData(TAG_NUM_10);
1391    ret = g_usbInterface->RequestWait(dev, waitData, bufferData, -TIME_WAIT);
1392    HDF_LOGI("UsbdRequestTest::UsbdRequestWait004 %{public}d RequestWait=%{public}d", __LINE__, ret);
1393    EXPECT_EQ(0, ret);
1394}
1395
1396/**
1397 * @tc.name: UsbdRequest005
1398 * @tc.desc: Test functions to RequestWait
1399 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData std::vector<uint8_t> &buffer,
1400 * int32_t timeout);
1401 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
1402 * @tc.type: FUNC
1403 */
1404HWTEST_F(UsbdRequestTest, UsbdRequestWait005, TestSize.Level1)
1405{
1406    uint8_t pointId = POINTID_DIR_IN;
1407    uint8_t interfaceId = INTERFACEID_OK;
1408    struct UsbDev dev = dev_;
1409    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1410    HDF_LOGI("UsbdRequestTest::UsbdRequestWait005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1411    ASSERT_EQ(0, ret);
1412    struct UsbPipe pipe = {interfaceId, pointId};
1413    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1414    std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1415    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1416    HDF_LOGI("UsbdRequestTest::UsbdRequestWait005 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1417    ASSERT_EQ(0, ret);
1418    std::vector<uint8_t> waitData(TAG_NUM_10);
1419    dev.devAddr = DEV_ADDR_INVALID;
1420    dev.busNum = BUS_NUM_INVALID;
1421    ret = g_usbInterface->RequestWait(dev, waitData, bufferData, TIME_WAIT);
1422    HDF_LOGI("UsbdRequestTest::UsbdRequestWait005 %{public}d RequestWait=%{public}d", __LINE__, ret);
1423    EXPECT_NE(ret, 0);
1424}
1425
1426/**********************************************************************************************************/
1427
1428/**
1429 * @tc.name: UsbdRequest001
1430 * @tc.desc: Test functions to RequestCancel
1431 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
1432 * @tc.desc: Positive test: parameters correctly
1433 * @tc.type: FUNC
1434 */
1435HWTEST_F(UsbdRequestTest, UsbdRequestCancel001, TestSize.Level1)
1436{
1437    uint8_t pointId = POINTID_DIR_IN;
1438    uint8_t interfaceId = INTERFACEID_OK;
1439    struct UsbDev dev = dev_;
1440    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1441    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1442    ASSERT_EQ(0, ret);
1443    struct UsbPipe pipe = {interfaceId, pointId};
1444    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1445    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '1'};
1446    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1447    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel001 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1448    ASSERT_EQ(0, ret);
1449    ret = g_usbInterface->RequestCancel(dev, pipe);
1450    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel001 %{public}d RequestCancel=%{public}d", __LINE__, ret);
1451    EXPECT_EQ(0, ret);
1452}
1453
1454/**
1455 * @tc.name: UsbdRequest002
1456 * @tc.desc: Test functions to RequestCancel
1457 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
1458 * @tc.desc: Negative test: parameters exception, busNum error
1459 * @tc.type: FUNC
1460 */
1461HWTEST_F(UsbdRequestTest, UsbdRequestCancel002, TestSize.Level1)
1462{
1463    struct UsbDev dev = dev_;
1464    uint8_t pointId = POINTID_DIR_IN;
1465    uint8_t interfaceId = INTERFACEID_OK;
1466    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1467    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1468    ASSERT_EQ(0, ret);
1469    struct UsbPipe pipe = {interfaceId, pointId};
1470    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1471    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '2'};
1472    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1473    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1474    ASSERT_EQ(0, ret);
1475    dev.busNum = BUS_NUM_INVALID;
1476    ret = g_usbInterface->RequestCancel(dev, pipe);
1477    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 %{public}d RequestCancel=%{public}d", __LINE__, ret);
1478    EXPECT_NE(ret, 0);
1479    dev = dev_;
1480    ret = g_usbInterface->RequestCancel(dev, pipe);
1481    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 again %{public}d RequestCancel=%{public}d", __LINE__, ret);
1482    EXPECT_EQ(0, ret);
1483}
1484
1485/**
1486 * @tc.name: UsbdRequest003
1487 * @tc.desc: Test functions to RequestCancel
1488 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
1489 * @tc.desc: Negative test: parameters exception, devAddr error
1490 * @tc.type: FUNC
1491 */
1492HWTEST_F(UsbdRequestTest, UsbdRequestCancel003, TestSize.Level1)
1493{
1494    struct UsbDev dev = dev_;
1495    uint8_t pointId = POINTID_DIR_IN;
1496    uint8_t interfaceId = INTERFACEID_OK;
1497    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1498    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1499    ASSERT_EQ(0, ret);
1500    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1501    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '3'};
1502    struct UsbPipe pipe = {interfaceId, pointId};
1503    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1504    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel003 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1505    ASSERT_EQ(0, ret);
1506    dev.devAddr = DEV_ADDR_INVALID;
1507    ret = g_usbInterface->RequestCancel(dev, pipe);
1508    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel003 %{public}d RequestCancel=%{public}d", __LINE__, ret);
1509    EXPECT_NE(ret, 0);
1510    dev = dev_;
1511    ret = g_usbInterface->RequestCancel(dev, pipe);
1512    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel003 again %{public}d RequestCancel=%{public}d", __LINE__, ret);
1513    EXPECT_EQ(0, ret);
1514}
1515
1516/**
1517 * @tc.name: UsbdRequest004
1518 * @tc.desc: Test functions to RequestCancel
1519 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
1520 * @tc.desc: Positive test: intfId && endpointId error in pipe but not used
1521 * @tc.type: FUNC
1522 */
1523HWTEST_F(UsbdRequestTest, UsbdRequestCancel004, TestSize.Level1)
1524{
1525    struct UsbDev dev = dev_;
1526    uint8_t pointId = POINTID_DIR_OUT;
1527    uint8_t interfaceId = INTERFACEID_OK;
1528    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1529    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1530    ASSERT_EQ(0, ret);
1531    struct UsbPipe pipe = {interfaceId, pointId};
1532    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1533    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '4'};
1534    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1535    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1536    ASSERT_EQ(0, ret);
1537    pipe.intfId = INTERFACEID_INVALID;
1538    pipe.endpointId = POINTID_INVALID;
1539    ret = g_usbInterface->RequestCancel(dev, pipe);
1540    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d RequestCancel=%{public}d", __LINE__, ret);
1541    EXPECT_EQ(0, ret);
1542    pipe = {interfaceId, pointId};
1543    ret = g_usbInterface->RequestCancel(dev, pipe);
1544    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d again RequestCancel=%{public}d", __LINE__, ret);
1545    EXPECT_EQ(0, ret);
1546}
1547
1548/**
1549 * @tc.name: UsbdRequest005
1550 * @tc.desc: Test functions to RequestCancel
1551 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
1552 * @tc.desc: Negative test: call twice
1553 * @tc.type: FUNC
1554 */
1555HWTEST_F(UsbdRequestTest, UsbdRequestCancel005, TestSize.Level1)
1556{
1557    struct UsbDev dev = dev_;
1558    uint8_t pointId = POINTID_DIR_OUT;
1559    uint8_t interfaceId = INTERFACEID_OK;
1560    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1561    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1562    ASSERT_EQ(0, ret);
1563    struct UsbPipe pipe = {interfaceId, pointId};
1564    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1565    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '5'};
1566    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1567    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel005 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1568    ASSERT_EQ(0, ret);
1569    ret = g_usbInterface->RequestCancel(dev, pipe);
1570    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel005 %{public}d RequestCancel=%{public}d", __LINE__, ret);
1571    EXPECT_EQ(0, ret);
1572    dev = dev_;
1573    pipe = {interfaceId, pointId};
1574    ret = g_usbInterface->RequestCancel(dev, pipe);
1575    EXPECT_EQ(0, ret);
1576}
1577
1578/**
1579 * @tc.name: UsbdRequest006
1580 * @tc.desc: Test functions to RequestCancel
1581 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
1582 * @tc.desc: Negative test: parameters exception, busNum error && interfaceid ignore
1583 * @tc.type: FUNC
1584 */
1585HWTEST_F(UsbdRequestTest, UsbdRequestCancel006, TestSize.Level1)
1586{
1587    struct UsbDev dev = dev_;
1588    uint8_t pointId = POINTID_DIR_OUT;
1589    uint8_t interfaceId = INTERFACEID_OK;
1590    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1591    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1592    ASSERT_EQ(0, ret);
1593    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1594    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '6'};
1595    struct UsbPipe pipe = {interfaceId, pointId};
1596    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1597    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel006 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1598    ASSERT_EQ(0, ret);
1599    dev.busNum = BUS_NUM_INVALID;
1600    pipe.intfId = 224;
1601    ret = g_usbInterface->RequestCancel(dev, pipe);
1602    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel006 %{public}d RequestCancel=%{public}d", __LINE__, ret);
1603    EXPECT_NE(ret, 0);
1604    dev.busNum = dev_.busNum;
1605    pipe.intfId = INTERFACEID_OK;
1606    ret = g_usbInterface->RequestCancel(dev, pipe);
1607    EXPECT_EQ(0, ret);
1608}
1609
1610/**
1611 * @tc.name: UsbdRequest007
1612 * @tc.desc: Test functions to RequestCancel
1613 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
1614 * @tc.desc: Negative test: parameters exception, devAddr error && interfaceid ignore
1615 * @tc.type: FUNC
1616 */
1617HWTEST_F(UsbdRequestTest, UsbdRequestCancel007, TestSize.Level1)
1618{
1619    struct UsbDev dev = dev_;
1620    uint8_t pointId = POINTID_DIR_OUT;
1621    uint8_t interfaceId = INTERFACEID_OK;
1622    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1623    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1624    ASSERT_EQ(0, ret);
1625    struct UsbPipe pipe = {interfaceId, pointId};
1626    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1627    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '7'};;
1628    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1629    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel007 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1630    ASSERT_EQ(0, ret);
1631    dev.devAddr = DEV_ADDR_INVALID;
1632    pipe.intfId = INTERFACEID_INVALID;
1633    ret = g_usbInterface->RequestCancel(dev, pipe);
1634    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel007 %{public}d RequestCancel=%{public}d", __LINE__, ret);
1635    EXPECT_NE(ret, 0);
1636    dev.devAddr = dev_.devAddr;
1637    pipe.intfId = INTERFACEID_OK;
1638    ret = g_usbInterface->RequestCancel(dev, pipe);
1639    EXPECT_EQ(0, ret);
1640}
1641
1642/**
1643 * @tc.name: UsbdRequest008
1644 * @tc.desc: Test functions to RequestCancel
1645 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
1646 * @tc.desc: Negative test: parameters exception, busNum error && devAddr error && interfaceid ignore
1647 * @tc.type: FUNC
1648 */
1649HWTEST_F(UsbdRequestTest, UsbdRequestCancel008, TestSize.Level1)
1650{
1651    struct UsbDev dev = dev_;
1652    uint8_t pointId = POINTID_DIR_OUT;
1653    uint8_t interfaceId = INTERFACEID_OK;
1654    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1655    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1656    ASSERT_EQ(0, ret);
1657    struct UsbPipe pipe = {interfaceId, pointId};
1658    std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
1659    std::vector<uint8_t> bufferData = {'r', 'e', 'q', 'u', 'e', 's', 't', '0', '0', '8'};
1660    ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
1661    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel008 %{public}d RequestQueue=%{public}d", __LINE__, ret);
1662    ASSERT_EQ(0, ret);
1663    dev.busNum = BUS_NUM_INVALID;
1664    dev.devAddr = DEV_ADDR_INVALID;
1665    pipe.intfId = INTERFACEID_INVALID;
1666    ret = g_usbInterface->RequestCancel(dev, pipe);
1667    HDF_LOGI("UsbdRequestTest::UsbdRequestCancel008 %{public}d RequestCancel=%{public}d", __LINE__, ret);
1668    EXPECT_NE(ret, 0);
1669    dev = dev_;
1670    pipe.intfId = INTERFACEID_OK;
1671    ret = g_usbInterface->RequestCancel(dev, pipe);
1672    EXPECT_EQ(0, ret);
1673}
1674
1675/**********************************************************************************************************/
1676
1677/**
1678 * @tc.name: UsbdReleaseInterface001
1679 * @tc.desc: Test functions to ReleaseInterface
1680 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
1681 * @tc.desc: Positive test: parameters correctly
1682 * @tc.type: FUNC
1683 */
1684HWTEST_F(UsbdRequestTest, UsbdReleaseInterface001, TestSize.Level1)
1685{
1686    struct UsbDev dev = dev_;
1687    uint8_t interfaceId = INTERFACEID_OK;
1688    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1689    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1690    ASSERT_EQ(0, ret);;
1691    ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
1692    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface001 %{public}d ret=%{public}d", __LINE__, ret);
1693    EXPECT_EQ(0, ret);
1694}
1695
1696/**
1697 * @tc.name: UsbdReleaseInterface002
1698 * @tc.desc: Test functions to ReleaseInterface
1699 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
1700 * @tc.desc: Negative test: parameters exception, busNum error
1701 * @tc.type: FUNC
1702 */
1703HWTEST_F(UsbdRequestTest, UsbdReleaseInterface002, TestSize.Level1)
1704{
1705    struct UsbDev dev = dev_;
1706    uint8_t interfaceId = INTERFACEID_OK;
1707    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1708    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1709    ASSERT_EQ(0, ret);
1710    dev = {BUS_NUM_INVALID, dev_.devAddr};
1711    ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
1712    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface002 %{public}d ret=%{public}d", __LINE__, ret);
1713    EXPECT_NE(ret, 0);
1714}
1715
1716/**
1717 * @tc.name: UsbdReleaseInterface003
1718 * @tc.desc: Test functions to ReleaseInterface
1719 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
1720 * @tc.desc: Negative test: parameters exception, devAddr error
1721 * @tc.type: FUNC
1722 */
1723HWTEST_F(UsbdRequestTest, UsbdReleaseInterface003, TestSize.Level1)
1724{
1725    struct UsbDev dev = dev_;
1726    uint8_t interfaceId = INTERFACEID_OK;
1727    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1728    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1729    ASSERT_EQ(0, ret);
1730    dev = {dev_.busNum, DEV_ADDR_INVALID};
1731    ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
1732    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface003 %{public}d ret=%{public}d", __LINE__, ret);
1733    EXPECT_NE(ret, 0);
1734}
1735
1736/**
1737 * @tc.name: UsbdReleaseInterface004
1738 * @tc.desc: Test functions to ReleaseInterface
1739 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
1740 * @tc.desc: Negative test: parameters exception, interfaceid error
1741 * @tc.type: FUNC
1742 */
1743HWTEST_F(UsbdRequestTest, UsbdReleaseInterface004, TestSize.Level1)
1744{
1745    struct UsbDev dev = dev_;
1746    uint8_t interfaceId = INTERFACEID_OK;
1747    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1748    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1749    ASSERT_EQ(0, ret);
1750    interfaceId = INTERFACEID_INVALID;
1751    ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
1752    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface004 %{public}d ret=%{public}d", __LINE__, ret);
1753    EXPECT_NE(ret, 0);
1754}
1755
1756/**
1757 * @tc.name: UsbdReleaseInterface005
1758 * @tc.desc: Test functions to ReleaseInterface
1759 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
1760 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
1761 * @tc.type: FUNC
1762 */
1763HWTEST_F(UsbdRequestTest, UsbdReleaseInterface005, TestSize.Level1)
1764{
1765    struct UsbDev dev = dev_;
1766    uint8_t interfaceId = INTERFACEID_OK;
1767    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1768    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1769    ASSERT_EQ(0, ret);
1770    dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
1771    ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
1772    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface005 %{public}d ret=%{public}d", __LINE__, ret);
1773    EXPECT_NE(ret, 0);
1774}
1775
1776/**
1777 * @tc.name: UsbdReleaseInterface006
1778 * @tc.desc: Test functions to ReleaseInterface
1779 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
1780 * @tc.desc: Negative test: parameters exception, busNum && interfaceid error
1781 * @tc.type: FUNC
1782 */
1783HWTEST_F(UsbdRequestTest, UsbdReleaseInterface006, TestSize.Level1)
1784{
1785    struct UsbDev dev = dev_;
1786    uint8_t interfaceId = INTERFACEID_OK;
1787    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1788    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1789    ASSERT_EQ(0, ret);
1790    interfaceId = INTERFACEID_INVALID;
1791    dev = {DEV_ADDR_INVALID, dev_.devAddr};
1792    ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
1793    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface006 %{public}d ret=%{public}d", __LINE__, ret);
1794    EXPECT_NE(ret, 0);
1795}
1796
1797/**
1798 * @tc.name: UsbdReleaseInterface007
1799 * @tc.desc: Test functions to ReleaseInterface
1800 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
1801 * @tc.desc: Negative test: parameters exception, devAddr && interfaceid error
1802 * @tc.type: FUNC
1803 */
1804HWTEST_F(UsbdRequestTest, UsbdReleaseInterface007, TestSize.Level1)
1805{
1806    struct UsbDev dev = dev_;
1807    uint8_t interfaceId = INTERFACEID_OK;
1808    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1809    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1810    ASSERT_EQ(0, ret);
1811    interfaceId = INTERFACEID_INVALID;
1812    dev = {dev_.busNum, DEV_ADDR_INVALID};
1813    ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
1814    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface007 %{public}d ret=%{public}d", __LINE__, ret);
1815    EXPECT_NE(ret, 0);
1816}
1817
1818/**
1819 * @tc.name: UsbdReleaseInterface008
1820 * @tc.desc: Test functions to ReleaseInterface
1821 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
1822 * @tc.desc: Negative test: parameters exception, busNum && devAddr && interfaceid error
1823 * @tc.type: FUNC
1824 */
1825HWTEST_F(UsbdRequestTest, UsbdReleaseInterface008, TestSize.Level1)
1826{
1827    struct UsbDev dev = dev_;
1828    uint8_t interfaceId = INTERFACEID_OK;
1829    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1830    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1831    ASSERT_EQ(0, ret);
1832    interfaceId = INTERFACEID_INVALID;
1833    dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
1834    ret = g_usbInterface->ReleaseInterface(dev, interfaceId);
1835    HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface008 %{public}d ret=%{public}d", __LINE__, ret);
1836    EXPECT_NE(ret, 0);
1837}
1838
1839/**
1840 * @tc.name: BulkCancel001
1841 * @tc.desc: Test functions to BulkCancel
1842 * @tc.desc: int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe);
1843 * @tc.desc: Positive test: parameters correctly
1844 * @tc.type: FUNC
1845 */
1846HWTEST_F(UsbdRequestTest, BulkCancel001, TestSize.Level1)
1847{
1848    struct UsbDev dev = dev_;
1849    uint8_t interfaceId = INTERFACEID_OK;
1850    uint8_t pointId = POINTID_DIR_IN;
1851    struct UsbPipe pipe = {interfaceId, pointId};
1852    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1853    HDF_LOGI("UsbdRequestTest::BulkCancel001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1854    ASSERT_EQ(0, ret);
1855    sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1856    ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1857    HDF_LOGI("UsbdTransferTest::BulkCancel001 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1858    ASSERT_EQ(ret, 0);
1859    ret = g_usbInterface->BulkCancel(dev, pipe);
1860    HDF_LOGI("UsbdRequestTest::BulkCancel001 %{public}d BulkCancel=%{public}d", __LINE__, ret);
1861    ASSERT_EQ(0, ret);
1862    ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1863    HDF_LOGI("UsbdTransferTest::BulkCancel001 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1864    EXPECT_EQ(ret, 0);
1865}
1866
1867/**
1868 * @tc.name: BulkCancel002
1869 * @tc.desc: Test functions to BulkCancel
1870 * @tc.desc: int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe);
1871 * @tc.desc: Negative test: parameters exception, busNum error
1872 * @tc.type: FUNC
1873 */
1874HWTEST_F(UsbdRequestTest, BulkCancel002, TestSize.Level1)
1875{
1876    struct UsbDev dev = dev_;
1877    uint8_t interfaceId = INTERFACEID_OK;
1878    uint8_t pointId = POINTID_DIR_IN;
1879    struct UsbPipe pipe = {interfaceId, pointId};
1880    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1881    HDF_LOGI("UsbdRequestTest::BulkCancel002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1882    ASSERT_EQ(0, ret);
1883    sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1884    ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1885    HDF_LOGI("UsbdTransferTest::BulkCancel002 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1886    ASSERT_EQ(ret, 0);
1887    dev.busNum = BUS_NUM_INVALID;
1888    ret = g_usbInterface->BulkCancel(dev, pipe);
1889    HDF_LOGI("UsbdRequestTest::BulkCancel002 %{public}d BulkCancel=%{public}d", __LINE__, ret);
1890    ASSERT_NE(0, ret);
1891    dev = dev_;
1892    ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1893    HDF_LOGI("UsbdTransferTest::BulkCancel002 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1894    EXPECT_EQ(ret, 0);
1895}
1896
1897/**
1898 * @tc.name: BulkCancel003
1899 * @tc.desc: Test functions to BulkCancel
1900 * @tc.desc: int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe);
1901 * @tc.desc: Negative test: parameters exception, devAddr error
1902 * @tc.type: FUNC
1903 */
1904HWTEST_F(UsbdRequestTest, BulkCancel003, TestSize.Level1)
1905{
1906    struct UsbDev dev = dev_;
1907    uint8_t interfaceId = INTERFACEID_OK;
1908    uint8_t pointId = POINTID_DIR_IN;
1909    struct UsbPipe pipe = {interfaceId, pointId};
1910    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1911    HDF_LOGI("UsbdRequestTest::BulkCancel003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1912    ASSERT_EQ(0, ret);
1913    sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1914    ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1915    HDF_LOGI("UsbdTransferTest::BulkCancel003 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1916    ASSERT_EQ(ret, 0);
1917    dev.devAddr = DEV_ADDR_INVALID;
1918    ret = g_usbInterface->BulkCancel(dev, pipe);
1919    HDF_LOGI("UsbdRequestTest::BulkCancel003 %{public}d BulkCancel=%{public}d", __LINE__, ret);
1920    ASSERT_NE(0, ret);
1921    dev = dev_;
1922    ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1923    HDF_LOGI("UsbdTransferTest::BulkCancel003 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1924    EXPECT_EQ(ret, 0);
1925}
1926
1927/**
1928 * @tc.name: BulkCancel004
1929 * @tc.desc: Test functions to BulkCancel
1930 * @tc.desc: int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe);
1931 * @tc.desc: Negative test: parameters exception, busNum && devAddr && interfaceid error
1932 * @tc.type: FUNC
1933 */
1934HWTEST_F(UsbdRequestTest, BulkCancel004, TestSize.Level1)
1935{
1936    struct UsbDev dev = dev_;
1937    uint8_t interfaceId = INTERFACEID_OK;
1938    uint8_t pointId = POINTID_DIR_IN;
1939    struct UsbPipe pipe = {interfaceId, pointId};
1940    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1941    HDF_LOGI("UsbdRequestTest::BulkCancel004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1942    ASSERT_EQ(0, ret);
1943    sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1944    ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1945    HDF_LOGI("UsbdTransferTest::BulkCancel004 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1946    ASSERT_EQ(ret, 0);
1947    dev.busNum = BUS_NUM_INVALID;
1948    dev.devAddr = DEV_ADDR_INVALID;
1949    pipe.intfId = POINTID_INVALID;
1950    ret = g_usbInterface->BulkCancel(dev, pipe);
1951    HDF_LOGI("UsbdRequestTest::BulkCancel004 %{public}d BulkCancel=%{public}d", __LINE__, ret);
1952    ASSERT_NE(0, ret);
1953    dev = dev_;
1954    pipe = {interfaceId, pointId};
1955    ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1956    HDF_LOGI("UsbdTransferTest::BulkCancel004 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1957    EXPECT_EQ(ret, 0);
1958}
1959
1960/**
1961 * @tc.name: BulkCancel005
1962 * @tc.desc: Test functions to BulkCancel
1963 * @tc.desc: int32_t BulkCancel(const UsbDev &dev, const UsbPipe &pipe);
1964 * @tc.desc: Negative test: parameters exception, intfId error
1965 * @tc.type: FUNC
1966 */
1967HWTEST_F(UsbdRequestTest, BulkCancel005, TestSize.Level1)
1968{
1969    struct UsbDev dev = dev_;
1970    uint8_t interfaceId = INTERFACEID_OK;
1971    uint8_t pointId = POINTID_DIR_IN;
1972    struct UsbPipe pipe = {interfaceId, pointId};
1973    auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1974    HDF_LOGI("UsbdRequestTest::BulkCancel005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1975    ASSERT_EQ(0, ret);
1976    sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1977    ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1978    HDF_LOGI("UsbdTransferTest::BulkCancel004 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1979    ASSERT_EQ(ret, 0);
1980    pipe.intfId = POINTID_INVALID;
1981    ret = g_usbInterface->BulkCancel(dev, pipe);
1982    HDF_LOGI("UsbdRequestTest::BulkCancel004 %{public}d BulkCancel=%{public}d", __LINE__, ret);
1983    ASSERT_NE(0, ret);
1984    pipe = {interfaceId, pointId};
1985    ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1986    HDF_LOGI("UsbdTransferTest::BulkCancel004 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1987    EXPECT_EQ(ret, 0);
1988}
1989} // namespace
1990