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