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