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_1;
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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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: SetConfiguration001
2906 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
2907 * @tc.type: FUNC
2908 */
2909 HWTEST_F(UsbDevicePipeTest, SetConfiguration001, TestSize.Level1)
2910 {
2911 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetConfiguration001 : SetConfiguration");
2912 vector<UsbDevice> devi;
2913 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2914 auto ret = UsbSrvClient.GetDevices(devi);
2915 EXPECT_TRUE(ret == 0);
2916 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d ret=%{public}d", __LINE__, ret);
2917 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2918 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d size=%{public}zu", __LINE__,
2919 devi.size());
2920 USBDevicePipe pipe;
2921 UsbDevice device = devi.front();
2922 UsbSrvClient.RequestRight(device.GetName());
2923 USBConfig config = device.GetConfigs().front();
2924 ret = UsbSrvClient.OpenDevice(device, pipe);
2925 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d OpenDevice=%{public}d", __LINE__,
2926 ret);
2927 EXPECT_TRUE(ret == 0);
2928 ret = UsbSrvClient.SetConfiguration(pipe, config);
2929 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d SetConfiguration=%{public}d",
2930 __LINE__, ret);
2931 EXPECT_TRUE(ret == 0);
2932 bool close = UsbSrvClient.Close(pipe);
2933 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d close=%{public}d", __LINE__,
2934 close);
2935 EXPECT_TRUE(close);
2936 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetConfiguration001 : SetConfiguration");
2937 }
2938
2939 /**
2940 * @tc.name: SetConfiguration002
2941 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
2942 * @tc.type: FUNC
2943 */
2944 HWTEST_F(UsbDevicePipeTest, SetConfiguration002, TestSize.Level1)
2945 {
2946 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetConfiguration002 : SetConfiguration");
2947 vector<UsbDevice> devi;
2948 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2949 auto ret = UsbSrvClient.GetDevices(devi);
2950 EXPECT_TRUE(ret == 0);
2951 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d ret=%{public}d", __LINE__, ret);
2952 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2953 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d size=%{public}zu", __LINE__,
2954 devi.size());
2955 USBDevicePipe pipe;
2956 UsbDevice device = devi.front();
2957 UsbSrvClient.RequestRight(device.GetName());
2958 USBConfig config = device.GetConfigs().front();
2959 ret = UsbSrvClient.OpenDevice(device, pipe);
2960 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d OpenDevice=%{public}d", __LINE__,
2961 ret);
2962 EXPECT_TRUE(ret == 0);
2963 pipe.SetBusNum(BUFFER_SIZE);
2964 ret = UsbSrvClient.SetConfiguration(pipe, config);
2965 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d SetConfiguration=%{public}d",
2966 __LINE__, ret);
2967 EXPECT_TRUE(ret != 0);
2968 pipe.SetBusNum(device.GetBusNum());
2969 bool close = UsbSrvClient.Close(pipe);
2970 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d close=%{public}d", __LINE__,
2971 close);
2972 EXPECT_TRUE(close);
2973 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetConfiguration002 : SetConfiguration");
2974 }
2975
2976 /**
2977 * @tc.name: SetConfiguration003
2978 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
2979 * @tc.type: FUNC
2980 */
2981 HWTEST_F(UsbDevicePipeTest, SetConfiguration003, TestSize.Level1)
2982 {
2983 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetConfiguration003 : SetConfiguration");
2984 vector<UsbDevice> devi;
2985 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2986 auto ret = UsbSrvClient.GetDevices(devi);
2987 EXPECT_TRUE(ret == 0);
2988 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d ret=%{public}d", __LINE__, ret);
2989 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2990 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d size=%{public}zu", __LINE__,
2991 devi.size());
2992 USBDevicePipe pipe;
2993 UsbDevice device = devi.front();
2994 UsbSrvClient.RequestRight(device.GetName());
2995 USBConfig config = device.GetConfigs().front();
2996 ret = UsbSrvClient.OpenDevice(device, pipe);
2997 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d OpenDevice=%{public}d", __LINE__,
2998 ret);
2999 EXPECT_TRUE(ret == 0);
3000 pipe.SetDevAddr(BUFFER_SIZE);
3001 ret = UsbSrvClient.SetConfiguration(pipe, config);
3002 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d SetConfiguration=%{public}d",
3003 __LINE__, ret);
3004 EXPECT_TRUE(ret != 0);
3005 pipe.SetDevAddr(device.GetDevAddr());
3006 bool close = UsbSrvClient.Close(pipe);
3007 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d close=%{public}d", __LINE__,
3008 close);
3009 EXPECT_TRUE(close);
3010
3011 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetConfiguration003 : SetConfiguration");
3012 }
3013
3014 /**
3015 * @tc.name: Close001
3016 * @tc.desc: Test functions to Close();
3017 * @tc.type: FUNC
3018 */
3019 HWTEST_F(UsbDevicePipeTest, Close001, TestSize.Level1)
3020 {
3021 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Close001 : Close");
3022 vector<UsbDevice> devi;
3023 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3024 auto ret = UsbSrvClient.GetDevices(devi);
3025 EXPECT_TRUE(ret == 0);
3026 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d ret=%{public}d", __LINE__, ret);
3027 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3028 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d size=%{public}zu", __LINE__, devi.size());
3029 USBDevicePipe pipe;
3030 UsbDevice device = devi.front();
3031 UsbSrvClient.RequestRight(device.GetName());
3032 ret = UsbSrvClient.OpenDevice(device, pipe);
3033 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
3034 EXPECT_TRUE(ret == 0);
3035 ret = UsbSrvClient.Close(pipe);
3036 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d close=%{public}d", __LINE__, ret);
3037 EXPECT_TRUE(ret);
3038 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Close001 : Close");
3039 }
3040
3041 /**
3042 * @tc.name: Close002
3043 * @tc.desc: Test functions to Close();
3044 * @tc.type: FUNC
3045 */
3046 HWTEST_F(UsbDevicePipeTest, Close002, TestSize.Level1)
3047 {
3048 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Close002 : Close");
3049 vector<UsbDevice> devi;
3050 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3051 auto ret = UsbSrvClient.GetDevices(devi);
3052 EXPECT_TRUE(ret == 0);
3053 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d ret=%{public}d", __LINE__, ret);
3054 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3055 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d size=%{public}zu", __LINE__, devi.size());
3056 USBDevicePipe pipe;
3057 UsbDevice device = devi.front();
3058 UsbSrvClient.RequestRight(device.GetName());
3059 ret = UsbSrvClient.OpenDevice(device, pipe);
3060 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d OpenDevice=%{public}d", __LINE__, ret);
3061 EXPECT_TRUE(ret == 0);
3062 pipe.SetBusNum(BUFFER_SIZE);
3063 ret = UsbSrvClient.Close(pipe);
3064 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d close=%{public}d", __LINE__, ret);
3065 EXPECT_TRUE(!ret);
3066 pipe.SetBusNum(device.GetBusNum());
3067 ret = UsbSrvClient.Close(pipe);
3068 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d close=%{public}d", __LINE__, ret);
3069 EXPECT_TRUE(ret);
3070 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Close002 : Close");
3071 }
3072
3073 /**
3074 * @tc.name: Close003
3075 * @tc.desc: Test functions to Close();
3076 * @tc.type: FUNC
3077 */
3078 HWTEST_F(UsbDevicePipeTest, Close003, TestSize.Level1)
3079 {
3080 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Close003 : Close");
3081 vector<UsbDevice> devi;
3082 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3083 auto ret = UsbSrvClient.GetDevices(devi);
3084 EXPECT_TRUE(ret == 0);
3085 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d ret=%{public}d", __LINE__, ret);
3086 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3087 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d size=%{public}zu", __LINE__, devi.size());
3088 USBDevicePipe pipe;
3089 UsbDevice device = devi.front();
3090 UsbSrvClient.RequestRight(device.GetName());
3091 ret = UsbSrvClient.OpenDevice(device, pipe);
3092 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d OpenDevice=%{public}d", __LINE__, ret);
3093 EXPECT_TRUE(ret == 0);
3094 pipe.SetDevAddr(BUFFER_SIZE);
3095 ret = UsbSrvClient.Close(pipe);
3096 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d close=%{public}d", __LINE__, ret);
3097 EXPECT_TRUE(!ret);
3098 pipe.SetDevAddr(device.GetDevAddr());
3099 ret = UsbSrvClient.Close(pipe);
3100 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d close=%{public}d", __LINE__, ret);
3101 EXPECT_TRUE(ret);
3102 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Close003 : Close");
3103 }
3104
3105 /**
3106 * @tc.name: SetInterface001
3107 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3108 * @tc.type: FUNC
3109 */
3110 HWTEST_F(UsbDevicePipeTest, SetInterface001, TestSize.Level1)
3111 {
3112 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface001 : SetInterface");
3113 vector<UsbDevice> devi;
3114 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3115 auto ret = UsbSrvClient.GetDevices(devi);
3116 EXPECT_TRUE(ret == 0);
3117 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d ret=%{public}d", __LINE__, ret);
3118 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3119 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d size=%{public}zu", __LINE__,
3120 devi.size());
3121 USBDevicePipe pipe;
3122 UsbDevice device = devi.front();
3123 UsbSrvClient.RequestRight(device.GetName());
3124 ret = UsbSrvClient.OpenDevice(device, pipe);
3125 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d OpenDevice=%{public}d", __LINE__,
3126 ret);
3127 EXPECT_TRUE(ret == 0);
3128 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
3129 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3130 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d ClaimInterface=%{public}d", __LINE__,
3131 ret);
3132 EXPECT_TRUE(ret == 0);
3133 ret = UsbSrvClient.SetInterface(pipe, interface);
3134 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d SetInterface=%{public}d", __LINE__,
3135 ret);
3136 EXPECT_TRUE(ret == 0);
3137 bool close = UsbSrvClient.Close(pipe);
3138 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d close=%{public}d", __LINE__, close);
3139 EXPECT_TRUE(close);
3140 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface001 : SetInterface");
3141 }
3142
3143 /**
3144 * @tc.name: SetInterface002
3145 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3146 * @tc.type: FUNC
3147 */
3148 HWTEST_F(UsbDevicePipeTest, SetInterface002, TestSize.Level1)
3149 {
3150 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface002 : SetInterface");
3151 vector<UsbDevice> devi;
3152 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3153 auto ret = UsbSrvClient.GetDevices(devi);
3154 EXPECT_TRUE(ret == 0);
3155 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d ret=%{public}d", __LINE__, ret);
3156 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3157 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d size=%{public}zu", __LINE__,
3158 devi.size());
3159 USBDevicePipe pipe;
3160 UsbDevice device = devi.front();
3161 UsbSrvClient.RequestRight(device.GetName());
3162 ret = UsbSrvClient.OpenDevice(device, pipe);
3163 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d OpenDevice=%{public}d", __LINE__,
3164 ret);
3165 EXPECT_TRUE(ret == 0);
3166 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
3167 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3168 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d ClaimInterface=%{public}d", __LINE__,
3169 ret);
3170 EXPECT_TRUE(ret == 0);
3171 pipe.SetBusNum(BUFFER_SIZE);
3172 ret = UsbSrvClient.SetInterface(pipe, interface);
3173 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d SetInterface=%{public}d", __LINE__,
3174 ret);
3175 EXPECT_TRUE(ret != 0);
3176 pipe.SetBusNum(device.GetBusNum());
3177 bool close = UsbSrvClient.Close(pipe);
3178 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d close=%{public}d", __LINE__, close);
3179 EXPECT_TRUE(close);
3180 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface002 : SetInterface");
3181 }
3182
3183 /**
3184 * @tc.name: SetInterface003
3185 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3186 * @tc.type: FUNC
3187 */
3188 HWTEST_F(UsbDevicePipeTest, SetInterface003, TestSize.Level1)
3189 {
3190 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface003 : SetInterface");
3191 vector<UsbDevice> devi;
3192 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3193 auto ret = UsbSrvClient.GetDevices(devi);
3194 EXPECT_TRUE(ret == 0);
3195 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d ret=%{public}d", __LINE__, ret);
3196 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3197 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d size=%{public}zu", __LINE__,
3198 devi.size());
3199 USBDevicePipe pipe;
3200 UsbDevice device = devi.front();
3201 UsbSrvClient.RequestRight(device.GetName());
3202 ret = UsbSrvClient.OpenDevice(device, pipe);
3203 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d OpenDevice=%{public}d", __LINE__,
3204 ret);
3205 EXPECT_TRUE(ret == 0);
3206 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
3207 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3208 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d ClaimInterface=%{public}d", __LINE__,
3209 ret);
3210 EXPECT_TRUE(ret == 0);
3211 pipe.SetDevAddr(BUFFER_SIZE);
3212 ret = UsbSrvClient.SetInterface(pipe, interface);
3213 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d SetInterface=%{public}d", __LINE__,
3214 ret);
3215 EXPECT_TRUE(ret != 0);
3216 pipe.SetDevAddr(device.GetDevAddr());
3217 bool close = UsbSrvClient.Close(pipe);
3218 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d close=%{public}d", __LINE__, close);
3219 EXPECT_TRUE(close);
3220 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface003 : SetInterface");
3221 }
3222
3223 /**
3224 * @tc.name: SetInterface004
3225 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3226 * @tc.type: FUNC
3227 */
3228 HWTEST_F(UsbDevicePipeTest, SetInterface004, TestSize.Level1)
3229 {
3230 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface004 : SetInterface");
3231 vector<UsbDevice> devi;
3232 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3233 auto ret = UsbSrvClient.GetDevices(devi);
3234 EXPECT_TRUE(ret == 0);
3235 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d ret=%{public}d", __LINE__, ret);
3236 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3237 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d size=%{public}zu", __LINE__,
3238 devi.size());
3239 USBDevicePipe pipe;
3240 UsbDevice device = devi.front();
3241 UsbSrvClient.RequestRight(device.GetName());
3242 ret = UsbSrvClient.OpenDevice(device, pipe);
3243 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d OpenDevice=%{public}d", __LINE__,
3244 ret);
3245 EXPECT_TRUE(ret == 0);
3246 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
3247 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3248 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d ClaimInterface=%{public}d", __LINE__,
3249 ret);
3250 EXPECT_TRUE(ret == 0);
3251 ret = UsbSrvClient.SetInterface(pipe, interface);
3252 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d SetInterface=%{public}d", __LINE__,
3253 ret);
3254 EXPECT_TRUE(ret == 0);
3255 bool close = UsbSrvClient.Close(pipe);
3256 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d close=%{public}d", __LINE__, close);
3257 EXPECT_TRUE(close);
3258 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface004 : SetInterface");
3259 }
3260
3261 /**
3262 * @tc.name: SetInterface005
3263 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3264 * @tc.type: FUNC
3265 */
3266 HWTEST_F(UsbDevicePipeTest, SetInterface005, TestSize.Level1)
3267 {
3268 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface005 : SetInterface");
3269 vector<UsbDevice> devi;
3270 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3271 auto ret = UsbSrvClient.GetDevices(devi);
3272 EXPECT_TRUE(ret == 0);
3273 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d ret=%{public}d", __LINE__, ret);
3274 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3275 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d size=%{public}zu", __LINE__,
3276 devi.size());
3277 USBDevicePipe pipe;
3278 UsbDevice device = devi.front();
3279 UsbSrvClient.RequestRight(device.GetName());
3280 ret = UsbSrvClient.OpenDevice(device, pipe);
3281 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d OpenDevice=%{public}d", __LINE__,
3282 ret);
3283 EXPECT_TRUE(ret == 0);
3284 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
3285 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3286 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d ClaimInterface=%{public}d", __LINE__,
3287 ret);
3288 EXPECT_TRUE(ret == 0);
3289 pipe.SetBusNum(BUFFER_SIZE);
3290 ret = UsbSrvClient.SetInterface(pipe, interface);
3291 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d SetInterface=%{public}d", __LINE__,
3292 ret);
3293 EXPECT_TRUE(ret != 0);
3294 pipe.SetBusNum(device.GetBusNum());
3295 bool close = UsbSrvClient.Close(pipe);
3296 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d close=%{public}d", __LINE__, close);
3297 EXPECT_TRUE(close);
3298 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface005 : SetInterface");
3299 }
3300
3301 /**
3302 * @tc.name: SetInterface006
3303 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
3304 * @tc.type: FUNC
3305 */
3306 HWTEST_F(UsbDevicePipeTest, SetInterface006, TestSize.Level1)
3307 {
3308 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface006 : SetInterface");
3309 vector<UsbDevice> devi;
3310 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3311 auto ret = UsbSrvClient.GetDevices(devi);
3312 EXPECT_TRUE(ret == 0);
3313 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d ret=%{public}d", __LINE__, ret);
3314 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3315 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d size=%{public}zu", __LINE__,
3316 devi.size());
3317 USBDevicePipe pipe;
3318 UsbDevice device = devi.front();
3319 UsbSrvClient.RequestRight(device.GetName());
3320 ret = UsbSrvClient.OpenDevice(device, pipe);
3321 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d OpenDevice=%{public}d", __LINE__,
3322 ret);
3323 EXPECT_TRUE(ret == 0);
3324 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
3325 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
3326 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d ClaimInterface=%{public}d", __LINE__,
3327 ret);
3328 EXPECT_TRUE(ret == 0);
3329 pipe.SetDevAddr(BUFFER_SIZE);
3330 ret = UsbSrvClient.SetInterface(pipe, interface);
3331 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d SetInterface=%{public}d", __LINE__,
3332 ret);
3333 EXPECT_TRUE(ret != 0);
3334 pipe.SetDevAddr(device.GetDevAddr());
3335 bool close = UsbSrvClient.Close(pipe);
3336 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d close=%{public}d", __LINE__, close);
3337 EXPECT_TRUE(close);
3338 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface006 : SetInterface");
3339 }
3340
3341 /**
3342 * @tc.name: GetRawDescriptors001
3343 * @tc.desc: Test functions to GetRawDescriptors
3344 * @tc.type: FUNC
3345 */
3346 HWTEST_F(UsbDevicePipeTest, GetRawDescriptors001, TestSize.Level1)
3347 {
3348 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetRawDescriptors001 : GetRawDescriptors");
3349 vector<UsbDevice> devi;
3350 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3351 auto ret = UsbSrvClient.GetDevices(devi);
3352 EXPECT_TRUE(ret == 0);
3353 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d ret=%{public}d", __LINE__, ret);
3354 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3355 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d size=%{public}zu", __LINE__,
3356 devi.size());
3357 USBDevicePipe pipe;
3358 UsbDevice device = devi.front();
3359 UsbSrvClient.RequestRight(device.GetName());
3360 ret = UsbSrvClient.OpenDevice(device, pipe);
3361 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d OpenDevice=%{public}d",
3362 __LINE__, ret);
3363 EXPECT_TRUE(ret == 0);
3364 std::vector<uint8_t> vData;
3365 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
3366 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d GetRawDescriptors=%{public}d",
3367 __LINE__, ret);
3368 EXPECT_TRUE(ret == 0);
3369 ret = UsbSrvClient.Close(pipe);
3370 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3371 EXPECT_TRUE(ret);
3372 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetRawDescriptors001 : ControlTransfer");
3373 }
3374
3375 /**
3376 * @tc.name: GetRawDescriptors002
3377 * @tc.desc: Test functions to GetRawDescriptors
3378 * @tc.type: FUNC
3379 */
3380 HWTEST_F(UsbDevicePipeTest, GetRawDescriptors002, TestSize.Level1)
3381 {
3382 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetRawDescriptors002 : GetRawDescriptors");
3383 vector<UsbDevice> devi;
3384 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3385 auto ret = UsbSrvClient.GetDevices(devi);
3386 EXPECT_TRUE(ret == 0);
3387 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d ret=%{public}d", __LINE__, ret);
3388 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3389 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d size=%{public}zu", __LINE__,
3390 devi.size());
3391 USBDevicePipe pipe;
3392 UsbDevice device = devi.front();
3393 UsbSrvClient.RequestRight(device.GetName());
3394 ret = UsbSrvClient.OpenDevice(device, pipe);
3395 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d OpenDevice=%{public}d",
3396 __LINE__, ret);
3397 EXPECT_TRUE(ret == 0);
3398 std::vector<uint8_t> vData;
3399 USBDevicePipe pipeTmp = pipe;
3400 pipeTmp.SetBusNum(BUFFER_SIZE);
3401 ret = UsbSrvClient.GetRawDescriptors(pipeTmp, vData);
3402 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d GetRawDescriptors=%{public}d",
3403 __LINE__, ret);
3404 EXPECT_TRUE(ret != 0);
3405 ret = UsbSrvClient.Close(pipe);
3406 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3407 EXPECT_TRUE(ret);
3408 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetRawDescriptors002 : ControlTransfer");
3409 }
3410
3411 /**
3412 * @tc.name: GetRawDescriptors003
3413 * @tc.desc: Test functions to GetRawDescriptors
3414 * @tc.type: FUNC
3415 */
3416 HWTEST_F(UsbDevicePipeTest, GetRawDescriptors003, TestSize.Level1)
3417 {
3418 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetRawDescriptors003 : GetRawDescriptors");
3419 vector<UsbDevice> devi;
3420 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3421 auto ret = UsbSrvClient.GetDevices(devi);
3422 EXPECT_TRUE(ret == 0);
3423 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d ret=%{public}d", __LINE__, ret);
3424 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3425 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d size=%{public}zu", __LINE__,
3426 devi.size());
3427 USBDevicePipe pipe;
3428 UsbDevice device = devi.front();
3429 UsbSrvClient.RequestRight(device.GetName());
3430 ret = UsbSrvClient.OpenDevice(device, pipe);
3431 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d OpenDevice=%{public}d",
3432 __LINE__, ret);
3433 EXPECT_TRUE(ret == 0);
3434 std::vector<uint8_t> vData;
3435 USBDevicePipe pipeTmp = pipe;
3436 pipeTmp.SetDevAddr(BUFFER_SIZE);
3437 ret = UsbSrvClient.GetRawDescriptors(pipeTmp, vData);
3438 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d GetRawDescriptors=%{public}d",
3439 __LINE__, ret);
3440 EXPECT_TRUE(ret != 0);
3441 ret = UsbSrvClient.Close(pipe);
3442 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3443 EXPECT_TRUE(ret);
3444 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetRawDescriptors003 : ControlTransfer");
3445 }
3446
3447 /**
3448 * @tc.name: GetFileDescriptors001
3449 * @tc.desc: Test functions to GetRawDescriptors
3450 * @tc.type: FUNC
3451 */
3452 HWTEST_F(UsbDevicePipeTest, GetFileDescriptors001, TestSize.Level1)
3453 {
3454 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetFileDescriptors001 : GetRawDescriptors");
3455 vector<UsbDevice> devi;
3456 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3457 auto ret = UsbSrvClient.GetDevices(devi);
3458 EXPECT_TRUE(ret == 0);
3459 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d ret=%{public}d", __LINE__, ret);
3460 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3461 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d size=%{public}zu", __LINE__,
3462 devi.size());
3463 USBDevicePipe pipe;
3464 UsbDevice device = devi.front();
3465 UsbSrvClient.RequestRight(device.GetName());
3466 ret = UsbSrvClient.OpenDevice(device, pipe);
3467 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d OpenDevice=%{public}d",
3468 __LINE__, ret);
3469 EXPECT_TRUE(ret == 0);
3470 std::vector<uint8_t> vData;
3471 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
3472 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d GetRawDescriptors=%{public}d",
3473 __LINE__, ret);
3474 EXPECT_TRUE(ret == 0);
3475 int32_t fd = 0;
3476 ret = UsbSrvClient.GetFileDescriptor(pipe, fd);
3477 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d GetFileDescriptor=%{public}d",
3478 __LINE__, ret);
3479 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d fd=%{public}d",
3480 __LINE__, fd);
3481 EXPECT_TRUE(ret == 0);
3482 ret = ioctl(fd, USBDEVFS_GET_SPEED, NULL);
3483 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptor001 %{public}d fd=%{public}d ret=%{public}d",
3484 __LINE__, fd, ret);
3485 EXPECT_GE(ret, 0);
3486 ret = UsbSrvClient.Close(pipe);
3487 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3488 EXPECT_TRUE(ret);
3489 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetFileDescriptors001 : ControlTransfer");
3490 }
3491
3492 /**
3493 * @tc.name: GetFileDescriptors002
3494 * @tc.desc: Test functions to GetRawDescriptors
3495 * @tc.type: FUNC
3496 */
3497 HWTEST_F(UsbDevicePipeTest, GetFileDescriptors002, TestSize.Level1)
3498 {
3499 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetFileDescriptors002 : GetRawDescriptors");
3500 vector<UsbDevice> devi;
3501 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3502 auto ret = UsbSrvClient.GetDevices(devi);
3503 EXPECT_TRUE(ret == 0);
3504 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d ret=%{public}d", __LINE__, ret);
3505 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3506 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d size=%{public}zu", __LINE__,
3507 devi.size());
3508 USBDevicePipe pipe;
3509 UsbDevice device = devi.front();
3510 UsbSrvClient.RequestRight(device.GetName());
3511 ret = UsbSrvClient.OpenDevice(device, pipe);
3512 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d OpenDevice=%{public}d",
3513 __LINE__, ret);
3514 EXPECT_TRUE(ret == 0);
3515 std::vector<uint8_t> vData;
3516 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
3517 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d GetRawDescriptors=%{public}d",
3518 __LINE__, ret);
3519 EXPECT_TRUE(ret == 0);
3520 USBDevicePipe pipeTmp = pipe;
3521 pipeTmp.SetBusNum(BUFFER_SIZE);
3522 int32_t fd = 0;
3523 ret = UsbSrvClient.GetFileDescriptor(pipeTmp, fd);
3524 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d GetFileDescriptor=%{public}d",
3525 __LINE__, ret);
3526 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d fd=%{public}d",
3527 __LINE__, fd);
3528 EXPECT_TRUE(ret != 0);
3529 ret = UsbSrvClient.Close(pipe);
3530 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3531 EXPECT_TRUE(ret);
3532 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetFileDescriptors002 : ControlTransfer");
3533 }
3534
3535 /**
3536 * @tc.name: GetFileDescriptors003
3537 * @tc.desc: Test functions to GetRawDescriptors
3538 * @tc.type: FUNC
3539 */
3540 HWTEST_F(UsbDevicePipeTest, GetFileDescriptors003, TestSize.Level1)
3541 {
3542 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetFileDescriptors003 : GetRawDescriptors");
3543 vector<UsbDevice> devi;
3544 auto &UsbSrvClient = UsbSrvClient::GetInstance();
3545 auto ret = UsbSrvClient.GetDevices(devi);
3546 EXPECT_TRUE(ret == 0);
3547 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d ret=%{public}d", __LINE__, ret);
3548 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
3549 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d size=%{public}zu", __LINE__,
3550 devi.size());
3551 USBDevicePipe pipe;
3552 UsbDevice device = devi.front();
3553 UsbSrvClient.RequestRight(device.GetName());
3554 ret = UsbSrvClient.OpenDevice(device, pipe);
3555 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d OpenDevice=%{public}d",
3556 __LINE__, ret);
3557 EXPECT_TRUE(ret == 0);
3558 std::vector<uint8_t> vData;
3559 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
3560 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d GetRawDescriptors=%{public}d",
3561 __LINE__, ret);
3562 EXPECT_TRUE(ret == 0);
3563 USBDevicePipe pipeTmp = pipe;
3564 pipeTmp.SetDevAddr(BUFFER_SIZE);
3565 int32_t fd = 0;
3566 ret = UsbSrvClient.GetFileDescriptor(pipeTmp, fd);
3567 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d GetFileDescriptor=%{public}d",
3568 __LINE__, ret);
3569 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d fd=%{public}d",
3570 __LINE__, fd);
3571 EXPECT_TRUE(ret != 0);
3572 ret = UsbSrvClient.Close(pipe);
3573 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
3574 EXPECT_TRUE(ret);
3575 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetFileDescriptors003 : ControlTransfer");
3576 }
3577 } // DevicePipe
3578 } // USB
3579 } // OHOS
3580