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