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_interrupt_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::UsbdAsyncInterruptTransfer {
42
43 UsbDev UsbdAsyncInterruptTransferTest::dev_ = {0, 0};
44 sptr<UsbSubscriberTest> UsbdAsyncInterruptTransferTest::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 UsbdAsyncInterruptTransferTest::SetUpTestCase(void)
82 {
83 std::cout << "Please connect the device that supports interruption, 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 UsbdAsyncInterruptTransferTest::TearDownTestCase(void)
93 {
94 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
95 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
96 auto ret = g_usbInterface->CloseDevice(dev_);
97 HDF_LOGI("UsbdAsyncInterruptTransferTest:: %{public}d Close=%{public}d", __LINE__, ret);
98 ASSERT_EQ(0, ret);
99 }
100
SetUp(void)101 void UsbdAsyncInterruptTransferTest::SetUp(void) {}
102
TearDown(void)103 void UsbdAsyncInterruptTransferTest::TearDown(void) {}
104
SubscriberEvent()105 void UsbdAsyncInterruptTransferTest::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("UsbdAsyncInterruptTransferTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
126 ASSERT_EQ(0, ret);
127 }
128
129 /**
130 * @tc.name: InterruptRead001
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: interrupt read, The parameters are correct.
135 * @tc.type: FUNC
136 */
137 HWTEST_F(UsbdAsyncInterruptTransferTest, InterruptRead001, TestSize.Level1)
138 {
139 HDF_LOGI("Case Start: InterruptRead001");
140 struct UsbDev dev = dev_;
141 struct USBTransferInfo info = {
142 .endpoint = ENDPOINT_ADDRESS_IN,
143 .flags = 0,
144 .type = LIBUSB_TRANSFER_TYPE_INTERRUPT,
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("UsbdAsyncTransferTest::InterruptRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
161 ret = g_usbInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
162 HDF_LOGI("UsbdAsyncTransferTest::InterruptRead001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
163 EXPECT_EQ(ret, 0);
164 HDF_LOGI("Case End: InterruptRead001");
165 }
166
167 /**
168 * @tc.name: InterruptWrite001
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: interrupt write, The parameters are correct.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(UsbdAsyncInterruptTransferTest, InterruptWrite001, TestSize.Level1)
176 {
177 HDF_LOGI("Case Start: InterruptWrite001");
178 struct UsbDev dev = dev_;
179 struct USBTransferInfo info = {
180 .endpoint = ENDPOINT_ADDRESS_OUT,
181 .flags = 0,
182 .type = LIBUSB_TRANSFER_TYPE_INTERRUPT,
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("UsbdAsyncTransferTest::InterruptWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
199 ret = g_usbInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
200 HDF_LOGI("UsbdAsyncTransferTest::InterruptWrite001 %{public}d UsbSubmitTransfer=%{public}d", __LINE__, ret);
201 EXPECT_NE(ret, 0);
202 HDF_LOGI("Case End: InterruptWrite001");
203 }
204
205 /**
206 * @tc.name: CancelInterruptTransfer001
207 * @tc.desc: Test functions to UsbCancelTransfer
208 * @tc.desc: int32_t UsbCancelTransfer(const UsbDev &dev, const int32_t endpoint);
209 * @tc.desc: Positive test: the parameters are correct.
210 * @tc.type: FUNC
211 */
212 HWTEST_F(UsbdAsyncInterruptTransferTest, CancelInterruptTransfer001, TestSize.Level1)
213 {
214 HDF_LOGI("Case Start: CancelInterruptTransfer001");
215 struct UsbDev dev = dev_;
216 struct USBTransferInfo info = {
217 .endpoint = ENDPOINT_ADDRESS_IN,
218 .flags = 0,
219 .type = LIBUSB_TRANSFER_TYPE_INTERRUPT,
220 .timeOut = 0,
221 .length = MAX_BUFFER_LENGTH,
222 .userData = 0,
223 .numIsoPackets = 0,
224 };
225 sptr<UsbdTransferCallbackTest> usbdBulkCallback = new UsbdTransferCallbackTest();
226 if (usbdBulkCallback == nullptr) {
227 HDF_LOGE("%{public}s:UsbdTransferCallbackTest new failed.", __func__);
228 exit(0);
229 }
230 sptr<Ashmem> ashmem;
231 int32_t asmSize = MAX_BUFFER_LENGTH;
232 uint8_t rflg = 0;
233 (void)InitAshmemOne(ashmem, asmSize, rflg);
234 auto ret = g_usbInterface->ClaimInterface(dev, INTERFACEID_OK, 1);
235 HDF_LOGI("UsbdAsyncInterruptTransfer::CancelInterruptTransfer001 %{public}d ClaimInterface=%{public}d",
236 __LINE__, ret);
237 int32_t submitTransferRet = 0;
238 for (int i = 0; i < 10; i++) {
239 submitTransferRet = g_usbInterface->UsbSubmitTransfer(dev, info, usbdBulkCallback, ashmem);
240 HDF_LOGI("UsbdAsyncInterruptTransfer::CancelInterruptTransfer001 %{public}d UsbSubmitTransfer=%{public}d",
241 __LINE__, submitTransferRet);
242 }
243 auto cancelTransferRet = g_usbInterface->UsbCancelTransfer(dev, ENDPOINT_ADDRESS_IN);
244 HDF_LOGI("UsbdAsyncInterruptTransfer::CancelInterruptTransfer001 %{public}d UsbCancelTransfer=%{public}d",
245 __LINE__, cancelTransferRet);
246 if (cancelTransferRet == 0 || cancelTransferRet == -5) {
247 EXPECT_TRUE(true);
248 } else {
249 EXPECT_TRUE(false);
250 }
251 HDF_LOGI("Case End: CancelInterruptTransfer001");
252 }
253
254 /**
255 * @tc.name: CancelInterruptTransfer002
256 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
257 const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
258 * @tc.desc: negative test: error device busnum and devaddr
259 * @tc.type: FUNC
260 */
261 HWTEST_F(UsbdAsyncInterruptTransferTest, CancelInterruptTransfer002, TestSize.Level1)
262 {
263 HDF_LOGI("Case Start: CancelInterruptTransfer002");
264 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
265 UsbDev device_ = {0, 0};
266 int errEndPoint = 0x12;
267
268 int32_t ret = adapter->AsyncCancelTransfer(device_, errEndPoint);
269 EXPECT_NE(ret, 0);
270 HDF_LOGI("Case End: CancelInterruptTransfer002");
271 }
272
273 /**
274 * @tc.name: AsyncCancelTransfer013
275 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
276 const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
277 * @tc.desc: negative test: device exit and transferList is nullptr
278 * @tc.type: FUNC
279 */
280 HWTEST_F(UsbdAsyncInterruptTransferTest, CancelInterruptTransfer003, TestSize.Level1)
281 {
282 HDF_LOGI("Case Start: CancelInterruptTransfer003");
283 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
284 UsbDev device_ = dev_;
285 int errEndPoint = 0x13;
286
287 int32_t ret = adapter->AsyncCancelTransfer(device_, errEndPoint);
288 EXPECT_NE(ret, 0);
289 HDF_LOGI("Case End: CancelInterruptTransfer003");
290 }
291
292 /**
293 * @tc.name: AsyncSubmitTransfer001
294 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
295 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
296 * @tc.desc: negative test: Wrong device bus number and bus address
297 * @tc.type: FUNC
298 */
299 HWTEST_F(UsbdAsyncInterruptTransferTest, AsyncSubmitTransfer001, TestSize.Level1)
300 {
301 HDF_LOGI("Case Start: AsyncSubmitTransfer001");
302 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
303 UsbDev device_ = {1, 2};
304 USBTransferInfo usbInfo_;
305
306 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
307 EXPECT_NE(ret, 0);
308 HDF_LOGI("Case End: AsyncSubmitTransfer001");
309 }
310
311 /**
312 * @tc.name: AsyncSubmitTransfer002
313 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
314 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
315 * @tc.desc: negative test: data transfer length is zero
316 * @tc.type: FUNC
317 */
318 HWTEST_F(UsbdAsyncInterruptTransferTest, AsyncSubmitTransfer002, TestSize.Level1)
319 {
320 HDF_LOGI("Case Start: AsyncSubmitTransfer002");
321 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
322 UsbDev device_ = dev_;
323 USBTransferInfo usbInfo_;
324 usbInfo_.length = 0;
325
326 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
327 EXPECT_NE(ret, 0);
328 HDF_LOGI("Case End: AsyncSubmitTransfer002");
329 }
330
331 /**
332 * @tc.name: AsyncSubmitTransfer003
333 * @tc.desc: Test functions to int32_t AsyncSubmitTransfer(const UsbDev &dev, const USBTransferInfo &info,
334 * const sptr<IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
335 * @tc.desc: negative test, use error endpoint
336 * @tc.type: FUNC
337 */
338 HWTEST_F(UsbdAsyncInterruptTransferTest, AsyncSubmitTransfer003, TestSize.Level1)
339 {
340 HDF_LOGI("Case Start: AsyncSubmitTransfer003");
341 std::shared_ptr<LibusbAdapter> adapter = LibusbAdapter::GetInstance();
342 UsbDev device_ = dev_;
343 USBTransferInfo usbInfo_;
344 usbInfo_.endpoint = ENDPOINT_ADDRESS_IN - 0x09;
345 usbInfo_.flags = 0;
346 usbInfo_.type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
347 usbInfo_.timeOut = 1000;
348 usbInfo_.userData = 0;
349 usbInfo_.numIsoPackets = 0;
350 usbInfo_.length = 0;
351
352 int32_t ret = adapter->AsyncSubmitTransfer(device_, usbInfo_, nullptr, nullptr);
353 EXPECT_NE(ret, 0);
354 HDF_LOGI("Case End: AsyncSubmitTransfer003");
355 }
356 } // namespace OHOS::USB::UsbdAsyncInterruptTransfer
357