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