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