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