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