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 #include <iostream>
16 #include <vector>
17
18 #include "hdf_log.h"
19 #include "securec.h"
20 #include "usbd_transfer_test.h"
21 #include "v1_2/iusb_interface.h"
22 #include "v1_2/usb_types.h"
23
24 const int SLEEP_TIME = 3;
25 const uint8_t BUS_NUM_INVALID = 255;
26 const uint8_t DEV_ADDR_INVALID = 255;
27 const uint32_t MAX_BUFFER_LENGTH = 255;
28 const uint8_t INTERFACEID_OK = 1;
29 const uint8_t INTERFACEID_EFFECTIVE = 0;
30 const uint8_t PIPE_ENDPOINTID_INVALID = 244;
31 const uint8_t PIPE_INTERFACEID_INVALID = 244;
32 const uint8_t POINTID_INTERRUPT_IN = 129;
33 // data interface have 2 point : 1->bulk_out 2->bulk_in
34 const uint8_t POINTID_BULK_IN = USB_ENDPOINT_DIR_IN | 2;
35 const uint8_t POINTID_BULK_OUT = USB_ENDPOINT_DIR_OUT | 1;
36 const int32_t ASHMEM_MAX_SIZE = 1024;
37 const int32_t TRANSFER_TIME_OUT = 1000;
38
39 using namespace testing::ext;
40 using namespace OHOS;
41 using namespace OHOS::USB;
42 using namespace std;
43 using namespace OHOS::HDI::Usb::V1_0;
44 using namespace OHOS::HDI::Usb::V1_2;
45
46 UsbDev UsbdTransferTest::dev_ = {0, 0};
47 sptr<UsbSubscriberTest> UsbdTransferTest::subscriber_ = nullptr;
48
49 namespace {
50 sptr<OHOS::HDI::Usb::V1_2::IUsbInterface> g_usbInterface = nullptr;
51
InitAshmemOne(sptr<Ashmem> & asmptr,int32_t asmSize,uint8_t rflg)52 int32_t InitAshmemOne(sptr<Ashmem> &asmptr, int32_t asmSize, uint8_t rflg)
53 {
54 asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
55 if (asmptr == nullptr) {
56 HDF_LOGE("InitAshmemOne CreateAshmem failed\n");
57 return HDF_FAILURE;
58 }
59
60 asmptr->MapReadAndWriteAshmem();
61
62 if (rflg == 0) {
63 uint8_t tdata[ASHMEM_MAX_SIZE];
64 int32_t offset = 0;
65 int32_t tlen = 0;
66
67 int32_t retSafe = memset_s(tdata, sizeof(tdata), 'Y', ASHMEM_MAX_SIZE);
68 if (retSafe != EOK) {
69 HDF_LOGE("InitAshmemOne memset_s failed\n");
70 return HDF_FAILURE;
71 }
72 while (offset < asmSize) {
73 tlen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
74 asmptr->WriteToAshmem(tdata, tlen, offset);
75 offset += tlen;
76 }
77 }
78 return HDF_SUCCESS;
79 }
80
SwitchErrCode(int32_t ret)81 int32_t SwitchErrCode(int32_t ret)
82 {
83 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
84 }
85
SetUpTestCase(void)86 void UsbdTransferTest::SetUpTestCase(void)
87 {
88 g_usbInterface = OHOS::HDI::Usb::V1_2::IUsbInterface::Get();
89 if (g_usbInterface == nullptr) {
90 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
91 exit(0);
92 }
93 const int32_t DEFAULT_PORT_ID = 1;
94 const int32_t DEFAULT_ROLE_HOST = 1;
95 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, DEFAULT_ROLE_HOST, DEFAULT_ROLE_HOST);
96 sleep(SLEEP_TIME);
97 HDF_LOGI("UsbdTransferTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
98 ret = SwitchErrCode(ret);
99 ASSERT_EQ(0, ret);
100 if (ret != 0) {
101 exit(0);
102 }
103
104 subscriber_ = new UsbSubscriberTest();
105 if (subscriber_ == nullptr) {
106 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
107 exit(0);
108 }
109 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
110 HDF_LOGE("%{public}s: bind usbd subscriber_ failed\n", __func__);
111 exit(0);
112 }
113
114 std::cout << "please connect device, press enter to continue" << std::endl;
115 int c;
116 do {
117 c = getchar();
118 } while (c != '\n' && c != EOF);
119
120 dev_ = { subscriber_->busNum_, subscriber_->devAddr_ };
121 ret = g_usbInterface->OpenDevice(dev_);
122 HDF_LOGI("UsbdTransferTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
123 ASSERT_EQ(0, ret);
124 }
125
TearDownTestCase(void)126 void UsbdTransferTest::TearDownTestCase(void)
127 {
128 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
129 dev_ = { subscriber_->busNum_, subscriber_->devAddr_ };
130 auto ret = g_usbInterface->CloseDevice(dev_);
131 HDF_LOGI("UsbdTransferTest:: %{public}d Close=%{public}d", __LINE__, ret);
132 ASSERT_EQ(0, ret);
133 }
134
SetUp(void)135 void UsbdTransferTest::SetUp(void) {}
136
TearDown(void)137 void UsbdTransferTest::TearDown(void) {}
138
139 /**
140 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_0400
141 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
142 * std::vector<uint8_t> &data);
143 * @tc.desc: Positive test: parameters correctly
144 * @tc.type: FUNC
145 */
146 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_0400, Function | MediumTest | Level1)
147 {
148 struct UsbDev dev = dev_;
149 uint8_t interfaceId = INTERFACEID_EFFECTIVE;
150 uint8_t pointId = POINTID_INTERRUPT_IN;
151 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
152 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0400 "
153 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
154 ASSERT_EQ(0, ret);
155 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
156 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
157 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
158 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0400 "
159 "%{public}d UsbdInterruptTransferRead=%{public}d", __LINE__, ret);
160 ASSERT_EQ(0, ret);
161 }
162
163 /**
164 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_3900
165 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
166 * std::vector<uint8_t> &data);
167 * @tc.desc: Negative test: parameters exception, busNum error
168 * @tc.type: FUNC
169 */
170 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_3900, Function | MediumTest | Level1)
171 {
172 struct UsbDev dev = dev_;
173 uint8_t interfaceId = INTERFACEID_OK;
174 uint8_t pointId = POINTID_BULK_IN;
175 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
176 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_3900 "
177 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
178 ASSERT_EQ(0, ret);
179 dev.busNum = BUS_NUM_INVALID;
180 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
181 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
182 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
183 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_3900 "
184 "%{public}d UsbdInterruptTransferRead=%{public}d", __LINE__, ret);
185 ASSERT_NE(ret, 0);
186 }
187
188 /**
189 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4000
190 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
191 * std::vector<uint8_t> &data);
192 * @tc.desc: Negative test: parameters exception, devAddr error
193 * @tc.type: FUNC
194 */
195 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4000, Function | MediumTest | Level1)
196 {
197 struct UsbDev dev = dev_;
198 uint8_t interfaceId = INTERFACEID_OK;
199 uint8_t pointId = POINTID_BULK_IN;
200 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
201 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4000 "
202 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
203 ASSERT_EQ(0, ret);
204 dev.devAddr = DEV_ADDR_INVALID;
205 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
206 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
207 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
208 ASSERT_NE(ret, 0);
209 }
210
211 /**
212 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4100
213 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
214 * std::vector<uint8_t> &data);
215 * @tc.desc: Negative test: parameters exception, intfId error
216 * @tc.type: FUNC
217 */
218 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4100, Function | MediumTest | Level1)
219 {
220 struct UsbDev dev = dev_;
221 uint8_t interfaceId = INTERFACEID_OK;
222 uint8_t pointId = POINTID_BULK_IN;
223 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
224 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4100 "
225 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
226 ASSERT_EQ(0, ret);
227 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
228 pipe.intfId = PIPE_INTERFACEID_INVALID;
229 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
230 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
231 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4100 "
232 "%{public}d UsbdInterruptTransferRead=%{public}d", __LINE__, ret);
233 ASSERT_NE(ret, 0);
234 }
235
236 /**
237 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4200
238 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
239 * std::vector<uint8_t> &data);
240 * @tc.desc: Negative test: parameters exception, endpointId error
241 * @tc.type: FUNC
242 */
243 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4200, Function | MediumTest | Level1)
244 {
245 struct UsbDev dev = dev_;
246 uint8_t interfaceId = INTERFACEID_OK;
247 uint8_t pointId = POINTID_BULK_IN;
248 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
249 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4200 "
250 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
251 ASSERT_EQ(0, ret);
252 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
253 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
254 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
255 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
256 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4200 "
257 "%{public}d UsbdInterruptTransferRead=%{public}d", __LINE__, ret);
258 ASSERT_NE(ret, 0);
259 }
260
261 /**
262 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_1000
263 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
264 * std::vector<uint8_t> &data);
265 * @tc.desc: Positive test: parameters correctly
266 * @tc.type: FUNC
267 */
268 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_1000, Function | MediumTest | Level1)
269 {
270 struct UsbDev dev = dev_;
271 uint8_t interfaceId = INTERFACEID_OK;
272 uint8_t pointId = POINTID_BULK_OUT;
273 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
274 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_1000 "
275 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
276 ASSERT_EQ(0, ret);
277 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
278 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '1'};
279 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
280 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_1000 "
281 "%{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
282 ASSERT_NE(0, ret);
283 }
284
285 /**
286 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4300
287 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
288 * std::vector<uint8_t> &data);
289 * @tc.desc: Negative test: parameters exception, busNum error
290 * @tc.type: FUNC
291 */
292 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4300, Function | MediumTest | Level1)
293 {
294 struct UsbDev dev = dev_;
295 uint8_t interfaceId = INTERFACEID_OK;
296 uint8_t pointId = POINTID_BULK_OUT;
297 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
298 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4300 "
299 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
300 ASSERT_EQ(0, ret);
301 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
302 dev.busNum = BUS_NUM_INVALID;
303 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '2'};
304 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
305 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4300 "
306 "%{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
307 ASSERT_NE(ret, 0);
308 }
309
310 /**
311 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4400
312 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
313 * std::vector<uint8_t> &data);
314 * @tc.desc: Negative test: parameters exception, devAddr error
315 * @tc.type: FUNC
316 */
317 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4400, Function | MediumTest | Level1)
318 {
319 struct UsbDev dev = dev_;
320 uint8_t interfaceId = INTERFACEID_OK;
321 uint8_t pointId = POINTID_BULK_OUT;
322 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
323 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4400 "
324 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
325 ASSERT_EQ(0, ret);
326 dev.devAddr = DEV_ADDR_INVALID;
327 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
328 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '3'};
329 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
330 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4400 "
331 "%{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
332 ASSERT_NE(ret, 0);
333 }
334
335 /**
336 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4500
337 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
338 * std::vector<uint8_t> &data);
339 * @tc.desc: Negative test: parameters exception, intfId error
340 * @tc.type: FUNC
341 */
342 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4500, Function | MediumTest | Level1)
343 {
344 struct UsbDev dev = dev_;
345 uint8_t interfaceId = INTERFACEID_OK;
346 uint8_t pointId = POINTID_BULK_OUT;
347 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
348 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4500 "
349 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
350 ASSERT_EQ(0, ret);
351 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
352 pipe.intfId = PIPE_INTERFACEID_INVALID;
353 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '4'};
354 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
355 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4500 "
356 "%{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
357 ASSERT_NE(ret, 0);
358 }
359
360 /**
361 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4600
362 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
363 * std::vector<uint8_t> &data);
364 * @tc.desc: Negative test: parameters exception, endpointId error
365 * @tc.type: FUNC
366 */
367 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4600, Function | MediumTest | Level1)
368 {
369 struct UsbDev dev = dev_;
370 uint8_t interfaceId = INTERFACEID_OK;
371 uint8_t pointId = POINTID_BULK_OUT;
372 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
373 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4600 "
374 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
375 ASSERT_EQ(0, ret);
376 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
377 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
378 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '5'};
379 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
380 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4600 "
381 "%{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
382 ASSERT_NE(ret, 0);
383 }
384
385 /**
386 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4700
387 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
388 * std::vector<uint8_t> &data);
389 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
390 * @tc.type: FUNC
391 */
392 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4700, Function | MediumTest | Level1)
393 {
394 struct UsbDev dev = dev_;
395 uint8_t interfaceId = INTERFACEID_OK;
396 uint8_t pointId = POINTID_BULK_OUT;
397 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
398 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4700 "
399 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
400 ASSERT_EQ(0, ret);
401 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
402 dev.busNum = BUS_NUM_INVALID;
403 dev.devAddr = DEV_ADDR_INVALID;
404 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '6'};
405 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
406 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4700 "
407 "%{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
408 ASSERT_NE(ret, 0);
409 }
410
411 /**
412 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4800
413 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
414 * std::vector<uint8_t> &data);
415 * @tc.desc: Negative test: parameters exception, ClaimInterface failed first
416 * @tc.type: FUNC
417 */
418 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4800, Function | MediumTest | Level1)
419 {
420 struct UsbDev dev = dev_;
421 uint8_t interfaceId = INTERFACEID_OK;
422 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
423 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
424 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4800 "
425 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
426 ASSERT_EQ(0, ret);
427 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
428 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '7'};
429 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
430 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4800 "
431 "%{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
432 ASSERT_NE(ret, 0);
433 }
434
435 /**
436 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_4900
437 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
438 * std::vector<uint8_t> &data);
439 * Positive test: parameters correctly, different in timeout
440 * @tc.type: FUNC
441 */
442 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_4900, Function | MediumTest | Level1)
443 {
444 struct UsbDev dev = dev_;
445 uint8_t interfaceId = INTERFACEID_OK;
446 uint8_t pointId = POINTID_BULK_OUT;
447 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
448 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4900 "
449 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
450 ASSERT_EQ(0, ret);
451 OHOS::HDI::Usb::V1_0::UsbPipe pipe = { interfaceId, pointId };
452 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '8'};
453 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, -1, bufferData);
454 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_4900 "
455 "%{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
456 ASSERT_NE(0, ret);
457 }
458 } // namespace
459