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_request_test.h"
17
18 #include <csignal>
19 #include <iostream>
20 #include <vector>
21
22 #include "if_system_ability_manager.h"
23 #include "ipc_skeleton.h"
24 #include "iservice_registry.h"
25 #include "iusb_srv.h"
26 #include "system_ability_definition.h"
27 #include "usb_common.h"
28 #include "usb_device_pipe.h"
29 #include "usb_request.h"
30 #include "usb_srv_client.h"
31 #include "v1_0/usb_types.h"
32
33 using namespace testing::ext;
34 using namespace OHOS::USB;
35 using namespace OHOS;
36 using namespace std;
37
38 namespace OHOS {
39 namespace USB {
40 namespace Request {
41 constexpr int32_t SLEEP_TIME = 3;
42 constexpr int32_t TAG_SIZE = 50;
43 constexpr int32_t BUFFER_SIZE = 255;
SetUpTestCase(void)44 void UsbRequestTest::SetUpTestCase(void)
45 {
46 auto &srvClient = UsbSrvClient::GetInstance();
47 auto ret = srvClient.SetPortRole(1, 1, 1);
48 sleep(SLEEP_TIME);
49 USB_HILOGI(MODULE_USB_SERVICE, "UsbdRequestTest:: [Device] SetPortRole=%{public}d", ret);
50 ASSERT_TRUE(ret == 0);
51 if (ret != 0) {
52 exit(0);
53 }
54 std::cout << "please connect device, press enter to continue" << std::endl;
55 int32_t c;
56 while ((c = getchar()) != '\n' && c != EOF) {
57 ;
58 }
59 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbdRequestTest");
60 }
61
TearDownTestCase(void)62 void UsbRequestTest::TearDownTestCase(void)
63 {
64 USB_HILOGI(MODULE_USB_SERVICE, "End UsbdRequestTest");
65 }
66
SetUp(void)67 void UsbRequestTest::SetUp(void) {}
68
TearDown(void)69 void UsbRequestTest::TearDown(void) {}
70 /**
71 * @tc.name: UsbRequestInitialize001
72 * @tc.desc: Test functions of Initialize(const USBDevicePipe &pipe, const USBEndpoint &endpoint)
73 * @tc.type: FUNC
74 */
75 HWTEST_F(UsbRequestTest, UsbRequestInitialize001, TestSize.Level1)
76 {
77 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbRequestInitialize001 : Initialize");
78 vector<UsbDevice> delist;
79 auto &UsbSrvClient = UsbSrvClient::GetInstance();
80 auto ret = UsbSrvClient.GetDevices(delist);
81 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize001 %{public}d ret=%{public}d size:%{public}zu",
82 __LINE__, ret, delist.size());
83 EXPECT_TRUE(ret == 0);
84 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
85 UsbDevice device = delist.front();
86 UsbSrvClient.RequestRight(device.GetName());
87 USBDevicePipe pip;
88 ret = UsbSrvClient.OpenDevice(device, pip);
89 USB_HILOGI(
90 MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
91 EXPECT_TRUE(ret == 0);
92 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
93 USBEndpoint point = interface.GetEndpoints().front();
94 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
95 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize001 %{public}d ClaimInterface=%{public}d",
96 __LINE__, ret);
97 EXPECT_TRUE(ret == 0);
98 UsbRequest request;
99 uint8_t tag[TAG_SIZE] = "request read";
100 std::vector<uint8_t> cdata = {tag, tag + 12};
101 request.SetClientData(cdata);
102 ret = request.Initialize(pip, point);
103 USB_HILOGI(
104 MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize001 %{public}d Initialize=%{public}d ", __LINE__, ret);
105 EXPECT_TRUE(ret == 0);
106 bool close = UsbSrvClient.Close(pip);
107 USB_HILOGI(
108 MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize001 %{public}d close=%{public}d", __LINE__, close);
109 EXPECT_TRUE(close);
110 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbRequestInitialize001 : Initialize");
111 }
112
113 /**
114 * @tc.name: UsbRequestInitialize002
115 * @tc.desc: Test functions of Initialize(const USBDevicePipe &pipe, const USBEndpoint &endpoint)
116 * @tc.type: FUNC
117 */
118 HWTEST_F(UsbRequestTest, UsbRequestInitialize002, TestSize.Level1)
119 {
120 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbRequestInitialize002 : Initialize");
121 vector<UsbDevice> delist;
122 auto &UsbSrvClient = UsbSrvClient::GetInstance();
123 auto ret = UsbSrvClient.GetDevices(delist);
124 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize002 %{public}d ret=%{public}d size:%{public}zu",
125 __LINE__, ret, delist.size());
126 EXPECT_TRUE(ret == 0);
127 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
128 UsbDevice device = delist.front();
129 UsbSrvClient.RequestRight(device.GetName());
130 USBDevicePipe pip;
131 ret = UsbSrvClient.OpenDevice(device, pip);
132 USB_HILOGI(
133 MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize002 %{public}d OpenDevice=%{public}d", __LINE__, ret);
134 EXPECT_TRUE(ret == 0);
135 UsbRequest request;
136 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
137 USBEndpoint point = interface.GetEndpoints().at(1);
138 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
139 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize002 %{public}d ClaimInterface=%{public}d",
140 __LINE__, ret);
141 EXPECT_TRUE(ret == 0);
142 uint8_t tag[TAG_SIZE] = "request write";
143 std::vector<uint8_t> cdata = {tag, tag + 13};
144 request.SetClientData(cdata);
145 uint8_t buffer[BUFFER_SIZE] = "usb request test!";
146 std::vector<uint8_t> bufferdata = {buffer, buffer + 17};
147 request.SetReqData(bufferdata);
148 ret = request.Initialize(pip, point);
149 USB_HILOGI(
150 MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize002 %{public}d Initialize=%{public}d ", __LINE__, ret);
151 EXPECT_TRUE(ret == 0);
152 bool close = UsbSrvClient.Close(pip);
153 USB_HILOGI(
154 MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize002 %{public}d close=%{public}d", __LINE__, close);
155 EXPECT_TRUE(close);
156 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbRequestInitialize002 : Initialize");
157 }
158
159 /**
160 * @tc.name: UsbRequestInitialize003
161 * @tc.desc: Test functions of Initialize(const USBDevicePipe &pipe, const USBEndpoint &endpoint)
162 * @tc.type: FUNC
163 */
164 HWTEST_F(UsbRequestTest, UsbRequestInitialize003, TestSize.Level1)
165 {
166 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbRequestInitialize003 : Initialize");
167 vector<UsbDevice> delist;
168 auto &UsbSrvClient = UsbSrvClient::GetInstance();
169 auto ret = UsbSrvClient.GetDevices(delist);
170 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize003 %{public}d ret=%{public}d size:%{public}zu",
171 __LINE__, ret, delist.size());
172 EXPECT_TRUE(ret == 0);
173 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
174 UsbDevice device = delist.front();
175 UsbSrvClient.RequestRight(device.GetName());
176 USBDevicePipe pip;
177 ret = UsbSrvClient.OpenDevice(device, pip);
178 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize003 %{public}d ret=%{public}d ", __LINE__, ret);
179 EXPECT_TRUE(ret == 0);
180 UsbRequest request;
181 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
182 USBEndpoint point = interface.GetEndpoints().at(0);
183 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
184 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize003 %{public}d ClaimInterface=%{public}d",
185 __LINE__, ret);
186 EXPECT_TRUE(ret == 0);
187 uint8_t tag[TAG_SIZE] = "request read";
188 std::vector<uint8_t> cdata = {tag, tag + 12};
189 request.SetClientData(cdata);
190 pip.SetBusNum(BUFFER_SIZE);
191 ret = request.Initialize(pip, point);
192 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize003 %{public}d ret=%{public}d ", __LINE__, ret);
193 EXPECT_TRUE(ret != 0);
194 pip.SetBusNum(device.GetBusNum());
195 bool close = UsbSrvClient.Close(pip);
196 USB_HILOGI(
197 MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize003 %{public}d close=%{public}d", __LINE__, close);
198 EXPECT_TRUE(close);
199 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbRequestInitialize003 : Initialize");
200 }
201
202 /**
203 * @tc.name: UsbRequestInitialize004
204 * @tc.desc: Test functions of Initialize(const USBDevicePipe &pipe, const USBEndpoint &endpoint)
205 * @tc.type: FUNC
206 */
207 HWTEST_F(UsbRequestTest, UsbRequestInitialize004, TestSize.Level1)
208 {
209 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbRequestInitialize004 : Initialize");
210 vector<UsbDevice> delist;
211 auto &UsbSrvClient = UsbSrvClient::GetInstance();
212 auto ret = UsbSrvClient.GetDevices(delist);
213 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize004 %{public}d ret=%{public}d size:%{public}zu",
214 __LINE__, ret, delist.size());
215 EXPECT_TRUE(ret == 0);
216 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
217 UsbDevice device = delist.front();
218 UsbSrvClient.RequestRight(device.GetName());
219 USBDevicePipe pip;
220 ret = UsbSrvClient.OpenDevice(device, pip);
221 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize004 %{public}d ret=%{public}d ", __LINE__, ret);
222 EXPECT_TRUE(ret == 0);
223 UsbRequest request;
224 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
225 USBEndpoint point = interface.GetEndpoints().at(0);
226 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
227 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize004 %{public}d ClaimInterface=%{public}d",
228 __LINE__, ret);
229 EXPECT_TRUE(ret == 0);
230 uint8_t tag[TAG_SIZE] = "request read";
231 std::vector<uint8_t> cdata = {tag, tag + 12};
232 request.SetClientData(cdata);
233 pip.SetDevAddr(BUFFER_SIZE);
234 ret = request.Initialize(pip, point);
235 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize004 %{public}d ret=%{public}d ", __LINE__, ret);
236 EXPECT_TRUE(ret != 0);
237 pip.SetDevAddr(device.GetDevAddr());
238 bool close = UsbSrvClient.Close(pip);
239 USB_HILOGI(
240 MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize004 %{public}d close=%{public}d", __LINE__, close);
241 EXPECT_TRUE(close);
242 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbRequestInitialize004 : Initialize");
243 }
244
245 /**
246 * @tc.name: UsbRequestInitialize005
247 * @tc.desc: Test functions of Initialize(const USBDevicePipe &pipe, const USBEndpoint &endpoint)
248 * @tc.type: FUNC
249 */
250 HWTEST_F(UsbRequestTest, UsbRequestInitialize005, TestSize.Level1)
251 {
252 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbRequestInitialize005 : Initialize");
253 vector<UsbDevice> delist;
254 auto &UsbSrvClient = UsbSrvClient::GetInstance();
255 auto ret = UsbSrvClient.GetDevices(delist);
256 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize005 %{public}d ret=%{public}d size:%{public}zu",
257 __LINE__, ret, delist.size());
258 EXPECT_TRUE(ret == 0);
259 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
260 UsbDevice device = delist.front();
261 UsbSrvClient.RequestRight(device.GetName());
262 USBDevicePipe pip;
263 ret = UsbSrvClient.OpenDevice(device, pip);
264 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize005 %{public}d ret=%{public}d ", __LINE__, ret);
265 EXPECT_TRUE(ret == 0);
266 UsbRequest request;
267 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
268 USBEndpoint point = interface.GetEndpoints().at(1);
269 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
270 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize005 %{public}d ClaimInterface=%{public}d",
271 __LINE__, ret);
272 EXPECT_TRUE(ret == 0);
273 uint8_t tag[TAG_SIZE] = "request write";
274 std::vector<uint8_t> cdata = {tag, tag + 13};
275 request.SetClientData(cdata);
276 uint8_t buffer[BUFFER_SIZE] = "usb request test!";
277 std::vector<uint8_t> bufferdata = {buffer, buffer + 17};
278 request.SetReqData(bufferdata);
279 pip.SetBusNum(BUFFER_SIZE);
280 ret = request.Initialize(pip, point);
281 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize005 %{public}d ret=%{public}d ", __LINE__, ret);
282 EXPECT_TRUE(ret != 0);
283 pip.SetBusNum(device.GetBusNum());
284 bool close = UsbSrvClient.Close(pip);
285 USB_HILOGI(
286 MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize005 %{public}d close=%{public}d", __LINE__, close);
287 EXPECT_TRUE(close);
288 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbRequestInitialize005 : Initialize");
289 }
290
291 /**
292 * @tc.name: UsbRequestInitialize006
293 * @tc.desc: Test functions of Initialize(const USBDevicePipe &pipe, const USBEndpoint &endpoint)
294 * @tc.type: FUNC
295 */
296 HWTEST_F(UsbRequestTest, UsbRequestInitialize006, TestSize.Level1)
297 {
298 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbRequestInitialize006 : Initialize");
299 vector<UsbDevice> delist;
300 auto &UsbSrvClient = UsbSrvClient::GetInstance();
301 auto ret = UsbSrvClient.GetDevices(delist);
302 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize006 %{public}d ret=%{public}d size:%{public}zu",
303 __LINE__, ret, delist.size());
304 EXPECT_TRUE(ret == 0);
305 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
306 UsbDevice device = delist.front();
307 UsbSrvClient.RequestRight(device.GetName());
308 USBDevicePipe pip;
309 ret = UsbSrvClient.OpenDevice(device, pip);
310 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize006 %{public}d ret=%{public}d ", __LINE__, ret);
311 EXPECT_TRUE(ret == 0);
312 UsbRequest request;
313 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
314 USBEndpoint point = interface.GetEndpoints().at(1);
315 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
316 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize006 %{public}d ClaimInterface=%{public}d",
317 __LINE__, ret);
318 EXPECT_TRUE(ret == 0);
319 uint8_t tag[TAG_SIZE] = "request write";
320 std::vector<uint8_t> cdata = {tag, tag + 13};
321 request.SetClientData(cdata);
322 uint8_t buffer[BUFFER_SIZE] = "usb request test!";
323 std::vector<uint8_t> bufferdata = {buffer, buffer + 17};
324 request.SetReqData(bufferdata);
325 pip.SetDevAddr(BUFFER_SIZE);
326 ret = request.Initialize(pip, point);
327 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbRequestInitialize006 %{public}d ret=%{public}d ", __LINE__, ret);
328 EXPECT_TRUE(ret != 0);
329 pip.SetDevAddr(device.GetDevAddr());
330 bool close = UsbSrvClient.Close(pip);
331 USB_HILOGI(
332 MODULE_USB_SERVICE, "UsbRequestTest::UsbRequestInitialize006 %{public}d close=%{public}d", __LINE__, close);
333 EXPECT_TRUE(close);
334 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbRequestInitialize006 : Initialize");
335 }
336
337 /**
338 * @tc.name: UsbrequestQueue001
339 * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
340 * @tc.type: FUNC
341 */
342 HWTEST_F(UsbRequestTest, UsbrequestQueue001, TestSize.Level1)
343 {
344 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbrequestQueue001 : RequestQueue");
345 vector<UsbDevice> delist;
346 auto &UsbSrvClient = UsbSrvClient::GetInstance();
347 auto ret = UsbSrvClient.GetDevices(delist);
348 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue001 %{public}d ret=%{public}d size:%{public}zu",
349 __LINE__, ret, delist.size());
350 EXPECT_TRUE(ret == 0);
351 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
352 UsbDevice device = delist.front();
353 UsbSrvClient.RequestRight(device.GetName());
354 USBDevicePipe pip;
355 ret = UsbSrvClient.OpenDevice(device, pip);
356 USB_HILOGI(
357 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue001 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
358 EXPECT_TRUE(ret == 0);
359 UsbRequest request;
360 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
361 USBEndpoint point = interface.GetEndpoints().at(0);
362 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
363 USB_HILOGI(
364 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
365 EXPECT_TRUE(ret == 0);
366 uint8_t buffer[BUFFER_SIZE] = "request queue read001";
367 std::vector<uint8_t> cdata = {buffer, buffer + 21};
368 request.SetClientData(cdata);
369 uint8_t buffer1[BUFFER_SIZE] = {0};
370 std::vector<uint8_t> bufferdata = {buffer1, buffer1 + 17};
371 request.SetReqData(bufferdata);
372 ret = request.Initialize(pip, point);
373 USB_HILOGI(
374 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue001 %{public}d initialize=%{public}d ", __LINE__, ret);
375 EXPECT_TRUE(ret == 0);
376 ret = UsbSrvClient.RequestQueue(request);
377 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue001 %{public}d queue=%{public}d ", __LINE__, ret);
378 EXPECT_TRUE(ret == 0);
379 bool close = UsbSrvClient.Close(pip);
380 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue001 %{public}d close=%{public}d", __LINE__, close);
381 EXPECT_TRUE(close);
382 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbrequestQueue001 : RequestQueue");
383 }
384
385 /**
386 * @tc.name: UsbrequestQueue002
387 * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
388 * @tc.type: FUNC
389 */
390 HWTEST_F(UsbRequestTest, UsbrequestQueue002, TestSize.Level1)
391 {
392 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbrequestQueue002 : RequestQueue");
393 vector<UsbDevice> delist;
394 auto &UsbSrvClient = UsbSrvClient::GetInstance();
395 auto ret = UsbSrvClient.GetDevices(delist);
396 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue002 %{public}d ret=%{public}d size:%{public}zu",
397 __LINE__, ret, delist.size());
398 EXPECT_TRUE(ret == 0);
399 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
400 UsbDevice device = delist.front();
401 UsbSrvClient.RequestRight(device.GetName());
402 USBDevicePipe pip;
403 ret = UsbSrvClient.OpenDevice(device, pip);
404 USB_HILOGI(
405 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue002 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
406 EXPECT_TRUE(ret == 0);
407 UsbRequest request;
408 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
409 USBEndpoint point = interface.GetEndpoints().at(1);
410 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
411 USB_HILOGI(
412 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
413 EXPECT_TRUE(ret == 0);
414 uint8_t buffer[BUFFER_SIZE] = "request queue write 002";
415 std::vector<uint8_t> cdata = {buffer, buffer + 23};
416 request.SetClientData(cdata);
417 uint8_t buffer1[BUFFER_SIZE] = "usb request test!";
418 std::vector<uint8_t> bufferdata = {buffer1, buffer1 + 17};
419 request.SetReqData(bufferdata);
420 ret = request.Initialize(pip, point);
421 USB_HILOGI(
422 MODULE_USB_SERVICE, "UsbRequestTest:UsbrequestQueue002 %{public}d initialize=%{public}d ", __LINE__, ret);
423 EXPECT_TRUE(ret == 0);
424 ret = UsbSrvClient.RequestQueue(request);
425 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:UsbrequestQueue002 %{public}d queue=%{public}d ", __LINE__, ret);
426 EXPECT_TRUE(ret == 0);
427 bool close = UsbSrvClient.Close(pip);
428 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue002 %{public}d close=%{public}d", __LINE__, close);
429 EXPECT_TRUE(close);
430 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbrequestQueue002 : RequestQueue");
431 }
432
433 /**
434 * @tc.name: UsbrequestQueue003
435 * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
436 * @tc.type: FUNC
437 */
438 HWTEST_F(UsbRequestTest, UsbrequestQueue003, TestSize.Level1)
439 {
440 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbrequestQueue003 : RequestQueue");
441 vector<UsbDevice> delist;
442 auto &UsbSrvClient = UsbSrvClient::GetInstance();
443 auto ret = UsbSrvClient.GetDevices(delist);
444 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue003 %{public}d ret=%{public}d size:%{public}zu",
445 __LINE__, ret, delist.size());
446 EXPECT_TRUE(ret == 0);
447 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
448 UsbDevice device = delist.front();
449 UsbSrvClient.RequestRight(device.GetName());
450 USBDevicePipe pip;
451 ret = UsbSrvClient.OpenDevice(device, pip);
452 USB_HILOGI(
453 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue003 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
454 EXPECT_TRUE(ret == 0);
455 UsbRequest request;
456 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
457 USBEndpoint point = interface.GetEndpoints().at(0);
458 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
459 USB_HILOGI(
460 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
461 EXPECT_TRUE(ret == 0);
462 uint8_t buffer[BUFFER_SIZE] = "request queue read003";
463 std::vector<uint8_t> cdata = {buffer, buffer + 21};
464 request.SetClientData(cdata);
465 uint8_t buffer1[BUFFER_SIZE] = {0};
466 std::vector<uint8_t> bufferdata = {buffer1, buffer1 + 17};
467 request.SetReqData(bufferdata);
468 ret = request.Initialize(pip, point);
469 USB_HILOGI(
470 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue003 %{public}d initialize=%{public}d ", __LINE__, ret);
471 EXPECT_TRUE(ret == 0);
472 pip.SetBusNum(BUFFER_SIZE);
473 request.SetPipe(pip);
474 ret = UsbSrvClient.RequestQueue(request);
475 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue003 %{public}d queue=%{public}d ", __LINE__, ret);
476 EXPECT_TRUE(ret != 0);
477 pip.SetBusNum(device.GetBusNum());
478 bool close = UsbSrvClient.Close(pip);
479 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue003 %{public}d close=%{public}d", __LINE__, close);
480 EXPECT_TRUE(close);
481 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbrequestQueue003 : RequestQueue");
482 }
483
484 /**
485 * @tc.name: UsbrequestQueue004
486 * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
487 * @tc.type: FUNC
488 */
489 HWTEST_F(UsbRequestTest, UsbrequestQueue004, TestSize.Level1)
490 {
491 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbrequestQueue004 : RequestQueue");
492 vector<UsbDevice> delist;
493 auto &UsbSrvClient = UsbSrvClient::GetInstance();
494 auto ret = UsbSrvClient.GetDevices(delist);
495 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue004 %{public}d ret=%{public}d size:%{public}zu",
496 __LINE__, ret, delist.size());
497 EXPECT_TRUE(ret == 0);
498 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
499 UsbDevice device = delist.front();
500 UsbSrvClient.RequestRight(device.GetName());
501 USBDevicePipe pip;
502 ret = UsbSrvClient.OpenDevice(device, pip);
503 USB_HILOGI(
504 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue004 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
505 EXPECT_TRUE(ret == 0);
506 UsbRequest request;
507 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
508 USBEndpoint point = interface.GetEndpoints().at(0);
509 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
510 USB_HILOGI(
511 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
512 EXPECT_TRUE(ret == 0);
513 uint8_t buffer[BUFFER_SIZE] = "request queue read004";
514 std::vector<uint8_t> cdata = {buffer, buffer + 21};
515 request.SetClientData(cdata);
516 uint8_t buffer1[BUFFER_SIZE] = {0};
517 std::vector<uint8_t> bufferdata = {buffer1, buffer1 + 17};
518 request.SetReqData(bufferdata);
519 ret = request.Initialize(pip, point);
520 USB_HILOGI(
521 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue004 %{public}d initialize=%{public}d ", __LINE__, ret);
522 EXPECT_TRUE(ret == 0);
523 pip.SetDevAddr(BUFFER_SIZE);
524 request.SetPipe(pip);
525 ret = UsbSrvClient.RequestQueue(request);
526 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue004 %{public}d queue=%{public}d ", __LINE__, ret);
527 EXPECT_TRUE(ret != 0);
528 pip.SetDevAddr(device.GetDevAddr());
529 bool close = UsbSrvClient.Close(pip);
530 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue004 %{public}d close=%{public}d", __LINE__, close);
531 EXPECT_TRUE(close);
532 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbrequestQueue004 : RequestQueue");
533 }
534
535 /**
536 * @tc.name: UsbrequestQueue005
537 * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
538 * @tc.type: FUNC
539 */
540 HWTEST_F(UsbRequestTest, UsbrequestQueue005, TestSize.Level1)
541 {
542 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbrequestQueue005 : RequestQueue");
543 vector<UsbDevice> delist;
544 auto &UsbSrvClient = UsbSrvClient::GetInstance();
545 auto ret = UsbSrvClient.GetDevices(delist);
546 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue005 %{public}d ret=%{public}d size:%{public}zu",
547 __LINE__, ret, delist.size());
548 EXPECT_TRUE(ret == 0);
549 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
550 UsbDevice device = delist.front();
551 UsbSrvClient.RequestRight(device.GetName());
552 USBDevicePipe pip;
553 ret = UsbSrvClient.OpenDevice(device, pip);
554 USB_HILOGI(
555 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue005 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
556 EXPECT_TRUE(ret == 0);
557 UsbRequest request;
558 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
559 USBEndpoint point = interface.GetEndpoints().at(1);
560 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
561 USB_HILOGI(
562 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
563 EXPECT_TRUE(ret == 0);
564 uint8_t buffer[BUFFER_SIZE] = "request queue write005";
565 std::vector<uint8_t> cdata = {buffer, buffer + 22};
566 request.SetClientData(cdata);
567 uint8_t buffer1[BUFFER_SIZE] = "usb request test!";
568 std::vector<uint8_t> databuffer = {buffer1, buffer1 + 17};
569 request.SetReqData(databuffer);
570 ret = request.Initialize(pip, point);
571 USB_HILOGI(
572 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue005 %{public}d initialize=%{public}d ", __LINE__, ret);
573 EXPECT_TRUE(ret == 0);
574 pip.SetBusNum(BUFFER_SIZE);
575 request.SetPipe(pip);
576 ret = UsbSrvClient.RequestQueue(request);
577 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue005 %{public}d queue=%{public}d ", __LINE__, ret);
578 EXPECT_TRUE(ret != 0);
579 pip.SetBusNum(device.GetBusNum());
580 bool close = UsbSrvClient.Close(pip);
581 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue005 %{public}d close=%{public}d", __LINE__, close);
582 EXPECT_TRUE(close);
583 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbrequestQueue005 : RequestQueue");
584 }
585
586 /**
587 * @tc.name: UsbrequestQueue006
588 * @tc.desc: Test functions of RequestQueue(UsbRequest &request, uint8_t *buffer, uint32_t length)
589 * @tc.type: FUNC
590 */
591 HWTEST_F(UsbRequestTest, UsbrequestQueue006, TestSize.Level1)
592 {
593 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbrequestQueue006 : RequestQueue");
594 vector<UsbDevice> delist;
595 auto &UsbSrvClient = UsbSrvClient::GetInstance();
596 auto ret = UsbSrvClient.GetDevices(delist);
597 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue006 %{public}d ret=%{public}d size:%{public}zu",
598 __LINE__, ret, delist.size());
599 EXPECT_TRUE(ret == 0);
600 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
601 UsbDevice device = delist.front();
602 UsbSrvClient.RequestRight(device.GetName());
603 USBDevicePipe pip;
604 ret = UsbSrvClient.OpenDevice(device, pip);
605 USB_HILOGI(
606 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue006 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
607 EXPECT_TRUE(ret == 0);
608 UsbRequest request;
609 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
610 USBEndpoint point = interface.GetEndpoints().at(1);
611 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
612 USB_HILOGI(
613 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
614 EXPECT_TRUE(ret == 0);
615 uint8_t buffer[BUFFER_SIZE] = "request queue write006";
616 std::vector<uint8_t> cdata = {buffer, buffer + 22};
617 request.SetClientData(cdata);
618 uint8_t buffer1[BUFFER_SIZE] = "usb request test!";
619 std::vector<uint8_t> databuffer = {buffer1, buffer1 + 17};
620 request.SetReqData(databuffer);
621 ret = request.Initialize(pip, point);
622 USB_HILOGI(
623 MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue006 %{public}d initialize=%{public}d ", __LINE__, ret);
624 EXPECT_TRUE(ret == 0);
625 pip.SetDevAddr(BUFFER_SIZE);
626 request.SetPipe(pip);
627 ret = UsbSrvClient.RequestQueue(request);
628 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue006 %{public}d queue=%{public}d ", __LINE__, ret);
629 EXPECT_TRUE(ret != 0);
630 pip.SetDevAddr(device.GetDevAddr());
631 bool close = UsbSrvClient.Close(pip);
632 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::UsbrequestQueue006 %{public}d close=%{public}d", __LINE__, close);
633 EXPECT_TRUE(close);
634 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbrequestQueue006 : RequestQueue");
635 }
636
637 /**
638 * @tc.name: Usbrequestfree001
639 * @tc.desc: Test functions of RequestFree(UsbRequest &request);
640 * @tc.type: FUNC
641 */
642 HWTEST_F(UsbRequestTest, Usbrequestfree001, TestSize.Level1)
643 {
644 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestfree001 : RequestQueue");
645 vector<UsbDevice> delist;
646 auto &UsbSrvClient = UsbSrvClient::GetInstance();
647 auto ret = UsbSrvClient.GetDevices(delist);
648 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree001 %{public}d ret=%{public}d size:%{public}zu",
649 __LINE__, ret, delist.size());
650 EXPECT_TRUE(ret == 0);
651 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
652 UsbDevice device = delist.front();
653 UsbSrvClient.RequestRight(device.GetName());
654 USBDevicePipe pip;
655 ret = UsbSrvClient.OpenDevice(device, pip);
656 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree001 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
657 EXPECT_TRUE(ret == 0);
658 UsbRequest request;
659 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
660 USBEndpoint point = interface.GetEndpoints().at(0);
661 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
662 USB_HILOGI(
663 MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
664 EXPECT_TRUE(ret == 0);
665 uint8_t tag[TAG_SIZE] = "request free 001";
666 std::vector<uint8_t> cdata = {tag, tag + 16};
667 request.SetClientData(cdata);
668 ret = request.Initialize(pip, point);
669 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree001 %{public}d initialize=%{public}d ", __LINE__, ret);
670 EXPECT_TRUE(ret == 0);
671 ret = UsbSrvClient.RequestFree(request);
672 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree001 %{public}d free=%{public}d ", __LINE__, ret);
673 EXPECT_TRUE(ret == 0);
674 bool close = UsbSrvClient.Close(pip);
675 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree001 %{public}d close=%{public}d", __LINE__, close);
676 EXPECT_TRUE(close);
677 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestfree001 : RequestFree");
678 }
679
680 /**
681 * @tc.name: Usbrequestfree002
682 * @tc.desc: Test functions of RequestFree(UsbRequest &request);
683 * @tc.type: FUNC
684 */
685 HWTEST_F(UsbRequestTest, Usbrequestfree002, TestSize.Level1)
686 {
687 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestfree002 : RequestQueue");
688 vector<UsbDevice> delist;
689 auto &UsbSrvClient = UsbSrvClient::GetInstance();
690 auto ret = UsbSrvClient.GetDevices(delist);
691 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree002 %{public}d ret=%{public}d size:%{public}zu",
692 __LINE__, ret, delist.size());
693 EXPECT_TRUE(ret == 0);
694 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
695 UsbDevice device = delist.front();
696 UsbSrvClient.RequestRight(device.GetName());
697 USBDevicePipe pip;
698 ret = UsbSrvClient.OpenDevice(device, pip);
699 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree002 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
700 EXPECT_TRUE(ret == 0);
701 UsbRequest request;
702 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
703 USBEndpoint point = interface.GetEndpoints().at(0);
704 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
705 USB_HILOGI(
706 MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
707 EXPECT_TRUE(ret == 0);
708 uint8_t tag[TAG_SIZE] = "request free 002";
709 std::vector<uint8_t> cdata = {tag, tag + 16};
710 request.SetClientData(cdata);
711 ret = request.Initialize(pip, point);
712 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree002 %{public}d initialize=%{public}d ", __LINE__, ret);
713 EXPECT_TRUE(ret == 0);
714 pip.SetBusNum(BUFFER_SIZE);
715 request.SetPipe(pip);
716 ret = UsbSrvClient.RequestFree(request);
717 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree002 %{public}d free=%{public}d ", __LINE__, ret);
718 EXPECT_TRUE(ret != 0);
719 pip.SetBusNum(device.GetBusNum());
720 bool close = UsbSrvClient.Close(pip);
721 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree002 %{public}d close=%{public}d", __LINE__, close);
722 EXPECT_TRUE(close);
723 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestfree002 : RequestFree");
724 }
725
726 /**
727 * @tc.name: Usbrequestfree003
728 * @tc.desc: Test functions of RequestFree(UsbRequest &request);
729 * @tc.type: FUNC
730 */
731 HWTEST_F(UsbRequestTest, Usbrequestfree003, TestSize.Level1)
732 {
733 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestfree003 : RequestQueue");
734 vector<UsbDevice> delist;
735 auto &UsbSrvClient = UsbSrvClient::GetInstance();
736 auto ret = UsbSrvClient.GetDevices(delist);
737 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree003 %{public}d ret=%{public}d size:%{public}zu",
738 __LINE__, ret, delist.size());
739 EXPECT_TRUE(ret == 0);
740 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
741 UsbDevice device = delist.front();
742 UsbSrvClient.RequestRight(device.GetName());
743 USBDevicePipe pip;
744 ret = UsbSrvClient.OpenDevice(device, pip);
745 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree003 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
746 EXPECT_TRUE(ret == 0);
747 UsbRequest request;
748 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
749 USBEndpoint point = interface.GetEndpoints().at(0);
750 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
751 USB_HILOGI(
752 MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
753 EXPECT_TRUE(ret == 0);
754 uint8_t tag[TAG_SIZE] = "request free 003";
755 std::vector<uint8_t> cdata = {tag, tag + 16};
756 request.SetClientData(cdata);
757 ret = request.Initialize(pip, point);
758 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree003 %{public}d initialize=%{public}d ", __LINE__, ret);
759 EXPECT_TRUE(ret == 0);
760 pip.SetDevAddr(BUFFER_SIZE);
761 request.SetPipe(pip);
762 ret = UsbSrvClient.RequestFree(request);
763 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree003 %{public}d free=%{public}d ", __LINE__, ret);
764 EXPECT_TRUE(ret != 0);
765 pip.SetDevAddr(device.GetDevAddr());
766 bool close = UsbSrvClient.Close(pip);
767 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree003 %{public}d close=%{public}d", __LINE__, close);
768 EXPECT_TRUE(close);
769 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestfree003 : RequestFree");
770 }
771
772 /**
773 * @tc.name: Usbrequestfree004
774 * @tc.desc: Test functions of RequestFree(UsbRequest &request);
775 * @tc.type: FUNC
776 */
777 HWTEST_F(UsbRequestTest, Usbrequestfree004, TestSize.Level1)
778 {
779 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestfree004 : Requestfree");
780 vector<UsbDevice> delist;
781 auto &UsbSrvClient = UsbSrvClient::GetInstance();
782 auto ret = UsbSrvClient.GetDevices(delist);
783 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree004 %{public}d ret=%{public}d size:%{public}zu",
784 __LINE__, ret, delist.size());
785 EXPECT_TRUE(ret == 0);
786 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
787 UsbDevice device = delist.front();
788 UsbSrvClient.RequestRight(device.GetName());
789 USBDevicePipe pip;
790 ret = UsbSrvClient.OpenDevice(device, pip);
791 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree004 %{public}d OpenDevice=%{public}d", __LINE__, ret);
792 EXPECT_TRUE(ret == 0);
793 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
794 UsbRequest request;
795 USBEndpoint point = interface.GetEndpoints().at(1);
796 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
797 USB_HILOGI(
798 MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
799 EXPECT_TRUE(ret == 0);
800 uint8_t tag[TAG_SIZE] = "request free 004";
801 std::vector<uint8_t> cdata = {tag, tag + 16};
802 request.SetClientData(cdata);
803 uint8_t buffer[BUFFER_SIZE] = "usb request test!";
804 std::vector<uint8_t> databuffer = {buffer, buffer + 17};
805 request.SetReqData(databuffer);
806 ret = request.Initialize(pip, point);
807 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree004 %{public}d initialize=%{public}d ", __LINE__, ret);
808 EXPECT_TRUE(ret == 0);
809 ret = UsbSrvClient.RequestFree(request);
810 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree004 %{public}d free=%{public}d ", __LINE__, ret);
811 EXPECT_TRUE(ret == 0);
812 bool close = UsbSrvClient.Close(pip);
813 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree004 %{public}d close=%{public}d", __LINE__, close);
814 EXPECT_TRUE(close);
815 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestfree004 : Requestfree");
816 }
817
818 /**
819 * @tc.name: Usbrequestfree005
820 * @tc.desc: Test functions of RequestFree(UsbRequest &request);
821 * @tc.type: FUNC
822 */
823 HWTEST_F(UsbRequestTest, Usbrequestfree005, TestSize.Level1)
824 {
825 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestfree005 : RequestQueue");
826 vector<UsbDevice> delist;
827 auto &UsbSrvClient = UsbSrvClient::GetInstance();
828 auto ret = UsbSrvClient.GetDevices(delist);
829 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree005 %{public}d ret=%{public}d size:%{public}zu",
830 __LINE__, ret, delist.size());
831 EXPECT_TRUE(ret == 0);
832 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
833 UsbDevice device = delist.front();
834 UsbSrvClient.RequestRight(device.GetName());
835 USBDevicePipe pip;
836 ret = UsbSrvClient.OpenDevice(device, pip);
837 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree005 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
838 EXPECT_TRUE(ret == 0);
839 UsbRequest request;
840 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
841 USBEndpoint point = interface.GetEndpoints().at(1);
842 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
843 USB_HILOGI(
844 MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
845 EXPECT_TRUE(ret == 0);
846 uint8_t tag[TAG_SIZE] = "request free 005";
847 std::vector<uint8_t> cdata = {tag, tag + 16};
848 request.SetClientData(cdata);
849 uint8_t buffer[BUFFER_SIZE] = "usb request test!";
850 std::vector<uint8_t> databuffer = {buffer, buffer + 17};
851 request.SetReqData(databuffer);
852 ret = request.Initialize(pip, point);
853 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree005 %{public}d initialize=%{public}d ", __LINE__, ret);
854 EXPECT_TRUE(ret == 0);
855 pip.SetBusNum(BUFFER_SIZE);
856 request.SetPipe(pip);
857 ret = UsbSrvClient.RequestFree(request);
858 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree005 %{public}d free=%{public}d ", __LINE__, ret);
859 EXPECT_TRUE(ret != 0);
860 pip.SetBusNum(device.GetBusNum());
861 bool close = UsbSrvClient.Close(pip);
862 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree005 %{public}d close=%{public}d", __LINE__, close);
863 EXPECT_TRUE(close);
864 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestfree005 : RequestFree");
865 }
866
867 /**
868 * @tc.name: Usbrequestfree006
869 * @tc.desc: Test functions of RequestFree(UsbRequest &request);
870 * @tc.type: FUNC
871 */
872 HWTEST_F(UsbRequestTest, Usbrequestfree006, TestSize.Level1)
873 {
874 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestfree006 : RequestQueue");
875 vector<UsbDevice> delist;
876 auto &UsbSrvClient = UsbSrvClient::GetInstance();
877 auto ret = UsbSrvClient.GetDevices(delist);
878 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree006 %{public}d ret=%{public}d size:%{public}zu",
879 __LINE__, ret, delist.size());
880 EXPECT_TRUE(ret == 0);
881 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
882 UsbDevice device = delist.front();
883 UsbSrvClient.RequestRight(device.GetName());
884 USBDevicePipe pip;
885 ret = UsbSrvClient.OpenDevice(device, pip);
886 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree006 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
887 EXPECT_TRUE(ret == 0);
888 UsbRequest request;
889 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
890 USBEndpoint point = interface.GetEndpoints().at(1);
891 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
892 USB_HILOGI(
893 MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
894 EXPECT_TRUE(ret == 0);
895 uint8_t tag[TAG_SIZE] = "request free 006";
896 std::vector<uint8_t> cdata = {tag, tag + 16};
897 request.SetClientData(cdata);
898 uint8_t buffer[BUFFER_SIZE] = "usb request test!";
899 std::vector<uint8_t> databuffer = {buffer, buffer + 17};
900 request.SetReqData(databuffer);
901 ret = request.Initialize(pip, point);
902 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree006 %{public}d initialize=%{public}d ", __LINE__, ret);
903 EXPECT_TRUE(ret == 0);
904 pip.SetDevAddr(BUFFER_SIZE);
905 request.SetPipe(pip);
906 ret = UsbSrvClient.RequestFree(request);
907 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestfree006 %{public}d free=%{public}d ", __LINE__, ret);
908 EXPECT_TRUE(ret != 0);
909 pip.SetDevAddr(device.GetDevAddr());
910 bool close = UsbSrvClient.Close(pip);
911 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestfree006 %{public}d close=%{public}d", __LINE__, close);
912 EXPECT_TRUE(close);
913 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestfree006 : RequestFree");
914 }
915
916 /**
917 * @tc.name: Usbrequestabort001
918 * @tc.desc: Test functions of RequestAbort(request)
919 * @tc.type: FUNC
920 */
921 HWTEST_F(UsbRequestTest, Usbrequestabort001, TestSize.Level1)
922 {
923 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestabort001 : Requestabort");
924 vector<UsbDevice> delist;
925 auto &UsbSrvClient = UsbSrvClient::GetInstance();
926 auto ret = UsbSrvClient.GetDevices(delist);
927 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort001 %{public}d ret=%{public}d size:%{public}zu",
928 __LINE__, ret, delist.size());
929 EXPECT_TRUE(ret == 0);
930 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
931 UsbDevice device = delist.front();
932 UsbSrvClient.RequestRight(device.GetName());
933 USBDevicePipe pip;
934 ret = UsbSrvClient.OpenDevice(device, pip);
935 USB_HILOGI(
936 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort001 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
937 EXPECT_TRUE(ret == 0);
938 UsbRequest request;
939 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
940 USBEndpoint point = interface.GetEndpoints().at(0);
941 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
942 USB_HILOGI(
943 MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestabort001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
944 EXPECT_TRUE(ret == 0);
945 uint8_t tag[TAG_SIZE] = "hello world request013";
946 std::vector<uint8_t> cdata = {tag, tag + 22};
947 request.SetClientData(cdata);
948 ret = request.Initialize(pip, point);
949 USB_HILOGI(
950 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort001 %{public}d initialize=%{public}d ", __LINE__, ret);
951 EXPECT_TRUE(ret == 0);
952 uint8_t buffer[BUFFER_SIZE] = "request abort 001";
953 std::vector<uint8_t> databuffer = {buffer, buffer + 17};
954 request.SetReqData(databuffer);
955 ret = UsbSrvClient.RequestQueue(request);
956 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort001 %{public}d queue=%{public}d ", __LINE__, ret);
957 EXPECT_TRUE(ret == 0);
958 ret = UsbSrvClient.RequestAbort(request);
959 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort001 %{public}d Abort=%{public}d ", __LINE__, ret);
960 EXPECT_TRUE(ret == 0);
961 bool close = UsbSrvClient.Close(pip);
962 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestabort001 %{public}d close=%{public}d", __LINE__, close);
963 EXPECT_TRUE(close);
964 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestabort001 : Requestabort");
965 }
966
967 /**
968 * @tc.name: Usbrequestabort002
969 * @tc.desc: Test functions of RequestAbort(request)
970 * @tc.type: FUNC
971 */
972 HWTEST_F(UsbRequestTest, Usbrequestabort002, TestSize.Level1)
973 {
974 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestabort002 : Requestabort");
975 vector<UsbDevice> delist;
976 auto &UsbSrvClient = UsbSrvClient::GetInstance();
977 auto ret = UsbSrvClient.GetDevices(delist);
978 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort002 %{public}d ret=%{public}d size:%{public}zu",
979 __LINE__, ret, delist.size());
980 EXPECT_TRUE(ret == 0);
981 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
982 UsbDevice device = delist.front();
983 UsbSrvClient.RequestRight(device.GetName());
984 USBDevicePipe pip;
985 ret = UsbSrvClient.OpenDevice(device, pip);
986 USB_HILOGI(
987 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort002 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
988 EXPECT_TRUE(ret == 0);
989 UsbRequest request;
990 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
991 USBEndpoint point = interface.GetEndpoints().at(0);
992 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
993 USB_HILOGI(
994 MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestabort002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
995 EXPECT_TRUE(ret == 0);
996 uint8_t tag[TAG_SIZE] = "request abort 002";
997 std::vector<uint8_t> cdata = {tag, tag + 17};
998 request.SetClientData(cdata);
999 uint8_t buffer1[BUFFER_SIZE] = {0};
1000 std::vector<uint8_t> bufferdata = {buffer1, buffer1 + 17};
1001 request.SetReqData(bufferdata);
1002 ret = request.Initialize(pip, point);
1003 USB_HILOGI(
1004 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort002 %{public}d initialize=%{public}d ", __LINE__, ret);
1005 EXPECT_TRUE(ret == 0);
1006 ret = UsbSrvClient.RequestQueue(request);
1007 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort002 %{public}d queue=%{public}d ", __LINE__, ret);
1008 EXPECT_TRUE(ret == 0);
1009 pip.SetBusNum(BUFFER_SIZE);
1010 request.SetPipe(pip);
1011 ret = UsbSrvClient.RequestAbort(request);
1012 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort002 %{public}d Abort=%{public}d ", __LINE__, ret);
1013 EXPECT_TRUE(ret != 0);
1014 pip.SetBusNum(device.GetBusNum());
1015 bool close = UsbSrvClient.Close(pip);
1016 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestabort002 %{public}d close=%{public}d", __LINE__, close);
1017 EXPECT_TRUE(close);
1018 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestabort002 : Requestabort");
1019 }
1020
1021 /**
1022 * @tc.name: Usbrequestabort003
1023 * @tc.desc: Test functions of RequestAbort(request)
1024 * @tc.type: FUNC
1025 */
1026 HWTEST_F(UsbRequestTest, Usbrequestabort003, TestSize.Level1)
1027 {
1028 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestabort003 : Requestabort");
1029 vector<UsbDevice> delist;
1030 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1031 auto ret = UsbSrvClient.GetDevices(delist);
1032 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort003 %{public}d ret=%{public}d size:%{public}zu",
1033 __LINE__, ret, delist.size());
1034 EXPECT_TRUE(ret == 0);
1035 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1036 UsbDevice device = delist.front();
1037 UsbSrvClient.RequestRight(device.GetName());
1038 USBDevicePipe pip;
1039 ret = UsbSrvClient.OpenDevice(device, pip);
1040 USB_HILOGI(
1041 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort003 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
1042 EXPECT_TRUE(ret == 0);
1043 UsbRequest request;
1044 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1045 USBEndpoint point = interface.GetEndpoints().at(0);
1046 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1047 USB_HILOGI(
1048 MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestabort003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1049 EXPECT_TRUE(ret == 0);
1050 uint8_t tag[TAG_SIZE] = "request abort 003";
1051 std::vector<uint8_t> cdata = {tag, tag + 17};
1052 request.SetClientData(cdata);
1053 uint8_t buffer1[BUFFER_SIZE] = {0};
1054 std::vector<uint8_t> bufferdata = {buffer1, buffer1 + 17};
1055 request.SetReqData(bufferdata);
1056 ret = request.Initialize(pip, point);
1057 USB_HILOGI(
1058 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort003 %{public}d initialize=%{public}d ", __LINE__, ret);
1059 EXPECT_TRUE(ret == 0);
1060 ret = UsbSrvClient.RequestQueue(request);
1061 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort003 %{public}d queue=%{public}d ", __LINE__, ret);
1062 EXPECT_TRUE(ret == 0);
1063 pip.SetDevAddr(BUFFER_SIZE);
1064 request.SetPipe(pip);
1065 ret = UsbSrvClient.RequestAbort(request);
1066 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort003 %{public}d Abort=%{public}d ", __LINE__, ret);
1067 EXPECT_TRUE(ret != 0);
1068 pip.SetDevAddr(device.GetDevAddr());
1069 bool close = UsbSrvClient.Close(pip);
1070 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestabort003 %{public}d close=%{public}d", __LINE__, close);
1071 EXPECT_TRUE(close);
1072 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestabort003 : Requestabort");
1073 }
1074
1075 /**
1076 * @tc.name: Usbrequestabort004
1077 * @tc.desc: Test functions of RequestAbort(request)
1078 * @tc.type: FUNC
1079 */
1080 HWTEST_F(UsbRequestTest, Usbrequestabort004, TestSize.Level1)
1081 {
1082 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestabort004 : Requestabort");
1083 vector<UsbDevice> delist;
1084 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1085 auto ret = UsbSrvClient.GetDevices(delist);
1086 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort004 %{public}d ret=%{public}d size:%{public}zu",
1087 __LINE__, ret, delist.size());
1088 EXPECT_TRUE(ret == 0);
1089 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1090 UsbDevice device = delist.front();
1091 UsbSrvClient.RequestRight(device.GetName());
1092 USBDevicePipe pip;
1093 ret = UsbSrvClient.OpenDevice(device, pip);
1094 USB_HILOGI(
1095 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort004 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
1096 EXPECT_TRUE(ret == 0);
1097 UsbRequest request;
1098 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1099 USBEndpoint point = interface.GetEndpoints().at(1);
1100 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort004 %{public}d GetDirection=%{public}d ", __LINE__,
1101 point.GetDirection());
1102 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort004 %{public}d GetInterfaceId=%{public}d ", __LINE__,
1103 point.GetInterfaceId());
1104 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1105 EXPECT_TRUE(ret == 0);
1106 uint8_t tag[TAG_SIZE] = "hello world request013";
1107 std::vector<uint8_t> cdata = {tag, tag + 22};
1108 request.SetClientData(cdata);
1109 ret = request.Initialize(pip, point);
1110 EXPECT_TRUE(ret == 0);
1111 uint8_t buffer[BUFFER_SIZE] = "request abort 004";
1112 std::vector<uint8_t> databuffer = {buffer, buffer + 17};
1113 request.SetReqData(databuffer);
1114 ret = UsbSrvClient.RequestQueue(request);
1115 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort004 %{public}d queue=%{public}d ", __LINE__, ret);
1116 EXPECT_TRUE(ret == 0);
1117 ret = UsbSrvClient.RequestAbort(request);
1118 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort004 %{public}d abort=%{public}d ", __LINE__, ret);
1119 EXPECT_TRUE(ret == 0);
1120 bool close = UsbSrvClient.Close(pip);
1121 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestabort004 %{public}d close=%{public}d", __LINE__, close);
1122 EXPECT_TRUE(close);
1123 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestabort004 : Requestabort");
1124 }
1125
1126 /**
1127 * @tc.name: Usbrequestabort005
1128 * @tc.desc: Test functions of RequestAbort(request)
1129 * @tc.type: FUNC
1130 */
1131 HWTEST_F(UsbRequestTest, Usbrequestabort005, TestSize.Level1)
1132 {
1133 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestabort005 : Requestabort");
1134 vector<UsbDevice> delist;
1135 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1136 auto ret = UsbSrvClient.GetDevices(delist);
1137 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort005 %{public}d ret=%{public}d size:%{public}zu",
1138 __LINE__, ret, delist.size());
1139 EXPECT_TRUE(ret == 0);
1140 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1141 UsbDevice device = delist.front();
1142 UsbSrvClient.RequestRight(device.GetName());
1143 USBDevicePipe pip;
1144 ret = UsbSrvClient.OpenDevice(device, pip);
1145 USB_HILOGI(
1146 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort005 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
1147 EXPECT_TRUE(ret == 0);
1148 UsbRequest request;
1149 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1150 USBEndpoint point = interface.GetEndpoints().at(1);
1151 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1152 EXPECT_TRUE(ret == 0);
1153 uint8_t tag[TAG_SIZE] = "request abort 005";
1154 std::vector<uint8_t> cdata = {tag, tag + 17};
1155 request.SetClientData(cdata);
1156 ret = request.Initialize(pip, point);
1157 EXPECT_TRUE(ret == 0);
1158 uint8_t buffer[BUFFER_SIZE] = "usb request test 005";
1159 std::vector<uint8_t> databuffer = {buffer, buffer + 20};
1160 request.SetReqData(databuffer);
1161 ret = UsbSrvClient.RequestQueue(request);
1162 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort005 %{public}d queue=%{public}d ", __LINE__, ret);
1163 EXPECT_TRUE(ret == 0);
1164 pip.SetBusNum(BUFFER_SIZE);
1165 request.SetPipe(pip);
1166 ret = UsbSrvClient.RequestAbort(request);
1167 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort005 %{public}d Abort=%{public}d ", __LINE__, ret);
1168 EXPECT_TRUE(ret != 0);
1169 pip.SetBusNum(device.GetBusNum());
1170 bool close = UsbSrvClient.Close(pip);
1171 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestabort005 %{public}d close=%{public}d", __LINE__, close);
1172 EXPECT_TRUE(close);
1173 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestabort005 : Requestabort");
1174 }
1175
1176 /**
1177 * @tc.name: Usbrequestabort006
1178 * @tc.desc: Test functions of RequestAbort(request)
1179 * @tc.type: FUNC
1180 */
1181 HWTEST_F(UsbRequestTest, Usbrequestabort006, TestSize.Level1)
1182 {
1183 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : Usbrequestabort006 : Requestabort");
1184 vector<UsbDevice> delist;
1185 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1186 auto ret = UsbSrvClient.GetDevices(delist);
1187 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort006 %{public}d ret=%{public}d size:%{public}zu",
1188 __LINE__, ret, delist.size());
1189 EXPECT_TRUE(ret == 0);
1190 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1191 UsbDevice device = delist.front();
1192 UsbSrvClient.RequestRight(device.GetName());
1193 USBDevicePipe pip;
1194 ret = UsbSrvClient.OpenDevice(device, pip);
1195 USB_HILOGI(
1196 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort006 %{public}d OpenDevice=%{public}d ", __LINE__, ret);
1197 EXPECT_TRUE(ret == 0);
1198 UsbRequest request;
1199 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1200 USBEndpoint point = interface.GetEndpoints().at(1);
1201 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1202 EXPECT_TRUE(ret == 0);
1203 uint8_t tag[TAG_SIZE] = "request abort 006";
1204 std::vector<uint8_t> cdata = {tag, tag + 17};
1205 request.SetClientData(cdata);
1206 ret = request.Initialize(pip, point);
1207 EXPECT_TRUE(ret == 0);
1208 uint8_t buffer[BUFFER_SIZE] = "usb request test 006";
1209 std::vector<uint8_t> databuffer = {buffer, buffer + 20};
1210 request.SetReqData(databuffer);
1211 ret = UsbSrvClient.RequestQueue(request);
1212 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort006 %{public}d queue=%{public}d ", __LINE__, ret);
1213 EXPECT_TRUE(ret == 0);
1214 pip.SetDevAddr(BUFFER_SIZE);
1215 request.SetPipe(pip);
1216 ret = UsbSrvClient.RequestAbort(request);
1217 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort006 %{public}d Abort=%{public}d ", __LINE__, ret);
1218 EXPECT_TRUE(ret != 0);
1219 pip.SetDevAddr(device.GetDevAddr());
1220 bool close = UsbSrvClient.Close(pip);
1221 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::Usbrequestabort006 %{public}d close=%{public}d", __LINE__, close);
1222 EXPECT_TRUE(close);
1223 USB_HILOGI(MODULE_USB_SERVICE, "Case End : Usbrequestabort006 : Requestabort");
1224 }
1225
1226 /**
1227 * @tc.name: PipeRequestWait001
1228 * @tc.desc: Test functions of PipeRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
1229 * @tc.type: FUNC
1230 */
1231 HWTEST_F(UsbRequestTest, PipeRequestWait001, TestSize.Level1)
1232 {
1233 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : PipeRequestWait001 : Initialize");
1234 vector<UsbDevice> delist;
1235 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1236 auto ret = UsbSrvClient.GetDevices(delist);
1237 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:PipeRequestWait001 %{public}d ret=%{public}d size:%{public}zu",
1238 __LINE__, ret, delist.size());
1239 EXPECT_TRUE(ret == 0);
1240 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1241 UsbDevice device = delist.front();
1242 UsbSrvClient.RequestRight(device.GetName());
1243 USBDevicePipe pip;
1244 ret = UsbSrvClient.OpenDevice(device, pip);
1245 USB_HILOGI(
1246 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
1247 EXPECT_TRUE(ret == 0);
1248 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1249 USBEndpoint point = interface.GetEndpoints().front();
1250 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1251 USB_HILOGI(
1252 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1253 EXPECT_TRUE(ret == 0);
1254 UsbRequest request;
1255 uint8_t tag[TAG_SIZE] = "request wait 001";
1256 std::vector<uint8_t> cdata = {tag, tag + 16};
1257 request.SetClientData(cdata);
1258 uint8_t buffer1[BUFFER_SIZE] = {0};
1259 std::vector<uint8_t> bufferdata = {buffer1, buffer1 + 17};
1260 request.SetReqData(bufferdata);
1261 ret = request.Initialize(pip, point);
1262 USB_HILOGI(
1263 MODULE_USB_SERVICE, "UsbRequestTest:Usbrequestabort006 %{public}d initialize=%{public}d ", __LINE__, ret);
1264 EXPECT_TRUE(ret == 0);
1265 ret = UsbSrvClient.RequestQueue(request);
1266 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait002 %{public}d queue=%{public}d ", __LINE__, ret);
1267 EXPECT_TRUE(ret == 0);
1268 UsbRequest reqwait;
1269 ret = UsbSrvClient.PipeRequestWait(pip, 5000, reqwait);
1270 USB_HILOGI(
1271 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait001 %{public}d PipeRequestWait=%{public}d", __LINE__, ret);
1272 EXPECT_TRUE(ret == 0);
1273 bool close = UsbSrvClient.Close(pip);
1274 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait001 %{public}d close=%{public}d", __LINE__, close);
1275 EXPECT_TRUE(close);
1276 USB_HILOGI(MODULE_USB_SERVICE, "Case End : PipeRequestWait001 : Initialize");
1277 }
1278
1279 /**
1280 * @tc.name: PipeRequestWait002
1281 * @tc.desc: Test functions of PipeRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
1282 * @tc.type: FUNC
1283 */
1284 HWTEST_F(UsbRequestTest, PipeRequestWait002, TestSize.Level1)
1285 {
1286 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : PipeRequestWait002 : Initialize");
1287 vector<UsbDevice> delist;
1288 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1289 auto ret = UsbSrvClient.GetDevices(delist);
1290 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:PipeRequestWait002 %{public}d ret=%{public}d size:%{public}zu",
1291 __LINE__, ret, delist.size());
1292 EXPECT_TRUE(ret == 0);
1293 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1294 UsbDevice device = delist.front();
1295 UsbSrvClient.RequestRight(device.GetName());
1296 USBDevicePipe pip;
1297 ret = UsbSrvClient.OpenDevice(device, pip);
1298 USB_HILOGI(
1299 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait002 %{public}d OpenDevice=%{public}d", __LINE__, ret);
1300 EXPECT_TRUE(ret == 0);
1301 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1302 USBEndpoint point = interface.GetEndpoints().front();
1303 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1304 USB_HILOGI(
1305 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1306 EXPECT_TRUE(ret == 0);
1307 UsbRequest request;
1308 uint8_t tag[TAG_SIZE] = "request wait 002";
1309 std::vector<uint8_t> cdata = {tag, tag + 16};
1310 request.SetClientData(cdata);
1311 uint8_t buffer1[BUFFER_SIZE] = {0};
1312 std::vector<uint8_t> bufferdata = {buffer1, buffer1 + 17};
1313 request.SetReqData(bufferdata);
1314 ret = request.Initialize(pip, point);
1315 USB_HILOGI(
1316 MODULE_USB_SERVICE, "UsbRequestTest:PipeRequestWait002 %{public}d initialize=%{public}d ", __LINE__, ret);
1317 EXPECT_TRUE(ret == 0);
1318 ret = UsbSrvClient.RequestQueue(request);
1319 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait002 %{public}d queue=%{public}d ", __LINE__, ret);
1320 EXPECT_TRUE(ret == 0);
1321 UsbRequest reqwait;
1322 pip.SetBusNum(BUFFER_SIZE);
1323 ret = UsbSrvClient.PipeRequestWait(pip, 5000, reqwait);
1324 USB_HILOGI(
1325 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait002 %{public}d PipeRequestWait=%{public}d", __LINE__, ret);
1326 EXPECT_TRUE(ret != 0);
1327 pip.SetBusNum(device.GetBusNum());
1328 bool close = UsbSrvClient.Close(pip);
1329 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait002 %{public}d close=%{public}d", __LINE__, close);
1330 EXPECT_TRUE(close);
1331 USB_HILOGI(MODULE_USB_SERVICE, "Case End : PipeRequestWait002 : Initialize");
1332 }
1333
1334 /**
1335 * @tc.name: PipeRequestWait003
1336 * @tc.desc: Test functions of PipeRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
1337 * @tc.type: FUNC
1338 */
1339 HWTEST_F(UsbRequestTest, PipeRequestWait003, TestSize.Level1)
1340 {
1341 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : PipeRequestWait003 : Initialize");
1342 vector<UsbDevice> delist;
1343 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1344 auto ret = UsbSrvClient.GetDevices(delist);
1345 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:PipeRequestWait003 %{public}d ret=%{public}d size:%{public}zu",
1346 __LINE__, ret, delist.size());
1347 EXPECT_TRUE(ret == 0);
1348 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1349 UsbDevice device = delist.front();
1350 UsbSrvClient.RequestRight(device.GetName());
1351 USBDevicePipe pip;
1352 ret = UsbSrvClient.OpenDevice(device, pip);
1353 USB_HILOGI(
1354 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait003 %{public}d OpenDevice=%{public}d", __LINE__, ret);
1355 EXPECT_TRUE(ret == 0);
1356 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1357 USBEndpoint point = interface.GetEndpoints().front();
1358 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1359 USB_HILOGI(
1360 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1361 EXPECT_TRUE(ret == 0);
1362 UsbRequest request;
1363 uint8_t tag[TAG_SIZE] = "request wait 003";
1364 std::vector<uint8_t> cdata = {tag, tag + 16};
1365 request.SetClientData(cdata);
1366 uint8_t buffer1[BUFFER_SIZE] = {0};
1367 std::vector<uint8_t> bufferdata = {buffer1, buffer1 + 17};
1368 request.SetReqData(bufferdata);
1369 ret = request.Initialize(pip, point);
1370 USB_HILOGI(
1371 MODULE_USB_SERVICE, "UsbRequestTest:PipeRequestWait003 %{public}d initialize=%{public}d ", __LINE__, ret);
1372 EXPECT_TRUE(ret == 0);
1373 ret = UsbSrvClient.RequestQueue(request);
1374 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait003 %{public}d queue=%{public}d ", __LINE__, ret);
1375 EXPECT_TRUE(ret == 0);
1376 UsbRequest reqwait;
1377 pip.SetDevAddr(BUFFER_SIZE);
1378 ret = UsbSrvClient.PipeRequestWait(pip, 5000, reqwait);
1379 USB_HILOGI(
1380 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait003 %{public}d PipeRequestWait=%{public}d", __LINE__, ret);
1381 EXPECT_TRUE(ret != 0);
1382 pip.SetDevAddr(device.GetDevAddr());
1383 bool close = UsbSrvClient.Close(pip);
1384 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait003 %{public}d close=%{public}d", __LINE__, close);
1385 EXPECT_TRUE(close);
1386 USB_HILOGI(MODULE_USB_SERVICE, "Case End : PipeRequestWait003 : Initialize");
1387 }
1388
1389 /**
1390 * @tc.name: PipeRequestWait004
1391 * @tc.desc: Test functions of PipeRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
1392 * @tc.type: FUNC
1393 */
1394 HWTEST_F(UsbRequestTest, PipeRequestWait004, TestSize.Level1)
1395 {
1396 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : PipeRequestWait004 : Initialize");
1397 vector<UsbDevice> delist;
1398 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1399 auto ret = UsbSrvClient.GetDevices(delist);
1400 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:PipeRequestWait004 %{public}d ret=%{public}d size:%{public}zu",
1401 __LINE__, ret, delist.size());
1402 EXPECT_TRUE(ret == 0);
1403 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1404 UsbDevice device = delist.front();
1405 UsbSrvClient.RequestRight(device.GetName());
1406 USBDevicePipe pip;
1407 ret = UsbSrvClient.OpenDevice(device, pip);
1408 USB_HILOGI(
1409 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait004 %{public}d OpenDevice=%{public}d", __LINE__, ret);
1410 EXPECT_TRUE(ret == 0);
1411 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1412 USBEndpoint point = interface.GetEndpoints().at(1);
1413 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1414 EXPECT_TRUE(ret == 0);
1415 UsbRequest request;
1416 uint8_t tag[TAG_SIZE] = "request wait 004";
1417 std::vector<uint8_t> cdata = {tag, tag + 16};
1418 request.SetClientData(cdata);
1419 ret = request.Initialize(pip, point);
1420 USB_HILOGI(
1421 MODULE_USB_SERVICE, "UsbRequestTest:PipeRequestWait004 %{public}d initialize=%{public}d ", __LINE__, ret);
1422 EXPECT_TRUE(ret == 0);
1423 uint8_t buffer[BUFFER_SIZE] = "usb request wait test004";
1424 std::vector<uint8_t> databuffer = {buffer, buffer + 24};
1425 request.SetReqData(databuffer);
1426 ret = UsbSrvClient.RequestQueue(request);
1427 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait004 %{public}d queue=%{public}d ", __LINE__, ret);
1428 EXPECT_TRUE(ret == 0);
1429 UsbRequest reqwait;
1430 ret = UsbSrvClient.PipeRequestWait(pip, 5000, reqwait);
1431 USB_HILOGI(
1432 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait004 %{public}d PipeRequestWait=%{public}d", __LINE__, ret);
1433 EXPECT_TRUE(ret == 0);
1434 bool close = UsbSrvClient.Close(pip);
1435 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait004 %{public}d close=%{public}d", __LINE__, close);
1436 EXPECT_TRUE(close);
1437 USB_HILOGI(MODULE_USB_SERVICE, "Case End : PipeRequestWait004 : Initialize");
1438 }
1439
1440 /**
1441 * @tc.name: PipeRequestWait005
1442 * @tc.desc: Test functions of PipeRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
1443 * @tc.type: FUNC
1444 */
1445 HWTEST_F(UsbRequestTest, PipeRequestWait005, TestSize.Level1)
1446 {
1447 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : PipeRequestWait005 : Initialize");
1448 vector<UsbDevice> delist;
1449 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1450 auto ret = UsbSrvClient.GetDevices(delist);
1451 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:PipeRequestWait005 %{public}d ret=%{public}d size:%{public}zu",
1452 __LINE__, ret, delist.size());
1453 EXPECT_TRUE(ret == 0);
1454 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1455 UsbDevice device = delist.front();
1456 UsbSrvClient.RequestRight(device.GetName());
1457 USBDevicePipe pip;
1458 ret = UsbSrvClient.OpenDevice(device, pip);
1459 USB_HILOGI(
1460 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait005 %{public}d OpenDevice=%{public}d", __LINE__, ret);
1461 EXPECT_TRUE(ret == 0);
1462 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1463 USBEndpoint point = interface.GetEndpoints().at(1);
1464 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1465 EXPECT_TRUE(ret == 0);
1466 UsbRequest request;
1467 uint8_t tag[TAG_SIZE] = "request wait 005";
1468 std::vector<uint8_t> cdata = {tag, tag + 16};
1469 request.SetClientData(cdata);
1470 ret = request.Initialize(pip, point);
1471 EXPECT_TRUE(ret == 0);
1472 uint8_t buffer[BUFFER_SIZE] = "usb request wait test005";
1473 std::vector<uint8_t> databuffer = {buffer, buffer + 24};
1474 request.SetReqData(databuffer);
1475 ret = UsbSrvClient.RequestQueue(request);
1476 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait005 %{public}d queue=%{public}d ", __LINE__, ret);
1477 EXPECT_TRUE(ret == 0);
1478 UsbRequest reqwait;
1479 pip.SetBusNum(BUFFER_SIZE);
1480 ret = UsbSrvClient.PipeRequestWait(pip, 5000, reqwait);
1481 USB_HILOGI(
1482 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait005 %{public}d PipeRequestWait=%{public}d", __LINE__, ret);
1483 EXPECT_TRUE(ret != 0);
1484 pip.SetBusNum(device.GetBusNum());
1485 bool close = UsbSrvClient.Close(pip);
1486 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait005 %{public}d close=%{public}d", __LINE__, close);
1487 EXPECT_TRUE(close);
1488 USB_HILOGI(MODULE_USB_SERVICE, "Case End : PipeRequestWait005 : Initialize");
1489 }
1490
1491 /**
1492 * @tc.name: PipeRequestWait006
1493 * @tc.desc: Test functions of PipeRequestWait(USBDevicePipe &pip, int64_t timeout, UsbRequest &req)
1494 * @tc.type: FUNC
1495 */
1496 HWTEST_F(UsbRequestTest, PipeRequestWait006, TestSize.Level1)
1497 {
1498 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : PipeRequestWait006 : Initialize");
1499 vector<UsbDevice> delist;
1500 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1501 auto ret = UsbSrvClient.GetDevices(delist);
1502 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest:PipeRequestWait006 %{public}d ret=%{public}d size:%{public}zu",
1503 __LINE__, ret, delist.size());
1504 EXPECT_TRUE(ret == 0);
1505 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1506 UsbDevice device = delist.front();
1507 UsbSrvClient.RequestRight(device.GetName());
1508 USBDevicePipe pip;
1509 ret = UsbSrvClient.OpenDevice(device, pip);
1510 USB_HILOGI(
1511 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait006 %{public}d OpenDevice=%{public}d", __LINE__, ret);
1512 EXPECT_TRUE(ret == 0);
1513 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1514 USBEndpoint point = interface.GetEndpoints().at(1);
1515 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
1516 USB_HILOGI(
1517 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1518 EXPECT_TRUE(ret == 0);
1519 UsbRequest request;
1520 uint8_t tag[TAG_SIZE] = "request abort 006";
1521 std::vector<uint8_t> cdata = {tag, tag + 16};
1522 request.SetClientData(cdata);
1523 ret = request.Initialize(pip, point);
1524 EXPECT_TRUE(ret == 0);
1525 uint8_t buffer[BUFFER_SIZE] = "usb request wait test006";
1526 std::vector<uint8_t> databuffer = {buffer, buffer + 24};
1527 request.SetReqData(databuffer);
1528 ret = UsbSrvClient.RequestQueue(request);
1529 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait006 %{public}d queue=%{public}d ", __LINE__, ret);
1530 EXPECT_TRUE(ret == 0);
1531 UsbRequest reqwait;
1532 pip.SetDevAddr(BUFFER_SIZE);
1533 ret = UsbSrvClient.PipeRequestWait(pip, 5000, reqwait);
1534 USB_HILOGI(
1535 MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait006 %{public}d PipeRequestWait=%{public}d", __LINE__, ret);
1536 EXPECT_TRUE(ret != 0);
1537 pip.SetDevAddr(device.GetDevAddr());
1538 bool close = UsbSrvClient.Close(pip);
1539 USB_HILOGI(MODULE_USB_SERVICE, "UsbRequestTest::PipeRequestWait006 %{public}d close=%{public}d", __LINE__, close);
1540 EXPECT_TRUE(close);
1541 USB_HILOGI(MODULE_USB_SERVICE, "Case End : PipeRequestWait006 : Initialize");
1542 }
1543 } // namespace Request
1544 } // namespace USB
1545 } // namespace OHOS
1546