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