1 /*
2 * Copyright (c) 2025 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_bulk_transfer_test.h"
17 #include "libusb_adapter.h"
18
19 #include <iostream>
20 #include <vector>
21 #include <hdf_base.h>
22
23 #include "UsbSubscriberTest.h"
24 #include "usbd_type.h"
25 #include "usbd_wrapper.h"
26 #include "v1_2/iusb_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
35 using namespace testing::ext;
36 using namespace OHOS;
37 using namespace OHOS::USB;
38 using namespace OHOS::HDI::Usb::V1_2;
39 using OHOS::HDI::Usb::V1_2::USBTransferInfo;
40
41 namespace OHOS::USB::UsbdAsyncBulkTransfer {
42
43 UsbDev UsbdAsyncBulkTransferTest::dev_ = {0, 0};
44 sptr<UsbSubscriberTest> UsbdAsyncBulkTransferTest::subscriber_ = nullptr;
45 sptr<OHOS::HDI::Usb::V1_2::IUsbInterface> g_usbInterface = 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 UsbdAsyncBulkTransferTest::SetUpTestCase(void)
82 {
83 std::cout << "Please connect the device that supports bulk(rk3568), and press Enter." << std::endl;
84 int c;
85 do {
86 c = getchar();
87 } while (c != '\n' && c != EOF);
88
89 SubscriberEvent();
90 }
91
TearDownTestCase(void)92 void UsbdAsyncBulkTransferTest::TearDownTestCase(void)
93 {
94 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
95 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
96 auto ret = g_usbInterface->CloseDevice(dev_);
97 HDF_LOGI("UsbdAsyncBulkTransferTest:: %{public}d Close=%{public}d", __LINE__, ret);
98 ASSERT_EQ(0, ret);
99 }
100
SetUp(void)101 void UsbdAsyncBulkTransferTest::SetUp(void) {}
102
TearDown(void)103 void UsbdAsyncBulkTransferTest::TearDown(void) {}
104
SubscriberEvent()105 void UsbdAsyncBulkTransferTest::SubscriberEvent()
106 {
107 g_usbInterface = OHOS::HDI::Usb::V1_2::IUsbInterface::Get();
108 if (g_usbInterface == nullptr) {
109 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
110 exit(0);
111 }
112
113 subscriber_ = new UsbSubscriberTest();
114 if (subscriber_ == nullptr) {
115 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
116 exit(0);
117 }
118 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
119 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
120 exit(0);
121 }
122
123 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
124 int32_t ret = g_usbInterface->OpenDevice(dev_);
125 HDF_LOGI("UsbdAsyncBulkTransferTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
126 ASSERT_EQ(0, ret);
127 }
128
129 /**
130 * @tc.name: BulkRead001
131 * @tc.desc: Test functions to UsbSubmitTransfer
132 * @tc.desc: int32_t UsbSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
133 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem);
134 * @tc.desc: Positive test: bulk read, The parameters are correct.
135 * @tc.type: FUNC
136 */
137 HWTEST_F(UsbdAsyncBulkTransferTest, BulkRead001, TestSize.Level1)
138 {
139 HDF_LOGI("Case Start: BulkRead001");
140 struct UsbDev dev = dev_;
141 struct USBTransferInfo info = {
142 .endpoint = ENDPOINT_ADDRESS_IN,
143 .flags = 0,
144 .type = LIBUSB_TRANSFER_TYPE_BULK,
145 .timeOut = ASYNC_TRANSFER_TIME_OUT,
146 .length = MAX_BUFFER_LENGTH,
147 .userData = 0,
148 .numIsoPackets = 0,
149 };
150 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
151 if (usbdBulkCallback == nullptr) {
152 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
153 exit(0);
154 }
155 sptr<Ashmem> ashmem;
156 int32_t asmSize = MAX_BUFFER_LENGTH;
157 uint8_t rflg = 1;
158 (void)InitAshmemOne(ashmem, asmSize, rflg);
159 auto ret = g_usbInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
160 HDF_LOGI("UsbdAsyncBulkTransferTest::BulkRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
161 ret = g_usbInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
162 HDF_LOGI("UsbdAsyncBulkTransferTest::BulkRead001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
163 EXPECT_EQ(ret, 0);
164 HDF_LOGI("Case End: BulkRead001");
165 }
166
167 /**
168 * @tc.name: BulkWrite001
169 * @tc.desc: Test functions to UsbSubmitTransfer
170 * @tc.desc: int32_t UsbSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
171 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem);
172 * @tc.desc: Positive test: bulk write, The parameters are correct.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(UsbdAsyncBulkTransferTest, BulkWrite001, TestSize.Level1)
176 {
177 HDF_LOGI("Case Start: BulkWrite001");
178 struct UsbDev dev = dev_;
179 struct USBTransferInfo info = {
180 .endpoint = ENDPOINT_ADDRESS_OUT,
181 .flags = 0,
182 .type = LIBUSB_TRANSFER_TYPE_BULK,
183 .timeOut = ASYNC_TRANSFER_TIME_OUT,
184 .length = MAX_BUFFER_LENGTH,
185 .userData = 0,
186 .numIsoPackets = 0,
187 };
188 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
189 if (usbdBulkCallback == nullptr) {
190 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
191 exit(0);
192 }
193 sptr<Ashmem> ashmem;
194 int32_t asmSize = MAX_BUFFER_LENGTH;
195 uint8_t rflg = 0;
196 (void)InitAshmemOne(ashmem, asmSize, rflg);
197 auto ret = g_usbInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
198 HDF_LOGI("UsbdAsyncBulkTransferTest::BulkWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
199 ret = g_usbInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
200 if (ret == LIBUSB_ERROR_NOT_SUPPORTED) {
201 ret = 0;
202 }
203 HDF_LOGI("UsbdAsyncBulkTransferTest::BulkWrite001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
204 EXPECT_EQ(ret, 0);
205 HDF_LOGI("Case End: BulkWrite001");
206 }
207
208 /**
209 * @tc.name: CancelBulkTransfer001
210 * @tc.desc: Test functions to UsbCancelTransfer
211 * @tc.desc: int32_t UsbCancelTransfer(const UsbDev &dev, const int32_t endpoint);
212 * @tc.desc: Positive test: the parameters are correct.
213 * @tc.type: FUNC
214 */
215 HWTEST_F(UsbdAsyncBulkTransferTest, CancelBulkTransfer001, TestSize.Level1)
216 {
217 HDF_LOGI("Case Start: CancelBulkTransfer001");
218 struct UsbDev dev = dev_;
219 struct USBTransferInfo info = {
220 .endpoint = ENDPOINT_ADDRESS_IN,
221 .flags = 0,
222 .type = LIBUSB_TRANSFER_TYPE_BULK,
223 .timeOut = 0,
224 .length = MAX_BUFFER_LENGTH,
225 .userData = 0,
226 .numIsoPackets = 0,
227 };
228 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
229 if (usbdBulkCallback == nullptr) {
230 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
231 exit(0);
232 }
233 sptr<Ashmem> ashmem;
234 int32_t asmSize = MAX_BUFFER_LENGTH;
235 uint8_t rflg = 0;
236 (void)InitAshmemOne(ashmem, asmSize, rflg);
237 auto ret = g_usbInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
238 HDF_LOGI("UsbdAsyncBulkTransferTest::CancelBulkTransfer001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
239 int32_t submitTransferRet = 0;
240 for (int i = 0; i < 10; i++) {
241 submitTransferRet = g_usbInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
242 HDF_LOGI("UsbdAsyncBulkTransferTest::CancelBulkTransfer001 %{public}d UsbSubmitTransfer=%{public}d",
243 __LINE__, submitTransferRet);
244 }
245 auto cancelTransferRet = g_usbInterface->UsbCancelTransfer(dev, ENDPOINT_ADDRESS_IN);
246 if (cancelTransferRet == LIBUSB_ERROR_NOT_SUPPORTED) {
247 cancelTransferRet = 0;
248 }
249 HDF_LOGI("UsbdAsyncBulkTransferTest::CancelBulkTransfer001 %{public}d UsbCancelTransfer=%{public}d",
250 __LINE__, cancelTransferRet);
251 if (cancelTransferRet == 0 || cancelTransferRet == -5) {
252 EXPECT_TRUE(true);
253 } else {
254 EXPECT_TRUE(false);
255 }
256 HDF_LOGI("Case End: CancelBulkTransfer001");
257 }
258
259 /**
260 * @tc.name: CancelBulkTransfer002
261 * @tc.desc: Test functions to UsbCancelTransfer
262 * @tc.desc: int32_t UsbCancelTransfer(const UsbDev &dev, const int32_t endpoint);
263 * @tc.desc: Positive test: the parameters are correct.
264 * @tc.type: FUNC
265 */
266 HWTEST_F(UsbdAsyncBulkTransferTest, CancelBulkTransfer002, TestSize.Level1)
267 {
268 HDF_LOGI("Case Start: CancelBulkTransfer001");
269 struct UsbDev dev = dev_;
270 struct USBTransferInfo info = {
271 .endpoint = ENDPOINT_ADDRESS_OUT,
272 .flags = 0,
273 .type = LIBUSB_TRANSFER_TYPE_BULK,
274 .timeOut = 0,
275 .length = MAX_BUFFER_LENGTH,
276 .userData = 0,
277 .numIsoPackets = 0,
278 };
279 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
280 if (usbdBulkCallback == nullptr) {
281 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
282 exit(0);
283 }
284 sptr<Ashmem> ashmem;
285 int32_t asmSize = MAX_BUFFER_LENGTH;
286 uint8_t rflg = 0;
287 (void)InitAshmemOne(ashmem, asmSize, rflg);
288 auto ret = g_usbInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
289 HDF_LOGI("UsbdAsyncBulkTransferTest::CancelBulkTransfer002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
290 int32_t submitTransferRet = 0;
291 for (int i = 0; i < 10; i++) {
292 submitTransferRet = g_usbInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
293 HDF_LOGI("UsbdAsyncBulkTransferTest::CancelBulkTransfer002 %{public}d UsbSubmitTransfer=%{public}d",
294 __LINE__, submitTransferRet);
295 }
296 auto cancelTransferRet = g_usbInterface->UsbCancelTransfer(dev, ENDPOINT_ADDRESS_OUT);
297 if (cancelTransferRet == LIBUSB_ERROR_NOT_SUPPORTED) {
298 cancelTransferRet = 0;
299 }
300 HDF_LOGI("UsbdAsyncBulkTransferTest::CancelBulkTransfer002 %{public}d UsbCancelTransfer=%{public}d",
301 __LINE__, cancelTransferRet);
302 if (cancelTransferRet == 0 || cancelTransferRet == -5) {
303 EXPECT_TRUE(true);
304 } else {
305 EXPECT_TRUE(false);
306 }
307 HDF_LOGI("Case End: CancelBulkTransfer002");
308 }
309
310 /**
311 * @tc.name: CancelBulkTransfer003
312 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
313 const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
314 * @tc.desc: negative test: error device busnum and devaddr
315 * @tc.type: FUNC
316 */
317 HWTEST_F(UsbdAsyncBulkTransferTest, CancelBulkTransfer003, TestSize.Level1)
318 {
319 HDF_LOGI("Case Start: CancelBulkTransfer003");
320 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
321 UsbDev device_ = {0, 0};
322 int errEndPoint = 0x12;
323
324 int32_t ret = adapter->AsyncCancelTransfer(device_, errEndPoint);
325 EXPECT_NE(ret, 0);
326 HDF_LOGI("Case End: CancelBulkTransfer003");
327 }
328
329 /**
330 * @tc.name: CancelBulkTransfer004
331 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
332 const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
333 * @tc.desc: negative test: device exit and transferList is nullptr
334 * @tc.type: FUNC
335 */
336 HWTEST_F(UsbdAsyncBulkTransferTest, CancelBulkTransfer004, TestSize.Level1)
337 {
338 HDF_LOGI("Case Start: CancelBulkTransfer004");
339 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
340 UsbDev device_ = dev_;
341 int errEndPoint = 0x13;
342
343 int32_t ret = adapter->AsyncCancelTransfer(device_, errEndPoint);
344 EXPECT_NE(ret, 0);
345 HDF_LOGI("Case End: CancelBulkTransfer004");
346 }
347
348 /**
349 * @tc.name: AsyncSubmitTransfer001
350 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
351 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
352 * @tc.desc: negative test: Wrong device bus number and bus address
353 * @tc.type: FUNC
354 */
355 HWTEST_F(UsbdAsyncBulkTransferTest, AsyncSubmitTransfer001, TestSize.Level1)
356 {
357 HDF_LOGI("Case Start: AsyncSubmitTransfer001");
358 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
359 UsbDev device_ = {1, 2};
360 USBTransferInfo usbInfo_;
361
362 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
363 EXPECT_NE(ret, 0);
364 HDF_LOGI("Case End: AsyncSubmitTransfer001");
365 }
366
367 /**
368 * @tc.name: AsyncSubmitTransfer002
369 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
370 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
371 * @tc.desc: negative test: data transfer length is zero
372 * @tc.type: FUNC
373 */
374 HWTEST_F(UsbdAsyncBulkTransferTest, AsyncSubmitTransfer002, TestSize.Level1)
375 {
376 HDF_LOGI("Case Start: AsyncSubmitTransfer002");
377 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
378 UsbDev device_ = dev_;
379 USBTransferInfo usbInfo_;
380 usbInfo_.length = 0;
381
382 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
383 EXPECT_NE(ret, 0);
384 HDF_LOGI("Case End: AsyncSubmitTransfer002");
385 }
386
387 /**
388 * @tc.name: AsyncSubmitTransfer003
389 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
390 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
391 * @tc.desc: negative test, use error endpoint
392 * @tc.type: FUNC
393 */
394 HWTEST_F(UsbdAsyncBulkTransferTest, AsyncSubmitTransfer003, TestSize.Level1)
395 {
396 HDF_LOGI("Case Start: AsyncSubmitTransfer003");
397 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
398 UsbDev device_ = dev_;
399 USBTransferInfo usbInfo_;
400 usbInfo_.endpoint = ENDPOINT_ADDRESS_IN - 0x09;
401 usbInfo_.flags = 0;
402 usbInfo_.type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
403 usbInfo_.timeOut = 1000;
404 usbInfo_.userData = 0;
405 usbInfo_.numIsoPackets = 0;
406 usbInfo_.length = 0;
407
408 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
409 EXPECT_NE(ret, 0);
410 HDF_LOGI("Case End: AsyncSubmitTransfer003");
411 }
412 } // namespace OHOS::USB::UsbdAsyncBulkTransfer
413