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 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 BUS_NUM_222 = 222;
33 const uint32_t LENGTH_NUM_255 = 255;
34 const uint8_t INTERFACEID_1 = 1;
35 const uint8_t POINTID_1 = 1;
36 const uint8_t POINTID_129 = 129;
37
SetUpTestCase(void)38 void UsbdTransferTest::SetUpTestCase(void)
39 {
40 auto ret = UsbdClient::GetInstance().SetPortRole(1, 1, 1);
41 sleep(SLEEP_TIME);
42 HDF_LOGI("UsbdFunctionTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
43 ASSERT_TRUE(ret == 0);
44 if (ret != 0) {
45 exit(0);
46 }
47 std::cout << "please connect device, press enter to continue" << std::endl;
48 int c;
49 while ((c = getchar()) != '\n' && c != EOF) {
50 }
51 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
52 ret = UsbdClient::GetInstance().OpenDevice(dev);
53 HDF_LOGI("UsbdTransferTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
54 ASSERT_TRUE(ret == 0);
55 }
56
TearDownTestCase(void)57 void UsbdTransferTest::TearDownTestCase(void)
58 {
59 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
60 auto ret = UsbdClient::GetInstance().CloseDevice(dev);
61 HDF_LOGI("UsbdTransferTest:: %{public}d Close=%{public}d", __LINE__, ret);
62 ASSERT_TRUE(ret == 0);
63 }
64
SetUp(void)65 void UsbdTransferTest::SetUp(void) {}
66
TearDown(void)67 void UsbdTransferTest::TearDown(void) {}
68
69 /**
70 * @tc.name: UsbdControlTransfer001
71 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
72 * @tc.type: FUNC
73 */
74 HWTEST_F(UsbdTransferTest, UsbdControlTransfer001, Function | MediumTest | Level1)
75 {
76 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
77 dev.busNum = BUS_NUM_1;
78 dev.devAddr = DEV_ADDR_2;
79 uint8_t buffer[LENGTH_NUM_255] = {0};
80 uint32_t length = LENGTH_NUM_255;
81 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
82 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 8, 0, 0, 1000};
83 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
84 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer001 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
85 ASSERT_TRUE(ret == 0);
86 }
87
88 /**
89 * @tc.name: UsbdControlTransfer002
90 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
91 * @tc.type: FUNC
92 */
93 HWTEST_F(UsbdTransferTest, UsbdControlTransfer002, Function | MediumTest | Level1)
94 {
95 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
96 dev.busNum = BUS_NUM_255;
97 dev.devAddr = DEV_ADDR_2;
98 uint8_t buffer[LENGTH_NUM_255] = {0};
99 uint32_t length = LENGTH_NUM_255;
100 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
101 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 8, 0, 0, 1000};
102 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
103 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer002 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
104 ASSERT_TRUE(ret != 0);
105 }
106
107 /**
108 * @tc.name: UsbdControlTransfer004
109 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
110 * @tc.type: FUNC
111 */
112 HWTEST_F(UsbdTransferTest, UsbdControlTransfer004, Function | MediumTest | Level1)
113 {
114 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
115 dev.busNum = BUS_NUM_1;
116 dev.devAddr = DEV_ADDR_2;
117 uint32_t length = LENGTH_NUM_255;
118 uint8_t buffer[LENGTH_NUM_255] = {0};
119 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
120 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 6, 0x100, 0, 1000};
121 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
122 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer004 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
123 ASSERT_TRUE(ret == 0);
124 }
125
126 /**
127 * @tc.name: UsbdControlTransfer010
128 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
129 * @tc.type: FUNC
130 */
131 HWTEST_F(UsbdTransferTest, UsbdControlTransfer010, Function | MediumTest | Level1)
132 {
133 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
134 dev.busNum = BUS_NUM_1;
135 dev.devAddr = DEV_ADDR_2;
136 uint32_t length = LENGTH_NUM_255;
137 uint8_t buffer[LENGTH_NUM_255] = {0};
138 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
139 struct UsbCtrlTransfer ctrlparmas = {0b10000000, 0, 0, 0, 1000};
140 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
141 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer010 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
142 ASSERT_TRUE(ret == 0);
143 }
144
145 /**
146 * @tc.name: UsbdControlTransfer013
147 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
148 * @tc.type: FUNC
149 */
150 HWTEST_F(UsbdTransferTest, UsbdControlTransfer013, Function | MediumTest | Level1)
151 {
152 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
153 dev.busNum = BUS_NUM_1;
154 dev.devAddr = DEV_ADDR_2;
155 uint32_t length = LENGTH_NUM_255;
156 uint8_t buffer[LENGTH_NUM_255] = {0};
157 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
158 struct UsbCtrlTransfer ctrlparmas = {0b10000001, 0, 0, 0, 1000};
159 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
160 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer013 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
161 ASSERT_TRUE(ret == 0);
162 }
163
164 /**
165 * @tc.name: UsbdControlTransfer016
166 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
167 * @tc.type: FUNC
168 */
169 HWTEST_F(UsbdTransferTest, UsbdControlTransfer016, Function | MediumTest | Level1)
170 {
171 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
172 dev.busNum = BUS_NUM_1;
173 dev.devAddr = DEV_ADDR_2;
174 uint32_t length = LENGTH_NUM_255;
175 uint8_t buffer[LENGTH_NUM_255] = {0};
176 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
177 struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0, 0, 0, 1000};
178 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
179 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer016 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
180 ASSERT_TRUE(ret == 0);
181 }
182
183 /**
184 * @tc.name: UsbdControlTransfer019
185 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
186 * @tc.type: FUNC
187 */
188 HWTEST_F(UsbdTransferTest, UsbdControlTransfer019, Function | MediumTest | Level1)
189 {
190 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
191 dev.busNum = BUS_NUM_1;
192 dev.devAddr = DEV_ADDR_2;
193 uint32_t length = LENGTH_NUM_255;
194 uint8_t buffer[LENGTH_NUM_255] = {};
195 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
196 struct UsbCtrlTransfer ctrlparmas = {0b10000010, 0X0C, 0, 0, 1000};
197 auto ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrlparmas, bufferdata);
198 HDF_LOGI("UsbdTransferTest::UsbdControlTransfer019 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
199 ASSERT_TRUE(ret == 0);
200 }
201
202 /**
203 * @tc.name: UsbdBulkTransferRead001
204 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
205 * std::vector<uint8_t> &data);
206 * @tc.type: FUNC
207 */
208 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead001, Function | MediumTest | Level1)
209 {
210 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
211 dev.busNum = BUS_NUM_1;
212 dev.devAddr = DEV_ADDR_2;
213 uint8_t interfaceId = INTERFACEID_1;
214 uint8_t pointid = POINTID_129;
215 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
216 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
217 ASSERT_TRUE(ret == 0);
218 uint8_t buffer[LENGTH_NUM_255] = {0};
219 uint32_t length = LENGTH_NUM_255;
220 struct UsbPipe pipe = {interfaceId, pointid};
221 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
222 ret = UsbdClient::GetInstance().BulkTransferRead(dev, pipe, 1000, bufferdata);
223 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
224 ASSERT_TRUE(ret == 0);
225 }
226
227 /**
228 * @tc.name: UsbdBulkTransferRead002
229 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
230 * std::vector<uint8_t> &data);
231 * @tc.type: FUNC
232 */
233 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead002, Function | MediumTest | Level1)
234 {
235 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
236 dev.busNum = BUS_NUM_1;
237 dev.devAddr = DEV_ADDR_2;
238 uint8_t interfaceId = INTERFACEID_1;
239 uint8_t pointid = POINTID_129;
240 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
241 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d ReleaseInterface=%{public}d", __LINE__, ret);
242 ASSERT_TRUE(ret == 0);
243 dev.busNum = BUS_NUM_222;
244 uint32_t length = 100;
245 uint8_t buffer[100] = {0};
246 struct UsbPipe pipe = {interfaceId, pointid};
247 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
248 ret = UsbdClient::GetInstance().BulkTransferRead(dev, pipe, 1000, bufferdata);
249 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
250 ASSERT_TRUE(ret != 0);
251 }
252
253 /**
254 * @tc.name: UsbdBulkTransferWrite001
255 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
256 * std::vector<uint8_t> &data);
257 * @tc.type: FUNC
258 */
259 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite001, Function | MediumTest | Level1)
260 {
261 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
262 dev.busNum = BUS_NUM_1;
263 dev.devAddr = DEV_ADDR_2;
264 uint8_t interfaceId = INTERFACEID_1;
265 uint8_t pointid = POINTID_1;
266 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
267 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
268 ASSERT_TRUE(ret == 0);
269 uint32_t length = 100;
270 uint8_t buffer[100] = "hello world bulk writ01";
271 struct UsbPipe pipe = {interfaceId, pointid};
272 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
273 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
274 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
275 ASSERT_TRUE(ret == 0);
276 }
277
278 /**
279 * @tc.name: UsbdBulkTransferWrite002
280 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
281 * std::vector<uint8_t> &data);
282 * @tc.type: FUNC
283 */
284 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite002, Function | MediumTest | Level1)
285 {
286 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
287 dev.busNum = BUS_NUM_1;
288 dev.devAddr = DEV_ADDR_2;
289 uint8_t interfaceId = INTERFACEID_1;
290 uint8_t pointid = POINTID_1;
291 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
292 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
293 ASSERT_TRUE(ret == 0);
294 struct UsbPipe pipe = {interfaceId, pointid};
295 dev.busNum = 99;
296 uint32_t length = 100;
297 uint8_t buffer[100] = "hello world bulk writ02";
298 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
299 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, 1000, bufferdata);
300 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
301 ASSERT_TRUE(ret != 0);
302 }
303
304 /**
305 * @tc.name: UsbdBulkTransferWrite008
306 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
307 * std::vector<uint8_t> &data);
308 * @tc.type: FUNC
309 */
310 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite008, Function | MediumTest | Level1)
311 {
312 HDF_LOGI("Case Start : UsbdBulkTransferWrite008 : BulkTransferWrite");
313 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
314 dev.busNum = BUS_NUM_1;
315 dev.devAddr = DEV_ADDR_2;
316 uint8_t interfaceId = INTERFACEID_1;
317 uint8_t pointid = POINTID_1;
318 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
319 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
320 ASSERT_TRUE(ret == 0);
321 struct UsbPipe pipe = {interfaceId, pointid};
322 uint32_t length = 100;
323 uint8_t buffer[100] = "hello world bulk writ08";
324 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
325 ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, -1, bufferdata);
326 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
327 ASSERT_TRUE(ret == 0);
328 }
329
330 /**
331 * @tc.name: InterruptTransferRead001
332 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
333 * std::vector<uint8_t> &data);
334 * @tc.type: FUNC
335 */
336 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead001, Function | MediumTest | Level1)
337 {
338 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
339 dev.busNum = BUS_NUM_1;
340 dev.devAddr = DEV_ADDR_2;
341 uint8_t interfaceId = INTERFACEID_1;
342 uint8_t pointid = POINTID_129;
343 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
344 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
345 ASSERT_TRUE(ret == 0);
346 uint8_t buffer[LENGTH_NUM_255] = {0};
347 uint32_t length = LENGTH_NUM_255;
348 struct UsbPipe pipe = {interfaceId, pointid};
349 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
350 ret = UsbdClient::GetInstance().InterruptTransferRead(dev, pipe, 1000, bufferdata);
351 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
352 ret);
353 ASSERT_TRUE(ret == 0);
354 }
355
356 /**
357 * @tc.name: UsbdInterruptTransferRead002
358 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
359 * std::vector<uint8_t> &data);
360 * @tc.type: FUNC
361 */
362 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead002, Function | MediumTest | Level1)
363 {
364 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
365 dev.busNum = BUS_NUM_1;
366 dev.devAddr = DEV_ADDR_2;
367 uint8_t interfaceId = INTERFACEID_1;
368 uint8_t pointid = POINTID_129;
369 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
370 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d ReleaseInterface=%{public}d", __LINE__, ret);
371 ASSERT_TRUE(ret == 0);
372 dev.busNum = BUS_NUM_222;
373 uint32_t length = 100;
374 uint8_t buffer[100] = {0};
375 struct UsbPipe pipe = {interfaceId, pointid};
376 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
377 ret = UsbdClient::GetInstance().InterruptTransferRead(dev, pipe, 1000, bufferdata);
378 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
379 ret);
380 ASSERT_TRUE(ret != 0);
381 }
382
383 /**
384 * @tc.name: UsbdInterruptTransferWrite001
385 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
386 * std::vector<uint8_t> &data);
387 * @tc.type: FUNC
388 */
389 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite001, Function | MediumTest | Level1)
390 {
391 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
392 dev.busNum = BUS_NUM_1;
393 dev.devAddr = DEV_ADDR_2;
394 uint8_t interfaceId = INTERFACEID_1;
395 uint8_t pointid = POINTID_1;
396 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
397 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
398 ASSERT_TRUE(ret == 0);
399 uint32_t length = 100;
400 uint8_t buffer[100] = "hello world Interrupt writ01";
401 struct UsbPipe pipe = {interfaceId, pointid};
402 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
403 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
404 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
405 ret);
406 ASSERT_TRUE(ret == 0);
407 }
408
409 /**
410 * @tc.name: UsbdInterruptTransferWrite002
411 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
412 * std::vector<uint8_t> &data);
413 * @tc.type: FUNC
414 */
415 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite002, Function | MediumTest | Level1)
416 {
417 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
418 dev.busNum = BUS_NUM_1;
419 dev.devAddr = DEV_ADDR_2;
420 uint8_t interfaceId = INTERFACEID_1;
421 uint8_t pointid = POINTID_1;
422 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
423 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
424 ASSERT_TRUE(ret == 0);
425 struct UsbPipe pipe = {interfaceId, pointid};
426 dev.busNum = 99;
427 uint32_t length = 100;
428 uint8_t buffer[100] = "hello world Interrupt writ02";
429 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
430 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, 1000, bufferdata);
431 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
432 ret);
433 ASSERT_TRUE(ret != 0);
434 }
435
436 /**
437 * @tc.name: UsbdInterruptTransferWrite008
438 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
439 * std::vector<uint8_t> &data);
440 * @tc.type: FUNC
441 */
442 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite008, Function | MediumTest | Level1)
443 {
444 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
445 dev.busNum = BUS_NUM_1;
446 dev.devAddr = DEV_ADDR_2;
447 uint8_t interfaceId = INTERFACEID_1;
448 uint8_t pointid = POINTID_1;
449 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
450 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
451 ASSERT_TRUE(ret == 0);
452 struct UsbPipe pipe = {interfaceId, pointid};
453 uint32_t length = 100;
454 uint8_t buffer[100] = "hello world Interrupt writ08";
455 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
456 ret = UsbdClient::GetInstance().InterruptTransferWrite(dev, pipe, -1, bufferdata);
457 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d InterruptTransferWrite=%{public}d", __LINE__,
458 ret);
459 ASSERT_TRUE(ret == 0);
460 }
461
462 /**
463 * @tc.name: UsbdIsoTransferRead001
464 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
465 * std::vector<uint8_t> &data);
466 * @tc.type: FUNC
467 */
468 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead001, Function | MediumTest | Level1)
469 {
470 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
471 dev.busNum = BUS_NUM_1;
472 dev.devAddr = DEV_ADDR_2;
473 uint8_t interfaceId = INTERFACEID_1;
474 uint8_t pointid = POINTID_129;
475 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
476 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
477 ASSERT_TRUE(ret == 0);
478 uint8_t buffer[LENGTH_NUM_255] = {0};
479 uint32_t length = LENGTH_NUM_255;
480 struct UsbPipe pipe = {interfaceId, pointid};
481 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
482 ret = UsbdClient::GetInstance().IsoTransferRead(dev, pipe, 1000, bufferdata);
483 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
484 ASSERT_TRUE(ret == 0);
485 }
486
487 /**
488 * @tc.name: UsbdIsoTransferRead002
489 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
490 * std::vector<uint8_t> &data);
491 * @tc.type: FUNC
492 */
493 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead002, Function | MediumTest | Level1)
494 {
495 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
496 dev.busNum = BUS_NUM_1;
497 dev.devAddr = DEV_ADDR_2;
498 uint8_t interfaceId = INTERFACEID_1;
499 uint8_t pointid = POINTID_129;
500 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d interfaceId=%{public}d", __LINE__, interfaceId);
501 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
502 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d ReleaseInterface=%{public}d", __LINE__, ret);
503 ASSERT_TRUE(ret == 0);
504 dev.busNum = BUS_NUM_222;
505 uint32_t length = 100;
506 uint8_t buffer[100] = {0};
507 struct UsbPipe pipe = {interfaceId, pointid};
508 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
509 ret = UsbdClient::GetInstance().IsoTransferRead(dev, pipe, 1000, bufferdata);
510 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
511 ASSERT_TRUE(ret != 0);
512 }
513
514 /**
515 * @tc.name: UsbdIsoTransferWrite001
516 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
517 * std::vector<uint8_t> &data);
518 * @tc.type: FUNC
519 */
520 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite001, Function | MediumTest | Level1)
521 {
522 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
523 dev.busNum = BUS_NUM_1;
524 dev.devAddr = DEV_ADDR_2;
525 uint8_t interfaceId = INTERFACEID_1;
526 uint8_t pointid = POINTID_1;
527 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
528 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
529 ASSERT_TRUE(ret == 0);
530 uint32_t length = 100;
531 uint8_t buffer[100] = "hello world Iso writ01";
532 struct UsbPipe pipe = {interfaceId, pointid};
533 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
534 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
535 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
536 ASSERT_TRUE(ret == 0);
537 }
538
539 /**
540 * @tc.name: UsbdIsoTransferWrite002
541 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
542 * std::vector<uint8_t> &data);
543 * @tc.type: FUNC
544 */
545 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite002, Function | MediumTest | Level1)
546 {
547 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
548 dev.busNum = BUS_NUM_1;
549 dev.devAddr = DEV_ADDR_2;
550 uint8_t interfaceId = INTERFACEID_1;
551 uint8_t pointid = POINTID_1;
552 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
553 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
554 ASSERT_TRUE(ret == 0);
555 struct UsbPipe pipe = {interfaceId, pointid};
556 dev.busNum = 99;
557 uint32_t length = 100;
558 uint8_t buffer[100] = "hello world Iso writ02";
559 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
560 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, 1000, bufferdata);
561 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
562 ASSERT_TRUE(ret != 0);
563 }
564
565 /**
566 * @tc.name: UsbdIsoTransferWrite008
567 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
568 * std::vector<uint8_t> &data);
569 * @tc.type: FUNC
570 */
571 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite008, Function | MediumTest | Level1)
572 {
573 struct UsbDev dev = {BUS_NUM_1, DEV_ADDR_2};
574 dev.busNum = BUS_NUM_1;
575 dev.devAddr = DEV_ADDR_2;
576 uint8_t interfaceId = INTERFACEID_1;
577 uint8_t pointid = POINTID_1;
578 auto ret = UsbdClient::GetInstance().ClaimInterface(dev, interfaceId, true);
579 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
580 ASSERT_TRUE(ret == 0);
581 struct UsbPipe pipe = {interfaceId, pointid};
582 uint32_t length = 100;
583 uint8_t buffer[100] = "hello world Iso writ08";
584 std::vector<uint8_t> bufferdata = {buffer, buffer + length};
585 ret = UsbdClient::GetInstance().IsoTransferWrite(dev, pipe, -1, bufferdata);
586 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
587 ASSERT_TRUE(ret == 0);
588 }
589