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