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
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_srv_client.h"
28
29 using namespace testing::ext;
30 using namespace OHOS;
31 using namespace OHOS::USB;
32 using namespace std;
33 using namespace OHOS::HDI::Usb::V1_0;
34
35 namespace OHOS {
36 namespace USB {
37 namespace DevicePipe {
38 constexpr int32_t SLEEP_TIME = 3;
39 constexpr int32_t BUFFER_SIZE = 255;
SetUpTestCase(void)40 void UsbDevicePipeTest::SetUpTestCase(void)
41 {
42 auto &srvClient = UsbSrvClient::GetInstance();
43 auto ret = srvClient.SetPortRole(1, 1, 1);
44 sleep(SLEEP_TIME);
45 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest:: [Device] SetPortRole=%{public}d", ret);
46 ASSERT_TRUE(ret == 0);
47 if (ret != 0) {
48 exit(0);
49 }
50
51 std::cout << "please connect device, press enter to continue" << std::endl;
52 int32_t c;
53 while ((c = getchar()) != '\n' && c != EOF) {
54 ;
55 }
56 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbDevicePipeTest");
57 }
58
TearDownTestCase(void)59 void UsbDevicePipeTest::TearDownTestCase(void)
60 {
61 USB_HILOGI(MODULE_USB_SERVICE, "End UsbDevicePipeTest");
62 }
63
SetUp(void)64 void UsbDevicePipeTest::SetUp(void) {}
65
TearDown(void)66 void UsbDevicePipeTest::TearDown(void) {}
67
68 /**
69 * @tc.name: getDevices001
70 * @tc.desc: Test functions to getDevices(std::vector<UsbDevice> &deviceList);
71 * @tc.type: FUNC
72 */
73 HWTEST_F(UsbDevicePipeTest, getDevices001, TestSize.Level1)
74 {
75 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : getDevices001 : getDevices");
76 vector<UsbDevice> devi;
77 auto &UsbSrvClient = UsbSrvClient::GetInstance();
78 auto ret = UsbSrvClient.GetDevices(devi);
79 EXPECT_TRUE(ret == 0);
80 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::getDevices001 %{public}d ret=%{public}d", __LINE__, ret);
81 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
82 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::getDevices001 %{public}d size=%{public}zu", __LINE__,
83 devi.size());
84 USBDevicePipe pipe;
85 UsbDevice device = devi.front();
86 UsbSrvClient.RequestRight(device.GetName());
87 ret = UsbSrvClient.OpenDevice(device, pipe);
88 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::getDevices001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
89 EXPECT_TRUE(ret == 0);
90 ret = UsbSrvClient.Close(pipe);
91 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::getDevices001 %{public}d Close=%{public}d", __LINE__, ret);
92 EXPECT_TRUE(ret);
93 USB_HILOGI(MODULE_USB_SERVICE, "Case End : getDevices001 : getDevices");
94 }
95
96 /**
97 * @tc.name: UsbOpenDevice001
98 * @tc.desc: Test functions of OpenDevice
99 * @tc.desc: int32_t OpenDevice(const UsbDevice &device, USBDevicePipe &pip)
100 * @tc.desc: 正向测试：代码正常运行，返回结果为0
101 * @tc.type: FUNC
102 */
103 HWTEST_F(UsbDevicePipeTest, UsbOpenDevice001, TestSize.Level1)
104 {
105 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbOpenDevice001: OpenDevice");
106 auto &UsbSrvClient = UsbSrvClient::GetInstance();
107 std::vector<UsbDevice> deviceList;
108 auto ret = UsbSrvClient.GetDevices(deviceList);
109 EXPECT_TRUE(ret == 0);
110 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbOpenDevice001 %{public}d ret=%{public}d", __LINE__, ret);
111 EXPECT_TRUE(!(deviceList.empty())) << "delist NULL";
112 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbOpenDevice001 %{public}d size=%{public}zu", __LINE__,
113 deviceList.size());
114 UsbDevice device = deviceList.front();
115 USBDevicePipe pipe;
116 UsbSrvClient.RequestRight(device.GetName());
117 ret = UsbSrvClient.OpenDevice(device, pipe);
118 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbOpenDevice001 %{public}d OpenDevice=%{public}d", __LINE__,
119 ret);
120 EXPECT_TRUE(ret == 0);
121 ret = UsbSrvClient.Close(pipe);
122 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
123 EXPECT_TRUE(ret);
124 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbOpenDevice001: OpenDevice");
125 }
126
127 /**
128 * @tc.name: Usbcontrolstansfer001
129 * @tc.desc: Test functions to ControlTransfer
130 * @tc.type: FUNC
131 */
132 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer001, TestSize.Level1)
133 {
134 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer001 : ControlTransfer");
135 vector<UsbDevice> devi;
136 auto &UsbSrvClient = UsbSrvClient::GetInstance();
137 auto ret = UsbSrvClient.GetDevices(devi);
138 EXPECT_TRUE(ret == 0);
139 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer001 %{public}d ret=%{public}d", __LINE__, ret);
140 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
141 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer001 %{public}d size=%{public}zu", __LINE__,
142 devi.size());
143 USBDevicePipe pipe;
144 UsbDevice device = devi.front();
145 UsbSrvClient.RequestRight(device.GetName());
146 ret = UsbSrvClient.OpenDevice(device, pipe);
147 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer001 %{public}d OpenDevice=%{public}d",
148 __LINE__, ret);
149 EXPECT_TRUE(ret == 0);
150 uint32_t len = 8;
151 uint8_t buffer[BUFFER_SIZE] = {0};
152 struct UsbCtrlTransfer ctrldata = {0b10000000, 8, 0, 0, 500};
153 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
154 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
155 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer001 %{public}d ControlTransfer=%{public}d",
156 __LINE__, ret);
157 EXPECT_TRUE(ret == 0);
158 ret = UsbSrvClient.Close(pipe);
159 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
160 EXPECT_TRUE(ret);
161 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer001 : ControlTransfer");
162 }
163
164 /**
165 * @tc.name: Usbcontrolstansfer002
166 * @tc.desc: Test functions to ControlTransfer
167 * @tc.type: FUNC
168 */
169 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer002, TestSize.Level1)
170 {
171 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer002 : ControlTransfer");
172 vector<UsbDevice> devi;
173 auto &UsbSrvClient = UsbSrvClient::GetInstance();
174 auto ret = UsbSrvClient.GetDevices(devi);
175 EXPECT_TRUE(ret == 0);
176 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer002 %{public}d ret=%{public}d", __LINE__, ret);
177 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
178 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer002 %{public}d size=%{public}zu", __LINE__,
179 devi.size());
180 USBDevicePipe pipe;
181 UsbDevice device = devi.front();
182 UsbSrvClient.RequestRight(device.GetName());
183 ret = UsbSrvClient.OpenDevice(device, pipe);
184 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer002 %{public}d OpenDevice=%{public}d",
185 __LINE__, ret);
186 EXPECT_TRUE(ret == 0);
187 uint32_t len = 8;
188 uint8_t buffer[BUFFER_SIZE] = {0};
189 pipe.SetBusNum(BUFFER_SIZE);
190 struct UsbCtrlTransfer ctrldata = {0b10000000, 8, 0, 0, 500};
191 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
192 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
193 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer002 %{public}d ControlTransfer=%{public}d",
194 __LINE__, ret);
195 EXPECT_TRUE(ret != 0);
196 pipe.SetBusNum(device.GetBusNum());
197 ret = UsbSrvClient.Close(pipe);
198 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
199 EXPECT_TRUE(ret);
200 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer002 : ControlTransfer");
201 }
202
203 /**
204 * @tc.name: Usbcontrolstansfer003
205 * @tc.desc: Test functions to ControlTransfer
206 * @tc.type: FUNC
207 */
208 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer003, TestSize.Level1)
209 {
210 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer003 : ControlTransfer");
211 vector<UsbDevice> devi;
212 auto &UsbSrvClient = UsbSrvClient::GetInstance();
213 auto ret = UsbSrvClient.GetDevices(devi);
214 EXPECT_TRUE(ret == 0);
215 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer003 %{public}d ret=%{public}d", __LINE__, ret);
216 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
217 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer003 %{public}d size=%{public}zu", __LINE__,
218 devi.size());
219 USBDevicePipe pipe;
220 UsbDevice device = devi.front();
221 UsbSrvClient.RequestRight(device.GetName());
222 ret = UsbSrvClient.OpenDevice(device, pipe);
223 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer003 %{public}d OpenDevice=%{public}d",
224 __LINE__, ret);
225 EXPECT_TRUE(ret == 0);
226 uint32_t len = 8;
227 uint8_t buffer[BUFFER_SIZE] = {0};
228 pipe.SetDevAddr(BUFFER_SIZE);
229 struct UsbCtrlTransfer ctrldata = {0b10000000, 8, 0, 0, 500};
230 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
231 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
232 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer003 %{public}d ControlTransfer=%{public}d",
233 __LINE__, ret);
234 EXPECT_TRUE(ret != 0);
235 pipe.SetDevAddr(device.GetDevAddr());
236 ret = UsbSrvClient.Close(pipe);
237 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
238 EXPECT_TRUE(ret);
239 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer003 : ControlTransfer");
240 }
241
242 /**
243 * @tc.name: Usbcontrolstansfer004
244 * @tc.desc: Test functions to ControlTransfer
245 * @tc.type: FUNC
246 */
247 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer004, TestSize.Level1)
248 {
249 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer004 : ControlTransfer");
250 vector<UsbDevice> devi;
251 auto &UsbSrvClient = UsbSrvClient::GetInstance();
252 auto ret = UsbSrvClient.GetDevices(devi);
253 EXPECT_TRUE(ret == 0);
254 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer004 %{public}d ret=%{public}d", __LINE__, ret);
255 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
256 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer004 %{public}d size=%{public}zu", __LINE__,
257 devi.size());
258 USBDevicePipe pipe;
259 UsbDevice device = devi.front();
260 UsbSrvClient.RequestRight(device.GetName());
261 ret = UsbSrvClient.OpenDevice(device, pipe);
262 EXPECT_TRUE(ret == 0);
263 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer004 %{public}d OpenDevice=%{public}d",
264 __LINE__, ret);
265 uint32_t len = 8;
266 uint8_t buffer[BUFFER_SIZE] = {0};
267 struct UsbCtrlTransfer ctrldata = {0b10000000, 6, 0x100, 0, 500};
268 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
269 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
270 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer004 %{public}d ControlTransfer=%{public}d",
271 __LINE__, ret);
272 EXPECT_TRUE(ret == 0);
273 ret = UsbSrvClient.Close(pipe);
274 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
275 EXPECT_TRUE(ret);
276 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer004 : ControlTransfer");
277 }
278
279 /**
280 * @tc.name: Usbcontrolstansfer005
281 * @tc.desc: Test functions to ControlTransfer
282 * @tc.type: FUNC
283 */
284 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer005, TestSize.Level1)
285 {
286 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer005 : ControlTransfer");
287 vector<UsbDevice> devi;
288 auto &UsbSrvClient = UsbSrvClient::GetInstance();
289 auto ret = UsbSrvClient.GetDevices(devi);
290 EXPECT_TRUE(ret == 0);
291 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer005 %{public}d ret=%{public}d", __LINE__, ret);
292 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
293 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer005 %{public}d size=%{public}zu", __LINE__,
294 devi.size());
295 USBDevicePipe pipe;
296 UsbDevice device = devi.front();
297 UsbSrvClient.RequestRight(device.GetName());
298 ret = UsbSrvClient.OpenDevice(device, pipe);
299 EXPECT_TRUE(ret == 0);
300 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer005 %{public}d OpenDevice=%{public}d",
301 __LINE__, ret);
302 uint32_t len = 8;
303 uint8_t buffer[BUFFER_SIZE] = {0};
304 pipe.SetBusNum(BUFFER_SIZE);
305 struct UsbCtrlTransfer ctrldata = {0b10000000, 6, 0x100, 0, 500};
306 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
307 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
308 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer005 %{public}d ControlTransfer=%{public}d",
309 __LINE__, ret);
310 EXPECT_TRUE(ret != 0);
311 pipe.SetBusNum(device.GetBusNum());
312 ret = UsbSrvClient.Close(pipe);
313 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
314 EXPECT_TRUE(ret);
315 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer005 : ControlTransfer");
316 }
317
318 /**
319 * @tc.name: Usbcontrolstansfer006
320 * @tc.desc: Test functions to ControlTransfer
321 * @tc.type: FUNC
322 */
323 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer006, TestSize.Level1)
324 {
325 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer006 : ControlTransfer");
326 vector<UsbDevice> devi;
327 auto &UsbSrvClient = UsbSrvClient::GetInstance();
328 auto ret = UsbSrvClient.GetDevices(devi);
329 EXPECT_TRUE(ret == 0);
330 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer006 %{public}d ret=%{public}d", __LINE__, ret);
331 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
332 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer006 %{public}d size=%{public}zu", __LINE__,
333 devi.size());
334 USBDevicePipe pipe;
335 UsbDevice device = devi.front();
336 UsbSrvClient.RequestRight(device.GetName());
337 ret = UsbSrvClient.OpenDevice(device, pipe);
338 EXPECT_TRUE(ret == 0);
339 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer006 %{public}d OpenDevice=%{public}d",
340 __LINE__, ret);
341 uint32_t len = 8;
342 uint8_t buffer[BUFFER_SIZE] = {0};
343 pipe.SetDevAddr(BUFFER_SIZE);
344 struct UsbCtrlTransfer ctrldata = {0b10000000, 6, 0x100, 0, 500};
345 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
346 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
347 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer006 %{public}d ControlTransfer=%{public}d",
348 __LINE__, ret);
349 EXPECT_TRUE(ret != 0);
350 pipe.SetDevAddr(device.GetDevAddr());
351 ret = UsbSrvClient.Close(pipe);
352 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
353 EXPECT_TRUE(ret);
354 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer006 : ControlTransfer");
355 }
356
357 /**
358 * @tc.name: Usbcontrolstansfer007
359 * @tc.desc: Test functions to ControlTransfer
360 * @tc.type: FUNC
361 */
362 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer007, TestSize.Level1)
363 {
364 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer007 : ControlTransfer");
365 vector<UsbDevice> devi;
366 auto &UsbSrvClient = UsbSrvClient::GetInstance();
367 auto ret = UsbSrvClient.GetDevices(devi);
368 EXPECT_TRUE(ret == 0);
369 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d ret=%{public}d", __LINE__, ret);
370 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
371 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d size=%{public}zu", __LINE__,
372 devi.size());
373 USBDevicePipe pipe;
374 UsbDevice device = devi.front();
375 UsbSrvClient.RequestRight(device.GetName());
376 UsbInterface interface = device.GetConfigs().front().GetInterfaces().front();
377 ret = UsbSrvClient.OpenDevice(device, pipe);
378 EXPECT_TRUE(ret == 0);
379 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d OpenDevice=%{public}d",
380 __LINE__, ret);
381 uint32_t len = BUFFER_SIZE;
382 uint8_t buffer[BUFFER_SIZE] = {0};
383 struct UsbCtrlTransfer ctrldata = {0b10000001, 0X0A, 0, 0, 500};
384 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
385 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
386 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d ControlTransfer=%{public}d",
387 __LINE__, ret);
388 EXPECT_TRUE(ret == 0);
389 ret = UsbSrvClient.Close(pipe);
390 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer007 %{public}d Close=%{public}d", __LINE__,
391 ret);
392 EXPECT_TRUE(ret);
393 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer007 : ControlTransfer");
394 }
395
396 /**
397 * @tc.name: Usbcontrolstansfer008
398 * @tc.desc: Test functions to ControlTransfer
399 * @tc.type: FUNC
400 */
401 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer008, TestSize.Level1)
402 {
403 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer008 : ControlTransfer");
404 vector<UsbDevice> devi;
405 auto &UsbSrvClient = UsbSrvClient::GetInstance();
406 auto ret = UsbSrvClient.GetDevices(devi);
407 EXPECT_TRUE(ret == 0);
408 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d ret=%{public}d", __LINE__, ret);
409 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
410 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d size=%{public}zu", __LINE__,
411 devi.size());
412 USBDevicePipe pipe;
413 UsbDevice device = devi.front();
414 UsbSrvClient.RequestRight(device.GetName());
415 UsbInterface interface = device.GetConfigs().front().GetInterfaces().front();
416 ret = UsbSrvClient.OpenDevice(device, pipe);
417 EXPECT_TRUE(ret == 0);
418 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d OpenDevice=%{public}d",
419 __LINE__, ret);
420 uint32_t len = BUFFER_SIZE;
421 uint8_t buffer[BUFFER_SIZE] = {0};
422 pipe.SetBusNum(BUFFER_SIZE);
423 struct UsbCtrlTransfer ctrldata = {0b10000001, 0X0A, 0, 0, 500};
424 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
425 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
426 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d ControlTransfer=%{public}d",
427 __LINE__, ret);
428 EXPECT_TRUE(ret != 0);
429 pipe.SetBusNum(device.GetBusNum());
430 ret = UsbSrvClient.Close(pipe);
431 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer008 %{public}d Close=%{public}d", __LINE__,
432 ret);
433 EXPECT_TRUE(ret);
434 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer008 : ControlTransfer");
435 }
436
437 /**
438 * @tc.name: Usbcontrolstansfer009
439 * @tc.desc: Test functions to ControlTransfer
440 * @tc.type: FUNC
441 */
442 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer009, TestSize.Level1)
443 {
444 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer009 : ControlTransfer");
445 vector<UsbDevice> devi;
446 auto &UsbSrvClient = UsbSrvClient::GetInstance();
447 auto ret = UsbSrvClient.GetDevices(devi);
448 EXPECT_TRUE(ret == 0);
449 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d ret=%{public}d", __LINE__, ret);
450 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
451 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d size=%{public}zu", __LINE__,
452 devi.size());
453 USBDevicePipe pipe;
454 UsbDevice device = devi.front();
455 UsbSrvClient.RequestRight(device.GetName());
456 UsbInterface interface = device.GetConfigs().front().GetInterfaces().front();
457 ret = UsbSrvClient.OpenDevice(device, pipe);
458 EXPECT_TRUE(ret == 0);
459 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d OpenDevice=%{public}d",
460 __LINE__, ret);
461 uint32_t len = BUFFER_SIZE;
462 uint8_t buffer[BUFFER_SIZE] = {0};
463 pipe.SetDevAddr(BUFFER_SIZE);
464 struct UsbCtrlTransfer ctrldata = {0b10000001, 0X0A, 0, 0, 500};
465 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
466 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
467 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d ControlTransfer=%{public}d",
468 __LINE__, ret);
469 EXPECT_TRUE(ret != 0);
470 pipe.SetDevAddr(device.GetDevAddr());
471 ret = UsbSrvClient.Close(pipe);
472 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer009 %{public}d Close=%{public}d", __LINE__,
473 ret);
474 EXPECT_TRUE(ret);
475 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer009 : ControlTransfer");
476 }
477
478 /**
479 * @tc.name: Usbcontrolstansfer010
480 * @tc.desc: Test functions to ControlTransfer
481 * @tc.type: FUNC
482 */
483 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer010, TestSize.Level1)
484 {
485 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer010 : ControlTransfer");
486 vector<UsbDevice> devi;
487 auto &UsbSrvClient = UsbSrvClient::GetInstance();
488 auto ret = UsbSrvClient.GetDevices(devi);
489 EXPECT_TRUE(ret == 0);
490 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d ret=%{public}d", __LINE__, ret);
491 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
492 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d size=%{public}zu", __LINE__,
493 devi.size());
494 USBDevicePipe pipe;
495 UsbDevice device = devi.front();
496 UsbSrvClient.RequestRight(device.GetName());
497 ret = UsbSrvClient.OpenDevice(device, pipe);
498 EXPECT_TRUE(ret == 0);
499 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d OpenDevice=%{public}d",
500 __LINE__, ret);
501 uint32_t len = BUFFER_SIZE;
502 uint8_t buffer[BUFFER_SIZE] = {0};
503 struct UsbCtrlTransfer ctrldata = {0b10000000, 0, 0, 0, 500};
504 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
505 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
506 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d ControlTransfer=%{public}d",
507 __LINE__, ret);
508 EXPECT_TRUE(ret == 0);
509 ret = UsbSrvClient.Close(pipe);
510 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer010 %{public}d Close=%{public}d", __LINE__,
511 ret);
512 EXPECT_TRUE(ret);
513 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer010 : ControlTransfer");
514 }
515
516 /**
517 * @tc.name: Usbcontrolstansfer011
518 * @tc.desc: Test functions to ControlTransfer
519 * @tc.type: FUNC
520 */
521 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer011, TestSize.Level1)
522 {
523 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer011 : ControlTransfer");
524 vector<UsbDevice> devi;
525 auto &UsbSrvClient = UsbSrvClient::GetInstance();
526 auto ret = UsbSrvClient.GetDevices(devi);
527 EXPECT_TRUE(ret == 0);
528 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d ret=%{public}d", __LINE__, ret);
529 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
530 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d size=%{public}zu", __LINE__,
531 devi.size());
532 USBDevicePipe pipe;
533 UsbDevice device = devi.front();
534 UsbSrvClient.RequestRight(device.GetName());
535 ret = UsbSrvClient.OpenDevice(device, pipe);
536 EXPECT_TRUE(ret == 0);
537 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d OpenDevice=%{public}d",
538 __LINE__, ret);
539 uint32_t len = BUFFER_SIZE;
540 uint8_t buffer[BUFFER_SIZE] = {0};
541 pipe.SetBusNum(BUFFER_SIZE);
542 struct UsbCtrlTransfer ctrldata = {0b10000000, 0, 0, 0, 500};
543 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
544 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
545 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d ControlTransfer=%{public}d",
546 __LINE__, ret);
547 EXPECT_TRUE(ret != 0);
548 pipe.SetBusNum(device.GetBusNum());
549 ret = UsbSrvClient.Close(pipe);
550 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer011 %{public}d Close=%{public}d", __LINE__,
551 ret);
552 EXPECT_TRUE(ret);
553 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer011 : ControlTransfer");
554 }
555
556 /**
557 * @tc.name: Usbcontrolstansfer012
558 * @tc.desc: Test functions to ControlTransfer
559 * @tc.type: FUNC
560 */
561 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer012, TestSize.Level1)
562 {
563 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer012 : ControlTransfer");
564 vector<UsbDevice> devi;
565 auto &UsbSrvClient = UsbSrvClient::GetInstance();
566 auto ret = UsbSrvClient.GetDevices(devi);
567 EXPECT_TRUE(ret == 0);
568 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d ret=%{public}d", __LINE__, ret);
569 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
570 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d size=%{public}zu", __LINE__,
571 devi.size());
572 USBDevicePipe pipe;
573 UsbDevice device = devi.front();
574 UsbSrvClient.RequestRight(device.GetName());
575 ret = UsbSrvClient.OpenDevice(device, pipe);
576 EXPECT_TRUE(ret == 0);
577 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d OpenDevice=%{public}d",
578 __LINE__, ret);
579 uint32_t len = BUFFER_SIZE;
580 uint8_t buffer[BUFFER_SIZE] = {0};
581 pipe.SetDevAddr(BUFFER_SIZE);
582 struct UsbCtrlTransfer ctrldata = {0b10000000, 0, 0, 0, 500};
583 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
584 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
585 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d ControlTransfer=%{public}d",
586 __LINE__, ret);
587 EXPECT_TRUE(ret != 0);
588 pipe.SetDevAddr(device.GetDevAddr());
589 ret = UsbSrvClient.Close(pipe);
590 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer012 %{public}d Close=%{public}d", __LINE__,
591 ret);
592 EXPECT_TRUE(ret);
593 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer012 : ControlTransfer");
594 }
595
596 /**
597 * @tc.name: Usbcontrolstansfer0013
598 * @tc.desc: Test functions to ControlTransfer
599 * @tc.type: FUNC
600 */
601 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer0013, TestSize.Level1)
602 {
603 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer0013 : ControlTransfer");
604 vector<UsbDevice> devi;
605 auto &UsbSrvClient = UsbSrvClient::GetInstance();
606 auto ret = UsbSrvClient.GetDevices(devi);
607 EXPECT_TRUE(ret == 0);
608 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d ret=%{public}d", __LINE__,
609 ret);
610 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
611 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d size=%{public}zu", __LINE__,
612 devi.size());
613 USBDevicePipe pipe;
614 UsbDevice device = devi.front();
615 UsbSrvClient.RequestRight(device.GetName());
616 ret = UsbSrvClient.OpenDevice(device, pipe);
617 EXPECT_TRUE(ret == 0);
618 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d OpenDevice=%{public}d",
619 __LINE__, ret);
620 uint32_t len = BUFFER_SIZE;
621 uint8_t buffer[BUFFER_SIZE] = {0};
622 struct UsbCtrlTransfer ctrldata = {0b10000001, 0, 0, 0, 500};
623 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
624 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
625 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d ControlTransfer=%{public}d",
626 __LINE__, ret);
627 EXPECT_TRUE(ret == 0);
628 ret = UsbSrvClient.Close(pipe);
629 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0013 %{public}d Close=%{public}d", __LINE__,
630 ret);
631 EXPECT_TRUE(ret);
632 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer0013 : ControlTransfer");
633 }
634
635 /**
636 * @tc.name: Usbcontrolstansfer0014
637 * @tc.desc: Test functions to ControlTransfer
638 * @tc.type: FUNC
639 */
640 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer0014, TestSize.Level1)
641 {
642 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer0014 : ControlTransfer");
643 vector<UsbDevice> devi;
644 auto &UsbSrvClient = UsbSrvClient::GetInstance();
645 auto ret = UsbSrvClient.GetDevices(devi);
646 EXPECT_TRUE(ret == 0);
647 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d ret=%{public}d", __LINE__,
648 ret);
649 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
650 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d size=%{public}zu", __LINE__,
651 devi.size());
652 USBDevicePipe pipe;
653 UsbDevice device = devi.front();
654 UsbSrvClient.RequestRight(device.GetName());
655 ret = UsbSrvClient.OpenDevice(device, pipe);
656 EXPECT_TRUE(ret == 0);
657 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d OpenDevice=%{public}d",
658 __LINE__, ret);
659 uint32_t len = BUFFER_SIZE;
660 uint8_t buffer[BUFFER_SIZE] = {0};
661 pipe.SetBusNum(BUFFER_SIZE);
662 struct UsbCtrlTransfer ctrldata = {0b10000001, 0, 0, 0, 500};
663 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
664 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
665 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d ControlTransfer=%{public}d",
666 __LINE__, ret);
667 EXPECT_TRUE(ret != 0);
668 pipe.SetBusNum(device.GetBusNum());
669 ret = UsbSrvClient.Close(pipe);
670 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0014 %{public}d Close=%{public}d", __LINE__,
671 ret);
672 EXPECT_TRUE(ret);
673 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer0014 : ControlTransfer");
674 }
675
676 /**
677 * @tc.name: Usbcontrolstansfer0015
678 * @tc.desc: Test functions to ControlTransfer
679 * @tc.type: FUNC
680 */
681 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer0015, TestSize.Level1)
682 {
683 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer0015 : ControlTransfer");
684 vector<UsbDevice> devi;
685 auto &UsbSrvClient = UsbSrvClient::GetInstance();
686 auto ret = UsbSrvClient.GetDevices(devi);
687 EXPECT_TRUE(ret == 0);
688 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d ret=%{public}d", __LINE__,
689 ret);
690 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
691 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d size=%{public}zu", __LINE__,
692 devi.size());
693 USBDevicePipe pipe;
694 UsbDevice device = devi.front();
695 UsbSrvClient.RequestRight(device.GetName());
696 ret = UsbSrvClient.OpenDevice(device, pipe);
697 EXPECT_TRUE(ret == 0);
698 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d OpenDevice=%{public}d",
699 __LINE__, ret);
700 uint32_t len = BUFFER_SIZE;
701 uint8_t buffer[BUFFER_SIZE] = {0};
702 pipe.SetDevAddr(BUFFER_SIZE);
703 struct UsbCtrlTransfer ctrldata = {0b10000001, 0, 0, 0, 500};
704 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
705 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
706 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d ControlTransfer=%{public}d",
707 __LINE__, ret);
708 EXPECT_TRUE(ret != 0);
709 pipe.SetDevAddr(device.GetDevAddr());
710 ret = UsbSrvClient.Close(pipe);
711 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer0015 %{public}d Close=%{public}d", __LINE__,
712 ret);
713 EXPECT_TRUE(ret);
714 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer0015 : ControlTransfer");
715 }
716
717 /**
718 * @tc.name: Usbcontrolstansfer016
719 * @tc.desc: Test functions to ControlTransfer
720 * @tc.type: FUNC
721 */
722 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer016, TestSize.Level1)
723 {
724 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer016 : ControlTransfer");
725 vector<UsbDevice> devi;
726 auto &UsbSrvClient = UsbSrvClient::GetInstance();
727 auto ret = UsbSrvClient.GetDevices(devi);
728 EXPECT_TRUE(ret == 0);
729 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d ret=%{public}d", __LINE__, ret);
730 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
731 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d size=%{public}zu", __LINE__,
732 devi.size());
733 USBDevicePipe pipe;
734 UsbDevice device = devi.front();
735 UsbSrvClient.RequestRight(device.GetName());
736 ret = UsbSrvClient.OpenDevice(device, pipe);
737 EXPECT_TRUE(ret == 0);
738 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d OpenDevice=%{public}d",
739 __LINE__, ret);
740 uint32_t len = 16;
741 uint8_t buffer[BUFFER_SIZE] = {0};
742 struct UsbCtrlTransfer ctrldata = {0b10000010, 0, 0, 0, 500};
743 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
744 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
745 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d ControlTransfer=%{public}d",
746 __LINE__, ret);
747 EXPECT_TRUE(ret == 0);
748 ret = UsbSrvClient.Close(pipe);
749 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer016 %{public}d Close=%{public}d", __LINE__,
750 ret);
751 EXPECT_TRUE(ret);
752 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer016 : ControlTransfer");
753 }
754
755 /**
756 * @tc.name: Usbcontrolstansfer017
757 * @tc.desc: Test functions to ControlTransfer
758 * @tc.type: FUNC
759 */
760 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer017, TestSize.Level1)
761 {
762 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer017 : ControlTransfer");
763 vector<UsbDevice> devi;
764 auto &UsbSrvClient = UsbSrvClient::GetInstance();
765 auto ret = UsbSrvClient.GetDevices(devi);
766 EXPECT_TRUE(ret == 0);
767 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d ret=%{public}d", __LINE__, ret);
768 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
769 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d size=%{public}zu", __LINE__,
770 devi.size());
771 USBDevicePipe pipe;
772 UsbDevice device = devi.front();
773 UsbSrvClient.RequestRight(device.GetName());
774 ret = UsbSrvClient.OpenDevice(device, pipe);
775 EXPECT_TRUE(ret == 0);
776 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d OpenDevice=%{public}d",
777 __LINE__, ret);
778 uint32_t len = 16;
779 uint8_t buffer[BUFFER_SIZE] = {0};
780 pipe.SetBusNum(BUFFER_SIZE);
781 struct UsbCtrlTransfer ctrldata = {0b10000010, 0, 0, 0, 500};
782 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
783 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
784 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d ControlTransfer=%{public}d",
785 __LINE__, ret);
786 EXPECT_TRUE(ret != 0);
787 pipe.SetBusNum(device.GetBusNum());
788 ret = UsbSrvClient.Close(pipe);
789 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer017 %{public}d Close=%{public}d", __LINE__,
790 ret);
791 EXPECT_TRUE(ret);
792 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer017 : ControlTransfer");
793 }
794
795 /**
796 * @tc.name: Usbcontrolstansfer018
797 * @tc.desc: Test functions to ControlTransfer
798 * @tc.type: FUNC
799 */
800 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer018, TestSize.Level1)
801 {
802 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer018 : ControlTransfer");
803 vector<UsbDevice> devi;
804 auto &UsbSrvClient = UsbSrvClient::GetInstance();
805 auto ret = UsbSrvClient.GetDevices(devi);
806 EXPECT_TRUE(ret == 0);
807 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d ret=%{public}d", __LINE__, ret);
808 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
809 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d size=%{public}zu", __LINE__,
810 devi.size());
811 USBDevicePipe pipe;
812 UsbDevice device = devi.front();
813 UsbSrvClient.RequestRight(device.GetName());
814 ret = UsbSrvClient.OpenDevice(device, pipe);
815 EXPECT_TRUE(ret == 0);
816 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d OpenDevice=%{public}d",
817 __LINE__, ret);
818 uint32_t len = 16;
819 uint8_t buffer[BUFFER_SIZE] = {0};
820 pipe.SetDevAddr(BUFFER_SIZE);
821 struct UsbCtrlTransfer ctrldata = {0b10000010, 0, 0, 0, 500};
822 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
823 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
824 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d ControlTransfer=%{public}d",
825 __LINE__, ret);
826 EXPECT_TRUE(ret != 0);
827 pipe.SetDevAddr(device.GetDevAddr());
828 ret = UsbSrvClient.Close(pipe);
829 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer018 %{public}d Close=%{public}d", __LINE__,
830 ret);
831 EXPECT_TRUE(ret);
832 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer018 : ControlTransfer");
833 }
834
835 /**
836 * @tc.name: Usbcontrolstansfer019
837 * @tc.desc: Test functions to ControlTransfer
838 * @tc.type: FUNC
839 */
840 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer019, TestSize.Level1)
841 {
842 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer019 : ControlTransfer");
843 vector<UsbDevice> devi;
844 auto &UsbSrvClient = UsbSrvClient::GetInstance();
845 auto ret = UsbSrvClient.GetDevices(devi);
846 EXPECT_TRUE(ret == 0);
847 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer019 %{public}d ret=%{public}d", __LINE__, ret);
848 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
849 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer019 %{public}d size=%{public}zu", __LINE__,
850 devi.size());
851 USBDevicePipe pipe;
852 UsbDevice device = devi.front();
853 UsbSrvClient.RequestRight(device.GetName());
854 ret = UsbSrvClient.OpenDevice(device, pipe);
855 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer019 %{public}d OpenDevice=%{public}d",
856 __LINE__, ret);
857 EXPECT_TRUE(ret == 0);
858 uint32_t len = BUFFER_SIZE;
859 uint8_t buffer[BUFFER_SIZE] = {0};
860 struct UsbCtrlTransfer ctrldata = {0b10000010, 0X0C, 0, 0, 500};
861 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
862 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
863 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer019 %{public}d ControlTransfer=%{public}d",
864 __LINE__, ret);
865 EXPECT_TRUE(ret == 0);
866 ret = UsbSrvClient.Close(pipe);
867 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Close=%{public}d", ret);
868 EXPECT_TRUE(ret);
869 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer019 : ControlTransfer");
870 }
871
872 /**
873 * @tc.name: Usbcontrolstansfer020
874 * @tc.desc: Test functions to ControlTransfer
875 * @tc.type: FUNC
876 */
877 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer020, TestSize.Level1)
878 {
879 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer020 : ControlTransfer");
880 vector<UsbDevice> devi;
881 auto &UsbSrvClient = UsbSrvClient::GetInstance();
882 auto ret = UsbSrvClient.GetDevices(devi);
883 EXPECT_TRUE(ret == 0);
884 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer020 %{public}d ret=%{public}d", __LINE__, ret);
885 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
886 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer020 %{public}d size=%{public}zu", __LINE__,
887 devi.size());
888 USBDevicePipe pipe;
889 UsbDevice device = devi.front();
890 UsbSrvClient.RequestRight(device.GetName());
891 ret = UsbSrvClient.OpenDevice(device, pipe);
892 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer020 %{public}d OpenDevice=%{public}d",
893 __LINE__, ret);
894 EXPECT_TRUE(ret == 0);
895 uint32_t len = BUFFER_SIZE;
896 uint8_t buffer[BUFFER_SIZE] = {0};
897 pipe.SetBusNum(BUFFER_SIZE);
898 struct UsbCtrlTransfer ctrldata = {0b10000010, 0X0C, 0, 0, 500};
899 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
900 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
901 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer020 %{public}d ControlTransfer=%{public}d",
902 __LINE__, ret);
903 EXPECT_TRUE(ret != 0);
904 pipe.SetBusNum(device.GetBusNum());
905 ret = UsbSrvClient.Close(pipe);
906 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Close=%{public}d", ret);
907 EXPECT_TRUE(ret);
908 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer020 : ControlTransfer");
909 }
910
911 /**
912 * @tc.name: Usbcontrolstansfer021
913 * @tc.desc: Test functions to ControlTransfer
914 * @tc.type: FUNC
915 */
916 HWTEST_F(UsbDevicePipeTest, Usbcontrolstansfer021, TestSize.Level1)
917 {
918 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbcontrolstansfer021 : ControlTransfer");
919 vector<UsbDevice> devi;
920 auto &UsbSrvClient = UsbSrvClient::GetInstance();
921 auto ret = UsbSrvClient.GetDevices(devi);
922 EXPECT_TRUE(ret == 0);
923 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer021 %{public}d ret=%{public}d", __LINE__, ret);
924 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
925 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer021 %{public}d size=%{public}zu", __LINE__,
926 devi.size());
927 USBDevicePipe pipe;
928 UsbDevice device = devi.front();
929 UsbSrvClient.RequestRight(device.GetName());
930 ret = UsbSrvClient.OpenDevice(device, pipe);
931 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer021 %{public}d OpenDevice=%{public}d",
932 __LINE__, ret);
933 EXPECT_TRUE(ret == 0);
934 uint32_t len = BUFFER_SIZE;
935 uint8_t buffer[BUFFER_SIZE] = {0};
936 pipe.SetDevAddr(BUFFER_SIZE);
937 struct UsbCtrlTransfer ctrldata = {0b10000010, 0X0C, 0, 0, 500};
938 std::vector<uint8_t> ctrlbuffer = {buffer, buffer + len};
939 ret = UsbSrvClient.ControlTransfer(pipe, ctrldata, ctrlbuffer);
940 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Usbcontrolstansfer021 %{public}d ControlTransfer=%{public}d",
941 __LINE__, ret);
942 EXPECT_TRUE(ret != 0);
943 pipe.SetDevAddr(device.GetDevAddr());
944 ret = UsbSrvClient.Close(pipe);
945 USB_HILOGI(MODULE_USB_SERVICE, "UsbCoreTest::Close=%{public}d", ret);
946 EXPECT_TRUE(ret);
947 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbcontrolstansfer021 : ControlTransfer");
948 }
949
950 /**
951 * @tc.name: UsbClaimInterface001
952 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
953 * @tc.type: FUNC
954 */
955 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface001, TestSize.Level1)
956 {
957 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface001 : ClaimInterface");
958 vector<UsbDevice> devi;
959 auto &UsbSrvClient = UsbSrvClient::GetInstance();
960 auto ret = UsbSrvClient.GetDevices(devi);
961 EXPECT_TRUE(ret == 0);
962 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d ret=%{public}d", __LINE__, ret);
963 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
964 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d size=%{public}zu", __LINE__,
965 devi.size());
966 USBDevicePipe pipe;
967 UsbDevice device = devi.front();
968 UsbSrvClient.RequestRight(device.GetName());
969 ret = UsbSrvClient.OpenDevice(device, pipe);
970 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d OpenDevice=%{public}d", __LINE__,
971 ret);
972 EXPECT_TRUE(ret == 0);
973 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().front();
974 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
975 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d ClaimInterface=%{public}d",
976 __LINE__, ret);
977 EXPECT_TRUE(ret == 0);
978 bool close = UsbSrvClient.Close(pipe);
979 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface001 %{public}d close=%{public}d", __LINE__,
980 close);
981 EXPECT_TRUE(close);
982 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface001 : ClaimInterface");
983 }
984
985 /**
986 * @tc.name: UsbClaimInterface002
987 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
988 * @tc.type: FUNC
989 */
990 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface002, TestSize.Level1)
991 {
992 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface002 : ClaimInterface");
993 vector<UsbDevice> devi;
994 auto &UsbSrvClient = UsbSrvClient::GetInstance();
995 auto ret = UsbSrvClient.GetDevices(devi);
996 EXPECT_TRUE(ret == 0);
997 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d ret=%{public}d", __LINE__, ret);
998 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
999 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d size=%{public}zu", __LINE__,
1000 devi.size());
1001 USBDevicePipe pipe;
1002 UsbDevice device = devi.front();
1003 UsbSrvClient.RequestRight(device.GetName());
1004 ret = UsbSrvClient.OpenDevice(device, pipe);
1005 EXPECT_TRUE(ret == 0);
1006 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d OpenDevice=%{public}d", __LINE__,
1007 ret);
1008 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().front();
1009 ret = UsbSrvClient.ClaimInterface(pipe, interface, false);
1010 EXPECT_TRUE(ret == 0);
1011 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d ClaimInterface=%{public}d",
1012 __LINE__, ret);
1013 bool close = UsbSrvClient.Close(pipe);
1014 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface002 %{public}d close=%{public}d", __LINE__,
1015 close);
1016 EXPECT_TRUE(close);
1017 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface002 : ClaimInterface");
1018 }
1019
1020 /**
1021 * @tc.name: UsbClaimInterface003
1022 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
1023 * @tc.type: FUNC
1024 */
1025 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface003, TestSize.Level1)
1026 {
1027 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface003 : ClaimInterface");
1028 vector<UsbDevice> devi;
1029 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1030 auto ret = UsbSrvClient.GetDevices(devi);
1031 EXPECT_TRUE(ret == 0);
1032 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d ret=%{public}d", __LINE__, ret);
1033 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1034 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d size=%{public}zu", __LINE__,
1035 devi.size());
1036 USBDevicePipe pipe;
1037 UsbDevice device = devi.front();
1038 UsbSrvClient.RequestRight(device.GetName());
1039 ret = UsbSrvClient.OpenDevice(device, pipe);
1040 EXPECT_TRUE(ret == 0);
1041 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d OpenDevice=%{public}d", __LINE__,
1042 ret);
1043 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
1044 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1045 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d ClaimInterface=%{public}d",
1046 __LINE__, ret);
1047 EXPECT_TRUE(ret == 0);
1048 bool close = UsbSrvClient.Close(pipe);
1049 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface003 %{public}d close=%{public}d", __LINE__,
1050 close);
1051 EXPECT_TRUE(close);
1052 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface003 : ClaimInterface");
1053 }
1054
1055 /**
1056 * @tc.name: UsbClaimInterface004
1057 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
1058 * @tc.type: FUNC
1059 */
1060 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface004, TestSize.Level1)
1061 {
1062 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface004 : ClaimInterface");
1063 vector<UsbDevice> devi;
1064 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1065 auto ret = UsbSrvClient.GetDevices(devi);
1066 EXPECT_TRUE(ret == 0);
1067 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d ret=%{public}d", __LINE__, ret);
1068 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1069 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d size=%{public}zu", __LINE__,
1070 devi.size());
1071 USBDevicePipe pipe;
1072 UsbDevice device = devi.front();
1073 UsbSrvClient.RequestRight(device.GetName());
1074 ret = UsbSrvClient.OpenDevice(device, pipe);
1075 EXPECT_TRUE(ret == 0);
1076 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d OpenDevice=%{public}d", __LINE__,
1077 ret);
1078 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
1079 ret = UsbSrvClient.ClaimInterface(pipe, interface, false);
1080 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d ClaimInterface=%{public}d",
1081 __LINE__, ret);
1082 EXPECT_TRUE(ret == 0);
1083 bool close = UsbSrvClient.Close(pipe);
1084 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface004 %{public}d close=%{public}d", __LINE__,
1085 close);
1086 EXPECT_TRUE(close);
1087 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface004 : ClaimInterface");
1088 }
1089
1090 /**
1091 * @tc.name: UsbClaimInterface005
1092 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
1093 * @tc.type: FUNC
1094 */
1095 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface005, TestSize.Level1)
1096 {
1097 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface005 : ClaimInterface");
1098 vector<UsbDevice> devi;
1099 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1100 auto ret = UsbSrvClient.GetDevices(devi);
1101 EXPECT_TRUE(ret == 0);
1102 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d ret=%{public}d", __LINE__, ret);
1103 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1104 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d size=%{public}zu", __LINE__,
1105 devi.size());
1106 USBDevicePipe pipe;
1107 UsbDevice device = devi.front();
1108 UsbSrvClient.RequestRight(device.GetName());
1109 ret = UsbSrvClient.OpenDevice(device, pipe);
1110 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d OpenDevice=%{public}d", __LINE__,
1111 ret);
1112 EXPECT_TRUE(ret == 0);
1113 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().front();
1114 pipe.SetBusNum(BUFFER_SIZE);
1115 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1116 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d ClaimInterface=%{public}d",
1117 __LINE__, ret);
1118 EXPECT_TRUE(ret != 0);
1119 pipe.SetBusNum(device.GetBusNum());
1120 bool close = UsbSrvClient.Close(pipe);
1121 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface005 %{public}d close=%{public}d", __LINE__,
1122 close);
1123 EXPECT_TRUE(close);
1124 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface005 : ClaimInterface");
1125 }
1126
1127 /**
1128 * @tc.name: UsbClaimInterface006
1129 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
1130 * @tc.type: FUNC
1131 */
1132 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface006, TestSize.Level1)
1133 {
1134 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface006 : ClaimInterface");
1135 vector<UsbDevice> devi;
1136 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1137 auto ret = UsbSrvClient.GetDevices(devi);
1138 EXPECT_TRUE(ret == 0);
1139 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d ret=%{public}d", __LINE__, ret);
1140 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1141 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d size=%{public}zu", __LINE__,
1142 devi.size());
1143 USBDevicePipe pipe;
1144 UsbDevice device = devi.front();
1145 UsbSrvClient.RequestRight(device.GetName());
1146 ret = UsbSrvClient.OpenDevice(device, pipe);
1147 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d OpenDevice=%{public}d", __LINE__,
1148 ret);
1149 EXPECT_TRUE(ret == 0);
1150 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().front();
1151 pipe.SetDevAddr(BUFFER_SIZE);
1152 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1153 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d ClaimInterface=%{public}d",
1154 __LINE__, ret);
1155 EXPECT_TRUE(ret != 0);
1156 pipe.SetDevAddr(device.GetDevAddr());
1157 bool close = UsbSrvClient.Close(pipe);
1158 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface006 %{public}d close=%{public}d", __LINE__,
1159 close);
1160 EXPECT_TRUE(close);
1161 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface006 : ClaimInterface");
1162 }
1163
1164 /**
1165 * @tc.name: UsbClaimInterface007
1166 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
1167 * @tc.type: FUNC
1168 */
1169 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface007, TestSize.Level1)
1170 {
1171 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface007 : ClaimInterface");
1172 vector<UsbDevice> devi;
1173 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1174 auto ret = UsbSrvClient.GetDevices(devi);
1175 EXPECT_TRUE(ret == 0);
1176 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d ret=%{public}d", __LINE__, ret);
1177 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1178 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d size=%{public}zu", __LINE__,
1179 devi.size());
1180 USBDevicePipe pipe;
1181 UsbDevice device = devi.front();
1182 UsbSrvClient.RequestRight(device.GetName());
1183 ret = UsbSrvClient.OpenDevice(device, pipe);
1184 EXPECT_TRUE(ret == 0);
1185 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d OpenDevice=%{public}d", __LINE__,
1186 ret);
1187 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
1188 pipe.SetBusNum(BUFFER_SIZE);
1189 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1190 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d ClaimInterface=%{public}d",
1191 __LINE__, ret);
1192 EXPECT_TRUE(ret != 0);
1193 pipe.SetBusNum(device.GetBusNum());
1194 bool close = UsbSrvClient.Close(pipe);
1195 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface007 %{public}d close=%{public}d", __LINE__,
1196 close);
1197 EXPECT_TRUE(close);
1198 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface007 : ClaimInterface");
1199 }
1200
1201 /**
1202 * @tc.name: UsbClaimInterface008
1203 * @tc.desc: Test functions to ClaimInterface(const UsbInterface &interface, bool force);
1204 * @tc.type: FUNC
1205 */
1206 HWTEST_F(UsbDevicePipeTest, UsbClaimInterface008, TestSize.Level1)
1207 {
1208 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbClaimInterface008 : ClaimInterface");
1209 vector<UsbDevice> devi;
1210 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1211 auto ret = UsbSrvClient.GetDevices(devi);
1212 EXPECT_TRUE(ret == 0);
1213 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d ret=%{public}d", __LINE__, ret);
1214 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1215 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d size=%{public}zu", __LINE__,
1216 devi.size());
1217 USBDevicePipe pipe;
1218 UsbDevice device = devi.front();
1219 UsbSrvClient.RequestRight(device.GetName());
1220 ret = UsbSrvClient.OpenDevice(device, pipe);
1221 EXPECT_TRUE(ret == 0);
1222 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d OpenDevice=%{public}d", __LINE__,
1223 ret);
1224 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
1225 pipe.SetDevAddr(BUFFER_SIZE);
1226 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1227 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d ClaimInterface=%{public}d",
1228 __LINE__, ret);
1229 EXPECT_TRUE(ret != 0);
1230 pipe.SetDevAddr(device.GetDevAddr());
1231 bool close = UsbSrvClient.Close(pipe);
1232 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbClaimInterface008 %{public}d close=%{public}d", __LINE__,
1233 close);
1234 EXPECT_TRUE(close);
1235 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbClaimInterface008 : ClaimInterface");
1236 }
1237
1238 /**
1239 * @tc.name: UsbReleaseInterface001
1240 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
1241 * @tc.type: FUNC
1242 */
1243 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface001, TestSize.Level1)
1244 {
1245 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface001 : ReleaseInterface");
1246 vector<UsbDevice> devi;
1247 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1248 auto ret = UsbSrvClient.GetDevices(devi);
1249 EXPECT_TRUE(ret == 0);
1250 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d ret=%{public}d", __LINE__,
1251 ret);
1252 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1253 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d size=%{public}zu", __LINE__,
1254 devi.size());
1255 USBDevicePipe pipe;
1256 UsbDevice device = devi.front();
1257 UsbSrvClient.RequestRight(device.GetName());
1258 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
1259 ret = UsbSrvClient.OpenDevice(device, pipe);
1260 EXPECT_TRUE(ret == 0);
1261 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d OpenDevice=%{public}d",
1262 __LINE__, ret);
1263 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
1264 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d ReleaseInterface=%{public}d",
1265 __LINE__, ret);
1266 EXPECT_TRUE(ret == 0);
1267 bool close = UsbSrvClient.Close(pipe);
1268 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface001 %{public}d close=%{public}d", __LINE__,
1269 close);
1270 EXPECT_TRUE(close);
1271 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface001 : ReleaseInterface");
1272 }
1273
1274 /**
1275 * @tc.name: UsbReleaseInterface002
1276 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
1277 * @tc.type: FUNC
1278 */
1279 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface002, TestSize.Level1)
1280 {
1281 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface002 : ReleaseInterface");
1282 vector<UsbDevice> devi;
1283 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1284 auto ret = UsbSrvClient.GetDevices(devi);
1285 EXPECT_TRUE(ret == 0);
1286 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d ret=%{public}d", __LINE__,
1287 ret);
1288 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1289 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d size=%{public}zu", __LINE__,
1290 devi.size());
1291 USBDevicePipe pipe;
1292 UsbDevice device = devi.front();
1293 UsbSrvClient.RequestRight(device.GetName());
1294 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
1295 ret = UsbSrvClient.OpenDevice(device, pipe);
1296 EXPECT_TRUE(ret == 0);
1297 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d OpenDevice=%{public}d",
1298 __LINE__, ret);
1299 pipe.SetBusNum(BUFFER_SIZE);
1300 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
1301 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d ReleaseInterface=%{public}d",
1302 __LINE__, ret);
1303 EXPECT_TRUE(ret != 0);
1304 pipe.SetBusNum(device.GetBusNum());
1305 bool close = UsbSrvClient.Close(pipe);
1306 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface002 %{public}d close=%{public}d", __LINE__,
1307 close);
1308 EXPECT_TRUE(close);
1309 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface002 : ReleaseInterface");
1310 }
1311
1312 /**
1313 * @tc.name: UsbReleaseInterface003
1314 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
1315 * @tc.type: FUNC
1316 */
1317 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface003, TestSize.Level1)
1318 {
1319 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface003 : ReleaseInterface");
1320 vector<UsbDevice> devi;
1321 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1322 auto ret = UsbSrvClient.GetDevices(devi);
1323 EXPECT_TRUE(ret == 0);
1324 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d ret=%{public}d", __LINE__,
1325 ret);
1326 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1327 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d size=%{public}zu", __LINE__,
1328 devi.size());
1329 USBDevicePipe pipe;
1330 UsbDevice device = devi.front();
1331 UsbSrvClient.RequestRight(device.GetName());
1332 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
1333 ret = UsbSrvClient.OpenDevice(device, pipe);
1334 EXPECT_TRUE(ret == 0);
1335 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d OpenDevice=%{public}d",
1336 __LINE__, ret);
1337 pipe.SetDevAddr(BUFFER_SIZE);
1338 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
1339 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d ReleaseInterface=%{public}d",
1340 __LINE__, ret);
1341 EXPECT_TRUE(ret != 0);
1342 pipe.SetDevAddr(device.GetDevAddr());
1343 bool close = UsbSrvClient.Close(pipe);
1344 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface003 %{public}d close=%{public}d", __LINE__,
1345 close);
1346 EXPECT_TRUE(close);
1347 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface003 : ReleaseInterface");
1348 }
1349
1350 /**
1351 * @tc.name: UsbReleaseInterface004
1352 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
1353 * @tc.type: FUNC
1354 */
1355 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface004, TestSize.Level1)
1356 {
1357 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface004 : ReleaseInterface");
1358 vector<UsbDevice> devi;
1359 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1360 auto ret = UsbSrvClient.GetDevices(devi);
1361 EXPECT_TRUE(ret == 0);
1362 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d ret=%{public}d", __LINE__,
1363 ret);
1364 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1365 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d size=%{public}zu", __LINE__,
1366 devi.size());
1367 USBDevicePipe pipe;
1368 UsbDevice device = devi.front();
1369 UsbSrvClient.RequestRight(device.GetName());
1370 ret = UsbSrvClient.OpenDevice(device, pipe);
1371 EXPECT_TRUE(ret == 0);
1372 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d OpenDevice=%{public}d",
1373 __LINE__, ret);
1374 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
1375 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1376 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d ClaimInterface=%{public}d",
1377 __LINE__, ret);
1378 EXPECT_TRUE(ret == 0);
1379 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
1380 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d ReleaseInterface=%{public}d",
1381 __LINE__, ret);
1382 EXPECT_TRUE(ret == 0);
1383 bool close = UsbSrvClient.Close(pipe);
1384 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface004 %{public}d close=%{public}d", __LINE__,
1385 close);
1386 EXPECT_TRUE(close);
1387 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface004 : ReleaseInterface");
1388 }
1389
1390 /**
1391 * @tc.name: UsbReleaseInterface005
1392 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
1393 * @tc.type: FUNC
1394 */
1395 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface005, TestSize.Level1)
1396 {
1397 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface005 : ReleaseInterface");
1398 vector<UsbDevice> devi;
1399 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1400 auto ret = UsbSrvClient.GetDevices(devi);
1401 EXPECT_TRUE(ret == 0);
1402 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d ret=%{public}d", __LINE__,
1403 ret);
1404 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1405 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d size=%{public}zu", __LINE__,
1406 devi.size());
1407 USBDevicePipe pipe;
1408 UsbDevice device = devi.front();
1409 UsbSrvClient.RequestRight(device.GetName());
1410 ret = UsbSrvClient.OpenDevice(device, pipe);
1411 EXPECT_TRUE(ret == 0);
1412 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d OpenDevice=%{public}d",
1413 __LINE__, ret);
1414 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
1415 pipe.SetBusNum(BUFFER_SIZE);
1416 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
1417 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d ReleaseInterface=%{public}d",
1418 __LINE__, ret);
1419 EXPECT_TRUE(ret != 0);
1420 pipe.SetBusNum(device.GetBusNum());
1421 bool close = UsbSrvClient.Close(pipe);
1422 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface005 %{public}d close=%{public}d", __LINE__,
1423 close);
1424 EXPECT_TRUE(close);
1425 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface005 : ReleaseInterface");
1426 }
1427
1428 /**
1429 * @tc.name: UsbReleaseInterface006
1430 * @tc.desc: Test functions to ReleaseInterface(const UsbInterface &interface);
1431 * @tc.type: FUNC
1432 */
1433 HWTEST_F(UsbDevicePipeTest, UsbReleaseInterface006, TestSize.Level1)
1434 {
1435 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbReleaseInterface006 : ReleaseInterface");
1436 vector<UsbDevice> devi;
1437 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1438 auto ret = UsbSrvClient.GetDevices(devi);
1439 EXPECT_TRUE(ret == 0);
1440 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d ret=%{public}d", __LINE__,
1441 ret);
1442 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1443 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d size=%{public}zu", __LINE__,
1444 devi.size());
1445 USBDevicePipe pipe;
1446 UsbDevice device = devi.front();
1447 UsbSrvClient.RequestRight(device.GetName());
1448 ret = UsbSrvClient.OpenDevice(device, pipe);
1449 EXPECT_TRUE(ret == 0);
1450 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d OpenDevice=%{public}d",
1451 __LINE__, ret);
1452 UsbInterface interface = devi.front().GetConfigs().front().GetInterfaces().at(1);
1453 pipe.SetDevAddr(BUFFER_SIZE);
1454 ret = UsbSrvClient.ReleaseInterface(pipe, interface);
1455 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d ReleaseInterface=%{public}d",
1456 __LINE__, ret);
1457 EXPECT_TRUE(ret != 0);
1458 pipe.SetDevAddr(device.GetDevAddr());
1459 bool close = UsbSrvClient.Close(pipe);
1460 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbReleaseInterface006 %{public}d close=%{public}d", __LINE__,
1461 close);
1462 EXPECT_TRUE(close);
1463 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbReleaseInterface006 : ReleaseInterface");
1464 }
1465
1466 /**
1467 * @tc.name: UsbBulkTransfer001
1468 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1469 * timeout);
1470 * @tc.type: FUNC
1471 */
1472 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer001, TestSize.Level1)
1473 {
1474 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer001 : BulkTransfer");
1475 vector<UsbDevice> devi;
1476 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1477 auto ret = UsbSrvClient.GetDevices(devi);
1478 EXPECT_TRUE(ret == 0);
1479 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d ret=%{public}d", __LINE__, ret);
1480 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1481 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d size=%{public}zu", __LINE__,
1482 devi.size());
1483 USBDevicePipe pipe;
1484 UsbDevice device = devi.front();
1485 UsbSrvClient.RequestRight(device.GetName());
1486 ret = UsbSrvClient.OpenDevice(device, pipe);
1487 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d OpenDevice=%{public}d", __LINE__,
1488 ret);
1489 EXPECT_TRUE(ret == 0);
1490 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1491 USBEndpoint point = interface.GetEndpoints().front();
1492 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d point=%{public}d", __LINE__,
1493 point.GetInterfaceId());
1494 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1495 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d ClaimInterface=%{public}d",
1496 __LINE__, ret);
1497 EXPECT_TRUE(ret == 0);
1498 uint8_t buffer[BUFFER_SIZE] = "bulk read";
1499 uint32_t len = BUFFER_SIZE;
1500 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1501 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
1502 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d BulkTransfer=%{public}d", __LINE__,
1503 ret);
1504 EXPECT_TRUE(ret == 0);
1505 bool close = UsbSrvClient.Close(pipe);
1506 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer001 %{public}d close=%{public}d", __LINE__,
1507 close);
1508 EXPECT_TRUE(close);
1509 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer001 : BulkTransfer");
1510 }
1511
1512 /**
1513 * @tc.name: UsbBulkTransfer002
1514 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1515 * timeout);
1516 * @tc.type: FUNC
1517 */
1518 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer002, TestSize.Level1)
1519 {
1520 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer002 : BulkTransfer");
1521 vector<UsbDevice> devi;
1522 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1523 auto ret = UsbSrvClient.GetDevices(devi);
1524 EXPECT_TRUE(ret == 0);
1525 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d ret=%{public}d", __LINE__, ret);
1526 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1527 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d size=%{public}zu", __LINE__,
1528 devi.size());
1529 USBDevicePipe pipe;
1530 UsbDevice device = devi.front();
1531 UsbSrvClient.RequestRight(device.GetName());
1532 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1533 USBEndpoint point = interface.GetEndpoints().front();
1534 ret = UsbSrvClient.OpenDevice(device, pipe);
1535 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d OpenDevice=%{public}d", __LINE__,
1536 ret);
1537 EXPECT_TRUE(ret == 0);
1538 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1539 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d ClaimInterface=%{public}d",
1540 __LINE__, ret);
1541 EXPECT_TRUE(ret == 0);
1542 uint8_t buffer[BUFFER_SIZE] = "bulk read";
1543 uint32_t len = BUFFER_SIZE;
1544 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1545 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, -5);
1546 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d BulkTransfer=%{public}d", __LINE__,
1547 ret);
1548 EXPECT_TRUE(ret == 0);
1549 bool close = UsbSrvClient.Close(pipe);
1550 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer002 %{public}d close=%{public}d", __LINE__,
1551 close);
1552 EXPECT_TRUE(close);
1553 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer002 : BulkTransfer");
1554 }
1555
1556 /**
1557 * @tc.name: UsbBulkTransfer003
1558 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1559 * timeout);
1560 * @tc.type: FUNC
1561 */
1562 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer003, TestSize.Level1)
1563 {
1564 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer003 : BulkTransfer");
1565 vector<UsbDevice> devi;
1566 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1567 auto ret = UsbSrvClient.GetDevices(devi);
1568 EXPECT_TRUE(ret == 0);
1569 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d ret=%{public}d", __LINE__, ret);
1570 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1571 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d size=%{public}zu", __LINE__,
1572 devi.size());
1573 USBDevicePipe pipe;
1574 UsbDevice device = devi.front();
1575 UsbSrvClient.RequestRight(device.GetName());
1576 ret = UsbSrvClient.OpenDevice(device, pipe);
1577 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d OpenDevice=%{public}d", __LINE__,
1578 ret);
1579 EXPECT_TRUE(ret == 0);
1580 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1581 USBEndpoint point = interface.GetEndpoints().front();
1582 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1583 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d ClaimInterface=%{public}d",
1584 __LINE__, ret);
1585 EXPECT_TRUE(ret == 0);
1586 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d point=%{public}d", __LINE__,
1587 point.GetInterfaceId());
1588 uint8_t buffer[BUFFER_SIZE] = "bulk read";
1589 uint32_t len = BUFFER_SIZE;
1590 pipe.SetBusNum(BUFFER_SIZE);
1591 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1592 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
1593 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d BulkTransfer=%{public}d", __LINE__,
1594 ret);
1595 EXPECT_TRUE(ret != 0);
1596 pipe.SetBusNum(device.GetBusNum());
1597 bool close = UsbSrvClient.Close(pipe);
1598 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer003 %{public}d close=%{public}d", __LINE__,
1599 close);
1600 EXPECT_TRUE(close);
1601 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer003 : BulkTransfer");
1602 }
1603
1604 /**
1605 * @tc.name: UsbBulkTransfer004
1606 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1607 * timeout);
1608 * @tc.type: FUNC
1609 */
1610 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer004, TestSize.Level1)
1611 {
1612 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer004 : BulkTransfer");
1613 vector<UsbDevice> devi;
1614 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1615 auto ret = UsbSrvClient.GetDevices(devi);
1616 EXPECT_TRUE(ret == 0);
1617 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d ret=%{public}d", __LINE__, ret);
1618 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1619 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{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 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d OpenDevice=%{public}d", __LINE__,
1626 ret);
1627 EXPECT_TRUE(ret == 0);
1628 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1629 USBEndpoint point = interface.GetEndpoints().front();
1630 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d point=%{public}d", __LINE__,
1631 point.GetInterfaceId());
1632 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1633 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d ClaimInterface=%{public}d",
1634 __LINE__, ret);
1635 EXPECT_TRUE(ret == 0);
1636 uint8_t buffer[BUFFER_SIZE] = "bulk read";
1637 uint32_t len = BUFFER_SIZE;
1638 pipe.SetDevAddr(BUFFER_SIZE);
1639 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1640 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
1641 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d BulkTransfer=%{public}d", __LINE__,
1642 ret);
1643 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d len=%{public}d", __LINE__, len);
1644 EXPECT_TRUE(ret != 0);
1645 pipe.SetDevAddr(device.GetDevAddr());
1646 bool close = UsbSrvClient.Close(pipe);
1647 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer004 %{public}d close=%{public}d", __LINE__,
1648 close);
1649 EXPECT_TRUE(close);
1650 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer004 : BulkTransfer");
1651 }
1652
1653 /**
1654 * @tc.name: UsbBulkTransfer005
1655 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1656 * timeout);
1657 * @tc.type: FUNC
1658 */
1659 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer005, TestSize.Level1)
1660 {
1661 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer005 : BulkTransfer");
1662 vector<UsbDevice> devi;
1663 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1664 auto ret = UsbSrvClient.GetDevices(devi);
1665 EXPECT_TRUE(ret == 0);
1666 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d ret=%{public}d", __LINE__, ret);
1667 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1668 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d size=%{public}zu", __LINE__,
1669 devi.size());
1670 USBDevicePipe pipe;
1671 UsbDevice device = devi.front();
1672 UsbSrvClient.RequestRight(device.GetName());
1673 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1674 USBEndpoint point = interface.GetEndpoints().front();
1675 ret = UsbSrvClient.OpenDevice(device, pipe);
1676 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d OpenDevice=%{public}d", __LINE__,
1677 ret);
1678 EXPECT_TRUE(ret == 0);
1679 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1680 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d ClaimInterface=%{public}d",
1681 __LINE__, ret);
1682 EXPECT_TRUE(ret == 0);
1683 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d point=%{public}d", __LINE__,
1684 point.GetInterfaceId());
1685 uint8_t buffer[BUFFER_SIZE] = "bulk read";
1686 uint32_t len = BUFFER_SIZE;
1687 point.SetInterfaceId(BUFFER_SIZE);
1688 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1689 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
1690 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d BulkTransfer=%{public}d", __LINE__,
1691 ret);
1692 EXPECT_TRUE(ret != 0);
1693 bool close = UsbSrvClient.Close(pipe);
1694 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer005 %{public}d close=%{public}d", __LINE__,
1695 close);
1696 EXPECT_TRUE(close);
1697 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer005 : BulkTransfer");
1698 }
1699
1700 /**
1701 * @tc.name: UsbBulkTransfer006
1702 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1703 * timeout);
1704 * @tc.type: FUNC
1705 */
1706 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer006, TestSize.Level1)
1707 {
1708 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer006 : BulkTransfer");
1709 vector<UsbDevice> devi;
1710 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1711 auto ret = UsbSrvClient.GetDevices(devi);
1712 EXPECT_TRUE(ret == 0);
1713 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d ret=%{public}d", __LINE__, ret);
1714 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1715 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d size=%{public}zu", __LINE__,
1716 devi.size());
1717 USBDevicePipe pipe;
1718 UsbDevice device = devi.front();
1719 UsbSrvClient.RequestRight(device.GetName());
1720 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1721 USBEndpoint point = interface.GetEndpoints().front();
1722 ret = UsbSrvClient.OpenDevice(device, pipe);
1723 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d OpenDevice=%{public}d", __LINE__,
1724 ret);
1725 EXPECT_TRUE(ret == 0);
1726 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1727 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d ClaimInterface=%{public}d",
1728 __LINE__, ret);
1729 EXPECT_TRUE(ret == 0);
1730 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d point=%{public}d", __LINE__,
1731 point.GetInterfaceId());
1732 uint8_t buffer[BUFFER_SIZE] = "bulk read";
1733 uint32_t len = BUFFER_SIZE;
1734 point.SetAddr(BUFFER_SIZE);
1735 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1736 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
1737 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d BulkTransfer=%{public}d", __LINE__,
1738 ret);
1739 EXPECT_TRUE(ret != 0);
1740 bool close = UsbSrvClient.Close(pipe);
1741 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer006 %{public}d close=%{public}d", __LINE__,
1742 close);
1743 EXPECT_TRUE(close);
1744 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer006 : BulkTransfer");
1745 }
1746
1747 /**
1748 * @tc.name: UsbBulkTransfer007
1749 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1750 * timeout);
1751 * @tc.type: FUNC
1752 */
1753 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer007, TestSize.Level1)
1754 {
1755 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer007 : BulkTransfer");
1756 vector<UsbDevice> devi;
1757 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1758 auto ret = UsbSrvClient.GetDevices(devi);
1759 EXPECT_TRUE(ret == 0);
1760 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d ret=%{public}d", __LINE__, ret);
1761 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1762 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d size=%{public}zu", __LINE__,
1763 devi.size());
1764 USBDevicePipe pipe;
1765 UsbDevice device = devi.front();
1766 UsbSrvClient.RequestRight(device.GetName());
1767 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1768 USBEndpoint point = interface.GetEndpoints().at(1);
1769 ret = UsbSrvClient.OpenDevice(device, pipe);
1770 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d OpenDevice=%{public}d", __LINE__,
1771 ret);
1772 EXPECT_TRUE(ret == 0);
1773 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1774 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d ClaimInterface=%{public}d",
1775 __LINE__, ret);
1776 EXPECT_TRUE(ret == 0);
1777 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d point=%{public}d", __LINE__,
1778 point.GetInterfaceId());
1779 uint8_t buffer[BUFFER_SIZE] = "hello world Bulk transfer007";
1780 uint32_t len = BUFFER_SIZE;
1781 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1782 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
1783 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d BulkTransfer=%{public}d", __LINE__,
1784 ret);
1785 EXPECT_TRUE(ret == 0);
1786 bool close = UsbSrvClient.Close(pipe);
1787 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer007 %{public}d close=%{public}d", __LINE__,
1788 close);
1789 EXPECT_TRUE(close);
1790 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer007 : BulkTransfer");
1791 }
1792
1793 /**
1794 * @tc.name: UsbBulkTransfer008
1795 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1796 * timeout);
1797 * @tc.type: FUNC
1798 */
1799 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer008, TestSize.Level1)
1800 {
1801 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer008 : BulkTransfer");
1802 vector<UsbDevice> devi;
1803 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1804 auto ret = UsbSrvClient.GetDevices(devi);
1805 EXPECT_TRUE(ret == 0);
1806 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d ret=%{public}d", __LINE__, ret);
1807 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1808 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d size=%{public}zu", __LINE__,
1809 devi.size());
1810 USBDevicePipe pipe;
1811 UsbDevice device = devi.front();
1812 UsbSrvClient.RequestRight(device.GetName());
1813 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1814 USBEndpoint point = interface.GetEndpoints().at(1);
1815 ret = UsbSrvClient.OpenDevice(device, pipe);
1816 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d OpenDevice=%{public}d", __LINE__,
1817 ret);
1818 EXPECT_TRUE(ret == 0);
1819 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1820 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d ClaimInterface=%{public}d",
1821 __LINE__, ret);
1822 EXPECT_TRUE(ret == 0);
1823 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d point=%{public}d", __LINE__,
1824 point.GetInterfaceId());
1825 uint8_t buffer[BUFFER_SIZE] = "hello world Bulk transfer008";
1826 uint32_t len = BUFFER_SIZE;
1827 pipe.SetDevAddr(BUFFER_SIZE);
1828 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1829 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
1830 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d BulkTransfer=%{public}d", __LINE__,
1831 ret);
1832 EXPECT_TRUE(ret != 0);
1833 pipe.SetDevAddr(device.GetDevAddr());
1834 bool close = UsbSrvClient.Close(pipe);
1835 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer008 %{public}d close=%{public}d", __LINE__,
1836 close);
1837 EXPECT_TRUE(close);
1838 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer008 : BulkTransfer");
1839 }
1840
1841 /**
1842 * @tc.name: UsbBulkTransfer009
1843 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1844 * timeout);
1845 * @tc.type: FUNC
1846 */
1847 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer009, TestSize.Level1)
1848 {
1849 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer009 : BulkTransfer");
1850 vector<UsbDevice> devi;
1851 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1852 auto ret = UsbSrvClient.GetDevices(devi);
1853 EXPECT_TRUE(ret == 0);
1854 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d ret=%{public}d", __LINE__, ret);
1855 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1856 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d size=%{public}zu", __LINE__,
1857 devi.size());
1858 USBDevicePipe pipe;
1859 UsbDevice device = devi.front();
1860 UsbSrvClient.RequestRight(device.GetName());
1861 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1862 USBEndpoint point = interface.GetEndpoints().at(1);
1863 ret = UsbSrvClient.OpenDevice(device, pipe);
1864 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d OpenDevice=%{public}d", __LINE__,
1865 ret);
1866 EXPECT_TRUE(ret == 0);
1867 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1868 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d ClaimInterface=%{public}d",
1869 __LINE__, ret);
1870 EXPECT_TRUE(ret == 0);
1871 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d point=%{public}d", __LINE__,
1872 point.GetInterfaceId());
1873 uint8_t buffer[BUFFER_SIZE] = "hello world Bulk transfer009";
1874 uint32_t len = BUFFER_SIZE;
1875 pipe.SetBusNum(BUFFER_SIZE);
1876 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1877 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, 500);
1878 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d BulkTransfer=%{public}d", __LINE__,
1879 ret);
1880 EXPECT_TRUE(ret != 0);
1881 pipe.SetBusNum(device.GetBusNum());
1882 bool close = UsbSrvClient.Close(pipe);
1883 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer009 %{public}d close=%{public}d", __LINE__,
1884 close);
1885 EXPECT_TRUE(close);
1886 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer009 : BulkTransfer");
1887 }
1888
1889 /**
1890 * @tc.name: UsbBulkTransfer010
1891 * @tc.desc: Test functions to BulkTransfer(const USBEndpoint &endpoint, uint8_t *buffer, uint32_t &length, int32_t
1892 * timeout);
1893 * @tc.type: FUNC
1894 */
1895 HWTEST_F(UsbDevicePipeTest, UsbBulkTransfer010, TestSize.Level1)
1896 {
1897 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbBulkTransfer010 : BulkTransfer");
1898 vector<UsbDevice> devi;
1899 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1900 auto ret = UsbSrvClient.GetDevices(devi);
1901 EXPECT_TRUE(ret == 0);
1902 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d ret=%{public}d", __LINE__, ret);
1903 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1904 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d size=%{public}zu", __LINE__,
1905 devi.size());
1906 USBDevicePipe pipe;
1907 UsbDevice device = devi.front();
1908 UsbSrvClient.RequestRight(device.GetName());
1909 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1910 USBEndpoint point = interface.GetEndpoints().at(1);
1911 ret = UsbSrvClient.OpenDevice(device, pipe);
1912 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d OpenDevice=%{public}d", __LINE__,
1913 ret);
1914 EXPECT_TRUE(ret == 0);
1915 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1916 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d ClaimInterface=%{public}d",
1917 __LINE__, ret);
1918 EXPECT_TRUE(ret == 0);
1919 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d point=%{public}d", __LINE__,
1920 point.GetInterfaceId());
1921 uint8_t buffer[BUFFER_SIZE] = "hello world Bulk transfer010";
1922 uint32_t len = BUFFER_SIZE;
1923 std::vector<uint8_t> bulkbuffer = {buffer, buffer + len};
1924 ret = UsbSrvClient.BulkTransfer(pipe, point, bulkbuffer, -5);
1925 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d BulkTransfer=%{public}d", __LINE__,
1926 ret);
1927 EXPECT_TRUE(ret == 0);
1928 bool close = UsbSrvClient.Close(pipe);
1929 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::UsbBulkTransfer010 %{public}d close=%{public}d", __LINE__,
1930 close);
1931 EXPECT_TRUE(close);
1932 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbBulkTransfer010 : BulkTransfer");
1933 }
1934
1935 /**
1936 * @tc.name: SetConfiguration001
1937 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
1938 * @tc.type: FUNC
1939 */
1940 HWTEST_F(UsbDevicePipeTest, SetConfiguration001, TestSize.Level1)
1941 {
1942 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetConfiguration001 : SetConfiguration");
1943 vector<UsbDevice> devi;
1944 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1945 auto ret = UsbSrvClient.GetDevices(devi);
1946 EXPECT_TRUE(ret == 0);
1947 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d ret=%{public}d", __LINE__, ret);
1948 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1949 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d size=%{public}zu", __LINE__,
1950 devi.size());
1951 USBDevicePipe pipe;
1952 UsbDevice device = devi.front();
1953 UsbSrvClient.RequestRight(device.GetName());
1954 USBConfig config = device.GetConfigs().front();
1955 ret = UsbSrvClient.OpenDevice(device, pipe);
1956 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d OpenDevice=%{public}d", __LINE__,
1957 ret);
1958 EXPECT_TRUE(ret == 0);
1959 ret = UsbSrvClient.SetConfiguration(pipe, config);
1960 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d SetConfiguration=%{public}d",
1961 __LINE__, ret);
1962 EXPECT_TRUE(ret == 0);
1963 bool close = UsbSrvClient.Close(pipe);
1964 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration001 %{public}d close=%{public}d", __LINE__,
1965 close);
1966 EXPECT_TRUE(close);
1967 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetConfiguration001 : SetConfiguration");
1968 }
1969
1970 /**
1971 * @tc.name: SetConfiguration002
1972 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
1973 * @tc.type: FUNC
1974 */
1975 HWTEST_F(UsbDevicePipeTest, SetConfiguration002, TestSize.Level1)
1976 {
1977 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetConfiguration002 : SetConfiguration");
1978 vector<UsbDevice> devi;
1979 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1980 auto ret = UsbSrvClient.GetDevices(devi);
1981 EXPECT_TRUE(ret == 0);
1982 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d ret=%{public}d", __LINE__, ret);
1983 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1984 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d size=%{public}zu", __LINE__,
1985 devi.size());
1986 USBDevicePipe pipe;
1987 UsbDevice device = devi.front();
1988 UsbSrvClient.RequestRight(device.GetName());
1989 USBConfig config = device.GetConfigs().front();
1990 ret = UsbSrvClient.OpenDevice(device, pipe);
1991 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d OpenDevice=%{public}d", __LINE__,
1992 ret);
1993 EXPECT_TRUE(ret == 0);
1994 pipe.SetBusNum(BUFFER_SIZE);
1995 ret = UsbSrvClient.SetConfiguration(pipe, config);
1996 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d SetConfiguration=%{public}d",
1997 __LINE__, ret);
1998 EXPECT_TRUE(ret != 0);
1999 pipe.SetBusNum(device.GetBusNum());
2000 bool close = UsbSrvClient.Close(pipe);
2001 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration002 %{public}d close=%{public}d", __LINE__,
2002 close);
2003 EXPECT_TRUE(close);
2004 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetConfiguration002 : SetConfiguration");
2005 }
2006
2007 /**
2008 * @tc.name: SetConfiguration003
2009 * @tc.desc: Test functions to SetConfiguration(const USBConfig &config);
2010 * @tc.type: FUNC
2011 */
2012 HWTEST_F(UsbDevicePipeTest, SetConfiguration003, TestSize.Level1)
2013 {
2014 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetConfiguration003 : SetConfiguration");
2015 vector<UsbDevice> devi;
2016 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2017 auto ret = UsbSrvClient.GetDevices(devi);
2018 EXPECT_TRUE(ret == 0);
2019 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d ret=%{public}d", __LINE__, ret);
2020 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2021 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d size=%{public}zu", __LINE__,
2022 devi.size());
2023 USBDevicePipe pipe;
2024 UsbDevice device = devi.front();
2025 UsbSrvClient.RequestRight(device.GetName());
2026 USBConfig config = device.GetConfigs().front();
2027 ret = UsbSrvClient.OpenDevice(device, pipe);
2028 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d OpenDevice=%{public}d", __LINE__,
2029 ret);
2030 EXPECT_TRUE(ret == 0);
2031 pipe.SetDevAddr(BUFFER_SIZE);
2032 ret = UsbSrvClient.SetConfiguration(pipe, config);
2033 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d SetConfiguration=%{public}d",
2034 __LINE__, ret);
2035 EXPECT_TRUE(ret != 0);
2036 pipe.SetDevAddr(device.GetDevAddr());
2037 bool close = UsbSrvClient.Close(pipe);
2038 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetConfiguration003 %{public}d close=%{public}d", __LINE__,
2039 close);
2040 EXPECT_TRUE(close);
2041
2042 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetConfiguration003 : SetConfiguration");
2043 }
2044
2045 /**
2046 * @tc.name: Close001
2047 * @tc.desc: Test functions to Close();
2048 * @tc.type: FUNC
2049 */
2050 HWTEST_F(UsbDevicePipeTest, Close001, TestSize.Level1)
2051 {
2052 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Close001 : Close");
2053 vector<UsbDevice> devi;
2054 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2055 auto ret = UsbSrvClient.GetDevices(devi);
2056 EXPECT_TRUE(ret == 0);
2057 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d ret=%{public}d", __LINE__, ret);
2058 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2059 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d size=%{public}zu", __LINE__, devi.size());
2060 USBDevicePipe pipe;
2061 UsbDevice device = devi.front();
2062 UsbSrvClient.RequestRight(device.GetName());
2063 ret = UsbSrvClient.OpenDevice(device, pipe);
2064 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
2065 EXPECT_TRUE(ret == 0);
2066 ret = UsbSrvClient.Close(pipe);
2067 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close001 %{public}d close=%{public}d", __LINE__, ret);
2068 EXPECT_TRUE(ret);
2069 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Close001 : Close");
2070 }
2071
2072 /**
2073 * @tc.name: Close002
2074 * @tc.desc: Test functions to Close();
2075 * @tc.type: FUNC
2076 */
2077 HWTEST_F(UsbDevicePipeTest, Close002, TestSize.Level1)
2078 {
2079 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Close002 : Close");
2080 vector<UsbDevice> devi;
2081 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2082 auto ret = UsbSrvClient.GetDevices(devi);
2083 EXPECT_TRUE(ret == 0);
2084 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d ret=%{public}d", __LINE__, ret);
2085 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2086 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d size=%{public}zu", __LINE__, devi.size());
2087 USBDevicePipe pipe;
2088 UsbDevice device = devi.front();
2089 UsbSrvClient.RequestRight(device.GetName());
2090 ret = UsbSrvClient.OpenDevice(device, pipe);
2091 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d OpenDevice=%{public}d", __LINE__, ret);
2092 EXPECT_TRUE(ret == 0);
2093 pipe.SetBusNum(BUFFER_SIZE);
2094 ret = UsbSrvClient.Close(pipe);
2095 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d close=%{public}d", __LINE__, ret);
2096 EXPECT_TRUE(!ret);
2097 pipe.SetBusNum(device.GetBusNum());
2098 ret = UsbSrvClient.Close(pipe);
2099 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close002 %{public}d close=%{public}d", __LINE__, ret);
2100 EXPECT_TRUE(ret);
2101 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Close002 : Close");
2102 }
2103
2104 /**
2105 * @tc.name: Close003
2106 * @tc.desc: Test functions to Close();
2107 * @tc.type: FUNC
2108 */
2109 HWTEST_F(UsbDevicePipeTest, Close003, TestSize.Level1)
2110 {
2111 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Close003 : Close");
2112 vector<UsbDevice> devi;
2113 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2114 auto ret = UsbSrvClient.GetDevices(devi);
2115 EXPECT_TRUE(ret == 0);
2116 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d ret=%{public}d", __LINE__, ret);
2117 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2118 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d size=%{public}zu", __LINE__, devi.size());
2119 USBDevicePipe pipe;
2120 UsbDevice device = devi.front();
2121 UsbSrvClient.RequestRight(device.GetName());
2122 ret = UsbSrvClient.OpenDevice(device, pipe);
2123 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d OpenDevice=%{public}d", __LINE__, ret);
2124 EXPECT_TRUE(ret == 0);
2125 pipe.SetDevAddr(BUFFER_SIZE);
2126 ret = UsbSrvClient.Close(pipe);
2127 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d close=%{public}d", __LINE__, ret);
2128 EXPECT_TRUE(!ret);
2129 pipe.SetDevAddr(device.GetDevAddr());
2130 ret = UsbSrvClient.Close(pipe);
2131 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close003 %{public}d close=%{public}d", __LINE__, ret);
2132 EXPECT_TRUE(ret);
2133 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Close003 : Close");
2134 }
2135
2136 /**
2137 * @tc.name: SetInterface001
2138 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
2139 * @tc.type: FUNC
2140 */
2141 HWTEST_F(UsbDevicePipeTest, SetInterface001, TestSize.Level1)
2142 {
2143 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface001 : SetInterface");
2144 vector<UsbDevice> devi;
2145 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2146 auto ret = UsbSrvClient.GetDevices(devi);
2147 EXPECT_TRUE(ret == 0);
2148 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d ret=%{public}d", __LINE__, ret);
2149 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2150 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d size=%{public}zu", __LINE__,
2151 devi.size());
2152 USBDevicePipe pipe;
2153 UsbDevice device = devi.front();
2154 UsbSrvClient.RequestRight(device.GetName());
2155 ret = UsbSrvClient.OpenDevice(device, pipe);
2156 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d OpenDevice=%{public}d", __LINE__,
2157 ret);
2158 EXPECT_TRUE(ret == 0);
2159 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
2160 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2161 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d ClaimInterface=%{public}d", __LINE__,
2162 ret);
2163 EXPECT_TRUE(ret == 0);
2164 ret = UsbSrvClient.SetInterface(pipe, interface);
2165 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d SetInterface=%{public}d", __LINE__,
2166 ret);
2167 EXPECT_TRUE(ret == 0);
2168 bool close = UsbSrvClient.Close(pipe);
2169 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface001 %{public}d close=%{public}d", __LINE__, close);
2170 EXPECT_TRUE(close);
2171 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface001 : SetInterface");
2172 }
2173
2174 /**
2175 * @tc.name: SetInterface002
2176 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
2177 * @tc.type: FUNC
2178 */
2179 HWTEST_F(UsbDevicePipeTest, SetInterface002, TestSize.Level1)
2180 {
2181 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface002 : SetInterface");
2182 vector<UsbDevice> devi;
2183 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2184 auto ret = UsbSrvClient.GetDevices(devi);
2185 EXPECT_TRUE(ret == 0);
2186 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d ret=%{public}d", __LINE__, ret);
2187 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2188 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d size=%{public}zu", __LINE__,
2189 devi.size());
2190 USBDevicePipe pipe;
2191 UsbDevice device = devi.front();
2192 UsbSrvClient.RequestRight(device.GetName());
2193 ret = UsbSrvClient.OpenDevice(device, pipe);
2194 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d OpenDevice=%{public}d", __LINE__,
2195 ret);
2196 EXPECT_TRUE(ret == 0);
2197 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
2198 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2199 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d ClaimInterface=%{public}d", __LINE__,
2200 ret);
2201 EXPECT_TRUE(ret == 0);
2202 pipe.SetBusNum(BUFFER_SIZE);
2203 ret = UsbSrvClient.SetInterface(pipe, interface);
2204 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d SetInterface=%{public}d", __LINE__,
2205 ret);
2206 EXPECT_TRUE(ret != 0);
2207 pipe.SetBusNum(device.GetBusNum());
2208 bool close = UsbSrvClient.Close(pipe);
2209 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface002 %{public}d close=%{public}d", __LINE__, close);
2210 EXPECT_TRUE(close);
2211 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface002 : SetInterface");
2212 }
2213
2214 /**
2215 * @tc.name: SetInterface003
2216 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
2217 * @tc.type: FUNC
2218 */
2219 HWTEST_F(UsbDevicePipeTest, SetInterface003, TestSize.Level1)
2220 {
2221 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface003 : SetInterface");
2222 vector<UsbDevice> devi;
2223 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2224 auto ret = UsbSrvClient.GetDevices(devi);
2225 EXPECT_TRUE(ret == 0);
2226 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d ret=%{public}d", __LINE__, ret);
2227 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2228 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d size=%{public}zu", __LINE__,
2229 devi.size());
2230 USBDevicePipe pipe;
2231 UsbDevice device = devi.front();
2232 UsbSrvClient.RequestRight(device.GetName());
2233 ret = UsbSrvClient.OpenDevice(device, pipe);
2234 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d OpenDevice=%{public}d", __LINE__,
2235 ret);
2236 EXPECT_TRUE(ret == 0);
2237 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
2238 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2239 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d ClaimInterface=%{public}d", __LINE__,
2240 ret);
2241 EXPECT_TRUE(ret == 0);
2242 pipe.SetDevAddr(BUFFER_SIZE);
2243 ret = UsbSrvClient.SetInterface(pipe, interface);
2244 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d SetInterface=%{public}d", __LINE__,
2245 ret);
2246 EXPECT_TRUE(ret != 0);
2247 pipe.SetDevAddr(device.GetDevAddr());
2248 bool close = UsbSrvClient.Close(pipe);
2249 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface003 %{public}d close=%{public}d", __LINE__, close);
2250 EXPECT_TRUE(close);
2251 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface003 : SetInterface");
2252 }
2253
2254 /**
2255 * @tc.name: SetInterface004
2256 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
2257 * @tc.type: FUNC
2258 */
2259 HWTEST_F(UsbDevicePipeTest, SetInterface004, TestSize.Level1)
2260 {
2261 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface004 : SetInterface");
2262 vector<UsbDevice> devi;
2263 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2264 auto ret = UsbSrvClient.GetDevices(devi);
2265 EXPECT_TRUE(ret == 0);
2266 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d ret=%{public}d", __LINE__, ret);
2267 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2268 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d size=%{public}zu", __LINE__,
2269 devi.size());
2270 USBDevicePipe pipe;
2271 UsbDevice device = devi.front();
2272 UsbSrvClient.RequestRight(device.GetName());
2273 ret = UsbSrvClient.OpenDevice(device, pipe);
2274 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d OpenDevice=%{public}d", __LINE__,
2275 ret);
2276 EXPECT_TRUE(ret == 0);
2277 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
2278 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2279 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d ClaimInterface=%{public}d", __LINE__,
2280 ret);
2281 EXPECT_TRUE(ret == 0);
2282 ret = UsbSrvClient.SetInterface(pipe, interface);
2283 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d SetInterface=%{public}d", __LINE__,
2284 ret);
2285 EXPECT_TRUE(ret == 0);
2286 bool close = UsbSrvClient.Close(pipe);
2287 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface004 %{public}d close=%{public}d", __LINE__, close);
2288 EXPECT_TRUE(close);
2289 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface004 : SetInterface");
2290 }
2291
2292 /**
2293 * @tc.name: SetInterface005
2294 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
2295 * @tc.type: FUNC
2296 */
2297 HWTEST_F(UsbDevicePipeTest, SetInterface005, TestSize.Level1)
2298 {
2299 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface005 : SetInterface");
2300 vector<UsbDevice> devi;
2301 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2302 auto ret = UsbSrvClient.GetDevices(devi);
2303 EXPECT_TRUE(ret == 0);
2304 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d ret=%{public}d", __LINE__, ret);
2305 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2306 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d size=%{public}zu", __LINE__,
2307 devi.size());
2308 USBDevicePipe pipe;
2309 UsbDevice device = devi.front();
2310 UsbSrvClient.RequestRight(device.GetName());
2311 ret = UsbSrvClient.OpenDevice(device, pipe);
2312 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d OpenDevice=%{public}d", __LINE__,
2313 ret);
2314 EXPECT_TRUE(ret == 0);
2315 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
2316 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2317 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d ClaimInterface=%{public}d", __LINE__,
2318 ret);
2319 EXPECT_TRUE(ret == 0);
2320 pipe.SetBusNum(BUFFER_SIZE);
2321 ret = UsbSrvClient.SetInterface(pipe, interface);
2322 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d SetInterface=%{public}d", __LINE__,
2323 ret);
2324 EXPECT_TRUE(ret != 0);
2325 pipe.SetBusNum(device.GetBusNum());
2326 bool close = UsbSrvClient.Close(pipe);
2327 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface005 %{public}d close=%{public}d", __LINE__, close);
2328 EXPECT_TRUE(close);
2329 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface005 : SetInterface");
2330 }
2331
2332 /**
2333 * @tc.name: SetInterface006
2334 * @tc.desc: Test functions to SetInterface(const UsbInterface &interface);
2335 * @tc.type: FUNC
2336 */
2337 HWTEST_F(UsbDevicePipeTest, SetInterface006, TestSize.Level1)
2338 {
2339 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : SetInterface006 : SetInterface");
2340 vector<UsbDevice> devi;
2341 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2342 auto ret = UsbSrvClient.GetDevices(devi);
2343 EXPECT_TRUE(ret == 0);
2344 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d ret=%{public}d", __LINE__, ret);
2345 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2346 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d size=%{public}zu", __LINE__,
2347 devi.size());
2348 USBDevicePipe pipe;
2349 UsbDevice device = devi.front();
2350 UsbSrvClient.RequestRight(device.GetName());
2351 ret = UsbSrvClient.OpenDevice(device, pipe);
2352 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d OpenDevice=%{public}d", __LINE__,
2353 ret);
2354 EXPECT_TRUE(ret == 0);
2355 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
2356 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
2357 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d ClaimInterface=%{public}d", __LINE__,
2358 ret);
2359 EXPECT_TRUE(ret == 0);
2360 pipe.SetDevAddr(BUFFER_SIZE);
2361 ret = UsbSrvClient.SetInterface(pipe, interface);
2362 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d SetInterface=%{public}d", __LINE__,
2363 ret);
2364 EXPECT_TRUE(ret != 0);
2365 pipe.SetDevAddr(device.GetDevAddr());
2366 bool close = UsbSrvClient.Close(pipe);
2367 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d close=%{public}d", __LINE__, close);
2368 EXPECT_TRUE(close);
2369 USB_HILOGI(MODULE_USB_SERVICE, "Case End : SetInterface006 : SetInterface");
2370 }
2371
2372 /**
2373 * @tc.name: GetRawDescriptors001
2374 * @tc.desc: Test functions to GetRawDescriptors
2375 * @tc.type: FUNC
2376 */
2377 HWTEST_F(UsbDevicePipeTest, GetRawDescriptors001, TestSize.Level1)
2378 {
2379 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetRawDescriptors001 : GetRawDescriptors");
2380 vector<UsbDevice> devi;
2381 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2382 auto ret = UsbSrvClient.GetDevices(devi);
2383 EXPECT_TRUE(ret == 0);
2384 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d ret=%{public}d", __LINE__, ret);
2385 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2386 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d size=%{public}zu", __LINE__,
2387 devi.size());
2388 USBDevicePipe pipe;
2389 UsbDevice device = devi.front();
2390 UsbSrvClient.RequestRight(device.GetName());
2391 ret = UsbSrvClient.OpenDevice(device, pipe);
2392 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d OpenDevice=%{public}d",
2393 __LINE__, ret);
2394 EXPECT_TRUE(ret == 0);
2395 std::vector<uint8_t> vData;
2396 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
2397 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors001 %{public}d GetRawDescriptors=%{public}d",
2398 __LINE__, ret);
2399 EXPECT_TRUE(ret == 0);
2400 ret = UsbSrvClient.Close(pipe);
2401 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
2402 EXPECT_TRUE(ret);
2403 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetRawDescriptors001 : ControlTransfer");
2404 }
2405
2406 /**
2407 * @tc.name: GetRawDescriptors002
2408 * @tc.desc: Test functions to GetRawDescriptors
2409 * @tc.type: FUNC
2410 */
2411 HWTEST_F(UsbDevicePipeTest, GetRawDescriptors002, TestSize.Level1)
2412 {
2413 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetRawDescriptors002 : GetRawDescriptors");
2414 vector<UsbDevice> devi;
2415 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2416 auto ret = UsbSrvClient.GetDevices(devi);
2417 EXPECT_TRUE(ret == 0);
2418 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d ret=%{public}d", __LINE__, ret);
2419 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2420 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d size=%{public}zu", __LINE__,
2421 devi.size());
2422 USBDevicePipe pipe;
2423 UsbDevice device = devi.front();
2424 UsbSrvClient.RequestRight(device.GetName());
2425 ret = UsbSrvClient.OpenDevice(device, pipe);
2426 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d OpenDevice=%{public}d",
2427 __LINE__, ret);
2428 EXPECT_TRUE(ret == 0);
2429 std::vector<uint8_t> vData;
2430 USBDevicePipe pipeTmp = pipe;
2431 pipeTmp.SetBusNum(BUFFER_SIZE);
2432 ret = UsbSrvClient.GetRawDescriptors(pipeTmp, vData);
2433 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors002 %{public}d GetRawDescriptors=%{public}d",
2434 __LINE__, ret);
2435 EXPECT_TRUE(ret != 0);
2436 ret = UsbSrvClient.Close(pipe);
2437 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
2438 EXPECT_TRUE(ret);
2439 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetRawDescriptors002 : ControlTransfer");
2440 }
2441
2442 /**
2443 * @tc.name: GetRawDescriptors003
2444 * @tc.desc: Test functions to GetRawDescriptors
2445 * @tc.type: FUNC
2446 */
2447 HWTEST_F(UsbDevicePipeTest, GetRawDescriptors003, TestSize.Level1)
2448 {
2449 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetRawDescriptors003 : GetRawDescriptors");
2450 vector<UsbDevice> devi;
2451 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2452 auto ret = UsbSrvClient.GetDevices(devi);
2453 EXPECT_TRUE(ret == 0);
2454 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d ret=%{public}d", __LINE__, ret);
2455 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2456 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d size=%{public}zu", __LINE__,
2457 devi.size());
2458 USBDevicePipe pipe;
2459 UsbDevice device = devi.front();
2460 UsbSrvClient.RequestRight(device.GetName());
2461 ret = UsbSrvClient.OpenDevice(device, pipe);
2462 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d OpenDevice=%{public}d",
2463 __LINE__, ret);
2464 EXPECT_TRUE(ret == 0);
2465 std::vector<uint8_t> vData;
2466 USBDevicePipe pipeTmp = pipe;
2467 pipeTmp.SetDevAddr(BUFFER_SIZE);
2468 ret = UsbSrvClient.GetRawDescriptors(pipeTmp, vData);
2469 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetRawDescriptors003 %{public}d GetRawDescriptors=%{public}d",
2470 __LINE__, ret);
2471 EXPECT_TRUE(ret != 0);
2472 ret = UsbSrvClient.Close(pipe);
2473 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
2474 EXPECT_TRUE(ret);
2475 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetRawDescriptors003 : ControlTransfer");
2476 }
2477
2478 /**
2479 * @tc.name: GetFileDescriptors001
2480 * @tc.desc: Test functions to GetRawDescriptors
2481 * @tc.type: FUNC
2482 */
2483 HWTEST_F(UsbDevicePipeTest, GetFileDescriptors001, TestSize.Level1)
2484 {
2485 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetFileDescriptors001 : GetRawDescriptors");
2486 vector<UsbDevice> devi;
2487 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2488 auto ret = UsbSrvClient.GetDevices(devi);
2489 EXPECT_TRUE(ret == 0);
2490 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d ret=%{public}d", __LINE__, ret);
2491 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2492 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d size=%{public}zu", __LINE__,
2493 devi.size());
2494 USBDevicePipe pipe;
2495 UsbDevice device = devi.front();
2496 UsbSrvClient.RequestRight(device.GetName());
2497 ret = UsbSrvClient.OpenDevice(device, pipe);
2498 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d OpenDevice=%{public}d",
2499 __LINE__, ret);
2500 EXPECT_TRUE(ret == 0);
2501 std::vector<uint8_t> vData;
2502 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
2503 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d GetRawDescriptors=%{public}d",
2504 __LINE__, ret);
2505 EXPECT_TRUE(ret == 0);
2506 int32_t fd = 0;
2507 ret = UsbSrvClient.GetFileDescriptor(pipe, fd);
2508 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d GetFileDescriptor=%{public}d",
2509 __LINE__, ret);
2510 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d fd=%{public}d",
2511 __LINE__, fd);
2512 EXPECT_TRUE(ret == 0);
2513 ret = UsbSrvClient.Close(pipe);
2514 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
2515 EXPECT_TRUE(ret);
2516 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetFileDescriptors001 : ControlTransfer");
2517 }
2518
2519 /**
2520 * @tc.name: GetFileDescriptors002
2521 * @tc.desc: Test functions to GetRawDescriptors
2522 * @tc.type: FUNC
2523 */
2524 HWTEST_F(UsbDevicePipeTest, GetFileDescriptors002, TestSize.Level1)
2525 {
2526 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetFileDescriptors002 : GetRawDescriptors");
2527 vector<UsbDevice> devi;
2528 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2529 auto ret = UsbSrvClient.GetDevices(devi);
2530 EXPECT_TRUE(ret == 0);
2531 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d ret=%{public}d", __LINE__, ret);
2532 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2533 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d size=%{public}zu", __LINE__,
2534 devi.size());
2535 USBDevicePipe pipe;
2536 UsbDevice device = devi.front();
2537 UsbSrvClient.RequestRight(device.GetName());
2538 ret = UsbSrvClient.OpenDevice(device, pipe);
2539 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d OpenDevice=%{public}d",
2540 __LINE__, ret);
2541 EXPECT_TRUE(ret == 0);
2542 std::vector<uint8_t> vData;
2543 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
2544 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d GetRawDescriptors=%{public}d",
2545 __LINE__, ret);
2546 EXPECT_TRUE(ret == 0);
2547 USBDevicePipe pipeTmp = pipe;
2548 pipeTmp.SetBusNum(BUFFER_SIZE);
2549 int32_t fd = 0;
2550 ret = UsbSrvClient.GetFileDescriptor(pipeTmp, fd);
2551 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors002 %{public}d GetFileDescriptor=%{public}d",
2552 __LINE__, ret);
2553 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d fd=%{public}d",
2554 __LINE__, fd);
2555 EXPECT_TRUE(ret != 0);
2556 ret = UsbSrvClient.Close(pipe);
2557 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
2558 EXPECT_TRUE(ret);
2559 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetFileDescriptors002 : ControlTransfer");
2560 }
2561
2562 /**
2563 * @tc.name: GetFileDescriptors003
2564 * @tc.desc: Test functions to GetRawDescriptors
2565 * @tc.type: FUNC
2566 */
2567 HWTEST_F(UsbDevicePipeTest, GetFileDescriptors003, TestSize.Level1)
2568 {
2569 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetFileDescriptors003 : GetRawDescriptors");
2570 vector<UsbDevice> devi;
2571 auto &UsbSrvClient = UsbSrvClient::GetInstance();
2572 auto ret = UsbSrvClient.GetDevices(devi);
2573 EXPECT_TRUE(ret == 0);
2574 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d ret=%{public}d", __LINE__, ret);
2575 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
2576 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d size=%{public}zu", __LINE__,
2577 devi.size());
2578 USBDevicePipe pipe;
2579 UsbDevice device = devi.front();
2580 UsbSrvClient.RequestRight(device.GetName());
2581 ret = UsbSrvClient.OpenDevice(device, pipe);
2582 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d OpenDevice=%{public}d",
2583 __LINE__, ret);
2584 EXPECT_TRUE(ret == 0);
2585 std::vector<uint8_t> vData;
2586 ret = UsbSrvClient.GetRawDescriptors(pipe, vData);
2587 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d GetRawDescriptors=%{public}d",
2588 __LINE__, ret);
2589 EXPECT_TRUE(ret == 0);
2590 USBDevicePipe pipeTmp = pipe;
2591 pipeTmp.SetDevAddr(BUFFER_SIZE);
2592 int32_t fd = 0;
2593 ret = UsbSrvClient.GetFileDescriptor(pipeTmp, fd);
2594 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors003 %{public}d GetFileDescriptor=%{public}d",
2595 __LINE__, ret);
2596 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::GetFileDescriptors001 %{public}d fd=%{public}d",
2597 __LINE__, fd);
2598 EXPECT_TRUE(ret != 0);
2599 ret = UsbSrvClient.Close(pipe);
2600 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::Close=%{public}d", ret);
2601 EXPECT_TRUE(ret);
2602 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetFileDescriptors003 : ControlTransfer");
2603 }
2604 } // DevicePipe
2605 } // USB
2606 } // OHOS
2607