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