1 /*
2 * Copyright (c) 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_bulkcallback_test.h"
17
18 #include <sys/time.h>
19
20 #include <iostream>
21 #include <vector>
22
23 #include "ashmem.h"
24 #include "delayed_sp_singleton.h"
25 #include "hilog_wrapper.h"
26 #include "if_system_ability_manager.h"
27 #include "iservice_registry.h"
28 #include "securec.h"
29 #include "system_ability_definition.h"
30 #include "usb_callback_test.h"
31 #include "usb_errors.h"
32 #include "usb_srv_client.h"
33
34 using namespace testing::ext;
35 using namespace OHOS;
36 using namespace OHOS::USB;
37 using namespace std;
38
39 namespace OHOS {
40 namespace USB {
41 namespace BulkCallback {
42 constexpr int32_t SLEEP_TIME = 3;
43 constexpr int32_t BUFFER_SIZE = 255;
44 constexpr uint32_t ASHMEM_MAX_SIZE = 1024;
45 constexpr uint32_t MEM_DATA = 1024 * 1024;
InitAshmemOne(sptr<Ashmem> & asmptr,int32_t asmSize,uint8_t rflg)46 static int32_t InitAshmemOne(sptr<Ashmem> &asmptr, int32_t asmSize, uint8_t rflg)
47 {
48 asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
49 if (asmptr == nullptr) {
50 USB_HILOGE(MODULE_USB_SERVICE, "InitAshmemOne CreateAshmem failed\n");
51 return UEC_SERVICE_NO_MEMORY;
52 }
53
54 asmptr->MapReadAndWriteAshmem();
55
56 if (rflg == 0) {
57 uint8_t tdata[ASHMEM_MAX_SIZE];
58 int32_t offset = 0;
59 int32_t tlen = 0;
60
61 int32_t retSafe = memset_s(tdata, sizeof(tdata), 'Y', ASHMEM_MAX_SIZE);
62 if (retSafe != EOK) {
63 USB_HILOGE(MODULE_USB_SERVICE, "InitAshmemOne memset_s failed\n");
64 return UEC_SERVICE_NO_MEMORY;
65 }
66 while (offset < asmSize) {
67 tlen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
68 asmptr->WriteToAshmem(tdata, tlen, offset);
69 offset += tlen;
70 }
71 }
72
73 return 0;
74 }
75
SetUpTestCase(void)76 void UsbBulkcallbackTest::SetUpTestCase(void)
77 {
78 auto &srvClient = UsbSrvClient::GetInstance();
79 auto ret = srvClient.SetPortRole(1, 1, 1);
80 sleep(SLEEP_TIME);
81 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest:: [Device] SetPortRole=%{public}d", ret);
82 ASSERT_TRUE(ret == 0);
83 if (ret != 0) {
84 exit(0);
85 }
86
87 std::cout << "please connect device, press enter to continue" << std::endl;
88 int32_t c;
89 while ((c = getchar()) != '\n' && c != EOF) {
90 ;
91 }
92 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbBulkcallbackTest");
93 }
94
TearDownTestCase(void)95 void UsbBulkcallbackTest::TearDownTestCase(void)
96 {
97 USB_HILOGI(MODULE_USB_SERVICE, "End UsbBulkcallbackTest");
98 }
99
SetUp(void)100 void UsbBulkcallbackTest::SetUp(void) {}
101
TearDown(void)102 void UsbBulkcallbackTest::TearDown(void) {}
103
104 /**
105 * @tc.name: RegBulkCallback001
106 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
107 * sptr<IRemoteObject> &cb)
108 * @tc.type: FUNC
109 */
110 HWTEST_F(UsbBulkcallbackTest, RegBulkCallback001, TestSize.Level1)
111 {
112 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : RegBulkCallback001 : BulkTransfer");
113 vector<UsbDevice> devi;
114 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
115 auto &UsbSrvClient = UsbSrvClient::GetInstance();
116 auto ret = UsbSrvClient.GetDevices(devi);
117 EXPECT_TRUE(ret == 0);
118 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
119 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback001 %{public}d size=%{public}zu", __LINE__,
120 devi.size());
121 USBDevicePipe pipe;
122 UsbDevice device = devi.front();
123 UsbSrvClient.RequestRight(device.GetName());
124 ret = UsbSrvClient.OpenDevice(device, pipe);
125 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback001 %{public}d OpenDevice=%{public}d",
126 __LINE__, ret);
127 EXPECT_TRUE(ret == 0);
128 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
129 USBEndpoint point = interface.GetEndpoints().front();
130 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback001 %{public}d point=%{public}d", __LINE__,
131 point.GetInterfaceId());
132 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
133 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback001 %{public}d ClaimInterface=%{public}d",
134 __LINE__, ret);
135 EXPECT_TRUE(ret == 0);
136 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
137 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback001 %{public}d RegBulkCallback=%{public}d",
138 __LINE__, ret);
139 EXPECT_TRUE(ret == 0);
140 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
141 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback001 %{public}d UnRegBulkCallback=%{public}d",
142 __LINE__, ret);
143 EXPECT_TRUE(ret == 0);
144 bool close = UsbSrvClient.Close(pipe);
145 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback001 %{public}d close=%{public}d", __LINE__,
146 close);
147 EXPECT_TRUE(close);
148 USB_HILOGI(MODULE_USB_SERVICE, "Case End : RegBulkCallback001 : BulkTransfer");
149 }
150
151 /**
152 * @tc.name: RegBulkCallback002
153 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
154 * sptr<IRemoteObject> &cb)
155 * @tc.type: FUNC
156 */
157
158 HWTEST_F(UsbBulkcallbackTest, RegBulkCallback002, TestSize.Level1)
159 {
160 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : RegBulkCallback002 : BulkTransfer");
161 vector<UsbDevice> devi;
162 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
163 auto &UsbSrvClient = UsbSrvClient::GetInstance();
164 auto ret = UsbSrvClient.GetDevices(devi);
165 EXPECT_TRUE(ret == 0);
166 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
167 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback002 %{public}d size=%{public}zu", __LINE__,
168 devi.size());
169 USBDevicePipe pipe;
170 UsbDevice device = devi.front();
171 UsbSrvClient.RequestRight(device.GetName());
172 ret = UsbSrvClient.OpenDevice(device, pipe);
173 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback002 %{public}d OpenDevice=%{public}d",
174 __LINE__, ret);
175 EXPECT_TRUE(ret == 0);
176 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
177 USBEndpoint point = interface.GetEndpoints().at(1);
178 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback002 %{public}d point=%{public}d", __LINE__,
179 point.GetInterfaceId());
180 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
181 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback002 %{public}d ClaimInterface=%{public}d",
182 __LINE__, ret);
183 EXPECT_TRUE(ret == 0);
184 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
185 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback002 %{public}d RegBulkCallback=%{public}d",
186 __LINE__, ret);
187 EXPECT_TRUE(ret == 0);
188 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
189 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback002 %{public}d UnRegBulkCallback=%{public}d",
190 __LINE__, ret);
191 EXPECT_TRUE(ret == 0);
192 bool close = UsbSrvClient.Close(pipe);
193 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback002 %{public}d close=%{public}d", __LINE__,
194 close);
195 EXPECT_TRUE(close);
196 USB_HILOGI(MODULE_USB_SERVICE, "Case End : RegBulkCallback002 : BulkTransfer");
197 }
198
199 /**
200 * @tc.name: RegBulkCallback003
201 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
202 * sptr<IRemoteObject> &cb)
203 * @tc.type: FUNC
204 */
205
206 HWTEST_F(UsbBulkcallbackTest, RegBulkCallback003, TestSize.Level1)
207 {
208 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : RegBulkCallback003 : BulkTransfer");
209 vector<UsbDevice> devi;
210 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
211 auto &UsbSrvClient = UsbSrvClient::GetInstance();
212 auto ret = UsbSrvClient.GetDevices(devi);
213 EXPECT_TRUE(ret == 0);
214 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
215 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback003 %{public}d size=%{public}zu", __LINE__,
216 devi.size());
217 USBDevicePipe pipe;
218 UsbDevice device = devi.front();
219 UsbSrvClient.RequestRight(device.GetName());
220 ret = UsbSrvClient.OpenDevice(device, pipe);
221 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback003 %{public}d OpenDevice=%{public}d",
222 __LINE__, ret);
223 EXPECT_TRUE(ret == 0);
224 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
225 USBEndpoint point = interface.GetEndpoints().at(1);
226 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback003 %{public}d point=%{public}d", __LINE__,
227 point.GetInterfaceId());
228 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
229 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback003 %{public}d ClaimInterface=%{public}d",
230 __LINE__, ret);
231 EXPECT_TRUE(ret == 0);
232 pipe.SetBusNum(BUFFER_SIZE);
233 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
234 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback003 %{public}d RegBulkCallback=%{public}d",
235 __LINE__, ret);
236 EXPECT_TRUE(ret != 0);
237 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
238 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback003 %{public}d UnRegBulkCallback=%{public}d",
239 __LINE__, ret);
240 EXPECT_TRUE(ret != 0);
241 pipe.SetBusNum(device.GetBusNum());
242 bool close = UsbSrvClient.Close(pipe);
243 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback003 %{public}d close=%{public}d", __LINE__,
244 close);
245 EXPECT_TRUE(close);
246 USB_HILOGI(MODULE_USB_SERVICE, "Case End : RegBulkCallback003 : BulkTransfer");
247 }
248
249 /**
250 * @tc.name: RegBulkCallback004
251 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
252 * sptr<IRemoteObject> &cb)
253 * @tc.type: FUNC
254 */
255
256 HWTEST_F(UsbBulkcallbackTest, RegBulkCallback004, TestSize.Level1)
257 {
258 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : RegBulkCallback004 : BulkTransfer");
259 vector<UsbDevice> devi;
260 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
261 auto &UsbSrvClient = UsbSrvClient::GetInstance();
262 auto ret = UsbSrvClient.GetDevices(devi);
263 EXPECT_TRUE(ret == 0);
264 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
265 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback004 %{public}d size=%{public}zu", __LINE__,
266 devi.size());
267 USBDevicePipe pipe;
268 UsbDevice device = devi.front();
269 UsbSrvClient.RequestRight(device.GetName());
270 ret = UsbSrvClient.OpenDevice(device, pipe);
271 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback004 %{public}d OpenDevice=%{public}d",
272 __LINE__, ret);
273 EXPECT_TRUE(ret == 0);
274 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
275 USBEndpoint point = interface.GetEndpoints().at(1);
276 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback004 %{public}d point=%{public}d", __LINE__,
277 point.GetInterfaceId());
278 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
279 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback004 %{public}d ClaimInterface=%{public}d",
280 __LINE__, ret);
281 EXPECT_TRUE(ret == 0);
282 pipe.SetDevAddr(BUFFER_SIZE);
283 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
284 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback004 %{public}d RegBulkCallback=%{public}d",
285 __LINE__, ret);
286 EXPECT_TRUE(ret != 0);
287 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
288 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback004 %{public}d UnRegBulkCallback=%{public}d",
289 __LINE__, ret);
290 EXPECT_TRUE(ret != 0);
291 pipe.SetDevAddr(device.GetDevAddr());
292 bool close = UsbSrvClient.Close(pipe);
293 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback004 %{public}d close=%{public}d", __LINE__,
294 close);
295 EXPECT_TRUE(close);
296 USB_HILOGI(MODULE_USB_SERVICE, "Case End : RegBulkCallback004 : BulkTransfer");
297 }
298
299 /**
300 * @tc.name: RegBulkCallback005
301 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
302 * sptr<IRemoteObject> &cb)
303 * @tc.type: FUNC
304 */
305
306 HWTEST_F(UsbBulkcallbackTest, RegBulkCallback005, TestSize.Level1)
307 {
308 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : RegBulkCallback005 : BulkTransfer");
309 vector<UsbDevice> devi;
310 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
311 auto &UsbSrvClient = UsbSrvClient::GetInstance();
312 auto ret = UsbSrvClient.GetDevices(devi);
313 EXPECT_TRUE(ret == 0);
314 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
315 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback005 %{public}d size=%{public}zu", __LINE__,
316 devi.size());
317 USBDevicePipe pipe;
318 UsbDevice device = devi.front();
319 UsbSrvClient.RequestRight(device.GetName());
320 ret = UsbSrvClient.OpenDevice(device, pipe);
321 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback005 %{public}d OpenDevice=%{public}d",
322 __LINE__, ret);
323 EXPECT_TRUE(ret == 0);
324 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
325 USBEndpoint point = interface.GetEndpoints().at(0);
326 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback005 %{public}d point=%{public}d", __LINE__,
327 point.GetInterfaceId());
328 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
329 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback005 %{public}d ClaimInterface=%{public}d",
330 __LINE__, ret);
331 EXPECT_TRUE(ret == 0);
332 pipe.SetDevAddr(BUFFER_SIZE);
333 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
334 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback005 %{public}d RegBulkCallback=%{public}d",
335 __LINE__, ret);
336 EXPECT_TRUE(ret != 0);
337 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
338 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback005 %{public}d UnRegBulkCallback=%{public}d",
339 __LINE__, ret);
340 EXPECT_TRUE(ret != 0);
341 pipe.SetDevAddr(device.GetDevAddr());
342 bool close = UsbSrvClient.Close(pipe);
343 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback005 %{public}d close=%{public}d", __LINE__,
344 close);
345 EXPECT_TRUE(close);
346 USB_HILOGI(MODULE_USB_SERVICE, "Case End : RegBulkCallback005 : BulkTransfer");
347 }
348
349 /**
350 * @tc.name: RegBulkCallback006
351 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
352 * sptr<IRemoteObject> &cb)
353 * @tc.type: FUNC
354 */
355
356 HWTEST_F(UsbBulkcallbackTest, RegBulkCallback006, TestSize.Level1)
357 {
358 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : RegBulkCallback006 : BulkTransfer");
359 vector<UsbDevice> devi;
360 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
361 auto &UsbSrvClient = UsbSrvClient::GetInstance();
362 auto ret = UsbSrvClient.GetDevices(devi);
363 EXPECT_TRUE(ret == 0);
364 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
365 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback006 %{public}d size=%{public}zu", __LINE__,
366 devi.size());
367 USBDevicePipe pipe;
368 UsbDevice device = devi.front();
369 UsbSrvClient.RequestRight(device.GetName());
370 ret = UsbSrvClient.OpenDevice(device, pipe);
371 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback006 %{public}d OpenDevice=%{public}d",
372 __LINE__, ret);
373 EXPECT_TRUE(ret == 0);
374 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
375 USBEndpoint point = interface.GetEndpoints().at(0);
376 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback006 %{public}d point=%{public}d", __LINE__,
377 point.GetInterfaceId());
378 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
379 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback006 %{public}d ClaimInterface=%{public}d",
380 __LINE__, ret);
381 EXPECT_TRUE(ret == 0);
382 pipe.SetBusNum(BUFFER_SIZE);
383 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
384 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback006 %{public}d RegBulkCallback=%{public}d",
385 __LINE__, ret);
386 EXPECT_TRUE(ret != 0);
387 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
388 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback006 %{public}d UnRegBulkCallback=%{public}d",
389 __LINE__, ret);
390 EXPECT_TRUE(ret != 0);
391 pipe.SetBusNum(device.GetBusNum());
392 bool close = UsbSrvClient.Close(pipe);
393 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::RegBulkCallback006 %{public}d close=%{public}d", __LINE__,
394 close);
395 EXPECT_TRUE(close);
396 USB_HILOGI(MODULE_USB_SERVICE, "Case End : RegBulkCallback006 : BulkTransfer");
397 }
398
399 /**
400 * @tc.name: BulkRead001
401 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
402 * @tc.type: FUNC
403 */
404 HWTEST_F(UsbBulkcallbackTest, BulkRead001, TestSize.Level1)
405 {
406 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : BulkRead001 : BulkTransfer");
407 vector<UsbDevice> devi;
408 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
409 sptr<Ashmem> ashmem;
410 uint8_t rflg = 0;
411 int32_t asmSize = MEM_DATA;
412 auto &UsbSrvClient = UsbSrvClient::GetInstance();
413 auto ret = UsbSrvClient.GetDevices(devi);
414 EXPECT_TRUE(ret == 0);
415 ret = InitAshmemOne(ashmem, asmSize, rflg);
416 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead001 %{public}d ret=%{public}d", __LINE__, ret);
417 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
418 USBDevicePipe pipe;
419 UsbDevice device = devi.front();
420 UsbSrvClient.RequestRight(device.GetName());
421 ret = UsbSrvClient.OpenDevice(device, pipe);
422 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
423 EXPECT_TRUE(ret == 0);
424 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
425 USBEndpoint point = interface.GetEndpoints().front();
426 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead001 %{public}d point=%{public}d", __LINE__,
427 point.GetInterfaceId());
428 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
429 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead001 %{public}d ClaimInterface=%{public}d", __LINE__,
430 ret);
431 EXPECT_TRUE(ret == 0);
432 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
433 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead001 %{public}d RegBulkCallback=%{public}d", __LINE__,
434 ret);
435 EXPECT_TRUE(ret == 0);
436 ret = UsbSrvClient.BulkRead(pipe, point, ashmem);
437 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead001 %{public}d BulkRead=%{public}d", __LINE__, ret);
438 EXPECT_TRUE(ret == 0);
439 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
440 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead001 %{public}d UnRegBulkCallback=%{public}d",
441 __LINE__, ret);
442 EXPECT_TRUE(ret == 0);
443 ret = UsbSrvClient.BulkCancel(pipe, point);
444 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead001 %{public}d BulkCancel=%{public}d", __LINE__, ret);
445 EXPECT_TRUE(ret == 0);
446 bool close = UsbSrvClient.Close(pipe);
447 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead001 %{public}d close=%{public}d", __LINE__, close);
448 EXPECT_TRUE(close);
449 USB_HILOGI(MODULE_USB_SERVICE, "Case End : BulkRead001 : BulkTransfer");
450 }
451
452 /**
453 * @tc.name: BulkRead002
454 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
455 * @tc.type: FUNC
456 */
457 HWTEST_F(UsbBulkcallbackTest, BulkRead002, TestSize.Level1)
458 {
459 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : BulkRead002 : BulkTransfer");
460 vector<UsbDevice> devi;
461 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
462 sptr<Ashmem> ashmem;
463 uint8_t rflg = 0;
464 int32_t asmSize = MEM_DATA;
465 auto &UsbSrvClient = UsbSrvClient::GetInstance();
466 auto ret = UsbSrvClient.GetDevices(devi);
467 EXPECT_TRUE(ret == 0);
468 ret = InitAshmemOne(ashmem, asmSize, rflg);
469 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead002 %{public}d ret=%{public}d", __LINE__, ret);
470 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
471 USBDevicePipe pipe;
472 UsbDevice device = devi.front();
473 UsbSrvClient.RequestRight(device.GetName());
474 ret = UsbSrvClient.OpenDevice(device, pipe);
475 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead002 %{public}d OpenDevice=%{public}d", __LINE__, ret);
476 EXPECT_TRUE(ret == 0);
477 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
478 USBEndpoint point = interface.GetEndpoints().at(1);
479 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead002 %{public}d point=%{public}d", __LINE__,
480 point.GetInterfaceId());
481 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
482 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead002 %{public}d ClaimInterface=%{public}d", __LINE__,
483 ret);
484 EXPECT_TRUE(ret == 0);
485 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
486 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead002 %{public}d RegBulkCallback=%{public}d", __LINE__,
487 ret);
488 EXPECT_TRUE(ret == 0);
489 ret = UsbSrvClient.BulkRead(pipe, point, ashmem);
490 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead002 %{public}d BulkRead=%{public}d", __LINE__, ret);
491 EXPECT_TRUE(ret != 0);
492 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
493 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead002 %{public}d UnRegBulkCallback=%{public}d",
494 __LINE__, ret);
495 EXPECT_TRUE(ret == 0);
496 ret = UsbSrvClient.BulkCancel(pipe, point);
497 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead002 %{public}d BulkCancel=%{public}d", __LINE__, ret);
498 EXPECT_TRUE(ret == 0);
499 bool close = UsbSrvClient.Close(pipe);
500 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead002 %{public}d close=%{public}d", __LINE__, close);
501 EXPECT_TRUE(close);
502 USB_HILOGI(MODULE_USB_SERVICE, "Case End : BulkRead002 : BulkTransfer");
503 }
504
505 /**
506 * @tc.name: BulkRead003
507 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
508 * @tc.type: FUNC
509 */
510 HWTEST_F(UsbBulkcallbackTest, BulkRead003, TestSize.Level1)
511 {
512 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : BulkRead003 : BulkTransfer");
513 vector<UsbDevice> devi;
514 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
515 sptr<Ashmem> ashmem;
516 uint8_t rflg = 0;
517 int32_t asmSize = MEM_DATA;
518 auto &UsbSrvClient = UsbSrvClient::GetInstance();
519 auto ret = UsbSrvClient.GetDevices(devi);
520 EXPECT_TRUE(ret == 0);
521 ret = InitAshmemOne(ashmem, asmSize, rflg);
522 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead003 %{public}d ret=%{public}d", __LINE__, ret);
523 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
524 USBDevicePipe pipe;
525 UsbDevice device = devi.front();
526 UsbSrvClient.RequestRight(device.GetName());
527 ret = UsbSrvClient.OpenDevice(device, pipe);
528 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead003 %{public}d OpenDevice=%{public}d", __LINE__, ret);
529 EXPECT_TRUE(ret == 0);
530 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
531 USBEndpoint point = interface.GetEndpoints().front();
532 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead003 %{public}d point=%{public}d", __LINE__,
533 point.GetInterfaceId());
534 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
535 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead003 %{public}d ClaimInterface=%{public}d", __LINE__,
536 ret);
537 EXPECT_TRUE(ret == 0);
538 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
539 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead003 %{public}d RegBulkCallback=%{public}d", __LINE__,
540 ret);
541 EXPECT_TRUE(ret == 0);
542 pipe.SetBusNum(BUFFER_SIZE);
543 ret = UsbSrvClient.BulkRead(pipe, point, ashmem);
544 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead003 %{public}d BulkRead=%{public}d", __LINE__, ret);
545 EXPECT_TRUE(ret != 0);
546 pipe.SetBusNum(device.GetBusNum());
547 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
548 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead003 %{public}d UnRegBulkCallback=%{public}d",
549 __LINE__, ret);
550 EXPECT_TRUE(ret == 0);
551 ret = UsbSrvClient.BulkCancel(pipe, point);
552 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead003 %{public}d BulkCancel=%{public}d", __LINE__, ret);
553 EXPECT_TRUE(ret == 0);
554 bool close = UsbSrvClient.Close(pipe);
555 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead003 %{public}d close=%{public}d", __LINE__, close);
556 EXPECT_TRUE(close);
557 USB_HILOGI(MODULE_USB_SERVICE, "Case End : BulkRead003 : BulkTransfer");
558 }
559
560 /**
561 * @tc.name: BulkRead004
562 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
563 * @tc.type: FUNC
564 */
565 HWTEST_F(UsbBulkcallbackTest, BulkRead004, TestSize.Level1)
566 {
567 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : BulkRead004 : BulkTransfer");
568 vector<UsbDevice> devi;
569 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
570 sptr<Ashmem> ashmem;
571 uint8_t rflg = 0;
572 int32_t asmSize = MEM_DATA;
573 auto &UsbSrvClient = UsbSrvClient::GetInstance();
574 auto ret = UsbSrvClient.GetDevices(devi);
575 EXPECT_TRUE(ret == 0);
576 ret = InitAshmemOne(ashmem, asmSize, rflg);
577 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead004 %{public}d ret=%{public}d", __LINE__, ret);
578 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
579 USBDevicePipe pipe;
580 UsbDevice device = devi.front();
581 UsbSrvClient.RequestRight(device.GetName());
582 ret = UsbSrvClient.OpenDevice(device, pipe);
583 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead004 %{public}d OpenDevice=%{public}d", __LINE__, ret);
584 EXPECT_TRUE(ret == 0);
585 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
586 USBEndpoint point = interface.GetEndpoints().front();
587 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead004 %{public}d point=%{public}d", __LINE__,
588 point.GetInterfaceId());
589 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
590 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead004 %{public}d ClaimInterface=%{public}d", __LINE__,
591 ret);
592 EXPECT_TRUE(ret == 0);
593 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
594 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead004 %{public}d RegBulkCallback=%{public}d", __LINE__,
595 ret);
596 EXPECT_TRUE(ret == 0);
597 pipe.SetDevAddr(BUFFER_SIZE);
598 ret = UsbSrvClient.BulkRead(pipe, point, ashmem);
599 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead004 %{public}d BulkRead=%{public}d", __LINE__, ret);
600 EXPECT_TRUE(ret != 0);
601 pipe.SetDevAddr(device.GetDevAddr());
602 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
603 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead004 %{public}d UnRegBulkCallback=%{public}d",
604 __LINE__, ret);
605 EXPECT_TRUE(ret == 0);
606 ret = UsbSrvClient.BulkCancel(pipe, point);
607 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead004 %{public}d BulkCancel=%{public}d", __LINE__, ret);
608 EXPECT_TRUE(ret == 0);
609 bool close = UsbSrvClient.Close(pipe);
610 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkRead004 %{public}d close=%{public}d", __LINE__, close);
611 EXPECT_TRUE(close);
612 USB_HILOGI(MODULE_USB_SERVICE, "Case End : BulkRead004 : BulkTransfer");
613 }
614
615 /**
616 * @tc.name: BulkWrite001
617 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
618 * @tc.type: FUNC
619 */
620 HWTEST_F(UsbBulkcallbackTest, BulkWrite001, TestSize.Level1)
621 {
622 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : BulkWrite001 : BulkTransfer");
623 vector<UsbDevice> devi;
624 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
625 sptr<Ashmem> ashmem;
626 uint8_t rflg = 0;
627 int32_t asmSize = MEM_DATA;
628 auto &UsbSrvClient = UsbSrvClient::GetInstance();
629 auto ret = UsbSrvClient.GetDevices(devi);
630 EXPECT_TRUE(ret == 0);
631 ret = InitAshmemOne(ashmem, asmSize, rflg);
632 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite001 %{public}d ret=%{public}d", __LINE__, ret);
633 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
634 USBDevicePipe pipe;
635 UsbDevice device = devi.front();
636 UsbSrvClient.RequestRight(device.GetName());
637 ret = UsbSrvClient.OpenDevice(device, pipe);
638 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite001 %{public}d OpenDevice=%{public}d", __LINE__,
639 ret);
640 EXPECT_TRUE(ret == 0);
641 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
642 USBEndpoint point = interface.GetEndpoints().at(1);
643 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite001 %{public}d point=%{public}d", __LINE__,
644 point.GetInterfaceId());
645 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
646 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite001 %{public}d ClaimInterface=%{public}d", __LINE__,
647 ret);
648 EXPECT_TRUE(ret == 0);
649 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
650 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite001 %{public}d RegBulkCallback=%{public}d", __LINE__,
651 ret);
652 EXPECT_TRUE(ret == 0);
653 ret = UsbSrvClient.BulkWrite(pipe, point, ashmem);
654 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite001 %{public}d BulkWrite=%{public}d", __LINE__, ret);
655 EXPECT_TRUE(ret == 0);
656 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
657 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite001 %{public}d UnRegBulkCallback=%{public}d",
658 __LINE__, ret);
659 EXPECT_TRUE(ret == 0);
660 ret = UsbSrvClient.BulkCancel(pipe, point);
661 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite001 %{public}d BulkCancel=%{public}d", __LINE__,
662 ret);
663 EXPECT_TRUE(ret == 0);
664 bool close = UsbSrvClient.Close(pipe);
665 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite001 %{public}d close=%{public}d", __LINE__, close);
666 EXPECT_TRUE(close);
667 USB_HILOGI(MODULE_USB_SERVICE, "Case End : BulkWrite001 : BulkTransfer");
668 }
669
670 /**
671 * @tc.name: BulkWrite002
672 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
673 * @tc.type: FUNC
674 */
675 HWTEST_F(UsbBulkcallbackTest, BulkWrite002, TestSize.Level1)
676 {
677 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : BulkWrite002 : BulkTransfer");
678 vector<UsbDevice> devi;
679 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
680 sptr<Ashmem> ashmem;
681 uint8_t rflg = 0;
682 int32_t asmSize = MEM_DATA;
683 auto &UsbSrvClient = UsbSrvClient::GetInstance();
684 auto ret = UsbSrvClient.GetDevices(devi);
685 EXPECT_TRUE(ret == 0);
686 ret = InitAshmemOne(ashmem, asmSize, rflg);
687 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite002 %{public}d ret=%{public}d", __LINE__, ret);
688 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
689 USBDevicePipe pipe;
690 UsbDevice device = devi.front();
691 UsbSrvClient.RequestRight(device.GetName());
692 ret = UsbSrvClient.OpenDevice(device, pipe);
693 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite002 %{public}d OpenDevice=%{public}d", __LINE__,
694 ret);
695 EXPECT_TRUE(ret == 0);
696 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
697 USBEndpoint point = interface.GetEndpoints().at(1);
698 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite002 %{public}d point=%{public}d", __LINE__,
699 point.GetInterfaceId());
700 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
701 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite002 %{public}d ClaimInterface=%{public}d", __LINE__,
702 ret);
703 EXPECT_TRUE(ret == 0);
704 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
705 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite002 %{public}d RegBulkCallback=%{public}d", __LINE__,
706 ret);
707 EXPECT_TRUE(ret == 0);
708 pipe.SetBusNum(BUFFER_SIZE);
709 ret = UsbSrvClient.BulkWrite(pipe, point, ashmem);
710 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite002 %{public}d BulkWrite=%{public}d", __LINE__, ret);
711 EXPECT_TRUE(ret != 0);
712 pipe.SetBusNum(device.GetBusNum());
713 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
714 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite002 %{public}d UnRegBulkCallback=%{public}d",
715 __LINE__, ret);
716 EXPECT_TRUE(ret == 0);
717 ret = UsbSrvClient.BulkCancel(pipe, point);
718 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite002 %{public}d BulkCancel=%{public}d", __LINE__,
719 ret);
720 EXPECT_TRUE(ret == 0);
721 bool close = UsbSrvClient.Close(pipe);
722 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite002 %{public}d close=%{public}d", __LINE__, close);
723 EXPECT_TRUE(close);
724 USB_HILOGI(MODULE_USB_SERVICE, "Case End : BulkWrite002 : BulkTransfer");
725 }
726
727 /**
728 * @tc.name: BulkWrite003
729 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
730 * @tc.type: FUNC
731 */
732 HWTEST_F(UsbBulkcallbackTest, BulkWrite003, TestSize.Level1)
733 {
734 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : BulkWrite003 : BulkTransfer");
735 vector<UsbDevice> devi;
736 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
737 sptr<Ashmem> ashmem;
738 uint8_t rflg = 0;
739 int32_t asmSize = MEM_DATA;
740 auto &UsbSrvClient = UsbSrvClient::GetInstance();
741 auto ret = UsbSrvClient.GetDevices(devi);
742 EXPECT_TRUE(ret == 0);
743 ret = InitAshmemOne(ashmem, asmSize, rflg);
744 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite003 %{public}d ret=%{public}d", __LINE__, ret);
745 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
746 USBDevicePipe pipe;
747 UsbDevice device = devi.front();
748 UsbSrvClient.RequestRight(device.GetName());
749 ret = UsbSrvClient.OpenDevice(device, pipe);
750 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite003 %{public}d OpenDevice=%{public}d", __LINE__,
751 ret);
752 EXPECT_TRUE(ret == 0);
753 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
754 USBEndpoint point = interface.GetEndpoints().at(1);
755 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite003 %{public}d point=%{public}d", __LINE__,
756 point.GetInterfaceId());
757 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
758 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite003 %{public}d ClaimInterface=%{public}d", __LINE__,
759 ret);
760 EXPECT_TRUE(ret == 0);
761 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
762 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite003 %{public}d RegBulkCallback=%{public}d", __LINE__,
763 ret);
764 EXPECT_TRUE(ret == 0);
765 pipe.SetDevAddr(BUFFER_SIZE);
766 ret = UsbSrvClient.BulkWrite(pipe, point, ashmem);
767 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite003 %{public}d BulkWrite=%{public}d", __LINE__, ret);
768 EXPECT_TRUE(ret != 0);
769 pipe.SetDevAddr(device.GetDevAddr());
770 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
771 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite003 %{public}d UnRegBulkCallback=%{public}d",
772 __LINE__, ret);
773 EXPECT_TRUE(ret == 0);
774 ret = UsbSrvClient.BulkCancel(pipe, point);
775 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite003 %{public}d BulkCancel=%{public}d", __LINE__,
776 ret);
777 EXPECT_TRUE(ret == 0);
778 bool close = UsbSrvClient.Close(pipe);
779 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkWrite003 %{public}d close=%{public}d", __LINE__, close);
780 EXPECT_TRUE(close);
781 USB_HILOGI(MODULE_USB_SERVICE, "Case End : BulkWrite003 : BulkTransfer");
782 }
783
784 /**
785 * @tc.name: BulkCancel001
786 * @tc.desc: Test functions to int32_t BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
787 * @tc.type: FUNC
788 */
789 HWTEST_F(UsbBulkcallbackTest, BulkCancel001, TestSize.Level1)
790 {
791 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : BulkCancel001 : BulkTransfer");
792 vector<UsbDevice> devi;
793 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
794 sptr<Ashmem> ashmem;
795 uint8_t rflg = 0;
796 int32_t asmSize = MEM_DATA;
797 auto &UsbSrvClient = UsbSrvClient::GetInstance();
798 auto ret = UsbSrvClient.GetDevices(devi);
799 EXPECT_TRUE(ret == 0);
800 ret = InitAshmemOne(ashmem, asmSize, rflg);
801 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
802 USBDevicePipe pipe;
803 UsbDevice device = devi.front();
804 UsbSrvClient.RequestRight(device.GetName());
805 ret = UsbSrvClient.OpenDevice(device, pipe);
806 EXPECT_TRUE(ret == 0);
807 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
808 USBEndpoint point = interface.GetEndpoints().front();
809 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
810 EXPECT_TRUE(ret == 0);
811 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
812 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel001 %{public}d RegBulkCallback=%{public}d",
813 __LINE__, ret);
814 EXPECT_TRUE(ret == 0);
815 ret = UsbSrvClient.BulkRead(pipe, point, ashmem);
816 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel001 %{public}d BulkRead=%{public}d", __LINE__, ret);
817 EXPECT_TRUE(ret == 0);
818 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
819 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel001 %{public}d UnRegBulkCallback=%{public}d",
820 __LINE__, ret);
821 EXPECT_TRUE(ret == 0);
822 pipe.SetBusNum(BUFFER_SIZE);
823 ret = UsbSrvClient.BulkCancel(pipe, point);
824 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel001 %{public}d BulkCancel=%{public}d", __LINE__,
825 ret);
826 EXPECT_TRUE(ret != 0);
827 pipe.SetBusNum(device.GetBusNum());
828 ret = UsbSrvClient.BulkCancel(pipe, point);
829 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel002 %{public}d BulkCancel=%{public}d", __LINE__,
830 ret);
831 EXPECT_TRUE(ret == 0);
832 bool close = UsbSrvClient.Close(pipe);
833 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel001 %{public}d close=%{public}d", __LINE__, close);
834 EXPECT_TRUE(close);
835 USB_HILOGI(MODULE_USB_SERVICE, "Case End : BulkCancel001 : BulkTransfer");
836 }
837
838 /**
839 * @tc.name: BulkCancel002
840 * @tc.desc: Test functions to int32_t BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
841 * @tc.type: FUNC
842 */
843 HWTEST_F(UsbBulkcallbackTest, BulkCancel002, TestSize.Level1)
844 {
845 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : BulkCancel002 : BulkTransfer");
846 vector<UsbDevice> devi;
847 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
848 sptr<Ashmem> ashmem;
849 uint8_t rflg = 0;
850 int32_t asmSize = MEM_DATA;
851 auto &UsbSrvClient = UsbSrvClient::GetInstance();
852 auto ret = UsbSrvClient.GetDevices(devi);
853 EXPECT_TRUE(ret == 0);
854 ret = InitAshmemOne(ashmem, asmSize, rflg);
855 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel002 %{public}d ret=%{public}d", __LINE__, ret);
856 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
857 USBDevicePipe pipe;
858 UsbDevice device = devi.front();
859 UsbSrvClient.RequestRight(device.GetName());
860 ret = UsbSrvClient.OpenDevice(device, pipe);
861 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel002 %{public}d OpenDevice=%{public}d", __LINE__,
862 ret);
863 EXPECT_TRUE(ret == 0);
864 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
865 USBEndpoint point = interface.GetEndpoints().front();
866 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
867 EXPECT_TRUE(ret == 0);
868 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
869 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel002 %{public}d RegBulkCallback=%{public}d",
870 __LINE__, ret);
871 EXPECT_TRUE(ret == 0);
872 ret = UsbSrvClient.BulkRead(pipe, point, ashmem);
873 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel002 %{public}d BulkRead=%{public}d", __LINE__, ret);
874 EXPECT_TRUE(ret == 0);
875 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
876 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel002 %{public}d UnRegBulkCallback=%{public}d",
877 __LINE__, ret);
878 EXPECT_TRUE(ret == 0);
879 pipe.SetDevAddr(BUFFER_SIZE);
880 ret = UsbSrvClient.BulkCancel(pipe, point);
881 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel002 %{public}d BulkCancel=%{public}d", __LINE__,
882 ret);
883 EXPECT_TRUE(ret != 0);
884 pipe.SetDevAddr(device.GetDevAddr());
885 ret = UsbSrvClient.BulkCancel(pipe, point);
886 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel002 %{public}d BulkCancel=%{public}d", __LINE__,
887 ret);
888 EXPECT_TRUE(ret == 0);
889 bool close = UsbSrvClient.Close(pipe);
890 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::BulkCancel002 %{public}d close=%{public}d", __LINE__, close);
891 EXPECT_TRUE(close);
892 USB_HILOGI(MODULE_USB_SERVICE, "Case End : BulkCancel002 : BulkTransfer");
893 }
894
895 /**
896 * @tc.name: UnRegBulkCallback001
897 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
898 * @tc.type: FUNC
899 */
900 HWTEST_F(UsbBulkcallbackTest, UnRegBulkCallback001, TestSize.Level1)
901 {
902 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UnRegBulkCallback001 : BulkTransfer");
903 vector<UsbDevice> devi;
904 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
905 auto &UsbSrvClient = UsbSrvClient::GetInstance();
906 auto ret = UsbSrvClient.GetDevices(devi);
907 EXPECT_TRUE(ret == 0);
908 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
909 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback001 %{public}d size=%{public}zu", __LINE__,
910 devi.size());
911 USBDevicePipe pipe;
912 UsbDevice device = devi.front();
913 UsbSrvClient.RequestRight(device.GetName());
914 ret = UsbSrvClient.OpenDevice(device, pipe);
915 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback001 %{public}d OpenDevice=%{public}d",
916 __LINE__, ret);
917 EXPECT_TRUE(ret == 0);
918 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
919 USBEndpoint point = interface.GetEndpoints().front();
920 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback001 %{public}d point=%{public}d", __LINE__,
921 point.GetInterfaceId());
922 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
923 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback001 %{public}d ClaimInterface=%{public}d",
924 __LINE__, ret);
925 EXPECT_TRUE(ret == 0);
926 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
927 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback001 %{public}d RegBulkCallback=%{public}d",
928 __LINE__, ret);
929 EXPECT_TRUE(ret == 0);
930 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
931 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback001 %{public}d UnRegBulkCallback=%{public}d",
932 __LINE__, ret);
933 EXPECT_TRUE(ret == 0);
934 bool close = UsbSrvClient.Close(pipe);
935 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback001 %{public}d close=%{public}d", __LINE__,
936 close);
937 EXPECT_TRUE(close);
938 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UnRegBulkCallback001 : BulkTransfer");
939 }
940
941 /**
942 * @tc.name: UnRegBulkCallback002
943 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
944 * @tc.type: FUNC
945 */
946 HWTEST_F(UsbBulkcallbackTest, UnRegBulkCallback002, TestSize.Level1)
947 {
948 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UnRegBulkCallback002 : BulkTransfer");
949 vector<UsbDevice> devi;
950 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
951 auto &UsbSrvClient = UsbSrvClient::GetInstance();
952 auto ret = UsbSrvClient.GetDevices(devi);
953 EXPECT_TRUE(ret == 0);
954 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
955 USBDevicePipe pipe;
956 UsbDevice device = devi.front();
957 UsbSrvClient.RequestRight(device.GetName());
958 ret = UsbSrvClient.OpenDevice(device, pipe);
959 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback002 %{public}d OpenDevice=%{public}d",
960 __LINE__, ret);
961 EXPECT_TRUE(ret == 0);
962 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
963 USBEndpoint point = interface.GetEndpoints().front();
964 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback002 %{public}d point=%{public}d", __LINE__,
965 point.GetInterfaceId());
966 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
967 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback002 %{public}d ClaimInterface=%{public}d",
968 __LINE__, ret);
969 EXPECT_TRUE(ret == 0);
970 pipe.SetBusNum(BUFFER_SIZE);
971 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
972 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback002 %{public}d RegBulkCallback=%{public}d",
973 __LINE__, ret);
974 EXPECT_TRUE(ret != 0);
975 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
976 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback002 %{public}d UnRegBulkCallback=%{public}d",
977 __LINE__, ret);
978 EXPECT_TRUE(ret != 0);
979 pipe.SetBusNum(device.GetBusNum());
980 bool close = UsbSrvClient.Close(pipe);
981 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback002 %{public}d close=%{public}d", __LINE__,
982 close);
983 EXPECT_TRUE(close);
984 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UnRegBulkCallback002 : BulkTransfer");
985 }
986
987 /**
988 * @tc.name: UnRegBulkCallback003
989 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
990 * @tc.type: FUNC
991 */
992 HWTEST_F(UsbBulkcallbackTest, UnRegBulkCallback003, TestSize.Level1)
993 {
994 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UnRegBulkCallback003 : BulkTransfer");
995 vector<UsbDevice> devi;
996 sptr<UsbCallbackTest> cb = new UsbCallbackTest();
997 auto &UsbSrvClient = UsbSrvClient::GetInstance();
998 auto ret = UsbSrvClient.GetDevices(devi);
999 EXPECT_TRUE(ret == 0);
1000 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1001 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback003 %{public}d size=%{public}zu", __LINE__,
1002 devi.size());
1003 USBDevicePipe pipe;
1004 UsbDevice device = devi.front();
1005 UsbSrvClient.RequestRight(device.GetName());
1006 ret = UsbSrvClient.OpenDevice(device, pipe);
1007 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback003 %{public}d OpenDevice=%{public}d",
1008 __LINE__, ret);
1009 EXPECT_TRUE(ret == 0);
1010 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(1);
1011 USBEndpoint point = interface.GetEndpoints().front();
1012 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback003 %{public}d point=%{public}d", __LINE__,
1013 point.GetInterfaceId());
1014 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
1015 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback003 %{public}d ClaimInterface=%{public}d",
1016 __LINE__, ret);
1017 EXPECT_TRUE(ret == 0);
1018 pipe.SetDevAddr(BUFFER_SIZE);
1019 ret = UsbSrvClient.RegBulkCallback(pipe, point, cb);
1020 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback003 %{public}d RegBulkCallback=%{public}d",
1021 __LINE__, ret);
1022 EXPECT_TRUE(ret != 0);
1023 ret = UsbSrvClient.UnRegBulkCallback(pipe, point);
1024 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback003 %{public}d UnRegBulkCallback=%{public}d",
1025 __LINE__, ret);
1026 EXPECT_TRUE(ret != 0);
1027 pipe.SetDevAddr(device.GetDevAddr());
1028 bool close = UsbSrvClient.Close(pipe);
1029 USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackTest::UnRegBulkCallback003 %{public}d close=%{public}d", __LINE__,
1030 close);
1031 EXPECT_TRUE(close);
1032 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UnRegBulkCallback003 : BulkTransfer");
1033 }
1034 } // BulkCallback
1035 } // USB
1036 } // OHOS
1037