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