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