1 /*
2 * Copyright (c) 2021-2022 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 "usb_device_pipe_test.h"
17
18 #include <sys/time.h>
19 #include <sys/ioctl.h>
20 #include <iostream>
21 #include <vector>
22
23 #include "delayed_sp_singleton.h"
24 #include "hilog_wrapper.h"
25 #include "if_system_ability_manager.h"
26 #include "system_ability_definition.h"
27 #include "usb_common_test.h"
28 #include "usb_srv_client.h"
29 #include "usb_errors.h"
30
31 using namespace testing::ext;
32 using namespace OHOS;
33 using namespace OHOS::USB;
34 using namespace std;
35 using namespace OHOS::HDI::Usb::V1_0;
36 using namespace OHOS::HDI::Usb::V1_2;
37 using namespace OHOS::USB::Common;
38
39 namespace OHOS {
40 namespace USB {
41 namespace DevicePipe {
42 constexpr int32_t USB_BUS_NUM_INVALID = -1;
43 constexpr int32_t USB_DEV_ADDR_INVALID = -1;
44 constexpr int32_t SLEEP_TIME = 3;
45 constexpr int32_t BUFFER_SIZE = 255;
46 #define USBDEVFS_GET_SPEED _IO('U', 31)
SetUpTestCase(void)47 void UsbDevicePipeTest::SetUpTestCase(void)
48 {
49 UsbCommonTest::GrantPermissionSysNative();
50 auto &srvClient = UsbSrvClient::GetInstance();
51 auto ret = srvClient.SetPortRole(1, 1, 1);
52 sleep(SLEEP_TIME);
53 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest:: [Device] SetPortRole=%{public}d", ret);
54 ret = UsbCommonTest::SwitchErrCode(ret);
55 ASSERT_TRUE(ret == 0);
56 if (ret != 0) {
57 exit(0);
58 }
59
60 std::cout << "please connect device, press enter to continue" << std::endl;
61 int32_t c;
62 while ((c = getchar()) != '\n' && c != EOF) {
63 ;
64 }
65 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbDevicePipeTest");
66 }
67
TearDownTestCase(void)68 void UsbDevicePipeTest::TearDownTestCase(void)
69 {
70 USB_HILOGI(MODULE_USB_SERVICE, "End UsbDevicePipeTest");
71 }
72
SetUp(void)73 void UsbDevicePipeTest::SetUp(void) {}
74
TearDown(void)75 void UsbDevicePipeTest::TearDown(void) {}
76
77 /**
78 * @tc.name: getDevices001
79 * @tc.desc: Test functions to getDevices(std::vector<UsbDevice> &deviceList);
80 * @tc.type: FUNC
81 */
82 HWTEST_F(UsbDevicePipeTest, getDevices001, TestSize.Level1)
83 {
84 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : getDevices001 : getDevices");
85 vector<UsbDevice> devi;
86 auto &UsbSrvClient = UsbSrvClient::GetInstance();
87 auto ret = UsbSrvClient.GetDevices(devi);
88 ASSERT_EQ(ret, 0);
89 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::getDevices001 %{public}d ret=%{public}d", __LINE__, ret);
90 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
91 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::getDevices001 %{public}d size=%{public}zu", __LINE__,
92 devi.size());
93 USBDevicePipe pipe;
94 UsbDevice device = devi.front();
95 UsbSrvClient.RequestRight(device.GetName());
96 ret = UsbSrvClient.OpenDevice(device, pipe);
97 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::getDevices001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
98 ASSERT_EQ(ret, 0);
99 ret = UsbSrvClient.Close(pipe);
100 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::getDevices001 %{public}d Close=%{public}d", __LINE__, ret);
101 EXPECT_TRUE(ret);
102 USB_HILOGI(MODULE_USB_SERVICE, "Case End : getDevices001 : getDevices");
103 }
104
105 /**
106 * @tc.name: UsbOpenDevice001
107 * @tc.desc: Test functions of OpenDevice
108 * @tc.desc: int32_t OpenDevice(const UsbDevice &device, USBDevicePipe &pip)
109 * @tc.desc: 正向测试：代码正常运行，返回结果为0
110 * @tc.type: FUNC
111 */
112 HWTEST_F(UsbDevicePipeTest, UsbOpenDevice001, TestSize.Level1)
113 {
114 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbOpenDevice001: OpenDevice");
115 auto &UsbSrvClient = UsbSrvClient::GetInstance();
116 std::vector<UsbDevice> deviceList;
117 auto ret = UsbSrvClient.GetDevices(deviceList);
118 ASSERT_EQ(ret, 0);
119 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbOpenDevice001 %{public}d ret=%{public}d", __LINE__, ret);
120 EXPECT_TRUE(!(deviceList.empty())) << "delist NULL";
121 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbOpenDevice001 %{public}d size=%{public}zu", __LINE__,
122 deviceList.size());
123 UsbDevice device = deviceList.front();
124 USBDevicePipe pipe;
125 UsbSrvClient.RequestRight(device.GetName());
126 ret = UsbSrvClient.OpenDevice(device, pipe);
127 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbOpenDevice001 %{public}d OpenDevice=%{public}d", __LINE__,
128 ret);
129 ASSERT_EQ(ret, 0);
130 ret = UsbSrvClient.Close(pipe);
131 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
132 EXPECT_TRUE(ret);
133 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbOpenDevice001: OpenDevice");
134 }
135
136 /**
137 * @tc.name: UsbResetDevice001
138 * @tc.desc: Test functions of ResetDevice
139 * @tc.desc: int32_t ResetDevice(const UsbDevice &device)
140 * @tc.desc: 正向测试：代码正常运行，返回结果为0
141 * @tc.type: FUNC
142 */
143 HWTEST_F(UsbDevicePipeTest, UsbResetDevice001, TestSize.Level1)
144 {
145 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbResetDevice001: ResetDevice");
146 auto &UsbSrvClient = UsbSrvClient::GetInstance();
147 std::vector<UsbDevice> deviceList;
148 auto ret = UsbSrvClient.GetDevices(deviceList);
149 ASSERT_EQ(ret, 0);
150 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice001 %{public}d ret=%{public}d", __LINE__, ret);
151 EXPECT_TRUE(!(deviceList.empty())) << "delist NULL";
152 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice001 %{public}d size=%{public}zu", __LINE__,
153 deviceList.size());
154 UsbDevice device = deviceList.front();
155 USBDevicePipe pipe;
156 UsbSrvClient.RequestRight(device.GetName());
157 ret = UsbSrvClient.OpenDevice(device, pipe);
158 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice001 %{public}d OpenDevice=%{public}d", __LINE__,
159 ret);
160 ret = UsbSrvClient.ResetDevice(device, pipe);
161 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice001 %{public}d ResetDevice=%{public}d", __LINE__,
162 ret);
163 ASSERT_EQ(ret, 0);
164 ret = UsbSrvClient.Close(pipe);
165 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
166 EXPECT_TRUE(ret);
167 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbResetDevice001: ResetDevice");
168 }
169
170 /**
171 * @tc.name: UsbResetDevice002
172 * @tc.desc: Test functions of ResetDevice
173 * @tc.desc: int32_t ResetDevice(const UsbDevice &device)=
174 * @tc.type: FUNC
175 */
176 HWTEST_F(UsbDevicePipeTest, UsbResetDevice002, TestSize.Level1)
177 {
178 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbResetDevice002: ResetDevice");
179 auto &UsbSrvClient = UsbSrvClient::GetInstance();
180 std::vector<UsbDevice> deviceList;
181 auto ret = UsbSrvClient.GetDevices(deviceList);
182 ASSERT_EQ(ret, 0);
183 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice002 %{public}d ret=%{public}d", __LINE__, ret);
184 EXPECT_TRUE(!(deviceList.empty())) << "delist NULL";
185 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice002 %{public}d size=%{public}zu", __LINE__,
186 deviceList.size());
187 UsbDevice device = deviceList.front();
188 USBDevicePipe pipe;
189 UsbSrvClient.RequestRight(device.GetName());
190 ret = UsbSrvClient.OpenDevice(device, pipe);
191 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice002 %{public}d OpenDevice=%{public}d", __LINE__,
192 ret);
193 device.SetBusNum(USB_BUS_NUM_INVALID);
194 ret = UsbSrvClient.ResetDevice(device, pipe);
195 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice002 %{public}d ResetDevice=%{public}d", __LINE__,
196 ret);
197 ASSERT_NE(ret, 0);
198 ret = UsbSrvClient.Close(pipe);
199 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
200 EXPECT_TRUE(ret);
201 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbResetDevice002: ResetDevice");
202 }
203
204 /**
205 * @tc.name: UsbResetDevice003
206 * @tc.desc: Test functions of ResetDevice
207 * @tc.desc: int32_t ResetDevice(const UsbDevice &device)=
208 * @tc.type: FUNC
209 */
210 HWTEST_F(UsbDevicePipeTest, UsbResetDevice003, TestSize.Level1)
211 {
212 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbResetDevice003: ResetDevice");
213 auto &UsbSrvClient = UsbSrvClient::GetInstance();
214 std::vector<UsbDevice> deviceList;
215 auto ret = UsbSrvClient.GetDevices(deviceList);
216 ASSERT_EQ(ret, 0);
217 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice003 %{public}d ret=%{public}d", __LINE__, ret);
218 EXPECT_TRUE(!(deviceList.empty())) << "delist NULL";
219 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice003 %{public}d size=%{public}zu", __LINE__,
220 deviceList.size());
221 UsbDevice device = deviceList.front();
222 USBDevicePipe pipe;
223 UsbSrvClient.RequestRight(device.GetName());
224 ret = UsbSrvClient.OpenDevice(device, pipe);
225 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice003 %{public}d OpenDevice=%{public}d", __LINE__,
226 ret);
227 device.SetDevAddr(USB_DEV_ADDR_INVALID);
228 ret = UsbSrvClient.ResetDevice(device, pipe);
229 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice003 %{public}d ResetDevice=%{public}d", __LINE__,
230 ret);
231 ASSERT_NE(ret, 0);
232 ret = UsbSrvClient.Close(pipe);
233 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
234 EXPECT_TRUE(ret);
235 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbResetDevice003: ResetDevice");
236 }
237
238 /**
239 * @tc.name: UsbResetDevice004
240 * @tc.desc: Test functions of ResetDevice
241 * @tc.desc: int32_t ResetDevice(const UsbDevice &device)=
242 * @tc.type: FUNC
243 */
244 HWTEST_F(UsbDevicePipeTest, UsbResetDevice004, TestSize.Level1)
245 {
246 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbResetDevice004: ResetDevice");
247 auto &UsbSrvClient = UsbSrvClient::GetInstance();
248 std::vector<UsbDevice> deviceList;
249 auto ret = UsbSrvClient.GetDevices(deviceList);
250 ASSERT_EQ(ret, 0);
251 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice004 %{public}d ret=%{public}d", __LINE__, ret);
252 EXPECT_TRUE(!(deviceList.empty())) << "delist NULL";
253 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice004 %{public}d size=%{public}zu", __LINE__,
254 deviceList.size());
255 UsbDevice device = deviceList.front();
256 USBDevicePipe pipe;
257 UsbSrvClient.RequestRight(device.GetName());
258 ret = UsbSrvClient.OpenDevice(device, pipe);
259 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice004 %{public}d OpenDevice=%{public}d", __LINE__,
260 ret);
261 device.SetBusNum(USB_BUS_NUM_INVALID);
262 device.SetDevAddr(USB_DEV_ADDR_INVALID);
263 ret = UsbSrvClient.ResetDevice(device, pipe);
264 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbResetDevice004 %{public}d ResetDevice=%{public}d", __LINE__,
265 ret);
266 ASSERT_NE(ret, 0);
267 ret = UsbSrvClient.Close(pipe);
268 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
269 EXPECT_TRUE(ret);
270 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbResetDevice004: ResetDevice");
271 }
272
273 /**
274 * @tc.name: Usbcontrolstansfer001
275 * @tc.desc: Test functions to ControlTransfer
276 * @tc.type: FUNC
277 */
278 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer001, TestSize.Level1)
279 {
280 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer001 : ControlTransfer");
281 vector<UsbDevice> devi;
282 auto &UsbSrvClient = UsbSrvClient::GetInstance();
283 auto ret = UsbSrvClient.GetDevices(devi);
284 ASSERT_EQ(ret, 0);
285 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer001 %{public}d ret=%{public}d", __LINE__, ret);
286 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
287 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer001 %{public}d size=%{public}zu", __LINE__,
288 devi.size());
289 USBDevicePipe pipe;
290 UsbDevice device = devi.front();
291 UsbSrvClient.RequestRight(device.GetName());
292 ret = UsbSrvClient.OpenDevice(device, pipe);
293 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer001 %{public}d OpenDevice=%{public}d",
294 __LINE__, ret);
295 ASSERT_EQ(ret, 0);
296 uint32_t len = 8;
297 uint8_t buffer[BUFFER_SIZE] = {0};
298 struct UsbCtrlTransfer ctrldata = {0b10000000, 8, 0, 0, 500};
299 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
300 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
301 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer001 %{public}d ControlTransfer=%{public}d",
302 __LINE__, ret);
303 ASSERT_EQ(ret, 0);
304 ret = UsbSrvClient.Close(pipe);
305 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
306 EXPECT_TRUE(ret);
307 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer001 : ControlTransfer");
308 }
309
310 /**
311 * @tc.name: Usbcontrolstansfer002
312 * @tc.desc: Test functions to ControlTransfer
313 * @tc.type: FUNC
314 */
315 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer002, TestSize.Level1)
316 {
317 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer002 : ControlTransfer");
318 vector<UsbDevice> devi;
319 auto &UsbSrvClient = UsbSrvClient::GetInstance();
320 auto ret = UsbSrvClient.GetDevices(devi);
321 ASSERT_EQ(ret, 0);
322 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer002 %{public}d ret=%{public}d", __LINE__, ret);
323 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
324 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer002 %{public}d size=%{public}zu", __LINE__,
325 devi.size());
326 USBDevicePipe pipe;
327 UsbDevice device = devi.front();
328 UsbSrvClient.RequestRight(device.GetName());
329 ret = UsbSrvClient.OpenDevice(device, pipe);
330 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer002 %{public}d OpenDevice=%{public}d",
331 __LINE__, ret);
332 ASSERT_EQ(ret, 0);
333 uint32_t len = 8;
334 uint8_t buffer[BUFFER_SIZE] = {0};
335 pipe.SetBusNum(BUFFER_SIZE);
336 struct UsbCtrlTransfer ctrldata = {0b10000000, 8, 0, 0, 500};
337 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
338 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
339 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer002 %{public}d ControlTransfer=%{public}d",
340 __LINE__, ret);
341 ASSERT_NE(ret, 0);
342 pipe.SetBusNum(device.GetBusNum());
343 ret = UsbSrvClient.Close(pipe);
344 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
345 EXPECT_TRUE(ret);
346 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer002 : ControlTransfer");
347 }
348
349 /**
350 * @tc.name: Usbcontrolstansfer003
351 * @tc.desc: Test functions to ControlTransfer
352 * @tc.type: FUNC
353 */
354 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer003, TestSize.Level1)
355 {
356 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer003 : ControlTransfer");
357 vector<UsbDevice> devi;
358 auto &UsbSrvClient = UsbSrvClient::GetInstance();
359 auto ret = UsbSrvClient.GetDevices(devi);
360 ASSERT_EQ(ret, 0);
361 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer003 %{public}d ret=%{public}d", __LINE__, ret);
362 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
363 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer003 %{public}d size=%{public}zu", __LINE__,
364 devi.size());
365 USBDevicePipe pipe;
366 UsbDevice device = devi.front();
367 UsbSrvClient.RequestRight(device.GetName());
368 ret = UsbSrvClient.OpenDevice(device, pipe);
369 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer003 %{public}d OpenDevice=%{public}d",
370 __LINE__, ret);
371 ASSERT_EQ(ret, 0);
372 uint32_t len = 8;
373 uint8_t buffer[BUFFER_SIZE] = {0};
374 pipe.SetDevAddr(BUFFER_SIZE);
375 struct UsbCtrlTransfer ctrldata = {0b10000000, 8, 0, 0, 500};
376 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
377 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
378 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer003 %{public}d ControlTransfer=%{public}d",
379 __LINE__, ret);
380 ASSERT_NE(ret, 0);
381 pipe.SetDevAddr(device.GetDevAddr());
382 ret = UsbSrvClient.Close(pipe);
383 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
384 EXPECT_TRUE(ret);
385 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer003 : ControlTransfer");
386 }
387
388 /**
389 * @tc.name: Usbcontrolstansfer004
390 * @tc.desc: Test functions to ControlTransfer
391 * @tc.type: FUNC
392 */
393 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer004, TestSize.Level1)
394 {
395 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer004 : ControlTransfer");
396 vector<UsbDevice> devi;
397 auto &UsbSrvClient = UsbSrvClient::GetInstance();
398 auto ret = UsbSrvClient.GetDevices(devi);
399 ASSERT_EQ(ret, 0);
400 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer004 %{public}d ret=%{public}d", __LINE__, ret);
401 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
402 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer004 %{public}d size=%{public}zu", __LINE__,
403 devi.size());
404 USBDevicePipe pipe;
405 UsbDevice device = devi.front();
406 UsbSrvClient.RequestRight(device.GetName());
407 ret = UsbSrvClient.OpenDevice(device, pipe);
408 ASSERT_EQ(ret, 0);
409 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer004 %{public}d OpenDevice=%{public}d",
410 __LINE__, ret);
411 uint32_t len = 8;
412 uint8_t buffer[BUFFER_SIZE] = {0};
413 struct UsbCtrlTransfer ctrldata = {0b10000000, 6, 0x100, 0, 500};
414 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
415 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
416 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer004 %{public}d ControlTransfer=%{public}d",
417 __LINE__, ret);
418 ASSERT_EQ(ret, 0);
419 ret = UsbSrvClient.Close(pipe);
420 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
421 EXPECT_TRUE(ret);
422 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer004 : ControlTransfer");
423 }
424
425 /**
426 * @tc.name: Usbcontrolstansfer005
427 * @tc.desc: Test functions to ControlTransfer
428 * @tc.type: FUNC
429 */
430 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer005, TestSize.Level1)
431 {
432 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer005 : ControlTransfer");
433 vector<UsbDevice> devi;
434 auto &UsbSrvClient = UsbSrvClient::GetInstance();
435 auto ret = UsbSrvClient.GetDevices(devi);
436 ASSERT_EQ(ret, 0);
437 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer005 %{public}d ret=%{public}d", __LINE__, ret);
438 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
439 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer005 %{public}d size=%{public}zu", __LINE__,
440 devi.size());
441 USBDevicePipe pipe;
442 UsbDevice device = devi.front();
443 UsbSrvClient.RequestRight(device.GetName());
444 ret = UsbSrvClient.OpenDevice(device, pipe);
445 ASSERT_EQ(ret, 0);
446 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer005 %{public}d OpenDevice=%{public}d",
447 __LINE__, ret);
448 uint32_t len = 8;
449 uint8_t buffer[BUFFER_SIZE] = {0};
450 pipe.SetBusNum(BUFFER_SIZE);
451 struct UsbCtrlTransfer ctrldata = {0b10000000, 6, 0x100, 0, 500};
452 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
453 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
454 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer005 %{public}d ControlTransfer=%{public}d",
455 __LINE__, ret);
456 ASSERT_NE(ret, 0);
457 pipe.SetBusNum(device.GetBusNum());
458 ret = UsbSrvClient.Close(pipe);
459 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
460 EXPECT_TRUE(ret);
461 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer005 : ControlTransfer");
462 }
463
464 /**
465 * @tc.name: Usbcontrolstansfer006
466 * @tc.desc: Test functions to ControlTransfer
467 * @tc.type: FUNC
468 */
469 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer006, TestSize.Level1)
470 {
471 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer006 : ControlTransfer");
472 vector<UsbDevice> devi;
473 auto &UsbSrvClient = UsbSrvClient::GetInstance();
474 auto ret = UsbSrvClient.GetDevices(devi);
475 ASSERT_EQ(ret, 0);
476 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer006 %{public}d ret=%{public}d", __LINE__, ret);
477 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
478 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer006 %{public}d size=%{public}zu", __LINE__,
479 devi.size());
480 USBDevicePipe pipe;
481 UsbDevice device = devi.front();
482 UsbSrvClient.RequestRight(device.GetName());
483 ret = UsbSrvClient.OpenDevice(device, pipe);
484 ASSERT_EQ(ret, 0);
485 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer006 %{public}d OpenDevice=%{public}d",
486 __LINE__, ret);
487 uint32_t len = 8;
488 uint8_t buffer[BUFFER_SIZE] = {0};
489 pipe.SetDevAddr(BUFFER_SIZE);
490 struct UsbCtrlTransfer ctrldata = {0b10000000, 6, 0x100, 0, 500};
491 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
492 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
493 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer006 %{public}d ControlTransfer=%{public}d",
494 __LINE__, ret);
495 ASSERT_NE(ret, 0);
496 pipe.SetDevAddr(device.GetDevAddr());
497 ret = UsbSrvClient.Close(pipe);
498 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
499 EXPECT_TRUE(ret);
500 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer006 : ControlTransfer");
501 }
502
503 /**
504 * @tc.name: Usbcontrolstansfer007
505 * @tc.desc: Test functions to ControlTransfer
506 * @tc.type: FUNC
507 */
508 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer007, TestSize.Level1)
509 {
510 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer007 : ControlTransfer");
511 vector<UsbDevice> devi;
512 auto &UsbSrvClient = UsbSrvClient::GetInstance();
513 auto ret = UsbSrvClient.GetDevices(devi);
514 ASSERT_EQ(ret, 0);
515 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d ret=%{public}d", __LINE__, ret);
516 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
517 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d size=%{public}zu", __LINE__,
518 devi.size());
519 USBDevicePipe pipe;
520 UsbDevice device = devi.front();
521 UsbSrvClient.RequestRight(device.GetName());
522 UsbInterface interface = device.GetConfigs().front().GetInterfaces().front();
523 ret = UsbSrvClient.OpenDevice(device, pipe);
524 ASSERT_EQ(ret, 0);
525 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d OpenDevice=%{public}d",
526 __LINE__, ret);
527 uint32_t len = BUFFER_SIZE;
528 uint8_t buffer[BUFFER_SIZE] = {0};
529 struct UsbCtrlTransfer ctrldata = {0b10000001, 0X0A, 0, 0, 500};
530 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
531 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
532 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d ControlTransfer=%{public}d",
533 __LINE__, ret);
534 ASSERT_EQ(ret, 0);
535 ret = UsbSrvClient.Close(pipe);
536 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d Close=%{public}d", __LINE__,
537 ret);
538 EXPECT_TRUE(ret);
539 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer007 : ControlTransfer");
540 }
541
542 /**
543 * @tc.name: Usbcontrolstansfer008
544 * @tc.desc: Test functions to ControlTransfer
545 * @tc.type: FUNC
546 */
547 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer008, TestSize.Level1)
548 {
549 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer008 : ControlTransfer");
550 vector<UsbDevice> devi;
551 auto &UsbSrvClient = UsbSrvClient::GetInstance();
552 auto ret = UsbSrvClient.GetDevices(devi);
553 ASSERT_EQ(ret, 0);
554 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d ret=%{public}d", __LINE__, ret);
555 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
556 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d size=%{public}zu", __LINE__,
557 devi.size());
558 USBDevicePipe pipe;
559 UsbDevice device = devi.front();
560 UsbSrvClient.RequestRight(device.GetName());
561 UsbInterface interface = device.GetConfigs().front().GetInterfaces().front();
562 ret = UsbSrvClient.OpenDevice(device, pipe);
563 ASSERT_EQ(ret, 0);
564 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d OpenDevice=%{public}d",
565 __LINE__, ret);
566 uint32_t len = BUFFER_SIZE;
567 uint8_t buffer[BUFFER_SIZE] = {0};
568 pipe.SetBusNum(BUFFER_SIZE);
569 struct UsbCtrlTransfer ctrldata = {0b10000001, 0X0A, 0, 0, 500};
570 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
571 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
572 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d ControlTransfer=%{public}d",
573 __LINE__, ret);
574 ASSERT_NE(ret, 0);
575 pipe.SetBusNum(device.GetBusNum());
576 ret = UsbSrvClient.Close(pipe);
577 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d Close=%{public}d", __LINE__,
578 ret);
579 EXPECT_TRUE(ret);
580 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer008 : ControlTransfer");
581 }
582
583 /**
584 * @tc.name: Usbcontrolstansfer009
585 * @tc.desc: Test functions to ControlTransfer
586 * @tc.type: FUNC
587 */
588 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer009, TestSize.Level1)
589 {
590 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer009 : ControlTransfer");
591 vector<UsbDevice> devi;
592 auto &UsbSrvClient = UsbSrvClient::GetInstance();
593 auto ret = UsbSrvClient.GetDevices(devi);
594 ASSERT_EQ(ret, 0);
595 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d ret=%{public}d", __LINE__, ret);
596 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
597 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d size=%{public}zu", __LINE__,
598 devi.size());
599 USBDevicePipe pipe;
600 UsbDevice device = devi.front();
601 UsbSrvClient.RequestRight(device.GetName());
602 UsbInterface interface = device.GetConfigs().front().GetInterfaces().front();
603 ret = UsbSrvClient.OpenDevice(device, pipe);
604 ASSERT_EQ(ret, 0);
605 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d OpenDevice=%{public}d",
606 __LINE__, ret);
607 uint32_t len = BUFFER_SIZE;
608 uint8_t buffer[BUFFER_SIZE] = {0};
609 pipe.SetDevAddr(BUFFER_SIZE);
610 struct UsbCtrlTransfer ctrldata = {0b10000001, 0X0A, 0, 0, 500};
611 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
612 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
613 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d ControlTransfer=%{public}d",
614 __LINE__, ret);
615 ASSERT_NE(ret, 0);
616 pipe.SetDevAddr(device.GetDevAddr());
617 ret = UsbSrvClient.Close(pipe);
618 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d Close=%{public}d", __LINE__,
619 ret);
620 EXPECT_TRUE(ret);
621 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer009 : ControlTransfer");
622 }
623
624 /**
625 * @tc.name: Usbcontrolstansfer010
626 * @tc.desc: Test functions to ControlTransfer
627 * @tc.type: FUNC
628 */
629 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer010, TestSize.Level1)
630 {
631 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer010 : ControlTransfer");
632 vector<UsbDevice> devi;
633 auto &UsbSrvClient = UsbSrvClient::GetInstance();
634 auto ret = UsbSrvClient.GetDevices(devi);
635 ASSERT_EQ(ret, 0);
636 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d ret=%{public}d", __LINE__, ret);
637 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
638 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d size=%{public}zu", __LINE__,
639 devi.size());
640 USBDevicePipe pipe;
641 UsbDevice device = devi.front();
642 UsbSrvClient.RequestRight(device.GetName());
643 ret = UsbSrvClient.OpenDevice(device, pipe);
644 ASSERT_EQ(ret, 0);
645 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d OpenDevice=%{public}d",
646 __LINE__, ret);
647 uint32_t len = BUFFER_SIZE;
648 uint8_t buffer[BUFFER_SIZE] = {0};
649 struct UsbCtrlTransfer ctrldata = {0b10000000, 0, 0, 0, 500};
650 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
651 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
652 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d ControlTransfer=%{public}d",
653 __LINE__, ret);
654 ASSERT_EQ(ret, 0);
655 ret = UsbSrvClient.Close(pipe);
656 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d Close=%{public}d", __LINE__,
657 ret);
658 EXPECT_TRUE(ret);
659 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer010 : ControlTransfer");
660 }
661
662 /**
663 * @tc.name: Usbcontrolstansfer011
664 * @tc.desc: Test functions to ControlTransfer
665 * @tc.type: FUNC
666 */
667 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer011, TestSize.Level1)
668 {
669 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer011 : ControlTransfer");
670 vector<UsbDevice> devi;
671 auto &UsbSrvClient = UsbSrvClient::GetInstance();
672 auto ret = UsbSrvClient.GetDevices(devi);
673 ASSERT_EQ(ret, 0);
674 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d ret=%{public}d", __LINE__, ret);
675 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
676 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d size=%{public}zu", __LINE__,
677 devi.size());
678 USBDevicePipe pipe;
679 UsbDevice device = devi.front();
680 UsbSrvClient.RequestRight(device.GetName());
681 ret = UsbSrvClient.OpenDevice(device, pipe);
682 ASSERT_EQ(ret, 0);
683 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d OpenDevice=%{public}d",
684 __LINE__, ret);
685 uint32_t len = BUFFER_SIZE;
686 uint8_t buffer[BUFFER_SIZE] = {0};
687 pipe.SetBusNum(BUFFER_SIZE);
688 struct UsbCtrlTransfer ctrldata = {0b10000000, 0, 0, 0, 500};
689 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
690 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
691 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d ControlTransfer=%{public}d",
692 __LINE__, ret);
693 ASSERT_NE(ret, 0);
694 pipe.SetBusNum(device.GetBusNum());
695 ret = UsbSrvClient.Close(pipe);
696 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d Close=%{public}d", __LINE__,
697 ret);
698 EXPECT_TRUE(ret);
699 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer011 : ControlTransfer");
700 }
701
702 /**
703 * @tc.name: Usbcontrolstansfer012
704 * @tc.desc: Test functions to ControlTransfer
705 * @tc.type: FUNC
706 */
707 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer012, TestSize.Level1)
708 {
709 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer012 : ControlTransfer");
710 vector<UsbDevice> devi;
711 auto &UsbSrvClient = UsbSrvClient::GetInstance();
712 auto ret = UsbSrvClient.GetDevices(devi);
713 ASSERT_EQ(ret, 0);
714 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d ret=%{public}d", __LINE__, ret);
715 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
716 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d size=%{public}zu", __LINE__,
717 devi.size());
718 USBDevicePipe pipe;
719 UsbDevice device = devi.front();
720 UsbSrvClient.RequestRight(device.GetName());
721 ret = UsbSrvClient.OpenDevice(device, pipe);
722 ASSERT_EQ(ret, 0);
723 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d OpenDevice=%{public}d",
724 __LINE__, ret);
725 uint32_t len = BUFFER_SIZE;
726 uint8_t buffer[BUFFER_SIZE] = {0};
727 pipe.SetDevAddr(BUFFER_SIZE);
728 struct UsbCtrlTransfer ctrldata = {0b10000000, 0, 0, 0, 500};
729 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
730 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
731 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d ControlTransfer=%{public}d",
732 __LINE__, ret);
733 ASSERT_NE(ret, 0);
734 pipe.SetDevAddr(device.GetDevAddr());
735 ret = UsbSrvClient.Close(pipe);
736 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d Close=%{public}d", __LINE__,
737 ret);
738 EXPECT_TRUE(ret);
739 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer012 : ControlTransfer");
740 }
741
742 /**
743 * @tc.name: Usbcontrolstansfer0013
744 * @tc.desc: Test functions to ControlTransfer
745 * @tc.type: FUNC
746 */
747 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer0013, TestSize.Level1)
748 {
749 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer0013 : ControlTransfer");
750 vector<UsbDevice> devi;
751 auto &UsbSrvClient = UsbSrvClient::GetInstance();
752 auto ret = UsbSrvClient.GetDevices(devi);
753 ASSERT_EQ(ret, 0);
754 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d ret=%{public}d", __LINE__,
755 ret);
756 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
757 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d size=%{public}zu", __LINE__,
758 devi.size());
759 USBDevicePipe pipe;
760 UsbDevice device = devi.front();
761 UsbSrvClient.RequestRight(device.GetName());
762 ret = UsbSrvClient.OpenDevice(device, pipe);
763 ASSERT_EQ(ret, 0);
764 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d OpenDevice=%{public}d",
765 __LINE__, ret);
766 uint32_t len = BUFFER_SIZE;
767 uint8_t buffer[BUFFER_SIZE] = {0};
768 struct UsbCtrlTransfer ctrldata = {0b10000001, 0, 0, 0, 500};
769 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
770 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
771 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d ControlTransfer=%{public}d",
772 __LINE__, ret);
773 ASSERT_EQ(ret, 0);
774 ret = UsbSrvClient.Close(pipe);
775 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d Close=%{public}d", __LINE__,
776 ret);
777 EXPECT_TRUE(ret);
778 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer0013 : ControlTransfer");
779 }
780
781 /**
782 * @tc.name: Usbcontrolstansfer0014
783 * @tc.desc: Test functions to ControlTransfer
784 * @tc.type: FUNC
785 */
786 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer0014, TestSize.Level1)
787 {
788 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer0014 : ControlTransfer");
789 vector<UsbDevice> devi;
790 auto &UsbSrvClient = UsbSrvClient::GetInstance();
791 auto ret = UsbSrvClient.GetDevices(devi);
792 ASSERT_EQ(ret, 0);
793 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d ret=%{public}d", __LINE__,
794 ret);
795 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
796 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d size=%{public}zu", __LINE__,
797 devi.size());
798 USBDevicePipe pipe;
799 UsbDevice device = devi.front();
800 UsbSrvClient.RequestRight(device.GetName());
801 ret = UsbSrvClient.OpenDevice(device, pipe);
802 ASSERT_EQ(ret, 0);
803 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d OpenDevice=%{public}d",
804 __LINE__, ret);
805 uint32_t len = BUFFER_SIZE;
806 uint8_t buffer[BUFFER_SIZE] = {0};
807 pipe.SetBusNum(BUFFER_SIZE);
808 struct UsbCtrlTransfer ctrldata = {0b10000001, 0, 0, 0, 500};
809 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
810 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
811 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d ControlTransfer=%{public}d",
812 __LINE__, ret);
813 ASSERT_NE(ret, 0);
814 pipe.SetBusNum(device.GetBusNum());
815 ret = UsbSrvClient.Close(pipe);
816 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d Close=%{public}d", __LINE__,
817 ret);
818 EXPECT_TRUE(ret);
819 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer0014 : ControlTransfer");
820 }
821
822 /**
823 * @tc.name: Usbcontrolstansfer0015
824 * @tc.desc: Test functions to ControlTransfer
825 * @tc.type: FUNC
826 */
827 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer0015, TestSize.Level1)
828 {
829 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer0015 : ControlTransfer");
830 vector<UsbDevice> devi;
831 auto &UsbSrvClient = UsbSrvClient::GetInstance();
832 auto ret = UsbSrvClient.GetDevices(devi);
833 ASSERT_EQ(ret, 0);
834 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d ret=%{public}d", __LINE__,
835 ret);
836 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
837 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d size=%{public}zu", __LINE__,
838 devi.size());
839 USBDevicePipe pipe;
840 UsbDevice device = devi.front();
841 UsbSrvClient.RequestRight(device.GetName());
842 ret = UsbSrvClient.OpenDevice(device, pipe);
843 ASSERT_EQ(ret, 0);
844 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d OpenDevice=%{public}d",
845 __LINE__, ret);
846 uint32_t len = BUFFER_SIZE;
847 uint8_t buffer[BUFFER_SIZE] = {0};
848 pipe.SetDevAddr(BUFFER_SIZE);
849 struct UsbCtrlTransfer ctrldata = {0b10000001, 0, 0, 0, 500};
850 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
851 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
852 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d ControlTransfer=%{public}d",
853 __LINE__, ret);
854 ASSERT_NE(ret, 0);
855 pipe.SetDevAddr(device.GetDevAddr());
856 ret = UsbSrvClient.Close(pipe);
857 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d Close=%{public}d", __LINE__,
858 ret);
859 EXPECT_TRUE(ret);
860 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer0015 : ControlTransfer");
861 }
862
863 /**
864 * @tc.name: Usbcontrolstansfer016
865 * @tc.desc: Test functions to ControlTransfer
866 * @tc.type: FUNC
867 */
868 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer016, TestSize.Level1)
869 {
870 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer016 : ControlTransfer");
871 vector<UsbDevice> devi;
872 auto &UsbSrvClient = UsbSrvClient::GetInstance();
873 auto ret = UsbSrvClient.GetDevices(devi);
874 ASSERT_EQ(ret, 0);
875 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d ret=%{public}d", __LINE__, ret);
876 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
877 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d size=%{public}zu", __LINE__,
878 devi.size());
879 USBDevicePipe pipe;
880 UsbDevice device = devi.front();
881 UsbSrvClient.RequestRight(device.GetName());
882 ret = UsbSrvClient.OpenDevice(device, pipe);
883 ASSERT_EQ(ret, 0);
884 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d OpenDevice=%{public}d",
885 __LINE__, ret);
886 uint32_t len = 16;
887 uint8_t buffer[BUFFER_SIZE] = {0};
888 struct UsbCtrlTransfer ctrldata = {0b10000010, 0, 0, 0, 500};
889 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
890 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
891 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d ControlTransfer=%{public}d",
892 __LINE__, ret);
893 ASSERT_EQ(ret, 0);
894 ret = UsbSrvClient.Close(pipe);
895 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d Close=%{public}d", __LINE__,
896 ret);
897 EXPECT_TRUE(ret);
898 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer016 : ControlTransfer");
899 }
900
901 /**
902 * @tc.name: Usbcontrolstansfer017
903 * @tc.desc: Test functions to ControlTransfer
904 * @tc.type: FUNC
905 */
906 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer017, TestSize.Level1)
907 {
908 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer017 : ControlTransfer");
909 vector<UsbDevice> devi;
910 auto &UsbSrvClient = UsbSrvClient::GetInstance();
911 auto ret = UsbSrvClient.GetDevices(devi);
912 ASSERT_EQ(ret, 0);
913 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d ret=%{public}d", __LINE__, ret);
914 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
915 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d size=%{public}zu", __LINE__,
916 devi.size());
917 USBDevicePipe pipe;
918 UsbDevice device = devi.front();
919 UsbSrvClient.RequestRight(device.GetName());
920 ret = UsbSrvClient.OpenDevice(device, pipe);
921 ASSERT_EQ(ret, 0);
922 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d OpenDevice=%{public}d",
923 __LINE__, ret);
924 uint32_t len = 16;
925 uint8_t buffer[BUFFER_SIZE] = {0};
926 pipe.SetBusNum(BUFFER_SIZE);
927 struct UsbCtrlTransfer ctrldata = {0b10000010, 0, 0, 0, 500};
928 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
929 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
930 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d ControlTransfer=%{public}d",
931 __LINE__, ret);
932 ASSERT_NE(ret, 0);
933 pipe.SetBusNum(device.GetBusNum());
934 ret = UsbSrvClient.Close(pipe);
935 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d Close=%{public}d", __LINE__,
936 ret);
937 EXPECT_TRUE(ret);
938 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer017 : ControlTransfer");
939 }
940
941 /**
942 * @tc.name: Usbcontrolstansfer018
943 * @tc.desc: Test functions to ControlTransfer
944 * @tc.type: FUNC
945 */
946 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer018, TestSize.Level1)
947 {
948 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer018 : ControlTransfer");
949 vector<UsbDevice> devi;
950 auto &UsbSrvClient = UsbSrvClient::GetInstance();
951 auto ret = UsbSrvClient.GetDevices(devi);
952 ASSERT_EQ(ret, 0);
953 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d ret=%{public}d", __LINE__, ret);
954 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
955 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d size=%{public}zu", __LINE__,
956 devi.size());
957 USBDevicePipe pipe;
958 UsbDevice device = devi.front();
959 UsbSrvClient.RequestRight(device.GetName());
960 ret = UsbSrvClient.OpenDevice(device, pipe);
961 ASSERT_EQ(ret, 0);
962 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d OpenDevice=%{public}d",
963 __LINE__, ret);
964 uint32_t len = 16;
965 uint8_t buffer[BUFFER_SIZE] = {0};
966 pipe.SetDevAddr(BUFFER_SIZE);
967 struct UsbCtrlTransfer ctrldata = {0b10000010, 0, 0, 0, 500};
968 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
969 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
970 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d ControlTransfer=%{public}d",
971 __LINE__, ret);
972 ASSERT_NE(ret, 0);
973 pipe.SetDevAddr(device.GetDevAddr());
974 ret = UsbSrvClient.Close(pipe);
975 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d Close=%{public}d", __LINE__,
976 ret);
977 EXPECT_TRUE(ret);
978 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer018 : ControlTransfer");
979 }
980
981 /**
982 * @tc.name: Usbcontrolstansfer019
983 * @tc.desc: Test functions to ControlTransfer
984 * @tc.type: FUNC
985 */
986 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer019, TestSize.Level1)
987 {
988 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer019 : ControlTransfer");
989 vector<UsbDevice> devi;
990 auto &UsbSrvClient = UsbSrvClient::GetInstance();
991 auto ret = UsbSrvClient.GetDevices(devi);
992 ASSERT_EQ(ret, 0);
993 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer019 %{public}d ret=%{public}d", __LINE__, ret);
994 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
995 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer019 %{public}d size=%{public}zu", __LINE__,
996 devi.size());
997 USBDevicePipe pipe;
998 UsbDevice device = devi.front();
999 UsbSrvClient.RequestRight(device.GetName());
1000 ret = UsbSrvClient.OpenDevice(device, pipe);
1001 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer019 %{public}d OpenDevice=%{public}d",
1002 __LINE__, ret);
1003 ASSERT_EQ(ret, 0);
1004 uint32_t len = BUFFER_SIZE;
1005 uint8_t buffer[BUFFER_SIZE] = {0};
1006 struct UsbCtrlTransfer ctrldata = {0b10000010, 0X0C, 0, 0, 500};
1007 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1008 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
1009 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer019 %{public}d ControlTransfer=%{public}d",
1010 __LINE__, ret);
1011 ASSERT_EQ(ret, 0);
1012 ret = UsbSrvClient.Close(pipe);
1013 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Close=%{public}d", ret);
1014 EXPECT_TRUE(ret);
1015 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer019 : ControlTransfer");
1016 }
1017
1018 /**
1019 * @tc.name: Usbcontrolstansfer020
1020 * @tc.desc: Test functions to ControlTransfer
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer020, TestSize.Level1)
1024 {
1025 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer020 : ControlTransfer");
1026 vector<UsbDevice> devi;
1027 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1028 auto ret = UsbSrvClient.GetDevices(devi);
1029 ASSERT_EQ(ret, 0);
1030 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer020 %{public}d ret=%{public}d", __LINE__, ret);
1031 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1032 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer020 %{public}d size=%{public}zu", __LINE__,
1033 devi.size());
1034 USBDevicePipe pipe;
1035 UsbDevice device = devi.front();
1036 UsbSrvClient.RequestRight(device.GetName());
1037 ret = UsbSrvClient.OpenDevice(device, pipe);
1038 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer020 %{public}d OpenDevice=%{public}d",
1039 __LINE__, ret);
1040 ASSERT_EQ(ret, 0);
1041 uint32_t len = BUFFER_SIZE;
1042 uint8_t buffer[BUFFER_SIZE] = {0};
1043 pipe.SetBusNum(BUFFER_SIZE);
1044 struct UsbCtrlTransfer ctrldata = {0b10000010, 0X0C, 0, 0, 500};
1045 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1046 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
1047 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer020 %{public}d ControlTransfer=%{public}d",
1048 __LINE__, ret);
1049 ASSERT_NE(ret, 0);
1050 pipe.SetBusNum(device.GetBusNum());
1051 ret = UsbSrvClient.Close(pipe);
1052 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Close=%{public}d", ret);
1053 EXPECT_TRUE(ret);
1054 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer020 : ControlTransfer");
1055 }
1056
1057 /**
1058 * @tc.name: Usbcontrolstansfer021
1059 * @tc.desc: Test functions to ControlTransfer
1060 * @tc.type: FUNC
1061 */
1062 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer021, TestSize.Level1)
1063 {
1064 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer021 : ControlTransfer");
1065 vector<UsbDevice> devi;
1066 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1067 auto ret = UsbSrvClient.GetDevices(devi);
1068 ASSERT_EQ(ret, 0);
1069 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer021 %{public}d ret=%{public}d", __LINE__, ret);
1070 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1071 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer021 %{public}d size=%{public}zu", __LINE__,
1072 devi.size());
1073 USBDevicePipe pipe;
1074 UsbDevice device = devi.front();
1075 UsbSrvClient.RequestRight(device.GetName());
1076 ret = UsbSrvClient.OpenDevice(device, pipe);
1077 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer021 %{public}d OpenDevice=%{public}d",
1078 __LINE__, ret);
1079 ASSERT_EQ(ret, 0);
1080 uint32_t len = BUFFER_SIZE;
1081 uint8_t buffer[BUFFER_SIZE] = {0};
1082 pipe.SetDevAddr(BUFFER_SIZE);
1083 struct UsbCtrlTransfer ctrldata = {0b10000010, 0X0C, 0, 0, 500};
1084 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1085 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
1086 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer021 %{public}d ControlTransfer=%{public}d",
1087 __LINE__, ret);
1088 ASSERT_NE(ret, 0);
1089 pipe.SetDevAddr(device.GetDevAddr());
1090 ret = UsbSrvClient.Close(pipe);
1091 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Close=%{public}d", ret);
1092 EXPECT_TRUE(ret);
1093 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer021 : ControlTransfer");
1094 }
1095
1096 /**
1097 * @tc.name: Usbcontrolstansfer022
1098 * @tc.desc: Test functions to UsbControlTransfer
1099 * @tc.type: FUNC
1100 */
1101 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer022, TestSize.Level1)
1102 {
1103 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer022 : UsbControlTransfer");
1104 vector<UsbDevice> devi;
1105 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1106 auto ret = UsbSrvClient.GetDevices(devi);
1107 ASSERT_EQ(ret, 0);
1108 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer022 %{public}d ret=%{public}d", __LINE__, ret);
1109 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1110 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer022 %{public}d size=%{public}zu", __LINE__,
1111 devi.size());
1112 USBDevicePipe pipe;
1113 UsbDevice device = devi.front();
1114 UsbSrvClient.RequestRight(device.GetName());
1115 ret = UsbSrvClient.OpenDevice(device, pipe);
1116 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer022 %{public}d OpenDevice=%{public}d",
1117 __LINE__, ret);
1118 ASSERT_EQ(ret, 0);
1119 uint32_t len = 8;
1120 uint8_t buffer[BUFFER_SIZE] = {0};
1121 struct UsbCtrlTransferParams ctrldata = {0b10000000, 8, 0, 0, 0, 500};
1122 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1123 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1124 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer022 %{public}d UsbControlTransfer=%{public}d",
1125 __LINE__, ret);
1126 ASSERT_EQ(ret, 0);
1127 ret = UsbSrvClient.Close(pipe);
1128 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
1129 EXPECT_TRUE(ret);
1130 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer022 : UsbControlTransfer");
1131 }
1132
1133 /**
1134 * @tc.name: Usbcontrolstansfer023
1135 * @tc.desc: Test functions to UsbControlTransfer
1136 * @tc.type: FUNC
1137 */
1138 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer023, TestSize.Level1)
1139 {
1140 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer023 : UsbControlTransfer");
1141 vector<UsbDevice> devi;
1142 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1143 auto ret = UsbSrvClient.GetDevices(devi);
1144 ASSERT_EQ(ret, 0);
1145 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer023 %{public}d ret=%{public}d", __LINE__, ret);
1146 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1147 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer023 %{public}d size=%{public}zu", __LINE__,
1148 devi.size());
1149 USBDevicePipe pipe;
1150 UsbDevice device = devi.front();
1151 UsbSrvClient.RequestRight(device.GetName());
1152 ret = UsbSrvClient.OpenDevice(device, pipe);
1153 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer023 %{public}d OpenDevice=%{public}d",
1154 __LINE__, ret);
1155 ASSERT_EQ(ret, 0);
1156 uint32_t len = 8;
1157 uint8_t buffer[BUFFER_SIZE] = {0};
1158 pipe.SetBusNum(BUFFER_SIZE);
1159 struct UsbCtrlTransferParams ctrldata = {0b10000000, 8, 0, 0, 0, 500};
1160 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1161 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1162 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer023 %{public}d UsbControlTransfer=%{public}d",
1163 __LINE__, ret);
1164 ASSERT_NE(ret, 0);
1165 pipe.SetBusNum(device.GetBusNum());
1166 ret = UsbSrvClient.Close(pipe);
1167 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
1168 EXPECT_TRUE(ret);
1169 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer023 : UsbControlTransfer");
1170 }
1171
1172 /**
1173 * @tc.name: Usbcontrolstansfer024
1174 * @tc.desc: Test functions to UsbControlTransfer
1175 * @tc.type: FUNC
1176 */
1177 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer024, TestSize.Level1)
1178 {
1179 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer024 : UsbControlTransfer");
1180 vector<UsbDevice> devi;
1181 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1182 auto ret = UsbSrvClient.GetDevices(devi);
1183 ASSERT_EQ(ret, 0);
1184 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer024 %{public}d ret=%{public}d", __LINE__, ret);
1185 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1186 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer024 %{public}d size=%{public}zu", __LINE__,
1187 devi.size());
1188 USBDevicePipe pipe;
1189 UsbDevice device = devi.front();
1190 UsbSrvClient.RequestRight(device.GetName());
1191 ret = UsbSrvClient.OpenDevice(device, pipe);
1192 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer024 %{public}d OpenDevice=%{public}d",
1193 __LINE__, ret);
1194 ASSERT_EQ(ret, 0);
1195 uint32_t len = 8;
1196 uint8_t buffer[BUFFER_SIZE] = {0};
1197 pipe.SetDevAddr(BUFFER_SIZE);
1198 struct UsbCtrlTransferParams ctrldata = {0b10000000, 8, 0, 0, 0, 500};
1199 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1200 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1201 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer024 %{public}d UsbControlTransfer=%{public}d",
1202 __LINE__, ret);
1203 ASSERT_NE(ret, 0);
1204 pipe.SetDevAddr(device.GetDevAddr());
1205 ret = UsbSrvClient.Close(pipe);
1206 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
1207 EXPECT_TRUE(ret);
1208 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer024 : UsbControlTransfer");
1209 }
1210
1211 /**
1212 * @tc.name: Usbcontrolstansfer025
1213 * @tc.desc: Test functions to UsbControlTransfer
1214 * @tc.type: FUNC
1215 */
1216 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer025, TestSize.Level1)
1217 {
1218 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer025 : UsbControlTransfer");
1219 vector<UsbDevice> devi;
1220 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1221 auto ret = UsbSrvClient.GetDevices(devi);
1222 ASSERT_EQ(ret, 0);
1223 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer025 %{public}d ret=%{public}d", __LINE__, ret);
1224 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1225 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer025 %{public}d size=%{public}zu", __LINE__,
1226 devi.size());
1227 USBDevicePipe pipe;
1228 UsbDevice device = devi.front();
1229 UsbSrvClient.RequestRight(device.GetName());
1230 ret = UsbSrvClient.OpenDevice(device, pipe);
1231 ASSERT_EQ(ret, 0);
1232 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer025 %{public}d OpenDevice=%{public}d",
1233 __LINE__, ret);
1234 uint32_t len = 8;
1235 uint8_t buffer[BUFFER_SIZE] = {0};
1236 struct UsbCtrlTransferParams ctrldata = {0b10000000, 6, 0x100, 0, 0, 500};
1237 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1238 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1239 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer025 %{public}d UsbControlTransfer=%{public}d",
1240 __LINE__, ret);
1241 ASSERT_EQ(ret, 0);
1242 ret = UsbSrvClient.Close(pipe);
1243 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
1244 EXPECT_TRUE(ret);
1245 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer025 : UsbControlTransfer");
1246 }
1247
1248 /**
1249 * @tc.name: Usbcontrolstansfer026
1250 * @tc.desc: Test functions to UsbControlTransfer
1251 * @tc.type: FUNC
1252 */
1253 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer026, TestSize.Level1)
1254 {
1255 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer026 : UsbControlTransfer");
1256 vector<UsbDevice> devi;
1257 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1258 auto ret = UsbSrvClient.GetDevices(devi);
1259 ASSERT_EQ(ret, 0);
1260 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer026 %{public}d ret=%{public}d", __LINE__, ret);
1261 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1262 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer026 %{public}d size=%{public}zu", __LINE__,
1263 devi.size());
1264 USBDevicePipe pipe;
1265 UsbDevice device = devi.front();
1266 UsbSrvClient.RequestRight(device.GetName());
1267 ret = UsbSrvClient.OpenDevice(device, pipe);
1268 ASSERT_EQ(ret, 0);
1269 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer026 %{public}d OpenDevice=%{public}d",
1270 __LINE__, ret);
1271 uint32_t len = 8;
1272 uint8_t buffer[BUFFER_SIZE] = {0};
1273 pipe.SetBusNum(BUFFER_SIZE);
1274 struct UsbCtrlTransferParams ctrldata = {0b10000000, 6, 0x100, 0, 0, 500};
1275 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1276 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1277 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer026 %{public}d UsbControlTransfer=%{public}d",
1278 __LINE__, ret);
1279 ASSERT_NE(ret, 0);
1280 pipe.SetBusNum(device.GetBusNum());
1281 ret = UsbSrvClient.Close(pipe);
1282 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
1283 EXPECT_TRUE(ret);
1284 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer026 : UsbControlTransfer");
1285 }
1286
1287 /**
1288 * @tc.name: Usbcontrolstansfer027
1289 * @tc.desc: Test functions to UsbControlTransfer
1290 * @tc.type: FUNC
1291 */
1292 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer027, TestSize.Level1)
1293 {
1294 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer027 : UsbControlTransfer");
1295 vector<UsbDevice> devi;
1296 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1297 auto ret = UsbSrvClient.GetDevices(devi);
1298 ASSERT_EQ(ret, 0);
1299 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer027 %{public}d ret=%{public}d", __LINE__, ret);
1300 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1301 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer027 %{public}d size=%{public}zu", __LINE__,
1302 devi.size());
1303 USBDevicePipe pipe;
1304 UsbDevice device = devi.front();
1305 UsbSrvClient.RequestRight(device.GetName());
1306 ret = UsbSrvClient.OpenDevice(device, pipe);
1307 ASSERT_EQ(ret, 0);
1308 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer027 %{public}d OpenDevice=%{public}d",
1309 __LINE__, ret);
1310 uint32_t len = 8;
1311 uint8_t buffer[BUFFER_SIZE] = {0};
1312 pipe.SetDevAddr(BUFFER_SIZE);
1313 struct UsbCtrlTransferParams ctrldata = {0b10000000, 6, 0x100, 0, 0, 500};
1314 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1315 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1316 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer027 %{public}d UsbControlTransfer=%{public}d",
1317 __LINE__, ret);
1318 ASSERT_NE(ret, 0);
1319 pipe.SetDevAddr(device.GetDevAddr());
1320 ret = UsbSrvClient.Close(pipe);
1321 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
1322 EXPECT_TRUE(ret);
1323 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer027 : UsbControlTransfer");
1324 }
1325
1326 /**
1327 * @tc.name: Usbcontrolstansfer028
1328 * @tc.desc: Test functions to UsbControlTransfer
1329 * @tc.type: FUNC
1330 */
1331 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer028, TestSize.Level1)
1332 {
1333 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer028 : UsbControlTransfer");
1334 vector<UsbDevice> devi;
1335 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1336 auto ret = UsbSrvClient.GetDevices(devi);
1337 ASSERT_EQ(ret, 0);
1338 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer028 %{public}d ret=%{public}d", __LINE__, ret);
1339 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1340 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer028 %{public}d size=%{public}zu", __LINE__,
1341 devi.size());
1342 USBDevicePipe pipe;
1343 UsbDevice device = devi.front();
1344 UsbSrvClient.RequestRight(device.GetName());
1345 UsbInterface interface = device.GetConfigs().front().GetInterfaces().front();
1346 ret = UsbSrvClient.OpenDevice(device, pipe);
1347 ASSERT_EQ(ret, 0);
1348 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer028 %{public}d OpenDevice=%{public}d",
1349 __LINE__, ret);
1350 uint32_t len = BUFFER_SIZE;
1351 uint8_t buffer[BUFFER_SIZE] = {0};
1352 struct UsbCtrlTransferParams ctrldata = {0b10000001, 0X0A, 0, 0, 0, 500};
1353 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1354 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1355 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer028 %{public}d UsbControlTransfer=%{public}d",
1356 __LINE__, ret);
1357 ASSERT_EQ(ret, 0);
1358 ret = UsbSrvClient.Close(pipe);
1359 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer028 %{public}d Close=%{public}d", __LINE__,
1360 ret);
1361 EXPECT_TRUE(ret);
1362 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer028 : UsbControlTransfer");
1363 }
1364
1365 /**
1366 * @tc.name: Usbcontrolstansfer029
1367 * @tc.desc: Test functions to UsbControlTransfer
1368 * @tc.type: FUNC
1369 */
1370 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer029, TestSize.Level1)
1371 {
1372 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer029 : UsbControlTransfer");
1373 vector<UsbDevice> devi;
1374 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1375 auto ret = UsbSrvClient.GetDevices(devi);
1376 ASSERT_EQ(ret, 0);
1377 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer029 %{public}d ret=%{public}d", __LINE__, ret);
1378 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1379 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer029 %{public}d size=%{public}zu", __LINE__,
1380 devi.size());
1381 USBDevicePipe pipe;
1382 UsbDevice device = devi.front();
1383 UsbSrvClient.RequestRight(device.GetName());
1384 UsbInterface interface = device.GetConfigs().front().GetInterfaces().front();
1385 ret = UsbSrvClient.OpenDevice(device, pipe);
1386 ASSERT_EQ(ret, 0);
1387 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer029 %{public}d OpenDevice=%{public}d",
1388 __LINE__, ret);
1389 uint32_t len = BUFFER_SIZE;
1390 uint8_t buffer[BUFFER_SIZE] = {0};
1391 pipe.SetBusNum(BUFFER_SIZE);
1392 struct UsbCtrlTransferParams ctrldata = {0b10000001, 0X0A, 0, 0, 0, 500};
1393 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1394 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1395 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer029 %{public}d UsbControlTransfer=%{public}d",
1396 __LINE__, ret);
1397 ASSERT_NE(ret, 0);
1398 pipe.SetBusNum(device.GetBusNum());
1399 ret = UsbSrvClient.Close(pipe);
1400 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer029 %{public}d Close=%{public}d", __LINE__,
1401 ret);
1402 EXPECT_TRUE(ret);
1403 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer029 : UsbControlTransfer");
1404 }
1405
1406 /**
1407 * @tc.name: Usbcontrolstansfer030
1408 * @tc.desc: Test functions to UsbControlTransfer
1409 * @tc.type: FUNC
1410 */
1411 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer030, TestSize.Level1)
1412 {
1413 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer030 : UsbControlTransfer");
1414 vector<UsbDevice> devi;
1415 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1416 auto ret = UsbSrvClient.GetDevices(devi);
1417 ASSERT_EQ(ret, 0);
1418 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer030 %{public}d ret=%{public}d", __LINE__, ret);
1419 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1420 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer030 %{public}d size=%{public}zu", __LINE__,
1421 devi.size());
1422 USBDevicePipe pipe;
1423 UsbDevice device = devi.front();
1424 UsbSrvClient.RequestRight(device.GetName());
1425 UsbInterface interface = device.GetConfigs().front().GetInterfaces().front();
1426 ret = UsbSrvClient.OpenDevice(device, pipe);
1427 ASSERT_EQ(ret, 0);
1428 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer030 %{public}d OpenDevice=%{public}d",
1429 __LINE__, ret);
1430 uint32_t len = BUFFER_SIZE;
1431 uint8_t buffer[BUFFER_SIZE] = {0};
1432 pipe.SetDevAddr(BUFFER_SIZE);
1433 struct UsbCtrlTransferParams ctrldata = {0b10000001, 0X0A, 0, 0, 0, 500};
1434 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1435 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1436 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer030 %{public}d UsbControlTransfer=%{public}d",
1437 __LINE__, ret);
1438 ASSERT_NE(ret, 0);
1439 pipe.SetDevAddr(device.GetDevAddr());
1440 ret = UsbSrvClient.Close(pipe);
1441 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer030 %{public}d Close=%{public}d", __LINE__,
1442 ret);
1443 EXPECT_TRUE(ret);
1444 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer030 : UsbControlTransfer");
1445 }
1446
1447 /**
1448 * @tc.name: Usbcontrolstansfer031
1449 * @tc.desc: Test functions to UsbControlTransfer
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer031, TestSize.Level1)
1453 {
1454 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer031 : UsbControlTransfer");
1455 vector<UsbDevice> devi;
1456 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1457 auto ret = UsbSrvClient.GetDevices(devi);
1458 ASSERT_EQ(ret, 0);
1459 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer031 %{public}d ret=%{public}d", __LINE__, ret);
1460 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1461 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer031 %{public}d size=%{public}zu", __LINE__,
1462 devi.size());
1463 USBDevicePipe pipe;
1464 UsbDevice device = devi.front();
1465 UsbSrvClient.RequestRight(device.GetName());
1466 ret = UsbSrvClient.OpenDevice(device, pipe);
1467 ASSERT_EQ(ret, 0);
1468 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer031 %{public}d OpenDevice=%{public}d",
1469 __LINE__, ret);
1470 uint32_t len = BUFFER_SIZE;
1471 uint8_t buffer[BUFFER_SIZE] = {0};
1472 struct UsbCtrlTransferParams ctrldata = {0b10000000, 0, 0, 0, 0, 500};
1473 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1474 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1475 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer031 %{public}d UsbControlTransfer=%{public}d",
1476 __LINE__, ret);
1477 ASSERT_EQ(ret, 0);
1478 ret = UsbSrvClient.Close(pipe);
1479 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer031 %{public}d Close=%{public}d", __LINE__,
1480 ret);
1481 EXPECT_TRUE(ret);
1482 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer031 : UsbControlTransfer");
1483 }
1484
1485 /**
1486 * @tc.name: Usbcontrolstansfer032
1487 * @tc.desc: Test functions to UsbControlTransfer
1488 * @tc.type: FUNC
1489 */
1490 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer032, TestSize.Level1)
1491 {
1492 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer032 : UsbControlTransfer");
1493 vector<UsbDevice> devi;
1494 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1495 auto ret = UsbSrvClient.GetDevices(devi);
1496 ASSERT_EQ(ret, 0);
1497 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer032 %{public}d ret=%{public}d", __LINE__, ret);
1498 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1499 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer032 %{public}d size=%{public}zu", __LINE__,
1500 devi.size());
1501 USBDevicePipe pipe;
1502 UsbDevice device = devi.front();
1503 UsbSrvClient.RequestRight(device.GetName());
1504 ret = UsbSrvClient.OpenDevice(device, pipe);
1505 ASSERT_EQ(ret, 0);
1506 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer032 %{public}d OpenDevice=%{public}d",
1507 __LINE__, ret);
1508 uint32_t len = BUFFER_SIZE;
1509 uint8_t buffer[BUFFER_SIZE] = {0};
1510 pipe.SetBusNum(BUFFER_SIZE);
1511 struct UsbCtrlTransferParams ctrldata = {0b10000000, 0, 0, 0, 0, 500};
1512 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1513 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1514 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer032 %{public}d UsbControlTransfer=%{public}d",
1515 __LINE__, ret);
1516 ASSERT_NE(ret, 0);
1517 pipe.SetBusNum(device.GetBusNum());
1518 ret = UsbSrvClient.Close(pipe);
1519 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer032 %{public}d Close=%{public}d", __LINE__,
1520 ret);
1521 EXPECT_TRUE(ret);
1522 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer032 : UsbControlTransfer");
1523 }
1524
1525 /**
1526 * @tc.name: Usbcontrolstansfer033
1527 * @tc.desc: Test functions to UsbControlTransfer
1528 * @tc.type: FUNC
1529 */
1530 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer033, TestSize.Level1)
1531 {
1532 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer033 : UsbControlTransfer");
1533 vector<UsbDevice> devi;
1534 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1535 auto ret = UsbSrvClient.GetDevices(devi);
1536 ASSERT_EQ(ret, 0);
1537 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer033 %{public}d ret=%{public}d", __LINE__, ret);
1538 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1539 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer033 %{public}d size=%{public}zu", __LINE__,
1540 devi.size());
1541 USBDevicePipe pipe;
1542 UsbDevice device = devi.front();
1543 UsbSrvClient.RequestRight(device.GetName());
1544 ret = UsbSrvClient.OpenDevice(device, pipe);
1545 ASSERT_EQ(ret, 0);
1546 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer033 %{public}d OpenDevice=%{public}d",
1547 __LINE__, ret);
1548 uint32_t len = BUFFER_SIZE;
1549 uint8_t buffer[BUFFER_SIZE] = {0};
1550 pipe.SetDevAddr(BUFFER_SIZE);
1551 struct UsbCtrlTransferParams ctrldata = {0b10000000, 0, 0, 0, 0, 500};
1552 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1553 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1554 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer033 %{public}d UsbControlTransfer=%{public}d",
1555 __LINE__, ret);
1556 ASSERT_NE(ret, 0);
1557 pipe.SetDevAddr(device.GetDevAddr());
1558 ret = UsbSrvClient.Close(pipe);
1559 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer033 %{public}d Close=%{public}d", __LINE__,
1560 ret);
1561 EXPECT_TRUE(ret);
1562 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer033 : UsbControlTransfer");
1563 }
1564
1565 /**
1566 * @tc.name: Usbcontrolstansfer034
1567 * @tc.desc: Test functions to UsbControlTransfer
1568 * @tc.type: FUNC
1569 */
1570 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer034, TestSize.Level1)
1571 {
1572 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer034 : UsbControlTransfer");
1573 vector<UsbDevice> devi;
1574 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1575 auto ret = UsbSrvClient.GetDevices(devi);
1576 ASSERT_EQ(ret, 0);
1577 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer034 %{public}d ret=%{public}d", __LINE__,
1578 ret);
1579 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1580 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer034 %{public}d size=%{public}zu", __LINE__,
1581 devi.size());
1582 USBDevicePipe pipe;
1583 UsbDevice device = devi.front();
1584 UsbSrvClient.RequestRight(device.GetName());
1585 ret = UsbSrvClient.OpenDevice(device, pipe);
1586 ASSERT_EQ(ret, 0);
1587 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer034 %{public}d OpenDevice=%{public}d",
1588 __LINE__, ret);
1589 uint32_t len = BUFFER_SIZE;
1590 uint8_t buffer[BUFFER_SIZE] = {0};
1591 struct UsbCtrlTransferParams ctrldata = {0b10000001, 0, 0, 0, 0, 500};
1592 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1593 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1594 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer034 %{public}d UsbControlTransfer=%{public}d",
1595 __LINE__, ret);
1596 ASSERT_EQ(ret, 0);
1597 ret = UsbSrvClient.Close(pipe);
1598 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer034 %{public}d Close=%{public}d", __LINE__,
1599 ret);
1600 EXPECT_TRUE(ret);
1601 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer034 : UsbControlTransfer");
1602 }
1603
1604 /**
1605 * @tc.name: Usbcontrolstansfer035
1606 * @tc.desc: Test functions to UsbControlTransfer
1607 * @tc.type: FUNC
1608 */
1609 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer035, TestSize.Level1)
1610 {
1611 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer035 : UsbControlTransfer");
1612 vector<UsbDevice> devi;
1613 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1614 auto ret = UsbSrvClient.GetDevices(devi);
1615 ASSERT_EQ(ret, 0);
1616 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer035 %{public}d ret=%{public}d", __LINE__,
1617 ret);
1618 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1619 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer035 %{public}d size=%{public}zu", __LINE__,
1620 devi.size());
1621 USBDevicePipe pipe;
1622 UsbDevice device = devi.front();
1623 UsbSrvClient.RequestRight(device.GetName());
1624 ret = UsbSrvClient.OpenDevice(device, pipe);
1625 ASSERT_EQ(ret, 0);
1626 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer035 %{public}d OpenDevice=%{public}d",
1627 __LINE__, ret);
1628 uint32_t len = BUFFER_SIZE;
1629 uint8_t buffer[BUFFER_SIZE] = {0};
1630 pipe.SetBusNum(BUFFER_SIZE);
1631 struct UsbCtrlTransferParams ctrldata = {0b10000001, 0, 0, 0, 0, 500};
1632 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1633 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1634 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer035 %{public}d UsbControlTransfer=%{public}d",
1635 __LINE__, ret);
1636 ASSERT_NE(ret, 0);
1637 pipe.SetBusNum(device.GetBusNum());
1638 ret = UsbSrvClient.Close(pipe);
1639 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer035 %{public}d Close=%{public}d", __LINE__,
1640 ret);
1641 EXPECT_TRUE(ret);
1642 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer035 : UsbControlTransfer");
1643 }
1644
1645 /**
1646 * @tc.name: Usbcontrolstansfer036
1647 * @tc.desc: Test functions to UsbControlTransfer
1648 * @tc.type: FUNC
1649 */
1650 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer036, TestSize.Level1)
1651 {
1652 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer036 : UsbControlTransfer");
1653 vector<UsbDevice> devi;
1654 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1655 auto ret = UsbSrvClient.GetDevices(devi);
1656 ASSERT_EQ(ret, 0);
1657 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer036 %{public}d ret=%{public}d", __LINE__,
1658 ret);
1659 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1660 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer036 %{public}d size=%{public}zu", __LINE__,
1661 devi.size());
1662 USBDevicePipe pipe;
1663 UsbDevice device = devi.front();
1664 UsbSrvClient.RequestRight(device.GetName());
1665 ret = UsbSrvClient.OpenDevice(device, pipe);
1666 ASSERT_EQ(ret, 0);
1667 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer036 %{public}d OpenDevice=%{public}d",
1668 __LINE__, ret);
1669 uint32_t len = BUFFER_SIZE;
1670 uint8_t buffer[BUFFER_SIZE] = {0};
1671 pipe.SetDevAddr(BUFFER_SIZE);
1672 struct UsbCtrlTransferParams ctrldata = {0b10000001, 0, 0, 0, 0, 500};
1673 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1674 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1675 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer036 %{public}d UsbControlTransfer=%{public}d",
1676 __LINE__, ret);
1677 ASSERT_NE(ret, 0);
1678 pipe.SetDevAddr(device.GetDevAddr());
1679 ret = UsbSrvClient.Close(pipe);
1680 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer036 %{public}d Close=%{public}d", __LINE__,
1681 ret);
1682 EXPECT_TRUE(ret);
1683 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer036 : UsbControlTransfer");
1684 }
1685
1686 /**
1687 * @tc.name: Usbcontrolstansfer037
1688 * @tc.desc: Test functions to UsbControlTransfer
1689 * @tc.type: FUNC
1690 */
1691 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer037, TestSize.Level1)
1692 {
1693 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer037 : UsbControlTransfer");
1694 vector<UsbDevice> devi;
1695 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1696 auto ret = UsbSrvClient.GetDevices(devi);
1697 ASSERT_EQ(ret, 0);
1698 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer037 %{public}d ret=%{public}d", __LINE__, ret);
1699 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1700 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer037 %{public}d size=%{public}zu", __LINE__,
1701 devi.size());
1702 USBDevicePipe pipe;
1703 UsbDevice device = devi.front();
1704 UsbSrvClient.RequestRight(device.GetName());
1705 ret = UsbSrvClient.OpenDevice(device, pipe);
1706 ASSERT_EQ(ret, 0);
1707 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer037 %{public}d OpenDevice=%{public}d",
1708 __LINE__, ret);
1709 uint32_t len = 16;
1710 uint8_t buffer[BUFFER_SIZE] = {0};
1711 struct UsbCtrlTransferParams ctrldata = {0b10000010, 0, 0, 0, 0, 500};
1712 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1713 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1714 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer037 %{public}d UsbControlTransfer=%{public}d",
1715 __LINE__, ret);
1716 ASSERT_EQ(ret, 0);
1717 ret = UsbSrvClient.Close(pipe);
1718 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer037 %{public}d Close=%{public}d", __LINE__,
1719 ret);
1720 EXPECT_TRUE(ret);
1721 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer037 : UsbControlTransfer");
1722 }
1723
1724 /**
1725 * @tc.name: Usbcontrolstansfer038
1726 * @tc.desc: Test functions to UsbControlTransfer
1727 * @tc.type: FUNC
1728 */
1729 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer038, TestSize.Level1)
1730 {
1731 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer038 : UsbControlTransfer");
1732 vector<UsbDevice> devi;
1733 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1734 auto ret = UsbSrvClient.GetDevices(devi);
1735 ASSERT_EQ(ret, 0);
1736 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer038 %{public}d ret=%{public}d", __LINE__, ret);
1737 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1738 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer038 %{public}d size=%{public}zu", __LINE__,
1739 devi.size());
1740 USBDevicePipe pipe;
1741 UsbDevice device = devi.front();
1742 UsbSrvClient.RequestRight(device.GetName());
1743 ret = UsbSrvClient.OpenDevice(device, pipe);
1744 ASSERT_EQ(ret, 0);
1745 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer038 %{public}d OpenDevice=%{public}d",
1746 __LINE__, ret);
1747 uint32_t len = 16;
1748 uint8_t buffer[BUFFER_SIZE] = {0};
1749 pipe.SetBusNum(BUFFER_SIZE);
1750 struct UsbCtrlTransferParams ctrldata = {0b10000010, 0, 0, 0, 0, 500};
1751 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1752 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1753 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer038 %{public}d UsbControlTransfer=%{public}d",
1754 __LINE__, ret);
1755 ASSERT_NE(ret, 0);
1756 pipe.SetBusNum(device.GetBusNum());
1757 ret = UsbSrvClient.Close(pipe);
1758 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer038 %{public}d Close=%{public}d", __LINE__,
1759 ret);
1760 EXPECT_TRUE(ret);
1761 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer038 : UsbControlTransfer");
1762 }
1763
1764 /**
1765 * @tc.name: Usbcontrolstansfer039
1766 * @tc.desc: Test functions to UsbControlTransfer
1767 * @tc.type: FUNC
1768 */
1769 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer039, TestSize.Level1)
1770 {
1771 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer039 : UsbControlTransfer");
1772 vector<UsbDevice> devi;
1773 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1774 auto ret = UsbSrvClient.GetDevices(devi);
1775 ASSERT_EQ(ret, 0);
1776 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer039 %{public}d ret=%{public}d", __LINE__, ret);
1777 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1778 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer039 %{public}d size=%{public}zu", __LINE__,
1779 devi.size());
1780 USBDevicePipe pipe;
1781 UsbDevice device = devi.front();
1782 UsbSrvClient.RequestRight(device.GetName());
1783 ret = UsbSrvClient.OpenDevice(device, pipe);
1784 ASSERT_EQ(ret, 0);
1785 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer039 %{public}d OpenDevice=%{public}d",
1786 __LINE__, ret);
1787 uint32_t len = 16;
1788 uint8_t buffer[BUFFER_SIZE] = {0};
1789 pipe.SetDevAddr(BUFFER_SIZE);
1790 struct UsbCtrlTransferParams ctrldata = {0b10000010, 0, 0, 0, 0, 500};
1791 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1792 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1793 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer039 %{public}d UsbControlTransfer=%{public}d",
1794 __LINE__, ret);
1795 ASSERT_NE(ret, 0);
1796 pipe.SetDevAddr(device.GetDevAddr());
1797 ret = UsbSrvClient.Close(pipe);
1798 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer039 %{public}d Close=%{public}d", __LINE__,
1799 ret);
1800 EXPECT_TRUE(ret);
1801 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer039 : UsbControlTransfer");
1802 }
1803
1804 /**
1805 * @tc.name: Usbcontrolstansfer040
1806 * @tc.desc: Test functions to UsbControlTransfer
1807 * @tc.type: FUNC
1808 */
1809 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer040, TestSize.Level1)
1810 {
1811 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer040 : UsbControlTransfer");
1812 vector<UsbDevice> devi;
1813 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1814 auto ret = UsbSrvClient.GetDevices(devi);
1815 ASSERT_EQ(ret, 0);
1816 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer040 %{public}d ret=%{public}d", __LINE__, ret);
1817 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1818 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer040 %{public}d size=%{public}zu", __LINE__,
1819 devi.size());
1820 USBDevicePipe pipe;
1821 UsbDevice device = devi.front();
1822 UsbSrvClient.RequestRight(device.GetName());
1823 ret = UsbSrvClient.OpenDevice(device, pipe);
1824 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer040 %{public}d OpenDevice=%{public}d",
1825 __LINE__, ret);
1826 ASSERT_EQ(ret, 0);
1827 uint32_t len = BUFFER_SIZE;
1828 uint8_t buffer[BUFFER_SIZE] = {0};
1829 struct UsbCtrlTransferParams ctrldata = {0b10000010, 0X0C, 0, 0, 0, 500};
1830 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1831 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1832 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer040 %{public}d UsbControlTransfer=%{public}d",
1833 __LINE__, ret);
1834 ASSERT_EQ(ret, 0);
1835 ret = UsbSrvClient.Close(pipe);
1836 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Close=%{public}d", ret);
1837 EXPECT_TRUE(ret);
1838 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer040 : UsbControlTransfer");
1839 }
1840
1841 /**
1842 * @tc.name: Usbcontrolstansfer041
1843 * @tc.desc: Test functions to UsbControlTransfer
1844 * @tc.type: FUNC
1845 */
1846 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer041, TestSize.Level1)
1847 {
1848 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer041 : UsbControlTransfer");
1849 vector<UsbDevice> devi;
1850 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1851 auto ret = UsbSrvClient.GetDevices(devi);
1852 ASSERT_EQ(ret, 0);
1853 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer041 %{public}d ret=%{public}d", __LINE__, ret);
1854 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1855 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer041 %{public}d size=%{public}zu", __LINE__,
1856 devi.size());
1857 USBDevicePipe pipe;
1858 UsbDevice device = devi.front();
1859 UsbSrvClient.RequestRight(device.GetName());
1860 ret = UsbSrvClient.OpenDevice(device, pipe);
1861 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer041 %{public}d OpenDevice=%{public}d",
1862 __LINE__, ret);
1863 ASSERT_EQ(ret, 0);
1864 uint32_t len = BUFFER_SIZE;
1865 uint8_t buffer[BUFFER_SIZE] = {0};
1866 pipe.SetBusNum(BUFFER_SIZE);
1867 struct UsbCtrlTransferParams ctrldata = {0b10000010, 0X0C, 0, 0, 0, 500};
1868 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1869 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1870 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer041 %{public}d UsbControlTransfer=%{public}d",
1871 __LINE__, ret);
1872 ASSERT_NE(ret, 0);
1873 pipe.SetBusNum(device.GetBusNum());
1874 ret = UsbSrvClient.Close(pipe);
1875 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Close=%{public}d", ret);
1876 EXPECT_TRUE(ret);
1877 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer041 : UsbControlTransfer");
1878 }
1879
1880 /**
1881 * @tc.name: Usbcontrolstansfer042
1882 * @tc.desc: Test functions to UsbControlTransfer
1883 * @tc.type: FUNC
1884 */
1885 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer042, TestSize.Level1)
1886 {
1887 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer042 : UsbControlTransfer");
1888 vector<UsbDevice> devi;
1889 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1890 auto ret = UsbSrvClient.GetDevices(devi);
1891 ASSERT_EQ(ret, 0);
1892 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer042 %{public}d ret=%{public}d", __LINE__, ret);
1893 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1894 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer042 %{public}d size=%{public}zu", __LINE__,
1895 devi.size());
1896 USBDevicePipe pipe;
1897 UsbDevice device = devi.front();
1898 UsbSrvClient.RequestRight(device.GetName());
1899 ret = UsbSrvClient.OpenDevice(device, pipe);
1900 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer042 %{public}d OpenDevice=%{public}d",
1901 __LINE__, ret);
1902 ASSERT_EQ(ret, 0);
1903 uint32_t len = BUFFER_SIZE;
1904 uint8_t buffer[BUFFER_SIZE] = {0};
1905 pipe.SetDevAddr(BUFFER_SIZE);
1906 struct UsbCtrlTransferParams ctrldata = {0b10000010, 0X0C, 0, 0, 0, 500};
1907 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
1908 ret = UsbSrvClient.UsbControlTransfer(pipe, ctrldata, ctrlbuffer);
1909 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer042 %{public}d UsbControlTransfer=%{public}d",
1910 __LINE__, ret);
1911 ASSERT_NE(ret, 0);
1912 pipe.SetDevAddr(device.GetDevAddr());
1913 ret = UsbSrvClient.Close(pipe);
1914 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Close=%{public}d", ret);
1915 EXPECT_TRUE(ret);
1916 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer042 : UsbControlTransfer");
1917 }
1918
1919 /**
1920 * @tc.name: UsbClaimInterface001
1921 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
1922 * @tc.type: FUNC
1923 */
1924 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface001, TestSize.Level1)
1925 {
1926 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface001 : ClaimInterface");
1927 vector<UsbDevice> devi;
1928 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1929 auto ret = UsbSrvClient.GetDevices(devi);
1930 ASSERT_EQ(ret, 0);
1931 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d ret=%{public}d", __LINE__, ret);
1932 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1933 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d size=%{public}zu", __LINE__,
1934 devi.size());
1935 USBDevicePipe pipe;
1936 UsbDevice device = devi.front();
1937 UsbSrvClient.RequestRight(device.GetName());
1938 ret = UsbSrvClient.OpenDevice(device, pipe);
1939 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d OpenDevice=%{public}d", __LINE__,
1940 ret);
1941 ASSERT_EQ(ret, 0);
1942 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().front();
1943 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1944 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d ClaimInterface=%{public}d",
1945 __LINE__, ret);
1946 ASSERT_EQ(ret, 0);
1947 bool close = UsbSrvClient.Close(pipe);
1948 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d close=%{public}d", __LINE__,
1949 close);
1950 EXPECT_TRUE(close);
1951 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface001 : ClaimInterface");
1952 }
1953
1954 /**
1955 * @tc.name: UsbClaimInterface002
1956 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
1957 * @tc.type: FUNC
1958 */
1959 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface002, TestSize.Level1)
1960 {
1961 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface002 : ClaimInterface");
1962 vector<UsbDevice> devi;
1963 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1964 auto ret = UsbSrvClient.GetDevices(devi);
1965 ASSERT_EQ(ret, 0);
1966 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d ret=%{public}d", __LINE__, ret);
1967 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1968 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d size=%{public}zu", __LINE__,
1969 devi.size());
1970 USBDevicePipe pipe;
1971 UsbDevice device = devi.front();
1972 UsbSrvClient.RequestRight(device.GetName());
1973 ret = UsbSrvClient.OpenDevice(device, pipe);
1974 ASSERT_EQ(ret, 0);
1975 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d OpenDevice=%{public}d", __LINE__,
1976 ret);
1977 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().front();
1978 ret = UsbSrvClient.ClaimInterface(pipe, interface, false);
1979 ASSERT_EQ(ret, 0);
1980 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d ClaimInterface=%{public}d",
1981 __LINE__, ret);
1982 bool close = UsbSrvClient.Close(pipe);
1983 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d close=%{public}d", __LINE__,
1984 close);
1985 EXPECT_TRUE(close);
1986 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface002 : ClaimInterface");
1987 }
1988
1989 /**
1990 * @tc.name: UsbClaimInterface003
1991 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
1992 * @tc.type: FUNC
1993 */
1994 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface003, TestSize.Level1)
1995 {
1996 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface003 : ClaimInterface");
1997 vector<UsbDevice> devi;
1998 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1999 auto ret = UsbSrvClient.GetDevices(devi);
2000 ASSERT_EQ(ret, 0);
2001 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d ret=%{public}d", __LINE__, ret);
2002 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2003 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d size=%{public}zu", __LINE__,
2004 devi.size());
2005 USBDevicePipe pipe;
2006 UsbDevice device = devi.front();
2007 UsbSrvClient.RequestRight(device.GetName());
2008 ret = UsbSrvClient.OpenDevice(device, pipe);
2009 ASSERT_EQ(ret, 0);
2010 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d OpenDevice=%{public}d", __LINE__,
2011 ret);
2012 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
2013 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2014 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d ClaimInterface=%{public}d",
2015 __LINE__, ret);
2016 ASSERT_EQ(ret, 0);
2017 bool close = UsbSrvClient.Close(pipe);
2018 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d close=%{public}d", __LINE__,
2019 close);
2020 EXPECT_TRUE(close);
2021 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface003 : ClaimInterface");
2022 }
2023
2024 /**
2025 * @tc.name: UsbClaimInterface004
2026 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
2027 * @tc.type: FUNC
2028 */
2029 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface004, TestSize.Level1)
2030 {
2031 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface004 : ClaimInterface");
2032 vector<UsbDevice> devi;
2033 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2034 auto ret = UsbSrvClient.GetDevices(devi);
2035 ASSERT_EQ(ret, 0);
2036 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d ret=%{public}d", __LINE__, ret);
2037 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2038 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d size=%{public}zu", __LINE__,
2039 devi.size());
2040 USBDevicePipe pipe;
2041 UsbDevice device = devi.front();
2042 UsbSrvClient.RequestRight(device.GetName());
2043 ret = UsbSrvClient.OpenDevice(device, pipe);
2044 ASSERT_EQ(ret, 0);
2045 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d OpenDevice=%{public}d", __LINE__,
2046 ret);
2047 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
2048 ret = UsbSrvClient.ClaimInterface(pipe, interface, false);
2049 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d ClaimInterface=%{public}d",
2050 __LINE__, ret);
2051 ASSERT_EQ(ret, 0);
2052 bool close = UsbSrvClient.Close(pipe);
2053 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d close=%{public}d", __LINE__,
2054 close);
2055 EXPECT_TRUE(close);
2056 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface004 : ClaimInterface");
2057 }
2058
2059 /**
2060 * @tc.name: UsbClaimInterface005
2061 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
2062 * @tc.type: FUNC
2063 */
2064 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface005, TestSize.Level1)
2065 {
2066 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface005 : ClaimInterface");
2067 vector<UsbDevice> devi;
2068 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2069 auto ret = UsbSrvClient.GetDevices(devi);
2070 ASSERT_EQ(ret, 0);
2071 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d ret=%{public}d", __LINE__, ret);
2072 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2073 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d size=%{public}zu", __LINE__,
2074 devi.size());
2075 USBDevicePipe pipe;
2076 UsbDevice device = devi.front();
2077 UsbSrvClient.RequestRight(device.GetName());
2078 ret = UsbSrvClient.OpenDevice(device, pipe);
2079 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d OpenDevice=%{public}d", __LINE__,
2080 ret);
2081 ASSERT_EQ(ret, 0);
2082 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().front();
2083 pipe.SetBusNum(BUFFER_SIZE);
2084 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2085 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d ClaimInterface=%{public}d",
2086 __LINE__, ret);
2087 ASSERT_NE(ret, 0);
2088 pipe.SetBusNum(device.GetBusNum());
2089 bool close = UsbSrvClient.Close(pipe);
2090 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d close=%{public}d", __LINE__,
2091 close);
2092 EXPECT_TRUE(close);
2093 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface005 : ClaimInterface");
2094 }
2095
2096 /**
2097 * @tc.name: UsbClaimInterface006
2098 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
2099 * @tc.type: FUNC
2100 */
2101 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface006, TestSize.Level1)
2102 {
2103 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface006 : ClaimInterface");
2104 vector<UsbDevice> devi;
2105 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2106 auto ret = UsbSrvClient.GetDevices(devi);
2107 ASSERT_EQ(ret, 0);
2108 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d ret=%{public}d", __LINE__, ret);
2109 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2110 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d size=%{public}zu", __LINE__,
2111 devi.size());
2112 USBDevicePipe pipe;
2113 UsbDevice device = devi.front();
2114 UsbSrvClient.RequestRight(device.GetName());
2115 ret = UsbSrvClient.OpenDevice(device, pipe);
2116 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d OpenDevice=%{public}d", __LINE__,
2117 ret);
2118 ASSERT_EQ(ret, 0);
2119 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().front();
2120 pipe.SetDevAddr(BUFFER_SIZE);
2121 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2122 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d ClaimInterface=%{public}d",
2123 __LINE__, ret);
2124 ASSERT_NE(ret, 0);
2125 pipe.SetDevAddr(device.GetDevAddr());
2126 bool close = UsbSrvClient.Close(pipe);
2127 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d close=%{public}d", __LINE__,
2128 close);
2129 EXPECT_TRUE(close);
2130 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface006 : ClaimInterface");
2131 }
2132
2133 /**
2134 * @tc.name: UsbClaimInterface007
2135 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
2136 * @tc.type: FUNC
2137 */
2138 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface007, TestSize.Level1)
2139 {
2140 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface007 : ClaimInterface");
2141 vector<UsbDevice> devi;
2142 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2143 auto ret = UsbSrvClient.GetDevices(devi);
2144 ASSERT_EQ(ret, 0);
2145 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d ret=%{public}d", __LINE__, ret);
2146 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2147 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d size=%{public}zu", __LINE__,
2148 devi.size());
2149 USBDevicePipe pipe;
2150 UsbDevice device = devi.front();
2151 UsbSrvClient.RequestRight(device.GetName());
2152 ret = UsbSrvClient.OpenDevice(device, pipe);
2153 ASSERT_EQ(ret, 0);
2154 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d OpenDevice=%{public}d", __LINE__,
2155 ret);
2156 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
2157 pipe.SetBusNum(BUFFER_SIZE);
2158 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2159 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d ClaimInterface=%{public}d",
2160 __LINE__, ret);
2161 ASSERT_NE(ret, 0);
2162 pipe.SetBusNum(device.GetBusNum());
2163 bool close = UsbSrvClient.Close(pipe);
2164 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d close=%{public}d", __LINE__,
2165 close);
2166 EXPECT_TRUE(close);
2167 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface007 : ClaimInterface");
2168 }
2169
2170 /**
2171 * @tc.name: UsbClaimInterface008
2172 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
2173 * @tc.type: FUNC
2174 */
2175 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface008, TestSize.Level1)
2176 {
2177 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface008 : ClaimInterface");
2178 vector<UsbDevice> devi;
2179 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2180 auto ret = UsbSrvClient.GetDevices(devi);
2181 ASSERT_EQ(ret, 0);
2182 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d ret=%{public}d", __LINE__, ret);
2183 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2184 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d size=%{public}zu", __LINE__,
2185 devi.size());
2186 USBDevicePipe pipe;
2187 UsbDevice device = devi.front();
2188 UsbSrvClient.RequestRight(device.GetName());
2189 ret = UsbSrvClient.OpenDevice(device, pipe);
2190 ASSERT_EQ(ret, 0);
2191 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d OpenDevice=%{public}d", __LINE__,
2192 ret);
2193 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
2194 pipe.SetDevAddr(BUFFER_SIZE);
2195 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2196 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d ClaimInterface=%{public}d",
2197 __LINE__, ret);
2198 ASSERT_NE(ret, 0);
2199 pipe.SetDevAddr(device.GetDevAddr());
2200 bool close = UsbSrvClient.Close(pipe);
2201 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d close=%{public}d", __LINE__,
2202 close);
2203 EXPECT_TRUE(close);
2204 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface008 : ClaimInterface");
2205 }
2206
2207 /**
2208 * @tc.name: UsbReleaseInterface001
2209 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
2210 * @tc.type: FUNC
2211 */
2212 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface001, TestSize.Level1)
2213 {
2214 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface001 : ReleaseInterface");
2215 vector<UsbDevice> devi;
2216 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2217 auto ret = UsbSrvClient.GetDevices(devi);
2218 ASSERT_EQ(ret, 0);
2219 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d ret=%{public}d", __LINE__,
2220 ret);
2221 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2222 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d size=%{public}zu", __LINE__,
2223 devi.size());
2224 USBDevicePipe pipe;
2225 UsbDevice device = devi.front();
2226 UsbSrvClient.RequestRight(device.GetName());
2227 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
2228 ret = UsbSrvClient.OpenDevice(device, pipe);
2229 ASSERT_EQ(ret, 0);
2230 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d OpenDevice=%{public}d",
2231 __LINE__, ret);
2232 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
2233 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d ReleaseInterface=%{public}d",
2234 __LINE__, ret);
2235 ASSERT_NE(ret, 0);
2236 bool close = UsbSrvClient.Close(pipe);
2237 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d close=%{public}d", __LINE__,
2238 close);
2239 EXPECT_TRUE(close);
2240 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface001 : ReleaseInterface");
2241 }
2242
2243 /**
2244 * @tc.name: UsbReleaseInterface002
2245 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
2246 * @tc.type: FUNC
2247 */
2248 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface002, TestSize.Level1)
2249 {
2250 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface002 : ReleaseInterface");
2251 vector<UsbDevice> devi;
2252 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2253 auto ret = UsbSrvClient.GetDevices(devi);
2254 ASSERT_EQ(ret, 0);
2255 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d ret=%{public}d", __LINE__,
2256 ret);
2257 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2258 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d size=%{public}zu", __LINE__,
2259 devi.size());
2260 USBDevicePipe pipe;
2261 UsbDevice device = devi.front();
2262 UsbSrvClient.RequestRight(device.GetName());
2263 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
2264 ret = UsbSrvClient.OpenDevice(device, pipe);
2265 ASSERT_EQ(ret, 0);
2266 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d OpenDevice=%{public}d",
2267 __LINE__, ret);
2268 pipe.SetBusNum(BUFFER_SIZE);
2269 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
2270 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d ReleaseInterface=%{public}d",
2271 __LINE__, ret);
2272 ASSERT_NE(ret, 0);
2273 pipe.SetBusNum(device.GetBusNum());
2274 bool close = UsbSrvClient.Close(pipe);
2275 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d close=%{public}d", __LINE__,
2276 close);
2277 EXPECT_TRUE(close);
2278 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface002 : ReleaseInterface");
2279 }
2280
2281 /**
2282 * @tc.name: UsbReleaseInterface003
2283 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
2284 * @tc.type: FUNC
2285 */
2286 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface003, TestSize.Level1)
2287 {
2288 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface003 : ReleaseInterface");
2289 vector<UsbDevice> devi;
2290 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2291 auto ret = UsbSrvClient.GetDevices(devi);
2292 ASSERT_EQ(ret, 0);
2293 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d ret=%{public}d", __LINE__,
2294 ret);
2295 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2296 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d size=%{public}zu", __LINE__,
2297 devi.size());
2298 USBDevicePipe pipe;
2299 UsbDevice device = devi.front();
2300 UsbSrvClient.RequestRight(device.GetName());
2301 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
2302 ret = UsbSrvClient.OpenDevice(device, pipe);
2303 ASSERT_EQ(ret, 0);
2304 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d OpenDevice=%{public}d",
2305 __LINE__, ret);
2306 pipe.SetDevAddr(BUFFER_SIZE);
2307 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
2308 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d ReleaseInterface=%{public}d",
2309 __LINE__, ret);
2310 ASSERT_NE(ret, 0);
2311 pipe.SetDevAddr(device.GetDevAddr());
2312 bool close = UsbSrvClient.Close(pipe);
2313 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d close=%{public}d", __LINE__,
2314 close);
2315 EXPECT_TRUE(close);
2316 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface003 : ReleaseInterface");
2317 }
2318
2319 /**
2320 * @tc.name: UsbReleaseInterface004
2321 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
2322 * @tc.type: FUNC
2323 */
2324 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface004, TestSize.Level1)
2325 {
2326 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface004 : ReleaseInterface");
2327 vector<UsbDevice> devi;
2328 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2329 auto ret = UsbSrvClient.GetDevices(devi);
2330 ASSERT_EQ(ret, 0);
2331 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d ret=%{public}d", __LINE__,
2332 ret);
2333 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2334 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d size=%{public}zu", __LINE__,
2335 devi.size());
2336 USBDevicePipe pipe;
2337 UsbDevice device = devi.front();
2338 UsbSrvClient.RequestRight(device.GetName());
2339 ret = UsbSrvClient.OpenDevice(device, pipe);
2340 ASSERT_EQ(ret, 0);
2341 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d OpenDevice=%{public}d",
2342 __LINE__, ret);
2343 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
2344 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2345 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d ClaimInterface=%{public}d",
2346 __LINE__, ret);
2347 ASSERT_EQ(ret, 0);
2348 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
2349 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d ReleaseInterface=%{public}d",
2350 __LINE__, ret);
2351 ASSERT_EQ(ret, 0);
2352 bool close = UsbSrvClient.Close(pipe);
2353 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d close=%{public}d", __LINE__,
2354 close);
2355 EXPECT_TRUE(close);
2356 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface004 : ReleaseInterface");
2357 }
2358
2359 /**
2360 * @tc.name: UsbReleaseInterface005
2361 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
2362 * @tc.type: FUNC
2363 */
2364 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface005, TestSize.Level1)
2365 {
2366 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface005 : ReleaseInterface");
2367 vector<UsbDevice> devi;
2368 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2369 auto ret = UsbSrvClient.GetDevices(devi);
2370 ASSERT_EQ(ret, 0);
2371 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d ret=%{public}d", __LINE__,
2372 ret);
2373 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2374 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d size=%{public}zu", __LINE__,
2375 devi.size());
2376 USBDevicePipe pipe;
2377 UsbDevice device = devi.front();
2378 UsbSrvClient.RequestRight(device.GetName());
2379 ret = UsbSrvClient.OpenDevice(device, pipe);
2380 ASSERT_EQ(ret, 0);
2381 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d OpenDevice=%{public}d",
2382 __LINE__, ret);
2383 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
2384 pipe.SetBusNum(BUFFER_SIZE);
2385 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
2386 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d ReleaseInterface=%{public}d",
2387 __LINE__, ret);
2388 ASSERT_NE(ret, 0);
2389 pipe.SetBusNum(device.GetBusNum());
2390 bool close = UsbSrvClient.Close(pipe);
2391 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d close=%{public}d", __LINE__,
2392 close);
2393 EXPECT_TRUE(close);
2394 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface005 : ReleaseInterface");
2395 }
2396
2397 /**
2398 * @tc.name: UsbReleaseInterface006
2399 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
2400 * @tc.type: FUNC
2401 */
2402 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface006, TestSize.Level1)
2403 {
2404 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface006 : ReleaseInterface");
2405 vector<UsbDevice> devi;
2406 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2407 auto ret = UsbSrvClient.GetDevices(devi);
2408 ASSERT_EQ(ret, 0);
2409 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d ret=%{public}d", __LINE__,
2410 ret);
2411 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2412 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d size=%{public}zu", __LINE__,
2413 devi.size());
2414 USBDevicePipe pipe;
2415 UsbDevice device = devi.front();
2416 UsbSrvClient.RequestRight(device.GetName());
2417 ret = UsbSrvClient.OpenDevice(device, pipe);
2418 ASSERT_EQ(ret, 0);
2419 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d OpenDevice=%{public}d",
2420 __LINE__, ret);
2421 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
2422 pipe.SetDevAddr(BUFFER_SIZE);
2423 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
2424 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d ReleaseInterface=%{public}d",
2425 __LINE__, ret);
2426 ASSERT_NE(ret, 0);
2427 pipe.SetDevAddr(device.GetDevAddr());
2428 bool close = UsbSrvClient.Close(pipe);
2429 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d close=%{public}d", __LINE__,
2430 close);
2431 EXPECT_TRUE(close);
2432 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface006 : ReleaseInterface");
2433 }
2434
2435 /**
2436 * @tc.name: UsbBulkTransfer001
2437 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2438 * timeout);
2439 * @tc.type: FUNC
2440 */
2441 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer001, TestSize.Level1)
2442 {
2443 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer001 : BulkTransfer");
2444 vector<UsbDevice> devi;
2445 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2446 auto ret = UsbSrvClient.GetDevices(devi);
2447 ASSERT_EQ(ret, 0);
2448 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d ret=%{public}d", __LINE__, ret);
2449 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2450 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d size=%{public}zu", __LINE__,
2451 devi.size());
2452 USBDevicePipe pipe;
2453 UsbDevice device = devi.front();
2454 UsbSrvClient.RequestRight(device.GetName());
2455 ret = UsbSrvClient.OpenDevice(device, pipe);
2456 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d OpenDevice=%{public}d", __LINE__,
2457 ret);
2458 ASSERT_EQ(ret, 0);
2459 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2460 USBEndpoint point = interface.GetEndpoints().front();
2461 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d point=%{public}d", __LINE__,
2462 point.GetInterfaceId());
2463 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2464 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d ClaimInterface=%{public}d",
2465 __LINE__, ret);
2466 ASSERT_EQ(ret, 0);
2467 uint8_t buffer[BUFFER_SIZE] = "bulk read";
2468 uint32_t len = BUFFER_SIZE;
2469 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2470 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
2471 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d BulkTransfer=%{public}d", __LINE__,
2472 ret);
2473 ASSERT_EQ(ret, 0);
2474 bool close = UsbSrvClient.Close(pipe);
2475 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d close=%{public}d", __LINE__,
2476 close);
2477 EXPECT_TRUE(close);
2478 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer001 : BulkTransfer");
2479 }
2480
2481 /**
2482 * @tc.name: UsbBulkTransfer002
2483 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2484 * timeout);
2485 * @tc.type: FUNC
2486 */
2487 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer002, TestSize.Level1)
2488 {
2489 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer002 : BulkTransfer");
2490 vector<UsbDevice> devi;
2491 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2492 auto ret = UsbSrvClient.GetDevices(devi);
2493 ASSERT_EQ(ret, 0);
2494 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d ret=%{public}d", __LINE__, ret);
2495 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2496 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d size=%{public}zu", __LINE__,
2497 devi.size());
2498 USBDevicePipe pipe;
2499 UsbDevice device = devi.front();
2500 UsbSrvClient.RequestRight(device.GetName());
2501 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2502 USBEndpoint point = interface.GetEndpoints().front();
2503 ret = UsbSrvClient.OpenDevice(device, pipe);
2504 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d OpenDevice=%{public}d", __LINE__,
2505 ret);
2506 ASSERT_EQ(ret, 0);
2507 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2508 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d ClaimInterface=%{public}d",
2509 __LINE__, ret);
2510 ASSERT_EQ(ret, 0);
2511 uint8_t buffer[BUFFER_SIZE] = "bulk read";
2512 uint32_t len = BUFFER_SIZE;
2513 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2514 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, -5);
2515 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d BulkTransfer=%{public}d", __LINE__,
2516 ret);
2517 ASSERT_EQ(ret, 0);
2518 bool close = UsbSrvClient.Close(pipe);
2519 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d close=%{public}d", __LINE__,
2520 close);
2521 EXPECT_TRUE(close);
2522 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer002 : BulkTransfer");
2523 }
2524
2525 /**
2526 * @tc.name: UsbBulkTransfer003
2527 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2528 * timeout);
2529 * @tc.type: FUNC
2530 */
2531 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer003, TestSize.Level1)
2532 {
2533 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer003 : BulkTransfer");
2534 vector<UsbDevice> devi;
2535 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2536 auto ret = UsbSrvClient.GetDevices(devi);
2537 ASSERT_EQ(ret, 0);
2538 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d ret=%{public}d", __LINE__, ret);
2539 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2540 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d size=%{public}zu", __LINE__,
2541 devi.size());
2542 USBDevicePipe pipe;
2543 UsbDevice device = devi.front();
2544 UsbSrvClient.RequestRight(device.GetName());
2545 ret = UsbSrvClient.OpenDevice(device, pipe);
2546 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d OpenDevice=%{public}d", __LINE__,
2547 ret);
2548 ASSERT_EQ(ret, 0);
2549 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2550 USBEndpoint point = interface.GetEndpoints().front();
2551 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2552 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d ClaimInterface=%{public}d",
2553 __LINE__, ret);
2554 ASSERT_EQ(ret, 0);
2555 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d point=%{public}d", __LINE__,
2556 point.GetInterfaceId());
2557 uint8_t buffer[BUFFER_SIZE] = "bulk read";
2558 uint32_t len = BUFFER_SIZE;
2559 pipe.SetBusNum(BUFFER_SIZE);
2560 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2561 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
2562 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d BulkTransfer=%{public}d", __LINE__,
2563 ret);
2564 ASSERT_NE(ret, 0);
2565 pipe.SetBusNum(device.GetBusNum());
2566 bool close = UsbSrvClient.Close(pipe);
2567 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d close=%{public}d", __LINE__,
2568 close);
2569 EXPECT_TRUE(close);
2570 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer003 : BulkTransfer");
2571 }
2572
2573 /**
2574 * @tc.name: UsbBulkTransfer004
2575 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2576 * timeout);
2577 * @tc.type: FUNC
2578 */
2579 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer004, TestSize.Level1)
2580 {
2581 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer004 : BulkTransfer");
2582 vector<UsbDevice> devi;
2583 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2584 auto ret = UsbSrvClient.GetDevices(devi);
2585 ASSERT_EQ(ret, 0);
2586 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d ret=%{public}d", __LINE__, ret);
2587 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2588 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d size=%{public}zu", __LINE__,
2589 devi.size());
2590 USBDevicePipe pipe;
2591 UsbDevice device = devi.front();
2592 UsbSrvClient.RequestRight(device.GetName());
2593 ret = UsbSrvClient.OpenDevice(device, pipe);
2594 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d OpenDevice=%{public}d", __LINE__,
2595 ret);
2596 ASSERT_EQ(ret, 0);
2597 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2598 USBEndpoint point = interface.GetEndpoints().front();
2599 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d point=%{public}d", __LINE__,
2600 point.GetInterfaceId());
2601 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2602 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d ClaimInterface=%{public}d",
2603 __LINE__, ret);
2604 ASSERT_EQ(ret, 0);
2605 uint8_t buffer[BUFFER_SIZE] = "bulk read";
2606 uint32_t len = BUFFER_SIZE;
2607 pipe.SetDevAddr(BUFFER_SIZE);
2608 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2609 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
2610 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d BulkTransfer=%{public}d", __LINE__,
2611 ret);
2612 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d len=%{public}d", __LINE__, len);
2613 ASSERT_NE(ret, 0);
2614 pipe.SetDevAddr(device.GetDevAddr());
2615 bool close = UsbSrvClient.Close(pipe);
2616 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d close=%{public}d", __LINE__,
2617 close);
2618 EXPECT_TRUE(close);
2619 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer004 : BulkTransfer");
2620 }
2621
2622 /**
2623 * @tc.name: UsbBulkTransfer005
2624 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2625 * timeout);
2626 * @tc.type: FUNC
2627 */
2628 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer005, TestSize.Level1)
2629 {
2630 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer005 : BulkTransfer");
2631 vector<UsbDevice> devi;
2632 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2633 auto ret = UsbSrvClient.GetDevices(devi);
2634 ASSERT_EQ(ret, 0);
2635 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d ret=%{public}d", __LINE__, ret);
2636 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2637 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d size=%{public}zu", __LINE__,
2638 devi.size());
2639 USBDevicePipe pipe;
2640 UsbDevice device = devi.front();
2641 UsbSrvClient.RequestRight(device.GetName());
2642 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2643 USBEndpoint point = interface.GetEndpoints().front();
2644 ret = UsbSrvClient.OpenDevice(device, pipe);
2645 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d OpenDevice=%{public}d", __LINE__,
2646 ret);
2647 ASSERT_EQ(ret, 0);
2648 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2649 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d ClaimInterface=%{public}d",
2650 __LINE__, ret);
2651 ASSERT_EQ(ret, 0);
2652 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d point=%{public}d", __LINE__,
2653 point.GetInterfaceId());
2654 uint8_t buffer[BUFFER_SIZE] = "bulk read";
2655 uint32_t len = BUFFER_SIZE;
2656 point.SetInterfaceId(BUFFER_SIZE);
2657 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2658 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
2659 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d BulkTransfer=%{public}d", __LINE__,
2660 ret);
2661 ASSERT_NE(ret, 0);
2662 bool close = UsbSrvClient.Close(pipe);
2663 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d close=%{public}d", __LINE__,
2664 close);
2665 EXPECT_TRUE(close);
2666 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer005 : BulkTransfer");
2667 }
2668
2669 /**
2670 * @tc.name: UsbBulkTransfer006
2671 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2672 * timeout);
2673 * @tc.type: FUNC
2674 */
2675 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer006, TestSize.Level1)
2676 {
2677 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer006 : BulkTransfer");
2678 vector<UsbDevice> devi;
2679 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2680 auto ret = UsbSrvClient.GetDevices(devi);
2681 ASSERT_EQ(ret, 0);
2682 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d ret=%{public}d", __LINE__, ret);
2683 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2684 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d size=%{public}zu", __LINE__,
2685 devi.size());
2686 USBDevicePipe pipe;
2687 UsbDevice device = devi.front();
2688 UsbSrvClient.RequestRight(device.GetName());
2689 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2690 USBEndpoint point = interface.GetEndpoints().front();
2691 ret = UsbSrvClient.OpenDevice(device, pipe);
2692 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d OpenDevice=%{public}d", __LINE__,
2693 ret);
2694 ASSERT_EQ(ret, 0);
2695 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2696 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d ClaimInterface=%{public}d",
2697 __LINE__, ret);
2698 ASSERT_EQ(ret, 0);
2699 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d point=%{public}d", __LINE__,
2700 point.GetInterfaceId());
2701 uint8_t buffer[BUFFER_SIZE] = "bulk read";
2702 uint32_t len = BUFFER_SIZE;
2703 point.SetAddr(BUFFER_SIZE);
2704 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2705 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
2706 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d BulkTransfer=%{public}d", __LINE__,
2707 ret);
2708 ASSERT_NE(ret, 0);
2709 bool close = UsbSrvClient.Close(pipe);
2710 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d close=%{public}d", __LINE__,
2711 close);
2712 EXPECT_TRUE(close);
2713 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer006 : BulkTransfer");
2714 }
2715
2716 /**
2717 * @tc.name: UsbBulkTransfer007
2718 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2719 * timeout);
2720 * @tc.type: FUNC
2721 */
2722 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer007, TestSize.Level1)
2723 {
2724 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer007 : BulkTransfer");
2725 vector<UsbDevice> devi;
2726 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2727 auto ret = UsbSrvClient.GetDevices(devi);
2728 ASSERT_EQ(ret, 0);
2729 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d ret=%{public}d", __LINE__, ret);
2730 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2731 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d size=%{public}zu", __LINE__,
2732 devi.size());
2733 USBDevicePipe pipe;
2734 UsbDevice device = devi.front();
2735 UsbSrvClient.RequestRight(device.GetName());
2736 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2737 USBEndpoint point = interface.GetEndpoints().at(1);
2738 ret = UsbSrvClient.OpenDevice(device, pipe);
2739 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d OpenDevice=%{public}d", __LINE__,
2740 ret);
2741 ASSERT_EQ(ret, 0);
2742 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2743 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d ClaimInterface=%{public}d",
2744 __LINE__, ret);
2745 ASSERT_EQ(ret, 0);
2746 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d point=%{public}d", __LINE__,
2747 point.GetInterfaceId());
2748 uint8_t buffer[BUFFER_SIZE] = "hello world Bulk transfer007";
2749 uint32_t len = BUFFER_SIZE;
2750 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2751 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
2752 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d BulkTransfer=%{public}d", __LINE__,
2753 ret);
2754 ASSERT_EQ(ret, 0);
2755 bool close = UsbSrvClient.Close(pipe);
2756 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d close=%{public}d", __LINE__,
2757 close);
2758 EXPECT_TRUE(close);
2759 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer007 : BulkTransfer");
2760 }
2761
2762 /**
2763 * @tc.name: UsbBulkTransfer008
2764 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2765 * timeout);
2766 * @tc.type: FUNC
2767 */
2768 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer008, TestSize.Level1)
2769 {
2770 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer008 : BulkTransfer");
2771 vector<UsbDevice> devi;
2772 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2773 auto ret = UsbSrvClient.GetDevices(devi);
2774 ASSERT_EQ(ret, 0);
2775 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d ret=%{public}d", __LINE__, ret);
2776 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2777 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d size=%{public}zu", __LINE__,
2778 devi.size());
2779 USBDevicePipe pipe;
2780 UsbDevice device = devi.front();
2781 UsbSrvClient.RequestRight(device.GetName());
2782 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2783 USBEndpoint point = interface.GetEndpoints().at(1);
2784 ret = UsbSrvClient.OpenDevice(device, pipe);
2785 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d OpenDevice=%{public}d", __LINE__,
2786 ret);
2787 ASSERT_EQ(ret, 0);
2788 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2789 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d ClaimInterface=%{public}d",
2790 __LINE__, ret);
2791 ASSERT_EQ(ret, 0);
2792 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d point=%{public}d", __LINE__,
2793 point.GetInterfaceId());
2794 uint8_t buffer[BUFFER_SIZE] = "hello world Bulk transfer008";
2795 uint32_t len = BUFFER_SIZE;
2796 pipe.SetDevAddr(BUFFER_SIZE);
2797 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2798 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
2799 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d BulkTransfer=%{public}d", __LINE__,
2800 ret);
2801 ASSERT_NE(ret, 0);
2802 pipe.SetDevAddr(device.GetDevAddr());
2803 bool close = UsbSrvClient.Close(pipe);
2804 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d close=%{public}d", __LINE__,
2805 close);
2806 EXPECT_TRUE(close);
2807 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer008 : BulkTransfer");
2808 }
2809
2810 /**
2811 * @tc.name: UsbBulkTransfer009
2812 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2813 * timeout);
2814 * @tc.type: FUNC
2815 */
2816 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer009, TestSize.Level1)
2817 {
2818 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer009 : BulkTransfer");
2819 vector<UsbDevice> devi;
2820 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2821 auto ret = UsbSrvClient.GetDevices(devi);
2822 ASSERT_EQ(ret, 0);
2823 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d ret=%{public}d", __LINE__, ret);
2824 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2825 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d size=%{public}zu", __LINE__,
2826 devi.size());
2827 USBDevicePipe pipe;
2828 UsbDevice device = devi.front();
2829 UsbSrvClient.RequestRight(device.GetName());
2830 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2831 USBEndpoint point = interface.GetEndpoints().at(1);
2832 ret = UsbSrvClient.OpenDevice(device, pipe);
2833 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d OpenDevice=%{public}d", __LINE__,
2834 ret);
2835 ASSERT_EQ(ret, 0);
2836 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2837 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d ClaimInterface=%{public}d",
2838 __LINE__, ret);
2839 ASSERT_EQ(ret, 0);
2840 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d point=%{public}d", __LINE__,
2841 point.GetInterfaceId());
2842 uint8_t buffer[BUFFER_SIZE] = "hello world Bulk transfer009";
2843 uint32_t len = BUFFER_SIZE;
2844 pipe.SetBusNum(BUFFER_SIZE);
2845 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2846 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
2847 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d BulkTransfer=%{public}d", __LINE__,
2848 ret);
2849 ASSERT_NE(ret, 0);
2850 pipe.SetBusNum(device.GetBusNum());
2851 bool close = UsbSrvClient.Close(pipe);
2852 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d close=%{public}d", __LINE__,
2853 close);
2854 EXPECT_TRUE(close);
2855 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer009 : BulkTransfer");
2856 }
2857
2858 /**
2859 * @tc.name: UsbBulkTransfer010
2860 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2861 * timeout);
2862 * @tc.type: FUNC
2863 */
2864 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer010, TestSize.Level1)
2865 {
2866 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer010 : BulkTransfer");
2867 vector<UsbDevice> devi;
2868 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2869 auto ret = UsbSrvClient.GetDevices(devi);
2870 ASSERT_EQ(ret, 0);
2871 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d ret=%{public}d", __LINE__, ret);
2872 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2873 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d size=%{public}zu", __LINE__,
2874 devi.size());
2875 USBDevicePipe pipe;
2876 UsbDevice device = devi.front();
2877 UsbSrvClient.RequestRight(device.GetName());
2878 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2879 USBEndpoint point = interface.GetEndpoints().at(1);
2880 ret = UsbSrvClient.OpenDevice(device, pipe);
2881 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d OpenDevice=%{public}d", __LINE__,
2882 ret);
2883 ASSERT_EQ(ret, 0);
2884 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2885 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d ClaimInterface=%{public}d",
2886 __LINE__, ret);
2887 ASSERT_EQ(ret, 0);
2888 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d point=%{public}d", __LINE__,
2889 point.GetInterfaceId());
2890 uint8_t buffer[BUFFER_SIZE] = "hello world Bulk transfer010";
2891 uint32_t len = BUFFER_SIZE;
2892 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2893 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, -5);
2894 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d BulkTransfer=%{public}d", __LINE__,
2895 ret);
2896 ASSERT_EQ(ret, 0);
2897 bool close = UsbSrvClient.Close(pipe);
2898 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d close=%{public}d", __LINE__,
2899 close);
2900 EXPECT_TRUE(close);
2901 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer010 : BulkTransfer");
2902 }
2903
2904 /**
2905 * @tc.name: UsbBulkTransfer011
2906 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
2907 * timeout);
2908 * @tc.type: FUNC
2909 */
2910 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer011, TestSize.Level1)
2911 {
2912 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer011 : BulkTransfer");
2913 vector<UsbDevice> devi;
2914 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2915 auto ret = UsbSrvClient.GetDevices(devi);
2916 ASSERT_EQ(ret, 0);
2917 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer011 %{public}d ret=%{public}d", __LINE__, ret);
2918 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2919 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer011 %{public}d size=%{public}zu", __LINE__,
2920 devi.size());
2921 USBDevicePipe pipe;
2922 UsbDevice device = devi.front();
2923 UsbSrvClient.RequestRight(device.GetName());
2924 ret = UsbSrvClient.OpenDevice(device, pipe);
2925 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer011 %{public}d OpenDevice=%{public}d", __LINE__,
2926 ret);
2927 ASSERT_EQ(ret, 0);
2928 ret = UsbSrvClient.OpenDevice(device, pipe);
2929 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer011 %{public}d OpenDevice again=%{public}d",
2930 __LINE__, ret);
2931 ASSERT_EQ(ret, 0);
2932 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
2933 USBEndpoint point = interface.GetEndpoints().front();
2934 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer011 %{public}d point=%{public}d", __LINE__,
2935 point.GetInterfaceId());
2936 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2937 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer011 %{public}d ClaimInterface=%{public}d",
2938 __LINE__, ret);
2939 ASSERT_EQ(ret, 0);
2940 bool close = UsbSrvClient.Close(pipe);
2941 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer011 %{public}d close=%{public}d", __LINE__,
2942 close);
2943 EXPECT_TRUE(close);
2944 uint8_t buffer[BUFFER_SIZE] = "bulk read";
2945 uint32_t len = BUFFER_SIZE;
2946 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
2947 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
2948 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer011 %{public}d BulkTransfer=%{public}d", __LINE__,
2949 ret);
2950 ASSERT_EQ(ret, 0);
2951 close = UsbSrvClient.Close(pipe);
2952 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer011 %{public}d close=%{public}d", __LINE__,
2953 close);
2954 EXPECT_TRUE(close);
2955 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer011 : BulkTransfer");
2956 }
2957
2958 /**
2959 * @tc.name: SetConfiguration001
2960 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
2961 * @tc.type: FUNC
2962 */
2963 HWTEST_F(UsbDevicePipeTest, SetConfiguration001, TestSize.Level1)
2964 {
2965 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetConfiguration001 : SetConfiguration");
2966 vector<UsbDevice> devi;
2967 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2968 auto ret = UsbSrvClient.GetDevices(devi);
2969 ASSERT_EQ(ret, 0);
2970 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d ret=%{public}d", __LINE__, ret);
2971 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2972 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d size=%{public}zu", __LINE__,
2973 devi.size());
2974 USBDevicePipe pipe;
2975 UsbDevice device = devi.front();
2976 UsbSrvClient.RequestRight(device.GetName());
2977 USBConfig config = device.GetConfigs().front();
2978 ret = UsbSrvClient.OpenDevice(device, pipe);
2979 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d OpenDevice=%{public}d", __LINE__,
2980 ret);
2981 ASSERT_EQ(ret, 0);
2982 ret = UsbSrvClient.SetConfiguration(pipe, config);
2983 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d SetConfiguration=%{public}d",
2984 __LINE__, ret);
2985 ASSERT_EQ(ret, 0);
2986 bool close = UsbSrvClient.Close(pipe);
2987 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d close=%{public}d", __LINE__,
2988 close);
2989 EXPECT_TRUE(close);
2990 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetConfiguration001 : SetConfiguration");
2991 }
2992
2993 /**
2994 * @tc.name: SetConfiguration002
2995 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
2996 * @tc.type: FUNC
2997 */
2998 HWTEST_F(UsbDevicePipeTest, SetConfiguration002, TestSize.Level1)
2999 {
3000 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetConfiguration002 : SetConfiguration");
3001 vector<UsbDevice> devi;
3002 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3003 auto ret = UsbSrvClient.GetDevices(devi);
3004 ASSERT_EQ(ret, 0);
3005 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d ret=%{public}d", __LINE__, ret);
3006 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3007 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d size=%{public}zu", __LINE__,
3008 devi.size());
3009 USBDevicePipe pipe;
3010 UsbDevice device = devi.front();
3011 UsbSrvClient.RequestRight(device.GetName());
3012 USBConfig config = device.GetConfigs().front();
3013 ret = UsbSrvClient.OpenDevice(device, pipe);
3014 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d OpenDevice=%{public}d", __LINE__,
3015 ret);
3016 ASSERT_EQ(ret, 0);
3017 pipe.SetBusNum(BUFFER_SIZE);
3018 ret = UsbSrvClient.SetConfiguration(pipe, config);
3019 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d SetConfiguration=%{public}d",
3020 __LINE__, ret);
3021 ASSERT_NE(ret, 0);
3022 pipe.SetBusNum(device.GetBusNum());
3023 bool close = UsbSrvClient.Close(pipe);
3024 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d close=%{public}d", __LINE__,
3025 close);
3026 EXPECT_TRUE(close);
3027 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetConfiguration002 : SetConfiguration");
3028 }
3029
3030 /**
3031 * @tc.name: SetConfiguration003
3032 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
3033 * @tc.type: FUNC
3034 */
3035 HWTEST_F(UsbDevicePipeTest, SetConfiguration003, TestSize.Level1)
3036 {
3037 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetConfiguration003 : SetConfiguration");
3038 vector<UsbDevice> devi;
3039 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3040 auto ret = UsbSrvClient.GetDevices(devi);
3041 ASSERT_EQ(ret, 0);
3042 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d ret=%{public}d", __LINE__, ret);
3043 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3044 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d size=%{public}zu", __LINE__,
3045 devi.size());
3046 USBDevicePipe pipe;
3047 UsbDevice device = devi.front();
3048 UsbSrvClient.RequestRight(device.GetName());
3049 USBConfig config = device.GetConfigs().front();
3050 ret = UsbSrvClient.OpenDevice(device, pipe);
3051 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d OpenDevice=%{public}d", __LINE__,
3052 ret);
3053 ASSERT_EQ(ret, 0);
3054 pipe.SetDevAddr(BUFFER_SIZE);
3055 ret = UsbSrvClient.SetConfiguration(pipe, config);
3056 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d SetConfiguration=%{public}d",
3057 __LINE__, ret);
3058 ASSERT_NE(ret, 0);
3059 pipe.SetDevAddr(device.GetDevAddr());
3060 bool close = UsbSrvClient.Close(pipe);
3061 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d close=%{public}d", __LINE__,
3062 close);
3063 EXPECT_TRUE(close);
3064
3065 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetConfiguration003 : SetConfiguration");
3066 }
3067
3068 /**
3069 * @tc.name: Close001
3070 * @tc.desc: Test functions to Close();
3071 * @tc.type: FUNC
3072 */
3073 HWTEST_F(UsbDevicePipeTest, Close001, TestSize.Level1)
3074 {
3075 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Close001 : Close");
3076 vector<UsbDevice> devi;
3077 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3078 auto ret = UsbSrvClient.GetDevices(devi);
3079 ASSERT_EQ(ret, 0);
3080 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d ret=%{public}d", __LINE__, ret);
3081 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3082 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d size=%{public}zu", __LINE__, devi.size());
3083 USBDevicePipe pipe;
3084 UsbDevice device = devi.front();
3085 UsbSrvClient.RequestRight(device.GetName());
3086 ret = UsbSrvClient.OpenDevice(device, pipe);
3087 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
3088 ASSERT_EQ(ret, 0);
3089 ret = UsbSrvClient.Close(pipe);
3090 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d close=%{public}d", __LINE__, ret);
3091 EXPECT_TRUE(ret);
3092 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Close001 : Close");
3093 }
3094
3095 /**
3096 * @tc.name: Close002
3097 * @tc.desc: Test functions to Close();
3098 * @tc.type: FUNC
3099 */
3100 HWTEST_F(UsbDevicePipeTest, Close002, TestSize.Level1)
3101 {
3102 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Close002 : Close");
3103 vector<UsbDevice> devi;
3104 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3105 auto ret = UsbSrvClient.GetDevices(devi);
3106 ASSERT_EQ(ret, 0);
3107 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d ret=%{public}d", __LINE__, ret);
3108 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3109 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d size=%{public}zu", __LINE__, devi.size());
3110 USBDevicePipe pipe;
3111 UsbDevice device = devi.front();
3112 UsbSrvClient.RequestRight(device.GetName());
3113 ret = UsbSrvClient.OpenDevice(device, pipe);
3114 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d OpenDevice=%{public}d", __LINE__, ret);
3115 ASSERT_EQ(ret, 0);
3116 pipe.SetBusNum(BUFFER_SIZE);
3117 ret = UsbSrvClient.Close(pipe);
3118 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d close=%{public}d", __LINE__, ret);
3119 EXPECT_TRUE(!ret);
3120 pipe.SetBusNum(device.GetBusNum());
3121 ret = UsbSrvClient.Close(pipe);
3122 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d close=%{public}d", __LINE__, ret);
3123 EXPECT_TRUE(ret);
3124 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Close002 : Close");
3125 }
3126
3127 /**
3128 * @tc.name: Close003
3129 * @tc.desc: Test functions to Close();
3130 * @tc.type: FUNC
3131 */
3132 HWTEST_F(UsbDevicePipeTest, Close003, TestSize.Level1)
3133 {
3134 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Close003 : Close");
3135 vector<UsbDevice> devi;
3136 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3137 auto ret = UsbSrvClient.GetDevices(devi);
3138 ASSERT_EQ(ret, 0);
3139 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d ret=%{public}d", __LINE__, ret);
3140 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3141 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d size=%{public}zu", __LINE__, devi.size());
3142 USBDevicePipe pipe;
3143 UsbDevice device = devi.front();
3144 UsbSrvClient.RequestRight(device.GetName());
3145 ret = UsbSrvClient.OpenDevice(device, pipe);
3146 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d OpenDevice=%{public}d", __LINE__, ret);
3147 ASSERT_EQ(ret, 0);
3148 pipe.SetDevAddr(BUFFER_SIZE);
3149 ret = UsbSrvClient.Close(pipe);
3150 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d close=%{public}d", __LINE__, ret);
3151 EXPECT_TRUE(!ret);
3152 pipe.SetDevAddr(device.GetDevAddr());
3153 ret = UsbSrvClient.Close(pipe);
3154 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d close=%{public}d", __LINE__, ret);
3155 EXPECT_TRUE(ret);
3156 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Close003 : Close");
3157 }
3158
3159 /**
3160 * @tc.name: SetInterface001
3161 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3162 * @tc.type: FUNC
3163 */
3164 HWTEST_F(UsbDevicePipeTest, SetInterface001, TestSize.Level1)
3165 {
3166 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface001 : SetInterface");
3167 vector<UsbDevice> devi;
3168 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3169 auto ret = UsbSrvClient.GetDevices(devi);
3170 ASSERT_EQ(ret, 0);
3171 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d ret=%{public}d", __LINE__, ret);
3172 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3173 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d size=%{public}zu", __LINE__,
3174 devi.size());
3175 USBDevicePipe pipe;
3176 UsbDevice device = devi.front();
3177 UsbSrvClient.RequestRight(device.GetName());
3178 ret = UsbSrvClient.OpenDevice(device, pipe);
3179 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d OpenDevice=%{public}d", __LINE__,
3180 ret);
3181 ASSERT_EQ(ret, 0);
3182 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
3183 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3184 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d ClaimInterface=%{public}d", __LINE__,
3185 ret);
3186 ASSERT_EQ(ret, 0);
3187 ret = UsbSrvClient.SetInterface(pipe, interface);
3188 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d SetInterface=%{public}d", __LINE__,
3189 ret);
3190 ASSERT_EQ(ret, 0);
3191 bool close = UsbSrvClient.Close(pipe);
3192 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d close=%{public}d", __LINE__, close);
3193 EXPECT_TRUE(close);
3194 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface001 : SetInterface");
3195 }
3196
3197 /**
3198 * @tc.name: SetInterface002
3199 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3200 * @tc.type: FUNC
3201 */
3202 HWTEST_F(UsbDevicePipeTest, SetInterface002, TestSize.Level1)
3203 {
3204 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface002 : SetInterface");
3205 vector<UsbDevice> devi;
3206 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3207 auto ret = UsbSrvClient.GetDevices(devi);
3208 ASSERT_EQ(ret, 0);
3209 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d ret=%{public}d", __LINE__, ret);
3210 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3211 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d size=%{public}zu", __LINE__,
3212 devi.size());
3213 USBDevicePipe pipe;
3214 UsbDevice device = devi.front();
3215 UsbSrvClient.RequestRight(device.GetName());
3216 ret = UsbSrvClient.OpenDevice(device, pipe);
3217 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d OpenDevice=%{public}d", __LINE__,
3218 ret);
3219 ASSERT_EQ(ret, 0);
3220 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
3221 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3222 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d ClaimInterface=%{public}d", __LINE__,
3223 ret);
3224 ASSERT_EQ(ret, 0);
3225 pipe.SetBusNum(BUFFER_SIZE);
3226 ret = UsbSrvClient.SetInterface(pipe, interface);
3227 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d SetInterface=%{public}d", __LINE__,
3228 ret);
3229 ASSERT_NE(ret, 0);
3230 pipe.SetBusNum(device.GetBusNum());
3231 bool close = UsbSrvClient.Close(pipe);
3232 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d close=%{public}d", __LINE__, close);
3233 EXPECT_TRUE(close);
3234 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface002 : SetInterface");
3235 }
3236
3237 /**
3238 * @tc.name: SetInterface003
3239 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3240 * @tc.type: FUNC
3241 */
3242 HWTEST_F(UsbDevicePipeTest, SetInterface003, TestSize.Level1)
3243 {
3244 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface003 : SetInterface");
3245 vector<UsbDevice> devi;
3246 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3247 auto ret = UsbSrvClient.GetDevices(devi);
3248 ASSERT_EQ(ret, 0);
3249 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d ret=%{public}d", __LINE__, ret);
3250 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3251 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d size=%{public}zu", __LINE__,
3252 devi.size());
3253 USBDevicePipe pipe;
3254 UsbDevice device = devi.front();
3255 UsbSrvClient.RequestRight(device.GetName());
3256 ret = UsbSrvClient.OpenDevice(device, pipe);
3257 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d OpenDevice=%{public}d", __LINE__,
3258 ret);
3259 ASSERT_EQ(ret, 0);
3260 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
3261 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3262 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d ClaimInterface=%{public}d", __LINE__,
3263 ret);
3264 ASSERT_EQ(ret, 0);
3265 pipe.SetDevAddr(BUFFER_SIZE);
3266 ret = UsbSrvClient.SetInterface(pipe, interface);
3267 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d SetInterface=%{public}d", __LINE__,
3268 ret);
3269 ASSERT_NE(ret, 0);
3270 pipe.SetDevAddr(device.GetDevAddr());
3271 bool close = UsbSrvClient.Close(pipe);
3272 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d close=%{public}d", __LINE__, close);
3273 EXPECT_TRUE(close);
3274 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface003 : SetInterface");
3275 }
3276
3277 /**
3278 * @tc.name: SetInterface004
3279 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3280 * @tc.type: FUNC
3281 */
3282 HWTEST_F(UsbDevicePipeTest, SetInterface004, TestSize.Level1)
3283 {
3284 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface004 : SetInterface");
3285 vector<UsbDevice> devi;
3286 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3287 auto ret = UsbSrvClient.GetDevices(devi);
3288 ASSERT_EQ(ret, 0);
3289 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d ret=%{public}d", __LINE__, ret);
3290 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3291 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d size=%{public}zu", __LINE__,
3292 devi.size());
3293 USBDevicePipe pipe;
3294 UsbDevice device = devi.front();
3295 UsbSrvClient.RequestRight(device.GetName());
3296 ret = UsbSrvClient.OpenDevice(device, pipe);
3297 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d OpenDevice=%{public}d", __LINE__,
3298 ret);
3299 ASSERT_EQ(ret, 0);
3300 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
3301 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3302 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d ClaimInterface=%{public}d", __LINE__,
3303 ret);
3304 ASSERT_EQ(ret, 0);
3305 ret = UsbSrvClient.SetInterface(pipe, interface);
3306 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d SetInterface=%{public}d", __LINE__,
3307 ret);
3308 ASSERT_EQ(ret, 0);
3309 bool close = UsbSrvClient.Close(pipe);
3310 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d close=%{public}d", __LINE__, close);
3311 EXPECT_TRUE(close);
3312 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface004 : SetInterface");
3313 }
3314
3315 /**
3316 * @tc.name: SetInterface005
3317 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3318 * @tc.type: FUNC
3319 */
3320 HWTEST_F(UsbDevicePipeTest, SetInterface005, TestSize.Level1)
3321 {
3322 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface005 : SetInterface");
3323 vector<UsbDevice> devi;
3324 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3325 auto ret = UsbSrvClient.GetDevices(devi);
3326 ASSERT_EQ(ret, 0);
3327 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d ret=%{public}d", __LINE__, ret);
3328 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3329 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d size=%{public}zu", __LINE__,
3330 devi.size());
3331 USBDevicePipe pipe;
3332 UsbDevice device = devi.front();
3333 UsbSrvClient.RequestRight(device.GetName());
3334 ret = UsbSrvClient.OpenDevice(device, pipe);
3335 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d OpenDevice=%{public}d", __LINE__,
3336 ret);
3337 ASSERT_EQ(ret, 0);
3338 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
3339 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3340 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d ClaimInterface=%{public}d", __LINE__,
3341 ret);
3342 ASSERT_EQ(ret, 0);
3343 pipe.SetBusNum(BUFFER_SIZE);
3344 ret = UsbSrvClient.SetInterface(pipe, interface);
3345 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d SetInterface=%{public}d", __LINE__,
3346 ret);
3347 ASSERT_NE(ret, 0);
3348 pipe.SetBusNum(device.GetBusNum());
3349 bool close = UsbSrvClient.Close(pipe);
3350 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d close=%{public}d", __LINE__, close);
3351 EXPECT_TRUE(close);
3352 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface005 : SetInterface");
3353 }
3354
3355 /**
3356 * @tc.name: SetInterface006
3357 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3358 * @tc.type: FUNC
3359 */
3360 HWTEST_F(UsbDevicePipeTest, SetInterface006, TestSize.Level1)
3361 {
3362 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface006 : SetInterface");
3363 vector<UsbDevice> devi;
3364 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3365 auto ret = UsbSrvClient.GetDevices(devi);
3366 ASSERT_EQ(ret, 0);
3367 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d ret=%{public}d", __LINE__, ret);
3368 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3369 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d size=%{public}zu", __LINE__,
3370 devi.size());
3371 USBDevicePipe pipe;
3372 UsbDevice device = devi.front();
3373 UsbSrvClient.RequestRight(device.GetName());
3374 ret = UsbSrvClient.OpenDevice(device, pipe);
3375 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d OpenDevice=%{public}d", __LINE__,
3376 ret);
3377 ASSERT_EQ(ret, 0);
3378 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
3379 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3380 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d ClaimInterface=%{public}d", __LINE__,
3381 ret);
3382 ASSERT_EQ(ret, 0);
3383 pipe.SetDevAddr(BUFFER_SIZE);
3384 ret = UsbSrvClient.SetInterface(pipe, interface);
3385 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d SetInterface=%{public}d", __LINE__,
3386 ret);
3387 ASSERT_NE(ret, 0);
3388 pipe.SetDevAddr(device.GetDevAddr());
3389 bool close = UsbSrvClient.Close(pipe);
3390 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d close=%{public}d", __LINE__, close);
3391 EXPECT_TRUE(close);
3392 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface006 : SetInterface");
3393 }
3394
3395 /**
3396 * @tc.name: GetRawDescriptors001
3397 * @tc.desc: Test functions to GetRawDescriptors
3398 * @tc.type: FUNC
3399 */
3400 HWTEST_F(UsbDevicePipeTest, GetRawDescriptors001, TestSize.Level1)
3401 {
3402 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetRawDescriptors001 : GetRawDescriptors");
3403 vector<UsbDevice> devi;
3404 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3405 auto ret = UsbSrvClient.GetDevices(devi);
3406 ASSERT_EQ(ret, 0);
3407 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d ret=%{public}d", __LINE__, ret);
3408 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3409 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d size=%{public}zu", __LINE__,
3410 devi.size());
3411 USBDevicePipe pipe;
3412 UsbDevice device = devi.front();
3413 UsbSrvClient.RequestRight(device.GetName());
3414 ret = UsbSrvClient.OpenDevice(device, pipe);
3415 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d OpenDevice=%{public}d",
3416 __LINE__, ret);
3417 ASSERT_EQ(ret, 0);
3418 std::vector<uint8_t> vData;
3419 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
3420 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d GetRawDescriptors=%{public}d",
3421 __LINE__, ret);
3422 ASSERT_EQ(ret, 0);
3423 ret = UsbSrvClient.Close(pipe);
3424 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3425 EXPECT_TRUE(ret);
3426 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetRawDescriptors001 : ControlTransfer");
3427 }
3428
3429 /**
3430 * @tc.name: GetRawDescriptors002
3431 * @tc.desc: Test functions to GetRawDescriptors
3432 * @tc.type: FUNC
3433 */
3434 HWTEST_F(UsbDevicePipeTest, GetRawDescriptors002, TestSize.Level1)
3435 {
3436 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetRawDescriptors002 : GetRawDescriptors");
3437 vector<UsbDevice> devi;
3438 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3439 auto ret = UsbSrvClient.GetDevices(devi);
3440 ASSERT_EQ(ret, 0);
3441 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d ret=%{public}d", __LINE__, ret);
3442 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3443 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d size=%{public}zu", __LINE__,
3444 devi.size());
3445 USBDevicePipe pipe;
3446 UsbDevice device = devi.front();
3447 UsbSrvClient.RequestRight(device.GetName());
3448 ret = UsbSrvClient.OpenDevice(device, pipe);
3449 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d OpenDevice=%{public}d",
3450 __LINE__, ret);
3451 ASSERT_EQ(ret, 0);
3452 std::vector<uint8_t> vData;
3453 USBDevicePipe pipeTmp = pipe;
3454 pipeTmp.SetBusNum(BUFFER_SIZE);
3455 ret = UsbSrvClient.GetRawDescriptors(pipeTmp, vData);
3456 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d GetRawDescriptors=%{public}d",
3457 __LINE__, ret);
3458 ASSERT_NE(ret, 0);
3459 ret = UsbSrvClient.Close(pipe);
3460 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3461 EXPECT_TRUE(ret);
3462 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetRawDescriptors002 : ControlTransfer");
3463 }
3464
3465 /**
3466 * @tc.name: GetRawDescriptors003
3467 * @tc.desc: Test functions to GetRawDescriptors
3468 * @tc.type: FUNC
3469 */
3470 HWTEST_F(UsbDevicePipeTest, GetRawDescriptors003, TestSize.Level1)
3471 {
3472 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetRawDescriptors003 : GetRawDescriptors");
3473 vector<UsbDevice> devi;
3474 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3475 auto ret = UsbSrvClient.GetDevices(devi);
3476 ASSERT_EQ(ret, 0);
3477 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d ret=%{public}d", __LINE__, ret);
3478 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3479 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d size=%{public}zu", __LINE__,
3480 devi.size());
3481 USBDevicePipe pipe;
3482 UsbDevice device = devi.front();
3483 UsbSrvClient.RequestRight(device.GetName());
3484 ret = UsbSrvClient.OpenDevice(device, pipe);
3485 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d OpenDevice=%{public}d",
3486 __LINE__, ret);
3487 ASSERT_EQ(ret, 0);
3488 std::vector<uint8_t> vData;
3489 USBDevicePipe pipeTmp = pipe;
3490 pipeTmp.SetDevAddr(BUFFER_SIZE);
3491 ret = UsbSrvClient.GetRawDescriptors(pipeTmp, vData);
3492 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d GetRawDescriptors=%{public}d",
3493 __LINE__, ret);
3494 ASSERT_NE(ret, 0);
3495 ret = UsbSrvClient.Close(pipe);
3496 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3497 EXPECT_TRUE(ret);
3498 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetRawDescriptors003 : ControlTransfer");
3499 }
3500
3501 /**
3502 * @tc.name: GetFileDescriptors001
3503 * @tc.desc: Test functions to GetRawDescriptors
3504 * @tc.type: FUNC
3505 */
3506 HWTEST_F(UsbDevicePipeTest, GetFileDescriptors001, TestSize.Level1)
3507 {
3508 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetFileDescriptors001 : GetRawDescriptors");
3509 vector<UsbDevice> devi;
3510 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3511 auto ret = UsbSrvClient.GetDevices(devi);
3512 ASSERT_EQ(ret, 0);
3513 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d ret=%{public}d", __LINE__, ret);
3514 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3515 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d size=%{public}zu", __LINE__,
3516 devi.size());
3517 USBDevicePipe pipe;
3518 UsbDevice device = devi.front();
3519 UsbSrvClient.RequestRight(device.GetName());
3520 ret = UsbSrvClient.OpenDevice(device, pipe);
3521 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d OpenDevice=%{public}d",
3522 __LINE__, ret);
3523 ASSERT_EQ(ret, 0);
3524 std::vector<uint8_t> vData;
3525 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
3526 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d GetRawDescriptors=%{public}d",
3527 __LINE__, ret);
3528 ASSERT_EQ(ret, 0);
3529 int32_t fd = 0;
3530 ret = UsbSrvClient.GetFileDescriptor(pipe, fd);
3531 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d GetFileDescriptor=%{public}d",
3532 __LINE__, ret);
3533 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d fd=%{public}d",
3534 __LINE__, fd);
3535 ASSERT_EQ(ret, 0);
3536 ret = ioctl(fd, USBDEVFS_GET_SPEED, NULL);
3537 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptor001 %{public}d fd=%{public}d ret=%{public}d",
3538 __LINE__, fd, ret);
3539 EXPECT_GE(ret, 0);
3540 ret = UsbSrvClient.Close(pipe);
3541 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3542 EXPECT_TRUE(ret);
3543 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetFileDescriptors001 : ControlTransfer");
3544 }
3545
3546 /**
3547 * @tc.name: GetFileDescriptors002
3548 * @tc.desc: Test functions to GetRawDescriptors
3549 * @tc.type: FUNC
3550 */
3551 HWTEST_F(UsbDevicePipeTest, GetFileDescriptors002, TestSize.Level1)
3552 {
3553 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetFileDescriptors002 : GetRawDescriptors");
3554 vector<UsbDevice> devi;
3555 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3556 auto ret = UsbSrvClient.GetDevices(devi);
3557 ASSERT_EQ(ret, 0);
3558 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d ret=%{public}d", __LINE__, ret);
3559 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3560 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d size=%{public}zu", __LINE__,
3561 devi.size());
3562 USBDevicePipe pipe;
3563 UsbDevice device = devi.front();
3564 UsbSrvClient.RequestRight(device.GetName());
3565 ret = UsbSrvClient.OpenDevice(device, pipe);
3566 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d OpenDevice=%{public}d",
3567 __LINE__, ret);
3568 ASSERT_EQ(ret, 0);
3569 std::vector<uint8_t> vData;
3570 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
3571 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d GetRawDescriptors=%{public}d",
3572 __LINE__, ret);
3573 ASSERT_EQ(ret, 0);
3574 USBDevicePipe pipeTmp = pipe;
3575 pipeTmp.SetBusNum(BUFFER_SIZE);
3576 int32_t fd = 0;
3577 ret = UsbSrvClient.GetFileDescriptor(pipeTmp, fd);
3578 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d GetFileDescriptor=%{public}d",
3579 __LINE__, ret);
3580 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d fd=%{public}d",
3581 __LINE__, fd);
3582 ASSERT_NE(ret, 0);
3583 ret = UsbSrvClient.Close(pipe);
3584 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3585 EXPECT_TRUE(ret);
3586 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetFileDescriptors002 : ControlTransfer");
3587 }
3588
3589 /**
3590 * @tc.name: GetFileDescriptors003
3591 * @tc.desc: Test functions to GetRawDescriptors
3592 * @tc.type: FUNC
3593 */
3594 HWTEST_F(UsbDevicePipeTest, GetFileDescriptors003, TestSize.Level1)
3595 {
3596 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetFileDescriptors003 : GetRawDescriptors");
3597 vector<UsbDevice> devi;
3598 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3599 auto ret = UsbSrvClient.GetDevices(devi);
3600 ASSERT_EQ(ret, 0);
3601 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d ret=%{public}d", __LINE__, ret);
3602 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3603 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d size=%{public}zu", __LINE__,
3604 devi.size());
3605 USBDevicePipe pipe;
3606 UsbDevice device = devi.front();
3607 UsbSrvClient.RequestRight(device.GetName());
3608 ret = UsbSrvClient.OpenDevice(device, pipe);
3609 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d OpenDevice=%{public}d",
3610 __LINE__, ret);
3611 ASSERT_EQ(ret, 0);
3612 std::vector<uint8_t> vData;
3613 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
3614 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d GetRawDescriptors=%{public}d",
3615 __LINE__, ret);
3616 ASSERT_EQ(ret, 0);
3617 USBDevicePipe pipeTmp = pipe;
3618 pipeTmp.SetDevAddr(BUFFER_SIZE);
3619 int32_t fd = 0;
3620 ret = UsbSrvClient.GetFileDescriptor(pipeTmp, fd);
3621 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d GetFileDescriptor=%{public}d",
3622 __LINE__, ret);
3623 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d fd=%{public}d",
3624 __LINE__, fd);
3625 ASSERT_NE(ret, 0);
3626 ret = UsbSrvClient.Close(pipe);
3627 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3628 EXPECT_TRUE(ret);
3629 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetFileDescriptors003 : ControlTransfer");
3630 }
3631 } // DevicePipe
3632 } // USB
3633 } // OHOS
3634