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