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_transfer_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 const int SLEEP_TIME = 3;
24
25 const uint8_t BUS_NUM_1 = 1;
26 const uint8_t DEV_ADDR_2 = 2;
27
28 const uint8_t BUS_NUM_255 = 255;
29 const uint8_t DEV_ADDR_255 = 255;
30
31 const uint8_t BUS_NUM_222 = 222;
32
33 const uint32_t LENGTH_NUM_255 = 255;
34
35 const uint8_t INTERFACEID_1 = 1;
36
37 const uint8_t POINTID_1 = 1;
38 const uint8_t POINTID_129 = 129;
39
40 using namespace testing::ext;
41 using namespace OHOS;
42 using namespace OHOS::USB;
43 using namespace std;
44
SetUpTestCase(void)45 void UsbdTransferTest::SetUpTestCase(void)
46 {
47 auto ret = UsbdClient::GetInstance().SetPortRole(1, 1, 1);
48 sleep(SLEEP_TIME);
49 HDF_LOGI("UsbdFunctionTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
50 ASSERT_TRUE(ret == 0);
51 if (ret != 0) {
52 exit(0);
53 }
54 std::cout << "please connect device, press enter to continue" << std::endl;
55 int c;
56 while ((c = getchar()) != '\n' && c != EOF) {
57 }
58 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
59 ret = UsbdClient::GetInstance().OpenDevice(dev);
60 HDF_LOGI("UsbdTransferTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
61 ASSERT_TRUE(ret == 0);
62 }
63
TearDownTestCase(void)64 void UsbdTransferTest::TearDownTestCase(void)
65 {
66 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
67 auto ret = UsbdClient::GetInstance().CloseDevice(dev);
68 HDF_LOGI("UsbdTransferTest:: %{public}d Close=%{public}d", __LINE__, ret);
69 ASSERT_TRUE(ret == 0);
70 }
71
SetUp(void)72 void UsbdTransferTest::SetUp(void) {}
73
TearDown(void)74 void UsbdTransferTest::TearDown(void) {}
75
76 /**
77 * @tc.name: UsbdControlTransfer001
78 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
79 * @tc.type: FUNC
80 */
81 HWTEST_F(UsbdTransferTest, UsbdControlTransfer001, TestSize.Level1)
82 {
83 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
84 dev.busNum = BUS_NUM_1;
85 dev.devAddr = DEV_ADDR_2;
86 uint8_t buffer[LENGTH_NUM_255] = {0};
87 uint32_t length = LENGTH_NUM_255;
88 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
89 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 8, 0, 0, 1000};
90 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
91 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer001 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
92 ASSERT_TRUE(ret == 0);
93 }
94
95 /**
96 * @tc.name: UsbdControlTransfer002
97 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
98 * @tc.type: FUNC
99 */
100 HWTEST_F(UsbdTransferTest, UsbdControlTransfer002, TestSize.Level1)
101 {
102 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
103 dev.busNum = BUS_NUM_255;
104 dev.devAddr = DEV_ADDR_2;
105 uint8_t buffer[LENGTH_NUM_255] = {0};
106 uint32_t length = LENGTH_NUM_255;
107 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
108 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 8, 0, 0, 1000};
109 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
110 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer002 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
111 ASSERT_TRUE(ret != 0);
112 }
113
114 /**
115 * @tc.name: UsbdControlTransfer003
116 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
117 * @tc.type: FUNC
118 */
119 HWTEST_F(UsbdTransferTest, UsbdControlTransfer003, TestSize.Level1)
120 {
121 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
122 dev.busNum = BUS_NUM_1;
123 dev.devAddr = DEV_ADDR_255;
124 uint8_t buffer[LENGTH_NUM_255] = {0};
125 uint32_t length = LENGTH_NUM_255;
126 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
127 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 8, 0, 0, 1000};
128 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
129 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer003 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
130 ASSERT_TRUE(ret != 0);
131 }
132
133 /**
134 * @tc.name: UsbdControlTransfer004
135 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
136 * @tc.type: FUNC
137 */
138 HWTEST_F(UsbdTransferTest, UsbdControlTransfer004, TestSize.Level1)
139 {
140 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
141 dev.busNum = BUS_NUM_1;
142 dev.devAddr = DEV_ADDR_2;
143 uint32_t length = LENGTH_NUM_255;
144 uint8_t buffer[LENGTH_NUM_255] = {0};
145 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
146 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 6, 0x100, 0, 1000};
147 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
148 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer004 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
149 ASSERT_TRUE(ret == 0);
150 }
151
152 /**
153 * @tc.name: UsbdControlTransfer005
154 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
155 * @tc.type: FUNC
156 */
157 HWTEST_F(UsbdTransferTest, UsbdControlTransfer005, TestSize.Level1)
158 {
159 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
160 dev.busNum = BUS_NUM_255;
161 dev.devAddr = DEV_ADDR_2;
162 uint32_t length = LENGTH_NUM_255;
163 uint8_t buffer[LENGTH_NUM_255] = {0};
164 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
165 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 6, 0x100, 0, 1000};
166 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
167 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer005 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
168 ASSERT_TRUE(ret != 0);
169 }
170
171 /**
172 * @tc.name: UsbdControlTransfer006
173 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
174 * @tc.type: FUNC
175 */
176 HWTEST_F(UsbdTransferTest, UsbdControlTransfer006, TestSize.Level1)
177 {
178 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
179 dev.busNum = BUS_NUM_1;
180 dev.devAddr = DEV_ADDR_255;
181 uint32_t length = LENGTH_NUM_255;
182 uint8_t buffer[LENGTH_NUM_255] = {0};
183 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
184 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 6, 0x100, 0, 1000};
185 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
186 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer006 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
187 ASSERT_TRUE(ret != 0);
188 }
189
190 /**
191 * @tc.name: UsbdControlTransfer007
192 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
193 * @tc.type: FUNC
194 */
195 HWTEST_F(UsbdTransferTest, UsbdControlTransfer007, TestSize.Level1)
196 {
197 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
198 int32_t intercafeidex = 0;
199 dev.busNum = BUS_NUM_1;
200 dev.devAddr = DEV_ADDR_2;
201 uint32_t length = LENGTH_NUM_255;
202 uint8_t buffer[LENGTH_NUM_255] = {0};
203 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
204 struct UsbCtrlTransfer ctrlparmas = {0b10000001, 0X0A, 0, intercafeidex, 1000};
205 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
206 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer007 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
207 ASSERT_TRUE(ret == 0);
208 }
209
210 /**
211 * @tc.name: UsbdControlTransfer008
212 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
213 * @tc.type: FUNC
214 */
215 HWTEST_F(UsbdTransferTest, UsbdControlTransfer008, TestSize.Level1)
216 {
217 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
218 int32_t intercafeidex = 0;
219 dev.busNum = BUS_NUM_255;
220 dev.devAddr = DEV_ADDR_2;
221 uint32_t length = LENGTH_NUM_255;
222 uint8_t buffer[LENGTH_NUM_255] = {0};
223 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
224 struct UsbCtrlTransfer ctrlparmas = {0b10000001, 0X0A, 0, intercafeidex, 1000};
225 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
226 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer008 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
227 ASSERT_TRUE(ret != 0);
228 }
229
230 /**
231 * @tc.name: UsbdControlTransfer009
232 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
233 * @tc.type: FUNC
234 */
235 HWTEST_F(UsbdTransferTest, UsbdControlTransfer009, TestSize.Level1)
236 {
237 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
238 int32_t intercafeidex = 0;
239 dev.busNum = BUS_NUM_1;
240 dev.devAddr = DEV_ADDR_255;
241 uint32_t length = LENGTH_NUM_255;
242 uint8_t buffer[LENGTH_NUM_255] = {0};
243 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
244 struct UsbCtrlTransfer ctrlparmas = {0b10000001, 0X0A, 0, intercafeidex, 1000};
245 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
246 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer009 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
247 ASSERT_TRUE(ret != 0);
248 }
249
250 /**
251 * @tc.name: UsbdControlTransfer010
252 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
253 * @tc.type: FUNC
254 */
255 HWTEST_F(UsbdTransferTest, UsbdControlTransfer010, TestSize.Level1)
256 {
257 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
258 dev.busNum = BUS_NUM_1;
259 dev.devAddr = DEV_ADDR_2;
260 uint32_t length = LENGTH_NUM_255;
261 uint8_t buffer[LENGTH_NUM_255] = {0};
262 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
263 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 0, 0, 0, 1000};
264 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
265 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer010 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
266 ASSERT_TRUE(ret == 0);
267 }
268
269 /**
270 * @tc.name: UsbdControlTransfer011
271 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
272 * @tc.type: FUNC
273 */
274 HWTEST_F(UsbdTransferTest, UsbdControlTransfer011, TestSize.Level1)
275 {
276 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
277 dev.busNum = BUS_NUM_255;
278 dev.devAddr = DEV_ADDR_2;
279 uint32_t length = LENGTH_NUM_255;
280 uint8_t buffer[LENGTH_NUM_255] = {0};
281 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
282 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 0, 0, 0, 1000};
283 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
284 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer011 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
285 ASSERT_TRUE(ret != 0);
286 }
287
288 /**
289 * @tc.name: UsbdControlTransfer012
290 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
291 * @tc.type: FUNC
292 */
293 HWTEST_F(UsbdTransferTest, UsbdControlTransfer012, TestSize.Level1)
294 {
295 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
296 dev.busNum = BUS_NUM_1;
297 dev.devAddr = DEV_ADDR_255;
298 uint32_t length = LENGTH_NUM_255;
299 uint8_t buffer[LENGTH_NUM_255] = {0};
300 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
301 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 0, 0, 0, 1000};
302 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
303 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer012 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
304 ASSERT_TRUE(ret != 0);
305 }
306
307 /**
308 * @tc.name: UsbdControlTransfer013
309 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
310 * @tc.type: FUNC
311 */
312 HWTEST_F(UsbdTransferTest, UsbdControlTransfer013, TestSize.Level1)
313 {
314 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
315 dev.busNum = BUS_NUM_1;
316 dev.devAddr = DEV_ADDR_2;
317 uint32_t length = LENGTH_NUM_255;
318 uint8_t buffer[LENGTH_NUM_255] = {0};
319 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
320 struct UsbCtrlTransfer ctrlparmas = {0b10000001, 0, 0, 0, 1000};
321 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
322 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer013 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
323 ASSERT_TRUE(ret == 0);
324 }
325
326 /**
327 * @tc.name: UsbdControlTransfer014
328 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
329 * @tc.type: FUNC
330 */
331 HWTEST_F(UsbdTransferTest, UsbdControlTransfer014, TestSize.Level1)
332 {
333 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
334 dev.busNum = BUS_NUM_255;
335 dev.devAddr = DEV_ADDR_2;
336 uint32_t length = LENGTH_NUM_255;
337 uint8_t buffer[LENGTH_NUM_255] = {0};
338 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
339 struct UsbCtrlTransfer ctrlparmas = {0b10000001, 0, 0, 0, 1000};
340 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
341 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer014 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
342 ASSERT_TRUE(ret != 0);
343 }
344
345 /**
346 * @tc.name: UsbdControlTransfer015
347 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
348 * @tc.type: FUNC
349 */
350 HWTEST_F(UsbdTransferTest, UsbdControlTransfer015, TestSize.Level1)
351 {
352 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
353 dev.busNum = BUS_NUM_1;
354 dev.devAddr = DEV_ADDR_255;
355 uint32_t length = LENGTH_NUM_255;
356 uint8_t buffer[LENGTH_NUM_255] = {0};
357 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
358 struct UsbCtrlTransfer ctrlparmas = {0b10000001, 0, 0, 0, 1000};
359 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
360 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer015 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
361 ASSERT_TRUE(ret != 0);
362 }
363
364 /**
365 * @tc.name: UsbdControlTransfer016
366 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
367 * @tc.type: FUNC
368 */
369 HWTEST_F(UsbdTransferTest, UsbdControlTransfer016, TestSize.Level1)
370 {
371 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
372 dev.busNum = BUS_NUM_1;
373 dev.devAddr = DEV_ADDR_2;
374 uint32_t length = LENGTH_NUM_255;
375 uint8_t buffer[LENGTH_NUM_255] = {0};
376 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
377 struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0, 0, 0, 1000};
378 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
379 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer016 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
380 ASSERT_TRUE(ret == 0);
381 }
382
383 /**
384 * @tc.name: UsbdControlTransfer017
385 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
386 * @tc.type: FUNC
387 */
388 HWTEST_F(UsbdTransferTest, UsbdControlTransfer017, TestSize.Level1)
389 {
390 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
391 dev.busNum = BUS_NUM_255;
392 dev.devAddr = DEV_ADDR_2;
393 uint32_t length = LENGTH_NUM_255;
394 uint8_t buffer[LENGTH_NUM_255] = {0};
395 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
396 struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0, 0, 0, 1000};
397 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
398 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer017 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
399 ASSERT_TRUE(ret != 0);
400 }
401
402 /**
403 * @tc.name: UsbdControlTransfer018
404 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
405 * @tc.type: FUNC
406 */
407 HWTEST_F(UsbdTransferTest, UsbdControlTransfer018, TestSize.Level1)
408 {
409 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
410 dev.busNum = BUS_NUM_1;
411 dev.devAddr = DEV_ADDR_255;
412 uint32_t length = LENGTH_NUM_255;
413 uint8_t buffer[LENGTH_NUM_255] = {0};
414 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
415 struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0, 0, 0, 1000};
416 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
417 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer018 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
418 ASSERT_TRUE(ret != 0);
419 }
420
421 /**
422 * @tc.name: UsbdControlTransfer019
423 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
424 * @tc.type: FUNC
425 */
426 HWTEST_F(UsbdTransferTest, UsbdControlTransfer019, TestSize.Level1)
427 {
428 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
429 dev.busNum = BUS_NUM_1;
430 dev.devAddr = DEV_ADDR_2;
431 uint32_t length = LENGTH_NUM_255;
432 uint8_t buffer[LENGTH_NUM_255] = {};
433 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
434 struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0X0C, 0, 0, 1000};
435 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
436 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer019 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
437 ASSERT_TRUE(ret == 0);
438 }
439
440 /**
441 * @tc.name: UsbdControlTransfer020
442 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
443 * @tc.type: FUNC
444 */
445 HWTEST_F(UsbdTransferTest, UsbdControlTransfer020, TestSize.Level1)
446 {
447 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
448 dev.busNum = BUS_NUM_255;
449 dev.devAddr = DEV_ADDR_2;
450 uint32_t length = LENGTH_NUM_255;
451 uint8_t buffer[LENGTH_NUM_255] = {};
452 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
453 struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0X0C, 0, 0, 1000};
454 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
455 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer020 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
456 ASSERT_TRUE(ret != 0);
457 }
458
459 /**
460 * @tc.name: UsbdControlTransfer021
461 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
462 * @tc.type: FUNC
463 */
464 HWTEST_F(UsbdTransferTest, UsbdControlTransfer021, TestSize.Level1)
465 {
466 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
467 dev.busNum = BUS_NUM_1;
468 dev.devAddr = DEV_ADDR_255;
469 uint32_t length = LENGTH_NUM_255;
470 uint8_t buffer[LENGTH_NUM_255] = {};
471 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
472 struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0X0C, 0, 0, 1000};
473 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
474 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer021 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
475 ASSERT_TRUE(ret != 0);
476 }
477
478 /**
479 * @tc.name: UsbdBulkTransferRead001
480 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
481 * std::vector<uint8_t> &data);
482 * @tc.type: FUNC
483 */
484 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead001, TestSize.Level1)
485 {
486 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
487 dev.busNum = BUS_NUM_1;
488 dev.devAddr = DEV_ADDR_2;
489 uint8_t interfaceId = INTERFACEID_1;
490 uint8_t pointid = POINTID_129;
491 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
492 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
493 ASSERT_TRUE(ret == 0);
494 uint8_t buffer[LENGTH_NUM_255] = {0};
495 uint32_t length = LENGTH_NUM_255;
496 struct UsbPipe pipe = {interfaceId, pointid};
497 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
498 ret = UsbdClient::GetInstance().BulkTransferRead(dev, pipe, 1000, bufferdata);
499 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
500 ASSERT_TRUE(ret == 0);
501 }
502
503 /**
504 * @tc.name: UsbdBulkTransferRead002
505 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
506 * std::vector<uint8_t> &data);
507 * @tc.type: FUNC
508 */
509 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead002, TestSize.Level1)
510 {
511 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
512 dev.busNum = BUS_NUM_1;
513 dev.devAddr = DEV_ADDR_2;
514 uint8_t interfaceId = INTERFACEID_1;
515 uint8_t pointid = POINTID_129;
516 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
517 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d ReleaseInterface=%{public}d", __LINE__, ret);
518 ASSERT_TRUE(ret == 0);
519 dev.busNum = BUS_NUM_222;
520 uint32_t length = 100;
521 uint8_t buffer[100] = {0};
522 struct UsbPipe pipe = {interfaceId, pointid};
523 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
524 ret = UsbdClient::GetInstance().BulkTransferRead(dev, pipe, 1000, bufferdata);
525 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
526 ASSERT_TRUE(ret != 0);
527 }
528
529 /**
530 * @tc.name: UsbdBulkTransferRead003
531 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
532 * std::vector<uint8_t> &data);
533 * @tc.type: FUNC
534 */
535 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead003, TestSize.Level1)
536 {
537 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
538 dev.busNum = BUS_NUM_1;
539 dev.devAddr = DEV_ADDR_2;
540 uint8_t interfaceId = INTERFACEID_1;
541 uint8_t pointid = POINTID_129;
542 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
543 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
544 ASSERT_TRUE(ret == 0);
545 dev.devAddr = 244;
546 uint32_t length = 100;
547 uint8_t buffer[100] = {0};
548 struct UsbPipe pipe = {interfaceId, pointid};
549 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
550 ret = UsbdClient::GetInstance().BulkTransferRead(dev, pipe, 1000, bufferdata);
551 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead003 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
552 ASSERT_TRUE(ret != 0);
553 }
554
555 /**
556 * @tc.name: UsbdBulkTransferRead004
557 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
558 * std::vector<uint8_t> &data);
559 * @tc.type: FUNC
560 */
561 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead004, TestSize.Level1)
562 {
563 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
564 dev.busNum = BUS_NUM_1;
565 dev.devAddr = DEV_ADDR_2;
566 uint8_t interfaceId = INTERFACEID_1;
567 uint8_t pointid = POINTID_129;
568 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
569 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
570 ASSERT_TRUE(ret == 0);
571 uint8_t buffer[100] = {0};
572 uint32_t length = 100;
573 struct UsbPipe pipe = {interfaceId, pointid};
574 pipe.interfaceId = 244;
575 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
576 ret = UsbdClient::GetInstance().BulkTransferRead(dev, pipe, 1000, bufferdata);
577 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead004 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
578 ASSERT_TRUE(ret != 0);
579 }
580
581 /**
582 * @tc.name: UsbdBulkTransferRead005
583 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
584 * std::vector<uint8_t> &data);
585 * @tc.type: FUNC
586 */
587 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead005, TestSize.Level1)
588 {
589 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
590 dev.busNum = BUS_NUM_1;
591 dev.devAddr = DEV_ADDR_2;
592 uint8_t interfaceId = INTERFACEID_1;
593 uint8_t pointid = POINTID_129;
594 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
595 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
596 ASSERT_TRUE(ret == 0);
597 uint32_t length = 100;
598 uint8_t buffer[100] = {};
599 struct UsbPipe pipe = {interfaceId, pointid};
600 pipe.endpointId = 244;
601 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
602 ret = UsbdClient::GetInstance().BulkTransferRead(dev, pipe, 1000, bufferdata);
603 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead005 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
604 ASSERT_TRUE(ret != 0);
605 }
606
607 /**
608 * @tc.name: UsbdBulkTransferWrite001
609 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
610 * std::vector<uint8_t> &data);
611 * @tc.type: FUNC
612 */
613 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite001, TestSize.Level1)
614 {
615 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
616 dev.busNum = BUS_NUM_1;
617 dev.devAddr = DEV_ADDR_2;
618 uint8_t interfaceId = INTERFACEID_1;
619 uint8_t pointid = POINTID_1;
620 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
621 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
622 ASSERT_TRUE(ret == 0);
623 uint32_t length = 100;
624 uint8_t buffer[100] = "hello world bulk writ01";
625 struct UsbPipe pipe = {interfaceId, pointid};
626 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
627 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
628 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
629 ASSERT_TRUE(ret == 0);
630 }
631
632 /**
633 * @tc.name: UsbdBulkTransferWrite002
634 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
635 * std::vector<uint8_t> &data);
636 * @tc.type: FUNC
637 */
638 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite002, TestSize.Level1)
639 {
640 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
641 dev.busNum = BUS_NUM_1;
642 dev.devAddr = DEV_ADDR_2;
643 uint8_t interfaceId = INTERFACEID_1;
644 uint8_t pointid = POINTID_1;
645 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
646 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
647 ASSERT_TRUE(ret == 0);
648 struct UsbPipe pipe = {interfaceId, pointid};
649 dev.busNum = 99;
650 uint32_t length = 100;
651 uint8_t buffer[100] = "hello world bulk writ02";
652 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
653 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
654 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
655 ASSERT_TRUE(ret != 0);
656 }
657
658 /**
659 * @tc.name: UsbdBulkTransferWrite003
660 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
661 * std::vector<uint8_t> &data);
662 * @tc.type: FUNC
663 */
664 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite003, TestSize.Level1)
665 {
666 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
667 dev.busNum = BUS_NUM_1;
668 dev.devAddr = DEV_ADDR_2;
669 uint8_t interfaceId = INTERFACEID_1;
670 uint8_t pointid = POINTID_1;
671 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
672 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
673 ASSERT_TRUE(ret == 0);
674 dev.devAddr = 244;
675 uint32_t length = 100;
676 uint8_t buffer[100] = "hello world bulk writ03";
677 struct UsbPipe pipe = {interfaceId, pointid};
678 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
679 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
680 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite003 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
681 ASSERT_TRUE(ret != 0);
682 }
683
684 /**
685 * @tc.name: UsbdBulkTransferWrite004
686 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
687 * std::vector<uint8_t> &data);
688 * @tc.type: FUNC
689 */
690 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite004, TestSize.Level1)
691 {
692 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
693 dev.busNum = BUS_NUM_1;
694 dev.devAddr = DEV_ADDR_2;
695 uint8_t interfaceId = INTERFACEID_1;
696 uint8_t pointid = POINTID_1;
697 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
698 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
699 ASSERT_TRUE(ret == 0);
700 struct UsbPipe pipe = {interfaceId, pointid};
701 pipe.interfaceId = 255;
702 uint32_t length = 100;
703 uint8_t buffer[100] = "hello world bulk writ04";
704 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
705 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
706 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite004 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
707 ASSERT_TRUE(ret != 0);
708 }
709
710 /**
711 * @tc.name: UsbdBulkTransferWrite005
712 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
713 * std::vector<uint8_t> &data);
714 * @tc.type: FUNC
715 */
716 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite005, TestSize.Level1)
717 {
718 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
719 dev.busNum = BUS_NUM_1;
720 dev.devAddr = DEV_ADDR_2;
721 uint8_t interfaceId = INTERFACEID_1;
722 uint8_t pointid = POINTID_1;
723 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
724 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
725 ASSERT_TRUE(ret == 0);
726 struct UsbPipe pipe = {interfaceId, pointid};
727 pipe.endpointId = 255;
728 uint32_t length = 100;
729 uint8_t buffer[100] = "hello world bulk writ05";
730 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
731 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
732 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite005 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
733 ASSERT_TRUE(ret != 0);
734 }
735
736 /**
737 * @tc.name: UsbdBulkTransferWrite006
738 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
739 * std::vector<uint8_t> &data);
740 * @tc.type: FUNC
741 */
742 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite006, TestSize.Level1)
743 {
744 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
745 dev.busNum = BUS_NUM_1;
746 dev.devAddr = DEV_ADDR_2;
747 uint8_t interfaceId = INTERFACEID_1;
748 uint8_t pointid = POINTID_1;
749 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
750 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
751 ASSERT_TRUE(ret == 0);
752 struct UsbPipe pipe = {interfaceId, pointid};
753 dev.busNum = 99;
754 dev.devAddr = 99;
755 uint32_t length = 100;
756 uint8_t buffer[100] = "hello world bulk writ06";
757 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
758 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
759 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite006 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
760 ASSERT_TRUE(ret != 0);
761 }
762
763 /**
764 * @tc.name: UsbdBulkTransferWrite007
765 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
766 * std::vector<uint8_t> &data);
767 * @tc.type: FUNC
768 */
769 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite007, TestSize.Level1)
770 {
771 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
772 dev.busNum = BUS_NUM_1;
773 dev.devAddr = DEV_ADDR_2;
774 uint8_t interfaceId = INTERFACEID_1;
775 uint8_t pointid = 99;
776 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
777 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
778 ASSERT_TRUE(ret == 0);
779 struct UsbPipe pipe = {interfaceId, pointid};
780 uint32_t length = 100;
781 uint8_t buffer[100] = "hello world bulk writ07";
782 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
783 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
784 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite007 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
785 ASSERT_TRUE(ret != 0);
786 }
787
788 /**
789 * @tc.name: UsbdBulkTransferWrite008
790 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
791 * std::vector<uint8_t> &data);
792 * @tc.type: FUNC
793 */
794 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite008, TestSize.Level1)
795 {
796 HDF_LOGI("Case Start : UsbdBulkTransferWrite008 : BulkTransferWrite");
797 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
798 dev.busNum = BUS_NUM_1;
799 dev.devAddr = DEV_ADDR_2;
800 uint8_t interfaceId = INTERFACEID_1;
801 uint8_t pointid = POINTID_1;
802 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
803 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
804 ASSERT_TRUE(ret == 0);
805 struct UsbPipe pipe = {interfaceId, pointid};
806 uint32_t length = 100;
807 uint8_t buffer[100] = "hello world bulk writ08";
808 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
809 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, -1, bufferdata);
810 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
811 ASSERT_TRUE(ret == 0);
812 }
813
814 /**
815 * @tc.name: InterruptTransferRead001
816 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
817 * std::vector<uint8_t> &data);
818 * @tc.type: FUNC
819 */
820 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead001, TestSize.Level1)
821 {
822 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
823 dev.busNum = BUS_NUM_1;
824 dev.devAddr = DEV_ADDR_2;
825 uint8_t interfaceId = INTERFACEID_1;
826 uint8_t pointid = POINTID_129;
827 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
828 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
829 ASSERT_TRUE(ret == 0);
830 uint8_t buffer[LENGTH_NUM_255] = {0};
831 uint32_t length = LENGTH_NUM_255;
832 struct UsbPipe pipe = {interfaceId, pointid};
833 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
834 ret = UsbdClient::GetInstance().InterruptTransferRead(dev, pipe, 1000, bufferdata);
835 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
836 ret);
837 ASSERT_TRUE(ret == 0);
838 }
839
840 /**
841 * @tc.name: UsbdInterruptTransferRead002
842 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
843 * std::vector<uint8_t> &data);
844 * @tc.type: FUNC
845 */
846 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead002, TestSize.Level1)
847 {
848 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
849 dev.busNum = BUS_NUM_1;
850 dev.devAddr = DEV_ADDR_2;
851 uint8_t interfaceId = INTERFACEID_1;
852 uint8_t pointid = POINTID_129;
853 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
854 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d ReleaseInterface=%{public}d", __LINE__, ret);
855 ASSERT_TRUE(ret == 0);
856 dev.busNum = BUS_NUM_222;
857 uint32_t length = 100;
858 uint8_t buffer[100] = {0};
859 struct UsbPipe pipe = {interfaceId, pointid};
860 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
861 ret = UsbdClient::GetInstance().InterruptTransferRead(dev, pipe, 1000, bufferdata);
862 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
863 ret);
864 ASSERT_TRUE(ret != 0);
865 }
866
867 /**
868 * @tc.name: UsbdInterruptTransferRead003
869 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
870 * std::vector<uint8_t> &data);
871 * @tc.type: FUNC
872 */
873 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead003, TestSize.Level1)
874 {
875 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
876 dev.busNum = BUS_NUM_1;
877 dev.devAddr = DEV_ADDR_2;
878 uint8_t interfaceId = INTERFACEID_1;
879 uint8_t pointid = POINTID_129;
880 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
881 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
882 ASSERT_TRUE(ret == 0);
883 dev.devAddr = 244;
884 uint32_t length = 100;
885 uint8_t buffer[100] = {0};
886 struct UsbPipe pipe = {interfaceId, pointid};
887 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
888 ret = UsbdClient::GetInstance().InterruptTransferRead(dev, pipe, 1000, bufferdata);
889 ASSERT_TRUE(ret != 0);
890 }
891
892 /**
893 * @tc.name: UsbdInterruptTransferRead004
894 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
895 * std::vector<uint8_t> &data);
896 * @tc.type: FUNC
897 */
898 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead004, TestSize.Level1)
899 {
900 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
901 dev.busNum = BUS_NUM_1;
902 dev.devAddr = DEV_ADDR_2;
903 uint8_t interfaceId = INTERFACEID_1;
904 uint8_t pointid = POINTID_129;
905 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
906 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
907 ASSERT_TRUE(ret == 0);
908 uint8_t buffer[100] = {0};
909 uint32_t length = 100;
910 struct UsbPipe pipe = {interfaceId, pointid};
911 pipe.interfaceId = 244;
912 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
913 ret = UsbdClient::GetInstance().InterruptTransferRead(dev, pipe, 1000, bufferdata);
914 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead004 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
915 ret);
916 ASSERT_TRUE(ret != 0);
917 }
918
919 /**
920 * @tc.name: UsbdInterruptTransferRead005
921 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
922 * std::vector<uint8_t> &data);
923 * @tc.type: FUNC
924 */
925 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead005, TestSize.Level1)
926 {
927 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
928 dev.busNum = BUS_NUM_1;
929 dev.devAddr = DEV_ADDR_2;
930 uint8_t interfaceId = INTERFACEID_1;
931 uint8_t pointid = POINTID_129;
932 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
933 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
934 ASSERT_TRUE(ret == 0);
935 uint32_t length = 100;
936 uint8_t buffer[100] = {};
937 struct UsbPipe pipe = {interfaceId, pointid};
938 pipe.endpointId = 244;
939 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
940 ret = UsbdClient::GetInstance().InterruptTransferRead(dev, pipe, 1000, bufferdata);
941 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead005 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
942 ret);
943 ASSERT_TRUE(ret != 0);
944 }
945
946 /**
947 * @tc.name: UsbdInterruptTransferWrite001
948 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
949 * std::vector<uint8_t> &data);
950 * @tc.type: FUNC
951 */
952 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite001, TestSize.Level1)
953 {
954 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
955 dev.busNum = BUS_NUM_1;
956 dev.devAddr = DEV_ADDR_2;
957 uint8_t interfaceId = INTERFACEID_1;
958 uint8_t pointid = POINTID_1;
959 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
960 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
961 ASSERT_TRUE(ret == 0);
962 uint32_t length = 100;
963 uint8_t buffer[100] = "hello world Interrupt writ01";
964 struct UsbPipe pipe = {interfaceId, pointid};
965 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
966 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
967 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
968 ret);
969 ASSERT_TRUE(ret == 0);
970 }
971
972 /**
973 * @tc.name: UsbdInterruptTransferWrite002
974 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
975 * std::vector<uint8_t> &data);
976 * @tc.type: FUNC
977 */
978 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite002, TestSize.Level1)
979 {
980 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
981 dev.busNum = BUS_NUM_1;
982 dev.devAddr = DEV_ADDR_2;
983 uint8_t interfaceId = INTERFACEID_1;
984 uint8_t pointid = POINTID_1;
985 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
986 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
987 ASSERT_TRUE(ret == 0);
988 struct UsbPipe pipe = {interfaceId, pointid};
989 dev.busNum = 99;
990 uint32_t length = 100;
991 uint8_t buffer[100] = "hello world Interrupt writ02";
992 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
993 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
994 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
995 ret);
996 ASSERT_TRUE(ret != 0);
997 }
998
999 /**
1000 * @tc.name: UsbdInterruptTransferWrite003
1001 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1002 * std::vector<uint8_t> &data);
1003 * @tc.type: FUNC
1004 */
1005 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite003, TestSize.Level1)
1006 {
1007 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1008 dev.busNum = BUS_NUM_1;
1009 dev.devAddr = DEV_ADDR_2;
1010 uint8_t interfaceId = INTERFACEID_1;
1011 uint8_t pointid = POINTID_1;
1012 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1013 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1014 ASSERT_TRUE(ret == 0);
1015 dev.devAddr = 244;
1016 uint32_t length = 100;
1017 uint8_t buffer[100] = "hello world Interrupt writ03";
1018 struct UsbPipe pipe = {interfaceId, pointid};
1019 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1020 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
1021 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite003 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
1022 ret);
1023 ASSERT_TRUE(ret != 0);
1024 }
1025
1026 /**
1027 * @tc.name: UsbdInterruptTransferWrite004
1028 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1029 * std::vector<uint8_t> &data);
1030 * @tc.type: FUNC
1031 */
1032 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite004, TestSize.Level1)
1033 {
1034 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1035 dev.busNum = BUS_NUM_1;
1036 dev.devAddr = DEV_ADDR_2;
1037 uint8_t interfaceId = INTERFACEID_1;
1038 uint8_t pointid = POINTID_1;
1039 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1040 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1041 ASSERT_TRUE(ret == 0);
1042 struct UsbPipe pipe = {interfaceId, pointid};
1043 pipe.interfaceId = 255;
1044 uint32_t length = 100;
1045 uint8_t buffer[100] = "hello world Interrupt writ04";
1046 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1047 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
1048 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite004 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
1049 ret);
1050 ASSERT_TRUE(ret != 0);
1051 }
1052
1053 /**
1054 * @tc.name: UsbdInterruptTransferWrite005
1055 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1056 * std::vector<uint8_t> &data);
1057 * @tc.type: FUNC
1058 */
1059 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite005, TestSize.Level1)
1060 {
1061 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1062 dev.busNum = BUS_NUM_1;
1063 dev.devAddr = DEV_ADDR_2;
1064 uint8_t interfaceId = INTERFACEID_1;
1065 uint8_t pointid = POINTID_1;
1066 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1067 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1068 ASSERT_TRUE(ret == 0);
1069 struct UsbPipe pipe = {interfaceId, pointid};
1070 pipe.endpointId = 255;
1071 uint32_t length = 100;
1072 uint8_t buffer[100] = "hello world Interrupt writ05";
1073 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1074 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
1075 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite005 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
1076 ret);
1077 ASSERT_TRUE(ret != 0);
1078 }
1079
1080 /**
1081 * @tc.name: UsbdInterruptTransferWrite006
1082 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1083 * std::vector<uint8_t> &data);
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite006, TestSize.Level1)
1087 {
1088 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1089 dev.busNum = BUS_NUM_1;
1090 dev.devAddr = DEV_ADDR_2;
1091 uint8_t interfaceId = INTERFACEID_1;
1092 uint8_t pointid = POINTID_1;
1093 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1094 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1095 ASSERT_TRUE(ret == 0);
1096 struct UsbPipe pipe = {interfaceId, pointid};
1097 dev.busNum = 99;
1098 dev.devAddr = 99;
1099 uint32_t length = 100;
1100 uint8_t buffer[100] = "hello world Interrupt writ06";
1101 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1102 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
1103 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite006 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
1104 ret);
1105 ASSERT_TRUE(ret != 0);
1106 }
1107
1108 /**
1109 * @tc.name: UsbdInterruptTransferWrite007
1110 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1111 * std::vector<uint8_t> &data);
1112 * @tc.type: FUNC
1113 */
1114 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite007, TestSize.Level1)
1115 {
1116 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1117 dev.busNum = BUS_NUM_1;
1118 dev.devAddr = DEV_ADDR_2;
1119 uint8_t interfaceId = INTERFACEID_1;
1120 uint8_t pointid = 99;
1121 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1122 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1123 ASSERT_TRUE(ret == 0);
1124 struct UsbPipe pipe = {interfaceId, pointid};
1125 uint32_t length = 100;
1126 uint8_t buffer[100] = "hello world Interrupt writ07";
1127 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1128 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
1129 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite007 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
1130 ret);
1131 ASSERT_TRUE(ret != 0);
1132 }
1133
1134 /**
1135 * @tc.name: UsbdInterruptTransferWrite008
1136 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1137 * std::vector<uint8_t> &data);
1138 * @tc.type: FUNC
1139 */
1140 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite008, TestSize.Level1)
1141 {
1142 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1143 dev.busNum = BUS_NUM_1;
1144 dev.devAddr = DEV_ADDR_2;
1145 uint8_t interfaceId = INTERFACEID_1;
1146 uint8_t pointid = POINTID_1;
1147 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1148 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1149 ASSERT_TRUE(ret == 0);
1150 struct UsbPipe pipe = {interfaceId, pointid};
1151 uint32_t length = 100;
1152 uint8_t buffer[100] = "hello world Interrupt writ08";
1153 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1154 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, -1, bufferdata);
1155 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
1156 ret);
1157 ASSERT_TRUE(ret == 0);
1158 }
1159
1160 /**
1161 * @tc.name: UsbdIsoTransferRead001
1162 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1163 * std::vector<uint8_t> &data);
1164 * @tc.type: FUNC
1165 */
1166 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead001, TestSize.Level1)
1167 {
1168 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1169 dev.busNum = BUS_NUM_1;
1170 dev.devAddr = DEV_ADDR_2;
1171 uint8_t interfaceId = INTERFACEID_1;
1172 uint8_t pointid = POINTID_129;
1173 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1174 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1175 ASSERT_TRUE(ret == 0);
1176 uint8_t buffer[LENGTH_NUM_255] = {0};
1177 uint32_t length = LENGTH_NUM_255;
1178 struct UsbPipe pipe = {interfaceId, pointid};
1179 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1180 ret = UsbdClient::GetInstance().IsoTransferRead(dev, pipe, 1000, bufferdata);
1181 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1182 ASSERT_TRUE(ret == 0);
1183 }
1184
1185 /**
1186 * @tc.name: UsbdIsoTransferRead002
1187 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1188 * std::vector<uint8_t> &data);
1189 * @tc.type: FUNC
1190 */
1191 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead002, TestSize.Level1)
1192 {
1193 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1194 dev.busNum = BUS_NUM_1;
1195 dev.devAddr = DEV_ADDR_2;
1196 uint8_t interfaceId = INTERFACEID_1;
1197 uint8_t pointid = POINTID_129;
1198 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d interfaceId=%{public}d", __LINE__, interfaceId);
1199 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1200 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d ReleaseInterface=%{public}d", __LINE__, ret);
1201 ASSERT_TRUE(ret == 0);
1202 dev.busNum = BUS_NUM_222;
1203 uint32_t length = 100;
1204 uint8_t buffer[100] = {0};
1205 struct UsbPipe pipe = {interfaceId, pointid};
1206 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1207 ret = UsbdClient::GetInstance().IsoTransferRead(dev, pipe, 1000, bufferdata);
1208 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1209 ASSERT_TRUE(ret != 0);
1210 }
1211
1212 /**
1213 * @tc.name: UsbdIsoTransferRead003
1214 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1215 * std::vector<uint8_t> &data);
1216 * @tc.type: FUNC
1217 */
1218 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead003, TestSize.Level1)
1219 {
1220 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1221 dev.busNum = BUS_NUM_1;
1222 dev.devAddr = DEV_ADDR_2;
1223 uint8_t interfaceId = INTERFACEID_1;
1224 uint8_t pointid = POINTID_129;
1225 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1226 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1227 ASSERT_TRUE(ret == 0);
1228 dev.devAddr = 244;
1229 uint32_t length = 100;
1230 uint8_t buffer[100] = {0};
1231 struct UsbPipe pipe = {interfaceId, pointid};
1232 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1233 ret = UsbdClient::GetInstance().IsoTransferRead(dev, pipe, 1000, bufferdata);
1234 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead003 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1235 ASSERT_TRUE(ret != 0);
1236 }
1237
1238 /**
1239 * @tc.name: UsbdIsoTransferRead004
1240 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1241 * std::vector<uint8_t> &data);
1242 * @tc.type: FUNC
1243 */
1244 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead004, TestSize.Level1)
1245 {
1246 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1247 dev.busNum = BUS_NUM_1;
1248 dev.devAddr = DEV_ADDR_2;
1249 uint8_t interfaceId = INTERFACEID_1;
1250 uint8_t pointid = POINTID_129;
1251 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1252 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1253 ASSERT_TRUE(ret == 0);
1254 uint8_t buffer[100] = {0};
1255 uint32_t length = 100;
1256 struct UsbPipe pipe = {interfaceId, pointid};
1257 pipe.interfaceId = 244;
1258 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1259 ret = UsbdClient::GetInstance().IsoTransferRead(dev, pipe, 1000, bufferdata);
1260 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead004 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1261 ASSERT_TRUE(ret != 0);
1262 }
1263
1264 /**
1265 * @tc.name: UsbdIsoTransferRead005
1266 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1267 * std::vector<uint8_t> &data);
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead005, TestSize.Level1)
1271 {
1272 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1273 dev.busNum = BUS_NUM_1;
1274 dev.devAddr = DEV_ADDR_2;
1275 uint8_t interfaceId = INTERFACEID_1;
1276 uint8_t pointid = POINTID_129;
1277 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1278 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1279 ASSERT_TRUE(ret == 0);
1280 uint32_t length = 100;
1281 uint8_t buffer[100] = {};
1282 struct UsbPipe pipe = {interfaceId, pointid};
1283 pipe.endpointId = 244;
1284 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1285 ret = UsbdClient::GetInstance().IsoTransferRead(dev, pipe, 1000, bufferdata);
1286 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead005 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1287 ASSERT_TRUE(ret != 0);
1288 }
1289
1290 /**
1291 * @tc.name: UsbdIsoTransferWrite001
1292 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1293 * std::vector<uint8_t> &data);
1294 * @tc.type: FUNC
1295 */
1296 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite001, TestSize.Level1)
1297 {
1298 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1299 dev.busNum = BUS_NUM_1;
1300 dev.devAddr = DEV_ADDR_2;
1301 uint8_t interfaceId = INTERFACEID_1;
1302 uint8_t pointid = POINTID_1;
1303 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1304 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1305 ASSERT_TRUE(ret == 0);
1306 uint32_t length = 100;
1307 uint8_t buffer[100] = "hello world Iso writ01";
1308 struct UsbPipe pipe = {interfaceId, pointid};
1309 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1310 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
1311 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1312 ASSERT_TRUE(ret == 0);
1313 }
1314
1315 /**
1316 * @tc.name: UsbdIsoTransferWrite002
1317 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1318 * std::vector<uint8_t> &data);
1319 * @tc.type: FUNC
1320 */
1321 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite002, TestSize.Level1)
1322 {
1323 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1324 dev.busNum = BUS_NUM_1;
1325 dev.devAddr = DEV_ADDR_2;
1326 uint8_t interfaceId = INTERFACEID_1;
1327 uint8_t pointid = POINTID_1;
1328 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1329 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1330 ASSERT_TRUE(ret == 0);
1331 struct UsbPipe pipe = {interfaceId, pointid};
1332 dev.busNum = 99;
1333 uint32_t length = 100;
1334 uint8_t buffer[100] = "hello world Iso writ02";
1335 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1336 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
1337 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1338 ASSERT_TRUE(ret != 0);
1339 }
1340
1341 /**
1342 * @tc.name: UsbdIsoTransferWrite003
1343 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1344 * std::vector<uint8_t> &data);
1345 * @tc.type: FUNC
1346 */
1347 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite003, TestSize.Level1)
1348 {
1349 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1350 dev.busNum = BUS_NUM_1;
1351 dev.devAddr = DEV_ADDR_2;
1352 uint8_t interfaceId = INTERFACEID_1;
1353 uint8_t pointid = POINTID_1;
1354 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1355 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1356 ASSERT_TRUE(ret == 0);
1357 dev.devAddr = 244;
1358 uint32_t length = 100;
1359 uint8_t buffer[100] = "hello world Iso writ03";
1360 struct UsbPipe pipe = {interfaceId, pointid};
1361 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1362 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
1363 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite003 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1364 ASSERT_TRUE(ret != 0);
1365 }
1366
1367 /**
1368 * @tc.name: UsbdIsoTransferWrite004
1369 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1370 * std::vector<uint8_t> &data);
1371 * @tc.type: FUNC
1372 */
1373 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite004, TestSize.Level1)
1374 {
1375 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1376 dev.busNum = BUS_NUM_1;
1377 dev.devAddr = DEV_ADDR_2;
1378 uint8_t interfaceId = INTERFACEID_1;
1379 uint8_t pointid = POINTID_1;
1380 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1381 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1382 ASSERT_TRUE(ret == 0);
1383 struct UsbPipe pipe = {interfaceId, pointid};
1384 pipe.interfaceId = 255;
1385 uint32_t length = 100;
1386 uint8_t buffer[100] = "hello world Iso writ04";
1387 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1388 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
1389 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite004 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1390 ASSERT_TRUE(ret != 0);
1391 }
1392
1393 /**
1394 * @tc.name: UsbdIsoTransferWrite005
1395 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1396 * std::vector<uint8_t> &data);
1397 * @tc.type: FUNC
1398 */
1399 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite005, TestSize.Level1)
1400 {
1401 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1402 dev.busNum = BUS_NUM_1;
1403 dev.devAddr = DEV_ADDR_2;
1404 uint8_t interfaceId = INTERFACEID_1;
1405 uint8_t pointid = POINTID_1;
1406 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1407 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1408 ASSERT_TRUE(ret == 0);
1409 struct UsbPipe pipe = {interfaceId, pointid};
1410 pipe.endpointId = 255;
1411 uint32_t length = 100;
1412 uint8_t buffer[100] = "hello world Iso writ05";
1413 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1414 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
1415 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite005 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1416 ASSERT_TRUE(ret != 0);
1417 }
1418
1419 /**
1420 * @tc.name: UsbdIsoTransferWrite006
1421 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1422 * std::vector<uint8_t> &data);
1423 * @tc.type: FUNC
1424 */
1425 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite006, TestSize.Level1)
1426 {
1427 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1428 dev.busNum = BUS_NUM_1;
1429 dev.devAddr = DEV_ADDR_2;
1430 uint8_t interfaceId = INTERFACEID_1;
1431 uint8_t pointid = POINTID_1;
1432 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1433 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1434 ASSERT_TRUE(ret == 0);
1435 struct UsbPipe pipe = {interfaceId, pointid};
1436 dev.busNum = 99;
1437 dev.devAddr = 99;
1438 uint32_t length = 100;
1439 uint8_t buffer[100] = "hello world Iso writ06";
1440 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1441 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
1442 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite006 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1443 ASSERT_TRUE(ret != 0);
1444 }
1445
1446 /**
1447 * @tc.name: UsbdIsoTransferWrite007
1448 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1449 * std::vector<uint8_t> &data);
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite007, TestSize.Level1)
1453 {
1454 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1455 dev.busNum = BUS_NUM_1;
1456 dev.devAddr = DEV_ADDR_2;
1457 uint8_t interfaceId = INTERFACEID_1;
1458 uint8_t pointid = 99;
1459 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1460 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1461 ASSERT_TRUE(ret == 0);
1462 struct UsbPipe pipe = {interfaceId, pointid};
1463 uint32_t length = 100;
1464 uint8_t buffer[100] = "hello world Iso writ07";
1465 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1466 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
1467 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite007 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1468 ASSERT_TRUE(ret != 0);
1469 }
1470
1471 /**
1472 * @tc.name: UsbdIsoTransferWrite008
1473 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1474 * std::vector<uint8_t> &data);
1475 * @tc.type: FUNC
1476 */
1477 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite008, TestSize.Level1)
1478 {
1479 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
1480 dev.busNum = BUS_NUM_1;
1481 dev.devAddr = DEV_ADDR_2;
1482 uint8_t interfaceId = INTERFACEID_1;
1483 uint8_t pointid = POINTID_1;
1484 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
1485 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1486 ASSERT_TRUE(ret == 0);
1487 struct UsbPipe pipe = {interfaceId, pointid};
1488 uint32_t length = 100;
1489 uint8_t buffer[100] = "hello world Iso writ08";
1490 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
1491 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, -1, bufferdata);
1492 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1493 ASSERT_TRUE(ret == 0);
1494 }
1495