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