1 /*
2 * Copyright (c) 2024 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 "usbd_async_transfer_test.h"
17 #include "libusb_adapter.h"
18
19 #include <iostream>
20 #include <vector>
21 #include <hdf_base.h>
22
23 #include "UsbSubTest.h"
24 #include "usbd_type.h"
25 #include "usbd_wrapper.h"
26 #include "v2_0/iusb_host_interface.h"
27
28 constexpr uint8_t INTERFACEID_OK = 0;
29 constexpr uint32_t MAX_BUFFER_LENGTH = 0x0100U;
30 constexpr int32_t ASHMEM_MAX_SIZE = 1024;
31 constexpr int32_t ASYNC_TRANSFER_TIME_OUT = 1000;
32 constexpr int32_t ENDPOINT_ADDRESS_IN = 0x81; // device-to-host
33 constexpr int32_t ENDPOINT_ADDRESS_OUT = 0x1; // host-to-device
34 constexpr int32_t ISOCHRONOUS_PACKETS = 2;
35
36 using namespace testing::ext;
37 using namespace OHOS;
38 using namespace OHOS::USB;
39 using namespace OHOS::HDI::Usb::V2_0;
40 using OHOS::HDI::Usb::V2_0::USBTransferInfo;
41
42 namespace OHOS::USB::UsbdAsyncTransfer {
43 UsbDev UsbdAsyncTransferTest::dev_ = {0, 0};
44 sptr<UsbSubTest> UsbdAsyncTransferTest::subscriber_ = nullptr;
45 sptr<OHOS::HDI::Usb::V2_0::IUsbHostInterface> g_usbHostInterface = nullptr;
46
InitAshmemOne(sptr<Ashmem> & asmptr,int32_t asmSize,uint8_t rflg)47 int32_t InitAshmemOne(sptr<Ashmem> &asmptr, int32_t asmSize, uint8_t rflg)
48 {
49 asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
50 if (asmptr == nullptr) {
51 HDF_LOGE("InitAshmemOne CreateAshmem failed");
52 return HDF_FAILURE;
53 }
54
55 asmptr->MapReadAndWriteAshmem();
56
57 if (rflg == 0) {
58 uint8_t tdata[ASHMEM_MAX_SIZE];
59 int32_t offset = 0;
60 int32_t tlen = 0;
61
62 int32_t retSafe = memset_s(tdata, sizeof(tdata), 'Y', ASHMEM_MAX_SIZE);
63 if (retSafe != EOK) {
64 HDF_LOGE("InitAshmemOne memset_s failed");
65 return HDF_FAILURE;
66 }
67 while (offset < asmSize) {
68 tlen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
69 asmptr->WriteToAshmem(tdata, tlen, offset);
70 offset += tlen;
71 }
72 }
73 return HDF_SUCCESS;
74 }
75
SwitchErrCode(int32_t ret)76 int32_t SwitchErrCode(int32_t ret)
77 {
78 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
79 }
80
SetUpTestCase(void)81 void UsbdAsyncTransferTest::SetUpTestCase(void)
82 {
83 SubscriberEvent();
84 }
85
TearDownTestCase(void)86 void UsbdAsyncTransferTest::TearDownTestCase(void)
87 {
88 SubscriberEvent();
89 g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
90 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
91 auto ret = g_usbHostInterface->CloseDevice(dev_);
92 HDF_LOGI("UsbdAsyncTransferTest:: %{public}d Close=%{public}d", __LINE__, ret);
93 ASSERT_EQ(0, ret);
94 }
95
SetUp(void)96 void UsbdAsyncTransferTest::SetUp(void) {}
97
TearDown(void)98 void UsbdAsyncTransferTest::TearDown(void) {}
99
SubscriberEvent()100 void UsbdAsyncTransferTest::SubscriberEvent()
101 {
102 g_usbHostInterface = OHOS::HDI::Usb::V2_0::IUsbHostInterface::Get(true);
103 if (g_usbHostInterface == nullptr) {
104 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
105 exit(0);
106 }
107
108 subscriber_ = new UsbSubTest();
109 if (subscriber_ == nullptr) {
110 HDF_LOGE("%{public}s:UsbSubTest new failed.", __func__);
111 exit(0);
112 }
113 if (g_usbHostInterface->BindUsbdHostSubscriber(subscriber_) != HDF_SUCCESS) {
114 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
115 exit(0);
116 }
117 std::cout << "Please connect the device that supports interruption, and press Enter." << std::endl;
118 HDF_LOGE("%{public}s: SubscriberEvent busnum=%{public}d, devAddr=%{public}d.",
119 __func__, subscriber_->busNum_, subscriber_->devAddr_);
120 int c;
121 do {
122 c = getchar();
123 } while (c != '\n' && c != EOF);
124 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
125 int32_t ret = g_usbHostInterface->OpenDevice(dev_);
126 HDF_LOGI("UsbdAsyncTransferTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
127 ASSERT_EQ(0, ret);
128 }
129
130 /**
131 * @tc.name: InterruptRead001
132 * @tc.desc: Test functions to UsbSubmitTransfer
133 * @tc.desc: int32_t UsbSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
134 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem);
135 * @tc.desc: Positive test: interrupt read, The parameters are correct.
136 * @tc.type: FUNC
137 */
138 HWTEST_F(UsbdAsyncTransferTest, InterruptRead001, TestSize.Level1)
139 {
140 HDF_LOGI("Case Start: InterruptRead001");
141 struct UsbDev dev = dev_;
142 struct USBTransferInfo info = {
143 .endpoint = ENDPOINT_ADDRESS_IN,
144 .flags = 0,
145 .type = LIBUSB_TRANSFER_TYPE_INTERRUPT,
146 .timeOut = ASYNC_TRANSFER_TIME_OUT,
147 .length = MAX_BUFFER_LENGTH,
148 .userData = 0,
149 .numIsoPackets = 0,
150 };
151 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
152 if (usbdBulkCallback == nullptr) {
153 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
154 exit(0);
155 }
156 sptr<Ashmem> ashmem;
157 int32_t asmSize = MAX_BUFFER_LENGTH;
158 uint8_t rflg = 1;
159 (void)InitAshmemOne(ashmem, asmSize, rflg);
160 auto ret = g_usbHostInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
161 HDF_LOGI("UsbdAsyncTransferTest::InterruptRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
162 ret = g_usbHostInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
163 if (ret == LIBUSB_ERROR_NOT_SUPPORTED) {
164 ret = 0;
165 }
166 HDF_LOGE("UsbdAsyncTransferTest::InterruptRead001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
167 EXPECT_EQ(ret, 0);
168 HDF_LOGI("Case End: InterruptRead001");
169 }
170
171 /**
172 * @tc.name: InterruptWrite001
173 * @tc.desc: Test functions to UsbSubmitTransfer
174 * @tc.desc: int32_t UsbSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
175 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem);
176 * @tc.desc: Positive test: interrupt write, The parameters are correct.
177 * @tc.type: FUNC
178 */
179 HWTEST_F(UsbdAsyncTransferTest, InterruptWrite001, TestSize.Level1)
180 {
181 HDF_LOGI("Case Start: InterruptWrite001");
182 struct UsbDev dev = dev_;
183 struct USBTransferInfo info = {
184 .endpoint = ENDPOINT_ADDRESS_OUT,
185 .flags = 0,
186 .type = LIBUSB_TRANSFER_TYPE_INTERRUPT,
187 .timeOut = ASYNC_TRANSFER_TIME_OUT,
188 .length = MAX_BUFFER_LENGTH,
189 .userData = 0,
190 .numIsoPackets = 0,
191 };
192 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
193 if (usbdBulkCallback == nullptr) {
194 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
195 exit(0);
196 }
197 sptr<Ashmem> ashmem;
198 int32_t asmSize = MAX_BUFFER_LENGTH;
199 uint8_t rflg = 0;
200 (void)InitAshmemOne(ashmem, asmSize, rflg);
201 auto ret = g_usbHostInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
202 HDF_LOGI("UsbdAsyncTransferTest::InterruptWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
203 ret = g_usbHostInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
204 HDF_LOGI("UsbdAsyncTransferTest::InterruptWrite001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
205 EXPECT_NE(ret, 0);
206 HDF_LOGI("Case End: InterruptWrite001");
207 }
208
209 /**
210 * @tc.name: IsochronousRead001
211 * @tc.desc: Test functions to UsbSubmitTransfer
212 * @tc.desc: int32_t UsbSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
213 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem);
214 * @tc.desc: Positive test: isochronous read, The parameters are correct.
215 * @tc.type: FUNC
216 */
217 HWTEST_F(UsbdAsyncTransferTest, IsochronousRead001, TestSize.Level1)
218 {
219 HDF_LOGI("Case Start: IsochronousRead001");
220 struct UsbDev dev = dev_;
221 struct USBTransferInfo info = {
222 .endpoint = ENDPOINT_ADDRESS_IN,
223 .flags = 0,
224 .type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS,
225 .timeOut = ASYNC_TRANSFER_TIME_OUT,
226 .length = MAX_BUFFER_LENGTH,
227 .userData = 0,
228 .numIsoPackets = ISOCHRONOUS_PACKETS,
229 };
230 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
231 if (usbdBulkCallback == nullptr) {
232 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
233 exit(0);
234 }
235 sptr<Ashmem> ashmem;
236 int32_t asmSize = MAX_BUFFER_LENGTH;
237 uint8_t rflg = 1;
238 (void)InitAshmemOne(ashmem, asmSize, rflg);
239 auto ret = g_usbHostInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
240 HDF_LOGI("UsbdAsyncTransferTest::IsochronousRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
241 ret = g_usbHostInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
242 HDF_LOGI("UsbdAsyncTransferTest::IsochronousRead001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
243 EXPECT_NE(ret, 0);
244 HDF_LOGI("Case End: IsochronousRead001");
245 }
246
247 /**
248 * @tc.name: IsochronousWrite001
249 * @tc.desc: Test functions to UsbSubmitTransfer
250 * @tc.desc: int32_t UsbSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
251 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem);
252 * @tc.desc: Positive test: isochronous write, The parameters are correct.
253 * @tc.type: FUNC
254 */
255 HWTEST_F(UsbdAsyncTransferTest, IsochronousWrite001, TestSize.Level1)
256 {
257 HDF_LOGI("Case Start: IsochronousWrite001");
258 struct UsbDev dev = dev_;
259 struct USBTransferInfo info = {
260 .endpoint = ENDPOINT_ADDRESS_OUT,
261 .flags = 0,
262 .type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS,
263 .timeOut = ASYNC_TRANSFER_TIME_OUT,
264 .length = MAX_BUFFER_LENGTH,
265 .userData = 0,
266 .numIsoPackets = ISOCHRONOUS_PACKETS,
267 };
268 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
269 if (usbdBulkCallback == nullptr) {
270 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
271 exit(0);
272 }
273 sptr<Ashmem> ashmem;
274 int32_t asmSize = MAX_BUFFER_LENGTH;
275 uint8_t rflg = 0;
276 (void)InitAshmemOne(ashmem, asmSize, rflg);
277 auto ret = g_usbHostInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
278 HDF_LOGI("UsbdAsyncTransferTest::IsochronousWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
279 ret = g_usbHostInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
280 HDF_LOGI("UsbdAsyncTransferTest::IsochronousWrite001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
281 EXPECT_NE(ret, 0);
282 HDF_LOGI("Case End: IsochronousWrite001");
283 }
284
285 /**
286 * @tc.name: BulkRead001
287 * @tc.desc: Test functions to UsbSubmitTransfer
288 * @tc.desc: int32_t UsbSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
289 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem);
290 * @tc.desc: Positive test: bulk read, The parameters are correct.
291 * @tc.type: FUNC
292 */
293 HWTEST_F(UsbdAsyncTransferTest, BulkRead001, TestSize.Level1)
294 {
295 std::cout << "Please disconnect the currently connected device, then connect bulk device(rk3568), " \
296 "and press enter to continue" << std::endl;
297 int32_t c;
298 while ((c = getchar()) != '\n' && c != EOF) {}
299
300 SubscriberEvent();
301
302 HDF_LOGI("Case Start: BulkRead001");
303 struct UsbDev dev = dev_;
304 struct USBTransferInfo info = {
305 .endpoint = ENDPOINT_ADDRESS_IN,
306 .flags = 0,
307 .type = LIBUSB_TRANSFER_TYPE_BULK,
308 .timeOut = ASYNC_TRANSFER_TIME_OUT,
309 .length = MAX_BUFFER_LENGTH,
310 .userData = 0,
311 .numIsoPackets = 0,
312 };
313 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
314 if (usbdBulkCallback == nullptr) {
315 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
316 exit(0);
317 }
318 sptr<Ashmem> ashmem;
319 int32_t asmSize = MAX_BUFFER_LENGTH;
320 uint8_t rflg = 1;
321 (void)InitAshmemOne(ashmem, asmSize, rflg);
322 auto ret = g_usbHostInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
323 HDF_LOGI("UsbdAsyncTransferTest::BulkRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
324 ret = g_usbHostInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
325 if (ret == LIBUSB_ERROR_NOT_SUPPORTED) {
326 ret = 0;
327 }
328 HDF_LOGI("UsbdAsyncTransferTest::BulkRead001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
329 EXPECT_EQ(ret, 0);
330 HDF_LOGI("Case End: BulkRead001");
331 }
332
333 /**
334 * @tc.name: BulkWrite001
335 * @tc.desc: Test functions to UsbSubmitTransfer
336 * @tc.desc: int32_t UsbSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
337 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem);
338 * @tc.desc: Positive test: bulk write, The parameters are correct.
339 * @tc.type: FUNC
340 */
341 HWTEST_F(UsbdAsyncTransferTest, BulkWrite001, TestSize.Level1)
342 {
343 HDF_LOGI("Case Start: BulkWrite001");
344 struct UsbDev dev = dev_;
345 struct USBTransferInfo info = {
346 .endpoint = 0x1,
347 .flags = 0,
348 .type = LIBUSB_TRANSFER_TYPE_BULK,
349 .timeOut = ASYNC_TRANSFER_TIME_OUT,
350 .length = MAX_BUFFER_LENGTH,
351 .userData = 0,
352 .numIsoPackets = 0,
353 };
354 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
355 if (usbdBulkCallback == nullptr) {
356 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
357 exit(0);
358 }
359 sptr<Ashmem> ashmem;
360 int32_t asmSize = MAX_BUFFER_LENGTH;
361 uint8_t rflg = 0;
362 (void)InitAshmemOne(ashmem, asmSize, rflg);
363 auto ret = g_usbHostInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
364 HDF_LOGI("UsbdAsyncTransferTest::BulkWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
365 ret = g_usbHostInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
366 if (ret == LIBUSB_ERROR_NOT_SUPPORTED) {
367 ret = 0;
368 }
369 HDF_LOGI("UsbdAsyncTransferTest::BulkWrite001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
370 EXPECT_EQ(ret, 0);
371 HDF_LOGI("Case End: BulkWrite001");
372 }
373
374 /**
375 * @tc.name: UsbCancelTransfer001
376 * @tc.desc: Test functions to UsbCancelTransfer
377 * @tc.desc: int32_t UsbCancelTransfer(const UsbDev &dev, const int32_t endpoint);
378 * @tc.desc: Positive test: the parameters are correct.
379 * @tc.type: FUNC
380 */
381 HWTEST_F(UsbdAsyncTransferTest, CancelTransfer001, TestSize.Level1)
382 {
383 HDF_LOGI("Case Start: CancelTransfer001");
384 struct UsbDev dev = dev_;
385 struct USBTransferInfo info = {
386 .endpoint = 0x1,
387 .flags = 0,
388 .type = LIBUSB_TRANSFER_TYPE_BULK,
389 .timeOut = 0,
390 .length = MAX_BUFFER_LENGTH,
391 .userData = 0,
392 .numIsoPackets = 0,
393 };
394 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
395 if (usbdBulkCallback == nullptr) {
396 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
397 exit(0);
398 }
399 sptr<Ashmem> ashmem;
400 int32_t asmSize = MAX_BUFFER_LENGTH;
401 uint8_t rflg = 0;
402 (void)InitAshmemOne(ashmem, asmSize, rflg);
403 auto ret = g_usbHostInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
404 HDF_LOGI("UsbdAsyncTransferTest::CancelTransfer001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
405 int32_t submitTransferRet = 0;
406 for (int i = 0; i < 10; i++) {
407 submitTransferRet = g_usbHostInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
408 HDF_LOGI("UsbdAsyncTransferTest::CancelTransfer001 %{public}d UsbSubmitTransfer=%{public}d",
409 __LINE__, submitTransferRet);
410 }
411 auto cancelTransferRet = g_usbHostInterface->UsbCancelTransfer(dev, ENDPOINT_ADDRESS_IN);
412 if (cancelTransferRet == LIBUSB_ERROR_NOT_SUPPORTED) {
413 cancelTransferRet = 0;
414 }
415 HDF_LOGI("UsbdAsyncTransferTest::CancelTransfer001 %{public}d UsbCancelTransfer=%{public}d",
416 __LINE__, cancelTransferRet);
417 if (cancelTransferRet == 0 || cancelTransferRet == -5) {
418 EXPECT_TRUE(true);
419 } else {
420 EXPECT_TRUE(false);
421 }
422 HDF_LOGI("Case Start: CancelTransfer001");
423 }
424
425 /**
426 * @tc.name: AsyncSubmitTransfer008
427 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
428 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
429 * @tc.desc: negative test: No device connection
430 * @tc.type: FUNC
431 */
432 HWTEST_F(UsbdAsyncTransferTest, AsyncSubmitTransfer008, TestSize.Level1)
433 {
434 std::cout << "Please disconnect the currently connected device, press enter to continue" << std::endl;
435
436 int32_t c;
437 do {
438 c = getchar();
439 } while (c != '\n' && c != EOF);
440
441 HDF_LOGI("Case Start: AsyncSubmitTransfer008");
442 std::shared_ptr<HDI::Usb::V1_2::LibusbAdapter> adapter = HDI::Usb::V1_2::LibusbAdapter::GetInstance();
443 HDI::Usb::V1_0::UsbDev device_ = {1, 2};
444 HDI::Usb::V1_2::USBTransferInfo usbInfo_;
445
446 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
447 EXPECT_NE(ret, 0);
448 HDF_LOGI("Case Start: AsyncSubmitTransfer008");
449 }
450
451 /**
452 * @tc.name: AsyncSubmitTransfer009
453 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
454 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
455 * @tc.desc: negative test: Wrong device bus number and bus address
456 * @tc.type: FUNC
457 */
458 HWTEST_F(UsbdAsyncTransferTest, AsyncSubmitTransfer009, TestSize.Level1)
459 {
460 std::cout << "Please connect the device, press enter to continue" << std::endl;
461
462 int32_t c;
463 while ((c = getchar()) != '\n' && c != EOF) {}
464
465 SubscriberEvent();
466 HDF_LOGI("Case Start: AsyncSubmitTransfer009");
467 std::shared_ptr<HDI::Usb::V1_2::LibusbAdapter> adapter = HDI::Usb::V1_2::LibusbAdapter::GetInstance();
468 HDI::Usb::V1_0::UsbDev device_ = {1, 2};
469 HDI::Usb::V1_2::USBTransferInfo usbInfo_;
470
471 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
472 EXPECT_NE(ret, 0);
473 HDF_LOGI("Case End: AsyncSubmitTransfer009");
474 }
475
476 /**
477 * @tc.name: AsyncSubmitTransfer010
478 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
479 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
480 * @tc.desc: negative test: data transfer length is zero
481 * @tc.type: FUNC
482 */
483 HWTEST_F(UsbdAsyncTransferTest, AsyncSubmitTransfer010, TestSize.Level1)
484 {
485 HDF_LOGI("Case Start: AsyncSubmitTransfer010");
486 std::shared_ptr<HDI::Usb::V1_2::LibusbAdapter> adapter = HDI::Usb::V1_2::LibusbAdapter::GetInstance();
487 HDI::Usb::V1_0::UsbDev device_ = {dev_.busNum, dev_.devAddr};
488 HDI::Usb::V1_2::USBTransferInfo usbInfo_;
489 usbInfo_.length = 0;
490
491 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
492 EXPECT_NE(ret, 0);
493 HDF_LOGI("Case End: AsyncSubmitTransfer010");
494 }
495
496 /**
497 * @tc.name: AsyncSubmitTransfer011
498 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
499 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
500 * @tc.desc: negative test, use error endpoint
501 * @tc.type: FUNC
502 */
503 HWTEST_F(UsbdAsyncTransferTest, AsyncSubmitTransfer011, TestSize.Level1)
504 {
505 HDF_LOGI("Case Start: AsyncSubmitTransfer011");
506 std::shared_ptr<HDI::Usb::V1_2::LibusbAdapter> adapter = HDI::Usb::V1_2::LibusbAdapter::GetInstance();
507 HDI::Usb::V1_0::UsbDev device_ = {dev_.busNum, dev_.devAddr};
508 HDI::Usb::V1_2::USBTransferInfo usbInfo_;
509 usbInfo_.endpoint = ENDPOINT_ADDRESS_IN - 0x09;
510 usbInfo_.flags = 0;
511 usbInfo_.type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
512 usbInfo_.timeOut = 1000;
513 usbInfo_.userData = 0;
514 usbInfo_.numIsoPackets = 0;
515 usbInfo_.length = 0;
516
517 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
518 EXPECT_NE(ret, 0);
519 HDF_LOGI("Case End: AsyncSubmitTransfer011");
520 }
521
522 /**
523 * @tc.name: AsyncCancelTransfer012
524 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
525 const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
526 * @tc.desc: negative test: error device busnum and devaddr
527 * @tc.type: FUNC
528 */
529 HWTEST_F(UsbdAsyncTransferTest, AsyncCancelTransfer012, TestSize.Level1)
530 {
531 HDF_LOGI("Case Start: AsyncSubmitTransfer012");
532 std::shared_ptr<HDI::Usb::V1_2::LibusbAdapter> adapter = HDI::Usb::V1_2::LibusbAdapter::GetInstance();
533 HDI::Usb::V1_0::UsbDev device_ = {0, 0};
534 int errEndPoint = 0x12;
535
536 int32_t ret = adapter->AsyncCancelTransfer(device_, errEndPoint);
537 EXPECT_NE(ret, 0);
538 HDF_LOGI("Case End: AsyncSubmitTransfer012");
539 }
540
541 /**
542 * @tc.name: AsyncCancelTransfer013
543 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
544 const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
545 * @tc.desc: negative test: device exit and transferList is nullptr
546 * @tc.type: FUNC
547 */
548 HWTEST_F(UsbdAsyncTransferTest, AsyncCancelTransfer013, TestSize.Level1)
549 {
550 HDF_LOGI("Case Start: AsyncSubmitTransfer013");
551 std::shared_ptr<HDI::Usb::V1_2::LibusbAdapter> adapter = HDI::Usb::V1_2::LibusbAdapter::GetInstance();
552 HDI::Usb::V1_0::UsbDev device_ = {dev_.busNum, dev_.devAddr};
553 int errEndPoint = 0x13;
554
555 int32_t ret = adapter->AsyncCancelTransfer(device_, errEndPoint);
556 EXPECT_NE(ret, 0);
557 HDF_LOGI("Case End: AsyncSubmitTransfer013");
558 }
559
560 } // namespace