1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "usbd_request_test.h"
17 #include <iostream>
18 #include <vector>
19 #include "hdf_log.h"
20 #include "usb_param.h"
21 #include "usbd_client.h"
22
23 using namespace testing::ext;
24 using namespace OHOS;
25 using namespace OHOS::USB;
26 using namespace std;
27
28 const int SLEEP_TIME = 3;
29 const uint8_t BUS_NUM_1 = 1;
30 const uint8_t DEV_ADDR_2 = 2;
31 const uint8_t BUS_NUM_255 = 255;
32 const uint8_t DEV_ADDR_255 = 255;
33 const uint8_t BUS_NUM_222 = 222;
34 const uint8_t DEV_ADDR_222 = 222;
35 const uint32_t LENGTH_NUM_255 = 255;
36 const uint32_t TAG_LENGTH_NUM_1000 = 1000;
37 const int TAG_NUM_10 = 10;
38 const int TAG_NUM_11 = 11;
39 const uint8_t INTERFACEID_1 = 1;
40 const uint8_t POINTID_1 = 1;
41 const uint8_t POINTID_129 = 129;
42
SetUpTestCase(void)43 void UsbdRequestTest::SetUpTestCase(void)
44 {
45 auto ret = UsbdClient::GetInstance().SetPortRole(1, 1, 1);
46 sleep(SLEEP_TIME);
47 HDF_LOGI("UsbdFunctionTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
48 ASSERT_TRUE(ret == 0);
49 if (ret != 0) {
50 exit(0);
51 }
52 std::cout << "please connect device, press enter to continue" << std::endl;
53 int c;
54 while ((c = getchar()) != '\n' && c != EOF) {
55 }
56 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
57 ret = UsbdClient::GetInstance().OpenDevice(dev);
58 HDF_LOGI("UsbdRequestTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
59 ASSERT_TRUE(ret == 0);
60 }
61
TearDownTestCase(void)62 void UsbdRequestTest::TearDownTestCase(void)
63 {
64 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
65 auto ret = UsbdClient::GetInstance().CloseDevice(dev);
66 HDF_LOGI("UsbdRequestTest:: %{public}d Close=%{public}d", __LINE__, ret);
67 ASSERT_TRUE(ret == 0);
68 }
69
SetUp(void)70 void UsbdRequestTest::SetUp(void) {}
71
TearDown(void)72 void UsbdRequestTest::TearDown(void) {}
73
74 /**
75 * @tc.name: UsbdConfig001
76 * @tc.desc: Test functions to SetConfig
77 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
78 * @tc.type: FUNC
79 */
80 HWTEST_F(UsbdRequestTest, UsbdSetConfig001, Function | MediumTest | Level1)
81 {
82 uint8_t busNum = 1;
83 uint8_t devAddr = 2;
84 uint8_t configIndex = 1;
85 struct UsbDev dev = {busNum, devAddr};
86 auto ret = UsbdClient::GetInstance().SetConfig(dev, configIndex);
87 HDF_LOGI("UsbdRequestTest::UsbdSetConfigConfig001 %{public}d SetConfig=%{public}d", __LINE__, ret);
88 ASSERT_TRUE(ret == 0);
89 }
90
91 /**
92 * @tc.name: UsbdConfig002
93 * @tc.desc: Test functions to SetConfig
94 * @tc.desc: int32_t SetConfig(const UsbDev &dev, uint8_t configIndex);
95 * @tc.type: FUNC
96 */
97 HWTEST_F(UsbdRequestTest, UsbdSetConfig002, Function | MediumTest | Level1)
98 {
99 uint8_t busNum = BUS_NUM_222;
100 uint8_t devAddr = 2;
101 uint8_t configIndex = 1;
102 struct UsbDev dev = {busNum, devAddr};
103 auto ret = UsbdClient::GetInstance().SetConfig(dev, configIndex);
104 HDF_LOGI("UsbdRequestTest::UsbdSetConfig002 %{public}d SetConfig=%{public}d", __LINE__, ret);
105 ASSERT_TRUE(ret != 0);
106 }
107
108 /**
109 * @tc.name: UsbdConfig001
110 * @tc.desc: Test functions to GetConfig
111 * @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
112 * @tc.desc: 正向测试：参数正确
113 * @tc.type: FUNC
114 */
115 HWTEST_F(UsbdRequestTest, UsbdGetConfig001, Function | MediumTest | Level1)
116 {
117 uint8_t busNum = 1;
118 uint8_t devAddr = 2;
119 uint8_t configIndex = 1;
120 struct UsbDev dev = {busNum, devAddr};
121 auto ret = UsbdClient::GetInstance().GetConfig(dev, configIndex);
122 HDF_LOGI("UsbdRequestTest::UsbdGetConfig001 %{public}d GetConfig=%{public}d", __LINE__, ret);
123 ASSERT_TRUE(ret == 0);
124 }
125
126 /**
127 * @tc.name: UsbdConfig002
128 * @tc.desc: Test functions to GetConfig
129 * @tc.desc: int32_t GetConfig(const UsbDev &dev, uint8_t &configIndex);
130 * @tc.type: FUNC
131 */
132 HWTEST_F(UsbdRequestTest, UsbdGetConfig002, Function | MediumTest | Level1)
133 {
134 uint8_t busNum = BUS_NUM_222;
135 uint8_t devAddr = 2;
136 uint8_t configIndex = 1;
137 struct UsbDev dev = {busNum, devAddr};
138 auto ret = UsbdClient::GetInstance().GetConfig(dev, configIndex);
139 HDF_LOGI("UsbdRequestTest::UsbdGetConfig002 %{public}d GetConfig=%{public}d", __LINE__, ret);
140 ASSERT_TRUE(ret != 0);
141 }
142
143 /**
144 * @tc.name: UsbdClaimInterface001
145 * @tc.desc: Test functions to ClaimInterface
146 * @tc.desc: int32_t ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
147 * @tc.type: FUNC
148 */
149 HWTEST_F(UsbdRequestTest, UsbdClaimInterface001, Function | MediumTest | Level1)
150 {
151 uint8_t busNum = 1;
152 uint8_t devAddr = 2;
153 uint8_t interfaceId = INTERFACEID_1;
154 struct UsbDev dev = {busNum, devAddr};
155 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
156 HDF_LOGI("UsbdRequestTest::UsbdClaimInterface001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
157 ASSERT_TRUE(ret == 0);
158 }
159
160 /**
161 * @tc.name: UsbdClaimInterface002
162 * @tc.desc: Test functions to ClaimInterface
163 * @tc.desc: int32_t ClaimInterface(const UsbDev &dev, uint8_t interfaceId);
164 * @tc.type: FUNC
165 */
166 HWTEST_F(UsbdRequestTest, UsbdClaimInterface002, Function | MediumTest | Level1)
167 {
168 uint8_t busNum = 1;
169 uint8_t devAddr = 2;
170 uint8_t interfaceId = INTERFACEID_1;
171 struct UsbDev dev = {busNum, devAddr};
172 dev.busNum = 20;
173 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
174 HDF_LOGI("UsbdRequestTest::UsbdClaimInterface002 %{public}d ret=%{public}d", __LINE__, ret);
175 ASSERT_TRUE(ret != 0);
176 }
177
178 /**
179 * @tc.name: UsbdSetInterface001
180 * @tc.desc: Test functions to SetInterface
181 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
182 * @tc.type: FUNC
183 */
184 HWTEST_F(UsbdRequestTest, UsbdSetInterface001, Function | MediumTest | Level1)
185 {
186 uint8_t busNum = 1;
187 uint8_t devAddr = 2;
188 uint8_t interfaceId = INTERFACEID_1;
189 uint8_t altIndex = 0;
190
191 struct UsbDev dev = {busNum, devAddr};
192
193 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
194 HDF_LOGI("UsbdRequestTest::UsbdClaimInterface001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
195 ASSERT_TRUE(ret == 0);
196 ret = UsbdClient::GetInstance().SetInterface(dev, interfaceId, altIndex);
197 HDF_LOGI("UsbdRequestTest::UsbdSetInterface001 %{public}d ret=%{public}d", __LINE__, ret);
198 ASSERT_TRUE(ret == 0);
199 }
200
201 /**
202 * @tc.name: UsbdSetInterface002
203 * @tc.desc: Test functions to SetInterface
204 * @tc.desc: int32_t SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex);
205 * @tc.type: FUNC
206 */
207 HWTEST_F(UsbdRequestTest, UsbdSetInterface002, Function | MediumTest | Level1)
208 {
209 uint8_t busNum = 1;
210 uint8_t devAddr = 2;
211 uint8_t interfaceId = INTERFACEID_1;
212
213 uint8_t altIndex = 0;
214 struct UsbDev dev = {busNum, devAddr};
215
216
217 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
218 HDF_LOGI("UsbdRequestTest::UsbdSetInterface002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
219 ASSERT_TRUE(ret == 0);
220 dev.busNum = BUS_NUM_222;
221 ret = UsbdClient::GetInstance().SetInterface(dev, interfaceId, altIndex);
222 HDF_LOGI("UsbdRequestTest::UsbdSetInterface002 %{public}d ret=%{public}d", __LINE__, ret);
223 ASSERT_TRUE(ret != 0);
224 }
225
226 /**
227 * @tc.name: UsbdDescriptor001
228 * @tc.desc: Test functions to GetDeviceDescriptor
229 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
230 * @tc.type: FUNC
231 */
232 HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor001, Function | MediumTest | Level1)
233 {
234 uint8_t busNum = 1;
235 uint8_t devAddr = 2;
236 uint32_t length = LENGTH_NUM_255;
237 uint8_t buffer[LENGTH_NUM_255] = {0};
238 struct UsbDev dev = {busNum, devAddr};
239 std::vector<uint8_t> devdata(buffer, buffer + length);
240 auto ret = UsbdClient::GetInstance().GetDeviceDescriptor(dev, devdata);
241 HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor001 %{public}d ret=%{public}d", __LINE__, ret);
242 HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor001 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
243 devdata.size(), sizeof(devdata));
244 ASSERT_TRUE(ret == 0);
245 }
246
247 /**
248 * @tc.name: UsbdDescriptor002
249 * @tc.desc: Test functions to GetDeviceDescriptor
250 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
251 * @tc.type: FUNC
252 */
253 HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor002, Function | MediumTest | Level1)
254 {
255 uint8_t busNum = BUS_NUM_222;
256 uint8_t devAddr = 2;
257 uint8_t buffer[LENGTH_NUM_255] = {0};
258 uint32_t length = LENGTH_NUM_255;
259 struct UsbDev dev = {busNum, devAddr};
260 std::vector<uint8_t> devdata(buffer, buffer + length);
261 auto ret = UsbdClient::GetInstance().GetDeviceDescriptor(dev, devdata);
262 HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor002 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
263 devdata.size(), sizeof(devdata));
264 HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor002 %{public}d ret=%{public}d", __LINE__, ret);
265 ASSERT_TRUE(ret != 0);
266 }
267
268 /**
269 * @tc.name: UsbdDescriptor004
270 * @tc.desc: Test functions to GetDeviceDescriptor
271 * @tc.desc: int32_t GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
272 * @tc.type: FUNC
273 */
274 HWTEST_F(UsbdRequestTest, UsbdGetDeviceDescriptor004, Function | MediumTest | Level1)
275 {
276 uint8_t busNum = 1;
277 uint8_t devAddr = 2;
278 uint8_t buffer[LENGTH_NUM_255] = {};
279 uint32_t length = 0;
280 struct UsbDev dev = {busNum, devAddr};
281 std::vector<uint8_t> devdata(buffer, buffer + length);
282 auto ret = UsbdClient::GetInstance().GetDeviceDescriptor(dev, devdata);
283 HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor004 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
284 devdata.size(), sizeof(devdata));
285 HDF_LOGI("UsbdRequestTest::UsbdGetDeviceDescriptor004 %{public}d ret=%{public}d", __LINE__, ret);
286 ASSERT_TRUE(ret == 0);
287 }
288
289 /**
290 * @tc.name: UsbdDescriptor001
291 * @tc.desc: Test functions to GetStringDescriptor
292 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
293 * @tc.type: FUNC
294 */
295 HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor001, Function | MediumTest | Level1)
296 {
297 uint8_t busNum = 1;
298 uint8_t devAddr = 2;
299 uint8_t stringId = 0;
300 uint8_t buffer[LENGTH_NUM_255] = {0};
301 uint32_t length = LENGTH_NUM_255;
302 struct UsbDev dev = {busNum, devAddr};
303 std::vector<uint8_t> devdata(buffer, buffer + length);
304 auto ret = UsbdClient::GetInstance().GetStringDescriptor(dev, stringId, devdata);
305 HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor001 %{public}d ret=%{public}d", __LINE__, ret);
306 HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor001 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
307 devdata.size(), sizeof(devdata));
308 ASSERT_TRUE(ret == 0);
309 }
310
311 /**
312 * @tc.name: UsbdDescriptor002
313 * @tc.desc: Test functions to GetStringDescriptor
314 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
315 * @tc.type: FUNC
316 */
317 HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor002, Function | MediumTest | Level1)
318 {
319 uint8_t busNum = 1;
320 uint8_t devAddr = 2;
321 uint8_t stringId = 1;
322 uint8_t buffer[LENGTH_NUM_255] = {0};
323 uint32_t length = LENGTH_NUM_255;
324 struct UsbDev dev = {busNum, devAddr};
325 std::vector<uint8_t> devdata(buffer, buffer + length);
326 auto ret = UsbdClient::GetInstance().GetStringDescriptor(dev, stringId, devdata);
327 HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor002 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
328 devdata.size(), sizeof(devdata));
329 HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor002 %{public}d ret=%{public}d", __LINE__, ret);
330 ASSERT_TRUE(ret == 0);
331 }
332
333 /**
334 * @tc.name: UsbdDescriptor003
335 * @tc.desc: Test functions to GetStringDescriptor
336 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
337 * @tc.type: FUNC
338 */
339 HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor003, Function | MediumTest | Level1)
340 {
341 uint8_t busNum = 1;
342 uint8_t devAddr = 2;
343 uint8_t stringId = 222;
344 uint8_t buffer[LENGTH_NUM_255] = {0};
345 uint32_t length = LENGTH_NUM_255;
346 struct UsbDev dev = {busNum, devAddr};
347 std::vector<uint8_t> devdata(buffer, buffer + length);
348 auto ret = UsbdClient::GetInstance().GetStringDescriptor(dev, stringId, devdata);
349 HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor003 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
350 devdata.size(), sizeof(devdata));
351 HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor003 %{public}d ret=%{public}d", __LINE__, ret);
352 ASSERT_TRUE(ret == 0);
353 }
354
355 /**
356 * @tc.name: UsbdDescriptor004
357 * @tc.desc: Test functions to GetStringDescriptor
358 * @tc.desc: int32_t GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
359 * @tc.type: FUNC
360 */
361 HWTEST_F(UsbdRequestTest, UsbdGetStringDescriptor004, Function | MediumTest | Level1)
362 {
363 uint8_t busNum = 1;
364 uint8_t devAddr = 255;
365 uint8_t stringId = 0;
366 uint8_t buffer[LENGTH_NUM_255] = {0};
367 uint32_t length = 8;
368 struct UsbDev dev = {busNum, devAddr};
369 std::vector<uint8_t> devdata(buffer, buffer + length);
370 auto ret = UsbdClient::GetInstance().GetStringDescriptor(dev, stringId, devdata);
371 HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor004 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
372 devdata.size(), sizeof(devdata));
373 HDF_LOGI("UsbdRequestTest::UsbdGetStringDescriptor004 %{public}d ret=%{public}d", __LINE__, ret);
374 ASSERT_TRUE(ret != 0);
375 }
376
377 /**
378 * @tc.name: UsbdDescriptor001
379 * @tc.desc: Test functions to GetConfigDescriptor
380 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
381 * @tc.type: FUNC
382 */
383 HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor001, Function | MediumTest | Level1)
384 {
385 uint8_t busNum = 1;
386 uint8_t devAddr = 2;
387 uint8_t configId = 0;
388 uint8_t buffer[LENGTH_NUM_255] = {};
389 uint32_t length = LENGTH_NUM_255;
390 struct UsbDev dev = {busNum, devAddr};
391 std::vector<uint8_t> devdata(buffer, buffer + length);
392 auto ret = UsbdClient::GetInstance().GetConfigDescriptor(dev, configId, devdata);
393 HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor001 %{public}d ret=%{public}d", __LINE__, ret);
394 HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor001 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
395 devdata.size(), sizeof(devdata));
396 ASSERT_TRUE(ret == 0);
397 }
398
399 /**
400 * @tc.name: UsbdDescriptor002
401 * @tc.desc: Test functions to GetConfigDescriptor
402 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
403 * @tc.type: FUNC
404 */
405 HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor002, Function | MediumTest | Level1)
406 {
407 uint8_t busNum = BUS_NUM_222;
408 uint8_t devAddr = 2;
409 uint8_t configId = 1;
410 uint8_t buffer[LENGTH_NUM_255] = {};
411 uint32_t length = LENGTH_NUM_255;
412 struct UsbDev dev = {busNum, devAddr};
413 std::vector<uint8_t> devdata(buffer, buffer + length);
414 auto ret = UsbdClient::GetInstance().GetConfigDescriptor(dev, configId, devdata);
415 HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor002 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
416 devdata.size(), sizeof(devdata));
417 HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor002 %{public}d ret=%{public}d", __LINE__, ret);
418 ASSERT_TRUE(ret != 0);
419 }
420
421 /**
422 * @tc.name: UsbdDescriptor004
423 * @tc.desc: Test functions to GetConfigDescriptor
424 * @tc.desc: int32_t GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &decriptor);
425 * @tc.type: FUNC
426 */
427 HWTEST_F(UsbdRequestTest, UsbdGetConfigDescriptor004, Function | MediumTest | Level1)
428 {
429 uint8_t busNum = 1;
430 uint8_t devAddr = 2;
431 uint8_t configId = 1;
432 uint8_t buffer[LENGTH_NUM_255] = {};
433 uint32_t length = LENGTH_NUM_255;
434 struct UsbDev dev = {busNum, devAddr};
435 std::vector<uint8_t> devdata(buffer, buffer + length);
436 auto ret = UsbdClient::GetInstance().GetConfigDescriptor(dev, configId, devdata);
437 HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor004 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
438 devdata.size(), sizeof(devdata));
439 HDF_LOGI("UsbdRequestTest::UsbdGetConfigDescriptor004 %{public}d ret=%{public}d", __LINE__, ret);
440 ASSERT_TRUE(ret == 0);
441 }
442
443 /**
444 * @tc.name: UsbdGetRawDescriptor001
445 * @tc.desc: Test functions to GetRawDescriptor
446 * @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
447 * @tc.type: FUNC
448 */
449 HWTEST_F(UsbdRequestTest, UsbdGetRawDescriptor001, Function | MediumTest | Level1)
450 {
451 uint8_t busNum = 1;
452 uint8_t devAddr = 2;
453 struct UsbDev dev = {busNum, devAddr};
454 std::vector<uint8_t> rawData;
455 auto ret = UsbdClient::GetInstance().GetRawDescriptor(dev, rawData);
456 HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor001 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
457 rawData.size(), sizeof(rawData));
458 HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor001 %{public}d ret=%{public}d", __LINE__, ret);
459 ASSERT_TRUE(ret == 0);
460 }
461
462 /**
463 * @tc.name: UsbdGetRawDescriptor002
464 * @tc.desc: Test functions to GetRawDescriptor
465 * @tc.desc: int32_t GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &decriptor);
466 * @tc.type: FUNC
467 */
468 HWTEST_F(UsbdRequestTest, UsbdGetRawDescriptor002, Function | MediumTest | Level1)
469 {
470 uint8_t busNum = BUS_NUM_222;
471 uint8_t devAddr = 2;
472 struct UsbDev dev = {busNum, devAddr};
473 std::vector<uint8_t> rawData;
474 auto ret = UsbdClient::GetInstance().GetRawDescriptor(dev, rawData);
475 HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor002 %{public}d length=%{public}d buffer=%{public}d", __LINE__,
476 rawData.size(), sizeof(rawData));
477 HDF_LOGI("UsbdRequestTest::UsbdGetRawDescriptor002 %{public}d ret=%{public}d", __LINE__, ret);
478 ASSERT_TRUE(ret != 0);
479 }
480
481 /**
482 * @tc.name: GetFileDescriptor001
483 * @tc.desc: Test functions to GetFileDescriptor
484 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
485 * @tc.type: FUNC
486 */
487 HWTEST_F(UsbdRequestTest, GetFileDescriptor001, Function | MediumTest | Level1)
488 {
489 uint8_t busNum = 1;
490 uint8_t devAddr = 2;
491 struct UsbDev dev = {busNum, devAddr};
492 int32_t fd = 0;
493 auto ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
494 HDF_LOGI("UsbdRequestTest::GetFileDescriptor001 %{public}d GetFileDescriptor=%{public}d", __LINE__, ret);
495 HDF_LOGI("UsbdRequestTest::GetFileDescriptor001 %{public}d fd=%{public}d", __LINE__, fd);
496 ASSERT_TRUE(ret == 0);
497 }
498
499 /**
500 * @tc.name: GetFileDescriptor002
501 * @tc.desc: Test functions to GetFileDescriptor
502 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
503 * @tc.type: FUNC
504 */
505 HWTEST_F(UsbdRequestTest, GetFileDescriptor002, Function | MediumTest | Level1)
506 {
507 uint8_t busNum = BUS_NUM_222;
508 uint8_t devAddr = 2;
509 struct UsbDev dev = {busNum, devAddr};
510 int32_t fd = 0;
511 auto ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
512 HDF_LOGI("UsbdRequestTest::GetFileDescriptor002 %{public}d GetFileDescriptor=%{public}d", __LINE__, ret);
513 HDF_LOGI("UsbdRequestTest::GetFileDescriptor002 %{public}d fd=%{public}d", __LINE__, fd);
514 ASSERT_TRUE(ret != 0);
515 }
516
517 /**
518 * @tc.name: GetFileDescriptor003
519 * @tc.desc: Test functions to GetFileDescriptor
520 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
521 * @tc.type: FUNC
522 */
523 HWTEST_F(UsbdRequestTest, GetFileDescriptor003, Function | MediumTest | Level1)
524 {
525 uint8_t busNum = 1;
526 uint8_t devAddr = DEV_ADDR_222;
527 struct UsbDev dev = {busNum, devAddr};
528 int32_t fd = 0;
529 auto ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
530 HDF_LOGI("UsbdRequestTest::GetFileDescriptor003 %{public}d GetFileDescriptor=%{public}d", __LINE__, ret);
531 HDF_LOGI("UsbdRequestTest::GetFileDescriptor003 %{public}d fd=%{public}d", __LINE__, fd);
532 ASSERT_TRUE(ret != 0);
533 }
534
535 /**
536 * @tc.name: GetFileDescriptor004
537 * @tc.desc: Test functions to GetFileDescriptor
538 * @tc.desc: int32_t GetFileDescriptor(const UsbDev &dev, int32_t &fd);
539 * @tc.type: FUNC
540 */
541 HWTEST_F(UsbdRequestTest, GetFileDescriptor004, Function | MediumTest | Level1)
542 {
543 uint8_t busNum = 1;
544 uint8_t devAddr = 2;
545 struct UsbDev dev = {busNum, devAddr};
546 int32_t fd = LENGTH_NUM_255;
547 auto ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
548 HDF_LOGI("UsbdRequestTest::GetFileDescriptor004 %{public}d GetFileDescriptor=%{public}d", __LINE__, ret);
549 HDF_LOGI("UsbdRequestTest::GetFileDescriptor004 %{public}d fd=%{public}d", __LINE__, fd);
550 ASSERT_TRUE(ret == 0);
551 }
552
553 /**
554 * @tc.name: UsbdRequest001
555 * @tc.desc: Test functions to RequestQueue
556 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
557 std::vector<uint8_t> &buffer);
558 * @tc.type: FUNC
559 */
560 HWTEST_F(UsbdRequestTest, UsbdRequestQueue001, Function | MediumTest | Level1)
561 {
562 uint8_t pointid = POINTID_129;
563 uint8_t interfaceId = INTERFACEID_1;
564 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
565 dev.busNum = BUS_NUM_1;
566 dev.devAddr = DEV_ADDR_2;
567 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
568 HDF_LOGI("UsbdRequestTest::UsbdRequestQueue001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
569 ASSERT_TRUE(ret == 0);
570 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
571 uint8_t buffer[LENGTH_NUM_255] = {0};
572 uint32_t length = LENGTH_NUM_255;
573 struct UsbPipe pipe = {interfaceId, pointid};
574 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
575 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
576 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
577 HDF_LOGI("UsbdRequestTest::UsbdRequestQueue001 %{public}d interfaceId=%{public}d pointid=%{public}d", __LINE__,
578 interfaceId, pointid);
579 HDF_LOGI("UsbdRequestTest::UsbdRequestQueue001 %{public}d RequestQueue=%{public}d", __LINE__, ret);
580 ASSERT_TRUE(ret == 0);
581 }
582
583 /**
584 * @tc.name: UsbdRequest002
585 * @tc.desc: Test functions to RequestQueue
586 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
587 std::vector<uint8_t> &buffer);
588 * @tc.type: FUNC
589 */
590 HWTEST_F(UsbdRequestTest, UsbdRequestQueue002, Function | MediumTest | Level1)
591 {
592 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
593 dev.devAddr = DEV_ADDR_2;
594 dev.busNum = BUS_NUM_1;
595 uint8_t pointid = POINTID_129;
596 uint8_t interfaceId = INTERFACEID_1;
597 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
598 HDF_LOGI("UsbdRequestTest::UsbdRequestQueue002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
599 ASSERT_TRUE(ret == 0);
600 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
601 uint8_t buffer[LENGTH_NUM_255] = {0};
602 uint32_t length = LENGTH_NUM_255;
603 dev = {222, 222};
604 struct UsbPipe pipe = {interfaceId, pointid};
605 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
606 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
607 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
608 HDF_LOGI("UsbdRequestTest::UsbdRequestQueue002 %{public}d interfaceId=%{public}d pointid=%{public}d", __LINE__,
609 interfaceId, pointid);
610 HDF_LOGI("UsbdRequestTest::UsbdRequestQueue002 %{public}d RequestQueue=%{public}d", __LINE__, ret);
611 ASSERT_TRUE(ret != 0);
612 }
613
614 /**
615 * @tc.name: UsbdRequest007
616 * @tc.desc: Test functions to RequestQueue
617 * @tc.desc: int32_t RequestQueue(const UsbDev &dev, const UsbPipe &pipe, std::vector<uint8_t> &clientData,
618 std::vector<uint8_t> &buffer);
619 * @tc.type: FUNC
620 */
621 HWTEST_F(UsbdRequestTest, UsbdRequestQueue007, Function | MediumTest | Level1)
622 {
623 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
624 dev.busNum = BUS_NUM_1;
625 dev.devAddr = DEV_ADDR_2;
626 uint8_t buffer[LENGTH_NUM_255] = "request 007";
627 uint32_t length = LENGTH_NUM_255;
628 uint8_t pointid = POINTID_1;
629 uint8_t interfaceId = INTERFACEID_1;
630 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
631 HDF_LOGI("UsbdRequestTest::UsbdRequestQueue007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
632 ASSERT_TRUE(ret == 0);
633 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue write";
634 struct UsbPipe pipe = {interfaceId, pointid};
635 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_11};
636 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
637 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
638 HDF_LOGI("UsbdRequestTest::UsbdRequestQueue007 %{public}d RequestQueue=%{public}d", __LINE__, ret);
639 ASSERT_TRUE(ret == 0);
640 }
641
642 /**
643 * @tc.name: UsbdRequest001
644 * @tc.desc: Test functions to RequestWait
645 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
646 * int32_t timeout);
647 * @tc.type: FUNC
648 */
649 HWTEST_F(UsbdRequestTest, UsbdRequestWait001, Function | MediumTest | Level1)
650 {
651 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
652 dev.busNum = BUS_NUM_1;
653 dev.devAddr = DEV_ADDR_2;
654 uint8_t pointid = POINTID_129;
655 uint8_t interfaceId = INTERFACEID_1;
656 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
657 HDF_LOGI("UsbdRequestTest::UsbdRequestWait001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
658 ASSERT_TRUE(ret == 0);
659 uint8_t buffer[LENGTH_NUM_255] = {};
660 uint32_t length = LENGTH_NUM_255;
661 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
662 struct UsbPipe pipe = {interfaceId, pointid};
663 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
664 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
665 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
666 HDF_LOGI("UsbdRequestTest::UsbdRequestWait001 %{public}d RequestQueue=%{public}d", __LINE__, ret);
667 ASSERT_TRUE(ret == 0);
668 uint8_t *clientObj = new uint8_t[10];
669 std::vector<uint8_t> waitdata = {clientObj, clientObj + 10};
670 ret = UsbdClient::GetInstance().RequestWait(dev, waitdata, bufferdata, 10000);
671 HDF_LOGI("UsbdRequestTest::UsbdRequestWait001 %{public}d RequestWait=%{public}d", __LINE__, ret);
672 ASSERT_TRUE(ret == 0);
673 delete[] clientObj;
674 clientObj = nullptr;
675 }
676
677 /**
678 * @tc.name: UsbdRequest002
679 * @tc.desc: Test functions to RequestWait
680 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
681 * int32_t timeout);
682 * @tc.type: FUNC
683 */
684 HWTEST_F(UsbdRequestTest, UsbdRequestWait002, Function | MediumTest | Level1)
685 {
686 uint8_t pointid = POINTID_129;
687 uint8_t interfaceId = INTERFACEID_1;
688 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
689 dev.busNum = BUS_NUM_1;
690 dev.devAddr = DEV_ADDR_2;
691 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
692 HDF_LOGI("UsbdRequestTest::UsbdRequestWait002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
693 ASSERT_TRUE(ret == 0);
694 uint8_t buffer[LENGTH_NUM_255] = {};
695 uint32_t length = LENGTH_NUM_255;
696 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
697 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
698 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
699 struct UsbPipe pipe = {interfaceId, pointid};
700 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
701 HDF_LOGI("UsbdRequestTest::UsbdRequestWait002 %{public}d RequestQueue=%{public}d", __LINE__, ret);
702 ASSERT_TRUE(ret == 0);
703 dev.busNum = BUS_NUM_222;
704 uint8_t *clientObj = new uint8_t[10];
705 std::vector<uint8_t> waitdata = {clientObj, clientObj + 10};
706 ret = UsbdClient::GetInstance().RequestWait(dev, waitdata, bufferdata, 10000);
707 HDF_LOGI("UsbdRequestTest::UsbdRequestWait002 %{public}d RequestWait=%{public}d", __LINE__, ret);
708 ASSERT_TRUE(ret != 0);
709 delete[] clientObj;
710 clientObj = nullptr;
711 }
712
713 /**
714 * @tc.name: UsbdRequest004
715 * @tc.desc: Test functions to RequestWait
716 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
717 * int32_t timeout);
718 * @tc.type: FUNC
719 */
720 HWTEST_F(UsbdRequestTest, UsbdRequestWait004, Function | MediumTest | Level1)
721 {
722 uint8_t pointid = POINTID_129;
723 uint8_t interfaceId = INTERFACEID_1;
724 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
725 dev.busNum = BUS_NUM_1;
726 dev.devAddr = DEV_ADDR_2;
727 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
728 HDF_LOGI("UsbdRequestTest::UsbdRequestWait004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
729 ASSERT_TRUE(ret == 0);
730 uint8_t buffer[LENGTH_NUM_255] = {};
731 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
732 uint32_t length = LENGTH_NUM_255;
733 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
734 struct UsbPipe pipe = {interfaceId, pointid};
735 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
736 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
737 HDF_LOGI("UsbdRequestTest::UsbdRequestWait004 %{public}d RequestQueue=%{public}d", __LINE__, ret);
738 ASSERT_TRUE(ret == 0);
739 uint8_t *clientObj = new uint8_t[10];
740 std::vector<uint8_t> waitdata = {clientObj, clientObj + 10};
741 ret = UsbdClient::GetInstance().RequestWait(dev, waitdata, bufferdata, -10000);
742 HDF_LOGI("UsbdRequestTest::UsbdRequestWait004 %{public}d RequestWait=%{public}d", __LINE__, ret);
743 ASSERT_TRUE(ret == 0);
744 delete[] clientObj;
745 clientObj = nullptr;
746 }
747
748 /**
749 * @tc.name: UsbdRequest005
750 * @tc.desc: Test functions to RequestWait
751 * @tc.desc: int32_t RequestWait(const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer,
752 * int32_t timeout);
753 * @tc.type: FUNC
754 */
755 HWTEST_F(UsbdRequestTest, UsbdRequestWait005, Function | MediumTest | Level1)
756 {
757 uint8_t pointid = POINTID_129;
758 uint8_t interfaceId = INTERFACEID_1;
759 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
760 dev.busNum = BUS_NUM_1;
761 dev.devAddr = DEV_ADDR_2;
762 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
763 HDF_LOGI("UsbdRequestTest::UsbdRequestWait005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
764 ASSERT_TRUE(ret == 0);
765 uint32_t length = LENGTH_NUM_255;
766 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
767 uint8_t buffer[LENGTH_NUM_255] = {};
768 struct UsbPipe pipe = {interfaceId, pointid};
769 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
770 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
771 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
772 HDF_LOGI("UsbdRequestTest::UsbdRequestWait005 %{public}d RequestQueue=%{public}d", __LINE__, ret);
773 ASSERT_TRUE(ret == 0);
774 uint8_t *clientObj = new uint8_t[10];
775 std::vector<uint8_t> waitdata = {clientObj, clientObj + 10};
776 dev.devAddr = DEV_ADDR_255;
777 dev.busNum = BUS_NUM_255;
778 ret = UsbdClient::GetInstance().RequestWait(dev, waitdata, bufferdata, 10000);
779 HDF_LOGI("UsbdRequestTest::UsbdRequestWait005 %{public}d RequestWait=%{public}d", __LINE__, ret);
780 ASSERT_TRUE(ret != 0);
781 delete[] clientObj;
782 clientObj = nullptr;
783 }
784
785 /**
786 * @tc.name: UsbdRequest001
787 * @tc.desc: Test functions to RequestCancel
788 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
789 * @tc.type: FUNC
790 */
791 HWTEST_F(UsbdRequestTest, UsbdRequestCancel001, Function | MediumTest | Level1)
792 {
793 uint8_t pointid = POINTID_129;
794 uint8_t interfaceId = INTERFACEID_1;
795 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
796 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
797 dev.busNum = BUS_NUM_1;
798 dev.devAddr = DEV_ADDR_2;
799 uint8_t buffer[LENGTH_NUM_255] = "request001";
800 uint32_t length = LENGTH_NUM_255;
801 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
802 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
803 EXPECT_TRUE(ret == 0);
804 struct UsbPipe pipe = {interfaceId, pointid};
805 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
806 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
807 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
808 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel001 %{public}d RequestQueue=%{public}d", __LINE__, ret);
809 ASSERT_TRUE(ret == 0);
810 ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
811 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel001 %{public}d RequestCancel=%{public}d", __LINE__, ret);
812 ASSERT_TRUE(ret == 0);
813 }
814
815 /**
816 * @tc.name: UsbdRequest002
817 * @tc.desc: Test functions to RequestCancel
818 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
819 * @tc.type: FUNC
820 */
821 HWTEST_F(UsbdRequestTest, UsbdRequestCancel002, Function | MediumTest | Level1)
822 {
823 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
824 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
825 dev.busNum = BUS_NUM_1;
826 dev.devAddr = DEV_ADDR_2;
827 uint32_t length = LENGTH_NUM_255;
828 uint8_t pointid = POINTID_129;
829 uint8_t interfaceId = INTERFACEID_1;
830 uint8_t buffer[LENGTH_NUM_255] = "request002";
831 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
832 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
833 EXPECT_TRUE(ret == 0);
834 struct UsbPipe pipe = {interfaceId, pointid};
835 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
836 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
837 ;
838 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
839 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 %{public}d RequestQueue=%{public}d", __LINE__, ret);
840 ASSERT_TRUE(ret == 0);
841 dev.busNum = BUS_NUM_222;
842 ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
843 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel002 %{public}d RequestCancel=%{public}d", __LINE__, ret);
844 ASSERT_TRUE(ret != 0);
845 dev.busNum = BUS_NUM_1;
846 ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
847 ASSERT_TRUE(ret == 0);
848 }
849
850 /**
851 * @tc.name: UsbdRequest004
852 * @tc.desc: Test functions to RequestCancel
853 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
854 * @tc.type: FUNC
855 */
856 HWTEST_F(UsbdRequestTest, UsbdRequestCancel004, Function | MediumTest | Level1)
857 {
858 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue read";
859 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
860 dev.busNum = BUS_NUM_1;
861 dev.devAddr = DEV_ADDR_2;
862 uint32_t length = LENGTH_NUM_255;
863 uint8_t buffer[LENGTH_NUM_255] = "request004";
864 uint8_t pointid = POINTID_129;
865 uint8_t interfaceId = INTERFACEID_1;
866 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
867 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
868 EXPECT_TRUE(ret == 0);
869 struct UsbPipe pipe = {interfaceId, pointid};
870 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_10};
871 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
872 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
873 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d RequestQueue=%{public}d", __LINE__, ret);
874 ASSERT_TRUE(ret == 0);
875 pipe.interfaceId = 222;
876 pipe.endpointId = 222;
877 ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
878 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel004 %{public}d RequestCancel=%{public}d", __LINE__, ret);
879 ASSERT_TRUE(ret == 0);
880 }
881
882 /**
883 * @tc.name: UsbdRequest005
884 * @tc.desc: Test functions to RequestCancel
885 * @tc.desc: int32_t RequestCancel(const UsbDev &dev, const UsbPipe &pipe);
886 * @tc.type: FUNC
887 */
888 HWTEST_F(UsbdRequestTest, UsbdRequestCancel005, Function | MediumTest | Level1)
889 {
890 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
891 dev.busNum = BUS_NUM_1;
892 dev.devAddr = DEV_ADDR_2;
893 uint8_t buffer[LENGTH_NUM_255] = "request005";
894 uint32_t length = LENGTH_NUM_255;
895 uint8_t pointid = POINTID_1;
896 uint8_t interfaceId = INTERFACEID_1;
897 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
898 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
899 EXPECT_TRUE(ret == 0);
900 struct UsbPipe pipe = {interfaceId, pointid};
901 uint8_t tag[TAG_LENGTH_NUM_1000] = "queue Write";
902 std::vector<uint8_t> clientdata = {tag, tag + TAG_NUM_11};
903 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
904 ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientdata, bufferdata);
905 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel005 %{public}d RequestQueue=%{public}d", __LINE__, ret);
906 ASSERT_TRUE(ret == 0);
907 ret = UsbdClient::GetInstance().RequestCancel(dev, pipe);
908 HDF_LOGI("UsbdRequestTest::UsbdRequestCancel005 %{public}d RequestCancel=%{public}d", __LINE__, ret);
909 ASSERT_TRUE(ret == 0);
910 }
911
912 /**
913 * @tc.name: UsbdReleaseInterface001
914 * @tc.desc: Test functions to ReleaseInterface
915 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
916 * @tc.type: FUNC
917 */
918 HWTEST_F(UsbdRequestTest, UsbdReleaseInterface001, Function | MediumTest | Level1)
919 {
920 uint8_t busNum = 1;
921 uint8_t devAddr = 2;
922 uint8_t interfaceId = INTERFACEID_1;
923 struct UsbDev dev = {busNum, devAddr};
924 auto ret = UsbdClient::GetInstance().ReleaseInterface(dev, interfaceId);
925 HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface001 %{public}d ret=%{public}d", __LINE__, ret);
926 ASSERT_TRUE(ret == 0);
927 }
928
929 /**
930 * @tc.name: UsbdReleaseInterface002
931 * @tc.desc: Test functions to ReleaseInterface
932 * @tc.desc: int32_t ReleaseInterface(const UsbDev &dev, uint8_t interfaceId);
933 * @tc.type: FUNC
934 */
935 HWTEST_F(UsbdRequestTest, UsbdReleaseInterface002, Function | MediumTest | Level1)
936 {
937 uint8_t busNum = 25;
938 uint8_t devAddr = 2;
939 uint8_t interfaceId = INTERFACEID_1;
940 struct UsbDev dev = {busNum, devAddr};
941 auto ret = UsbdClient::GetInstance().ReleaseInterface(dev, interfaceId);
942 HDF_LOGI("UsbdRequestTest::UsbdReleaseInterface002 %{public}d ret=%{public}d", __LINE__, ret);
943 ASSERT_TRUE(ret != 0);
944 }
945