1 /*
2 * Copyright (c) 2024-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_0/iusb_interface.h"
22 #include "v1_0/usb_types.h"
23
24 const int SLEEP_TIME = 3;
25 const uint32_t MAX_BUFFER_LENGTH = 255;
26 const uint8_t SAMPLE_DATA_1 = 1;
27 const uint8_t SAMPLE_DATA_2 = 2;
28 const uint8_t SAMPLE_DATA_3 = 3;
29 const uint8_t INTERFACEID_OK = 1;
30 const int32_t TRANSFER_TIME_OUT = 1000;
31 const uint8_t POINTID_BULK_OUT = USB_ENDPOINT_DIR_OUT | 1;
32 const uint8_t POINTID_BULK_IN = USB_ENDPOINT_DIR_IN | 2;
33 const uint8_t PIPE_ENDPOINTID_INVALID = 244;
34 const int32_t ASHMEM_MAX_SIZE = 1024;
35
36 using namespace testing::ext;
37 using namespace OHOS;
38 using namespace OHOS::USB;
39 using namespace std;
40 using namespace OHOS::HDI::Usb::V1_0;
41
42 UsbDev UsbdTransferTestAdditional::dev_ = {0, 0};
43 sptr<UsbSubscriberTest> UsbdTransferTestAdditional::subscriber_ = nullptr;
44
45 namespace {
46 sptr<IUsbInterface> g_usbInterface = nullptr;
47
InitAshmemOne(sptr<Ashmem> & asmptr,int32_t asmSize,uint8_t rflg)48 int32_t InitAshmemOne(sptr<Ashmem> &asmptr, int32_t asmSize, uint8_t rflg)
49 {
50 asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
51 if (asmptr == nullptr) {
52 HDF_LOGE("InitAshmemOne CreateAshmem failed\n");
53 return HDF_FAILURE;
54 }
55
56 asmptr->MapReadAndWriteAshmem();
57
58 if (rflg == 0) {
59 uint8_t tdata[ASHMEM_MAX_SIZE];
60 int32_t offset = 0;
61 int32_t tlen = 0;
62
63 int32_t retSafe = memset_s(tdata, sizeof(tdata), 'Y', ASHMEM_MAX_SIZE);
64 if (retSafe != EOK) {
65 HDF_LOGE("InitAshmemOne memset_s failed\n");
66 return HDF_FAILURE;
67 }
68 while (offset < asmSize) {
69 tlen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
70 asmptr->WriteToAshmem(tdata, tlen, offset);
71 offset += tlen;
72 }
73 }
74 return HDF_SUCCESS;
75 }
76
SetUpTestCase(void)77 void UsbdTransferTestAdditional::SetUpTestCase(void)
78 {
79 g_usbInterface = IUsbInterface::Get();
80 if (g_usbInterface == nullptr) {
81 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
82 exit(0);
83 }
84 const int32_t DEFAULT_PORT_ID = 1;
85 const int32_t DEFAULT_ROLE_HOST = 1;
86 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, DEFAULT_ROLE_HOST, DEFAULT_ROLE_HOST);
87 sleep(SLEEP_TIME);
88 HDF_LOGI("UsbdTransferTestAdditional::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
89 if (ret != 0) {
90 ASSERT_EQ(HDF_ERR_NOT_SUPPORT, ret);
91 } else {
92 ASSERT_EQ(0, ret);
93 }
94
95 subscriber_ = new UsbSubscriberTest();
96 if (subscriber_ == nullptr) {
97 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
98 exit(0);
99 }
100 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
101 HDF_LOGE("%{public}s: bind usbd subscriber_ failed\n", __func__);
102 exit(0);
103 }
104
105 std::cout << "please connect device, press enter to continue" << std::endl;
106 int c;
107 while ((c = getchar()) != '\n' && c != EOF) {
108 }
109
110 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
111 ret = g_usbInterface->OpenDevice(dev_);
112 HDF_LOGI("UsbdTransferTestAdditional:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
113 ASSERT_EQ(0, ret);
114 }
115
TearDownTestCase(void)116 void UsbdTransferTestAdditional::TearDownTestCase(void)
117 {
118 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
119 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
120 auto ret = g_usbInterface->CloseDevice(dev_);
121 HDF_LOGI("UsbdTransferTestAdditional:: %{public}d Close=%{public}d", __LINE__, ret);
122 ASSERT_EQ(0, ret);
123 }
124
SetUp(void)125 void UsbdTransferTestAdditional::SetUp(void) {}
126
TearDown(void)127 void UsbdTransferTestAdditional::TearDown(void) {}
128
129 /**
130 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_0100
131 * @tc.name: testHdiUsbTransferTestBulkTransferWrite001
132 * @tc.desc: Writes data on a specified endpoint during bulk transfer.
133 * bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', ','}.
134 */
135 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkTransferWrite001, TestSize.Level1)
136 {
137 struct UsbDev dev = dev_;
138 uint8_t interfaceId = INTERFACEID_OK;
139 uint8_t pointId = POINTID_BULK_OUT;
140 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
141 ASSERT_EQ(0, ret);
142 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
143 std::vector<uint8_t> bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', ','};
144 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
145 ASSERT_EQ(0, ret);
146 }
147
148 /**
149 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_0200
150 * @tc.name: testHdiUsbTransferTestBulkTransferWrite002
151 * @tc.desc: Writes data on a specified endpoint during bulk transfer.
152 * bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '!'}.
153 */
154 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkTransferWrite002, TestSize.Level1)
155 {
156 struct UsbDev dev = dev_;
157 uint8_t interfaceId = INTERFACEID_OK;
158 uint8_t pointId = POINTID_BULK_OUT;
159 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
160 ASSERT_EQ(0, ret);
161 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
162 std::vector<uint8_t> bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '!'};
163 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
164 ASSERT_EQ(0, ret);
165 }
166
167 /**
168 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_0300
169 * @tc.name: testHdiUsbTransferTestBulkTransferWrite003
170 * @tc.desc: Writes data on a specified endpoint during bulk transfer.
171 * bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '~'}.
172 */
173 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkTransferWrite003, TestSize.Level1)
174 {
175 struct UsbDev dev = dev_;
176 uint8_t interfaceId = INTERFACEID_OK;
177 uint8_t pointId = POINTID_BULK_OUT;
178 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
179 ASSERT_EQ(0, ret);
180 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
181 std::vector<uint8_t> bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '~'};
182 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
183 ASSERT_EQ(0, ret);
184 }
185
186 /**
187 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_0400
188 * @tc.name: testHdiUsbTransferTestBulkTransferRead001
189 * @tc.desc: Writes data on a specified endpoint during bulk transfer.
190 * bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '~'} Check if the read is correct.
191 */
192 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkTransferRead001, TestSize.Level1)
193 {
194 struct UsbDev dev = dev_;
195 uint8_t interfaceId = INTERFACEID_OK;
196 uint8_t pointId = POINTID_BULK_OUT;
197 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
198 ASSERT_EQ(0, ret);
199 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
200 std::vector<uint8_t> bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '~'};
201 std::vector<uint8_t> bufferData1(MAX_BUFFER_LENGTH);
202 ret = g_usbInterface->BulkTransferWrite(dev, pipe, -1, bufferData);
203 ASSERT_EQ(0, ret);
204 pipe = {interfaceId, POINTID_BULK_IN};
205 ret = g_usbInterface->BulkTransferRead(dev, pipe, -1, bufferData1);
206 ASSERT_EQ(0, ret);
207 for (uint8_t i = 0; i < bufferData1.size(); ++i) {
208 std::cout << bufferData1[i] << " ";
209 }
210 std::cout << std::endl;
211 }
212
213 /**
214 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_0500
215 * @tc.name: testHdiUsbTransferTestBulkTransferRead002
216 * @tc.desc: Writes data on a specified endpoint during bulk transfer.
217 * bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '!'} Check if the read is correct.
218 */
219 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkTransferRead002, TestSize.Level1)
220 {
221 struct UsbDev dev = dev_;
222 uint8_t interfaceId = INTERFACEID_OK;
223 uint8_t pointId = POINTID_BULK_OUT;
224 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
225 ASSERT_EQ(0, ret);
226 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
227 std::vector<uint8_t> bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '!'};
228 std::vector<uint8_t> bufferData1(MAX_BUFFER_LENGTH);
229 ret = g_usbInterface->BulkTransferWrite(dev, pipe, -1, bufferData);
230 ASSERT_EQ(0, ret);
231 pipe = {interfaceId, POINTID_BULK_IN};
232 ret = g_usbInterface->BulkTransferRead(dev, pipe, -1, bufferData1);
233 ASSERT_EQ(0, ret);
234 for (uint8_t i = 0; i < bufferData1.size(); ++i) {
235 std::cout << bufferData1[i] << " ";
236 }
237 std::cout << std::endl;
238 }
239
240 /**
241 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_0600
242 * @tc.name: testHdiUsbTransferTestBulkTransferRead003
243 * @tc.desc: Writes data on a specified endpoint during bulk transfer.
244 * bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', ','} Check if the read is correct.
245 */
246 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkTransferRead003, TestSize.Level1)
247 {
248 struct UsbDev dev = dev_;
249 uint8_t interfaceId = INTERFACEID_OK;
250 uint8_t pointId = POINTID_BULK_OUT;
251 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
252 ASSERT_EQ(0, ret);
253 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
254 std::vector<uint8_t> bufferData = {'B', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', ','};
255 std::vector<uint8_t> bufferData1(MAX_BUFFER_LENGTH);
256 ret = g_usbInterface->BulkTransferWrite(dev, pipe, -1, bufferData);
257 ASSERT_EQ(0, ret);
258 pipe = {interfaceId, POINTID_BULK_IN};
259 ret = g_usbInterface->BulkTransferRead(dev, pipe, -1, bufferData1);
260 ASSERT_EQ(0, ret);
261 for (uint8_t i = 0; i < bufferData1.size(); ++i) {
262 std::cout << bufferData1[i] << " ";
263 }
264 std::cout << std::endl;
265 }
266
267 /**
268 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1300
269 * @tc.name: testHdiUsbTransferTestUnbindUsbdSubscriber001
270 * @tc.desc: Unbinds a subscriber twice.
271 */
272 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestUnbindUsbdSubscriber001, Function | MediumTest | Level2)
273 {
274 subscriber_ = new UsbSubscriberTest();
275 if (subscriber_ == nullptr) {
276 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
277 exit(0);
278 }
279 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_);
280 ASSERT_NE(0, ret);
281 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_);
282 ASSERT_NE(0, ret);
283 }
284
285 /**
286 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1400
287 * @tc.name: testHdiUsbTransferTestUnbindUsbdSubscriber002
288 * @tc.desc: Unbinds a subscriber for twice.unbind and bind, then Unbind twice.
289 */
290 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestUnbindUsbdSubscriber002, Function | MediumTest | Level2)
291 {
292 subscriber_ = new UsbSubscriberTest();
293 if (subscriber_ == nullptr) {
294 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
295 exit(0);
296 }
297 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_);
298 ASSERT_NE(0, ret);
299 ret = g_usbInterface->BindUsbdSubscriber(subscriber_);
300 ASSERT_EQ(0, ret);
301 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_);
302 ASSERT_EQ(0, ret);
303 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_);
304 ASSERT_NE(0, ret);
305 }
306
307 /**
308 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1500
309 * @tc.name: testHdiUsbTransferTestUnbindUsbdSubscriber003
310 * @tc.desc: Unbinds a subscriber twice.then unbind and bind.
311 */
312 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestUnbindUsbdSubscriber003, Function | MediumTest | Level2)
313 {
314 subscriber_ = new UsbSubscriberTest();
315 if (subscriber_ == nullptr) {
316 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
317 exit(0);
318 }
319 auto ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_);
320 ASSERT_NE(0, ret);
321 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_);
322 ASSERT_NE(0, ret);
323 ret = g_usbInterface->BindUsbdSubscriber(subscriber_);
324 ASSERT_EQ(0, ret);
325 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_);
326 ASSERT_EQ(0, ret);
327 }
328
329 /**
330 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1600
331 * @tc.name: testHdiUsbTransferTestbindUsbdSubscriber001
332 * @tc.desc: Binds a subscriber.unbind and bind twice.
333 */
334 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestbindUsbdSubscriber001, Function | MediumTest | Level1)
335 {
336 subscriber_ = new UsbSubscriberTest();
337 if (subscriber_ == nullptr) {
338 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
339 exit(0);
340 }
341 auto ret = g_usbInterface->BindUsbdSubscriber(subscriber_);
342 ASSERT_EQ(0, ret);
343 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber_);
344 ASSERT_EQ(0, ret);
345
346 sptr<UsbSubscriberTest> subscriber2 = new UsbSubscriberTest();
347 if (subscriber_ == nullptr) {
348 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
349 exit(0);
350 }
351 ret = g_usbInterface->BindUsbdSubscriber(subscriber2);
352 ASSERT_EQ(0, ret);
353 ret = g_usbInterface->UnbindUsbdSubscriber(subscriber2);
354 ASSERT_EQ(0, ret);
355 }
356
357 /**
358 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1700
359 * @tc.name: testHdiUsbTransferTestControlTransferRead001
360 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,0).see if bufferData is equal to
361 * bufferData1.
362 */
363 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferRead001, Function | MediumTest | Level1)
364 {
365 struct UsbDev dev = dev_;
366 std::vector<uint8_t> bufferData = {'r', 'e', 'a', 'd', 't', 'e', 's', 't', '0', '1'};
367 std::vector<uint8_t> bufferData1(MAX_BUFFER_LENGTH);
368 bufferData.push_back(SAMPLE_DATA_1);
369 bufferData.push_back(SAMPLE_DATA_2);
370 bufferData.push_back(SAMPLE_DATA_3);
371 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, -1};
372 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
373 ASSERT_EQ(0, ret);
374 ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, -1};
375 ret = g_usbInterface->ControlTransferRead(dev, ctrlparmas, bufferData1);
376 ASSERT_EQ(0, ret);
377 for (uint8_t i = 0; i < bufferData1.size(); ++i) {
378 std::cout << bufferData1[i] << " ";
379 }
380 std::cout << std::endl;
381 }
382
383 /**
384 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1800
385 * @tc.name: testHdiUsbTransferTestIsoTransferWrite001
386 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.timeout = 1.
387 */
388 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite001, Function | MediumTest | Level1)
389 {
390 struct UsbDev dev = dev_;
391 uint8_t interfaceId = INTERFACEID_OK;
392 uint8_t pointId = POINTID_BULK_OUT;
393 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
394 ASSERT_EQ(0, ret);
395 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
396 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '0', '1'};
397 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
398 ASSERT_EQ(0, ret);
399 }
400
401 /**
402 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1900
403 * @tc.name: testHdiUsbTransferTestIsoTransferWrite002
404 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.timeout = 50.
405 */
406 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite002, Function | MediumTest | Level1)
407 {
408 struct UsbDev dev = dev_;
409 uint8_t interfaceId = INTERFACEID_OK;
410 uint8_t pointId = POINTID_BULK_OUT;
411 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
412 ASSERT_EQ(0, ret);
413 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
414 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '0', '2'};
415 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
416 ASSERT_EQ(0, ret);
417 }
418
419 /**
420 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2000
421 * @tc.name: testHdiUsbTransferTestIsoTransferWrite003
422 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.timeout = 100.
423 */
424 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite003, Function | MediumTest | Level1)
425 {
426 struct UsbDev dev = dev_;
427 uint8_t interfaceId = INTERFACEID_OK;
428 uint8_t pointId = POINTID_BULK_OUT;
429 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
430 ASSERT_EQ(0, ret);
431 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
432 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '0', '3'};
433 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
434 ASSERT_EQ(0, ret);
435 }
436
437 /**
438 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2100
439 * @tc.name: testHdiUsbTransferTestIsoTransferWrite004
440 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.timeout = 255.
441 */
442 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite004, 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 ASSERT_EQ(0, ret);
449 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
450 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '0', '4'};
451 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
452 ASSERT_EQ(0, ret);
453 }
454
455 /**
456 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2200
457 * @tc.name: testHdiUsbTransferTestIsoTransferWrite005
458 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} timeout = 1.
459 */
460 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite005, Function | MediumTest | Level2)
461 {
462 struct UsbDev dev = dev_;
463 uint8_t interfaceId = INTERFACEID_OK;
464 uint8_t pointId = POINTID_BULK_OUT;
465 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
466 ASSERT_EQ(0, ret);
467 dev = {255, 255};
468 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
469 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '0', '5'};
470 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
471 ASSERT_NE(0, ret);
472 }
473
474 /**
475 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2300
476 * @tc.name: testHdiUsbTransferTestIsoTransferWrite006
477 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} timeout = 50.
478 */
479 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite006, Function | MediumTest | Level2)
480 {
481 struct UsbDev dev = dev_;
482 uint8_t interfaceId = INTERFACEID_OK;
483 uint8_t pointId = POINTID_BULK_OUT;
484 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
485 ASSERT_EQ(0, ret);
486 dev = {255, 255};
487 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
488 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '0', '6'};
489 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
490 ASSERT_NE(0, ret);
491 }
492
493 /**
494 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2400
495 * @tc.name: testHdiUsbTransferTestIsoTransferWrite007
496 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} timeout = 100.
497 */
498 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite007, Function | MediumTest | Level2)
499 {
500 struct UsbDev dev = dev_;
501 uint8_t interfaceId = INTERFACEID_OK;
502 uint8_t pointId = POINTID_BULK_OUT;
503 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
504 ASSERT_EQ(0, ret);
505 dev = {255, 255};
506 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
507 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '0', '7'};
508 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
509 ASSERT_NE(0, ret);
510 }
511
512 /**
513 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2500
514 * @tc.name: testHdiUsbTransferTestIsoTransferWrite008
515 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} timeout = 255.
516 */
517 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite008, Function | MediumTest | Level2)
518 {
519 struct UsbDev dev = dev_;
520 uint8_t interfaceId = INTERFACEID_OK;
521 uint8_t pointId = POINTID_BULK_OUT;
522 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
523 ASSERT_EQ(0, ret);
524 dev = {255, 255};
525 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
526 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '0', '8'};
527 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
528 ASSERT_NE(0, ret);
529 }
530
531 /**
532 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2600
533 * @tc.name: testHdiUsbTransferTestIsoTransferWrite009
534 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} timeout = 1.
535 */
536 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite009, Function | MediumTest | Level2)
537 {
538 struct UsbDev dev = dev_;
539 uint8_t interfaceId = INTERFACEID_OK;
540 uint8_t pointId = POINTID_BULK_OUT;
541 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
542 ASSERT_EQ(0, ret);
543 dev = {0, 255};
544 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
545 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '0', '9'};
546 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
547 ASSERT_NE(0, ret);
548 }
549
550 /**
551 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2700
552 * @tc.name: testHdiUsbTransferTestIsoTransferWrite010
553 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} timeout = 50.
554 */
555 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite010, Function | MediumTest | Level2)
556 {
557 struct UsbDev dev = dev_;
558 uint8_t interfaceId = INTERFACEID_OK;
559 uint8_t pointId = POINTID_BULK_OUT;
560 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
561 ASSERT_EQ(0, ret);
562 dev = {0, 255};
563 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
564 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '0'};
565 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
566 ASSERT_NE(0, ret);
567 }
568
569 /**
570 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2800
571 * @tc.name: testHdiUsbTransferTestIsoTransferWrite011
572 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} timeout = 100.
573 */
574 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite011, Function | MediumTest | Level2)
575 {
576 struct UsbDev dev = dev_;
577 uint8_t interfaceId = INTERFACEID_OK;
578 uint8_t pointId = POINTID_BULK_OUT;
579 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
580 ASSERT_EQ(0, ret);
581 dev = {0, 255};
582 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
583 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '1'};
584 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
585 ASSERT_NE(0, ret);
586 }
587
588 /**
589 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_2900
590 * @tc.name: testHdiUsbTransferTestIsoTransferWrite012
591 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} timeout = 255.
592 */
593 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite012, Function | MediumTest | Level2)
594 {
595 struct UsbDev dev = dev_;
596 uint8_t interfaceId = INTERFACEID_OK;
597 uint8_t pointId = POINTID_BULK_OUT;
598 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
599 ASSERT_EQ(0, ret);
600 dev = {0, 255};
601 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
602 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '2'};
603 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
604 ASSERT_NE(0, ret);
605 }
606
607 /**
608 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3000
609 * @tc.name: testHdiUsbTransferTestIsoTransferWrite013
610 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} timeout = 1.
611 */
612 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite013, Function | MediumTest | Level2)
613 {
614 struct UsbDev dev = dev_;
615 uint8_t interfaceId = INTERFACEID_OK;
616 uint8_t pointId = POINTID_BULK_OUT;
617 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
618 ASSERT_EQ(0, ret);
619 dev = {255, 0};
620 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
621 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '3'};
622 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
623 ASSERT_NE(0, ret);
624 }
625
626 /**
627 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3100
628 * @tc.name: testHdiUsbTransferTestIsoTransferWrite014
629 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} timeout = 50.
630 */
631 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite014, Function | MediumTest | Level2)
632 {
633 struct UsbDev dev = dev_;
634 uint8_t interfaceId = INTERFACEID_OK;
635 uint8_t pointId = POINTID_BULK_OUT;
636 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
637 ASSERT_EQ(0, ret);
638 dev = {255, 0};
639 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
640 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '4'};
641 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
642 ASSERT_NE(0, ret);
643 }
644
645 /**
646 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3200
647 * @tc.name: testHdiUsbTransferTestIsoTransferWrite015
648 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} timeout = 100.
649 */
650 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite015, Function | MediumTest | Level2)
651 {
652 struct UsbDev dev = dev_;
653 uint8_t interfaceId = INTERFACEID_OK;
654 uint8_t pointId = POINTID_BULK_OUT;
655 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
656 ASSERT_EQ(0, ret);
657 dev = {255, 0};
658 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
659 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '5'};
660 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
661 ASSERT_NE(0, ret);
662 }
663
664 /**
665 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3300
666 * @tc.name: testHdiUsbTransferTestIsoTransferWrite016
667 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} timeout = 255.
668 */
669 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite016, Function | MediumTest | Level2)
670 {
671 struct UsbDev dev = dev_;
672 uint8_t interfaceId = INTERFACEID_OK;
673 uint8_t pointId = POINTID_BULK_OUT;
674 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
675 ASSERT_EQ(0, ret);
676 dev = {255, 0};
677 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
678 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '6'};
679 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
680 ASSERT_NE(0, ret);
681 }
682
683 /**
684 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3400
685 * @tc.name: testHdiUsbTransferTestIsoTransferWrite017
686 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} timeout = 1 pipe = { 1,
687 * 244 }.
688 */
689 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite017, Function | MediumTest | Level2)
690 {
691 struct UsbDev dev = dev_;
692 uint8_t interfaceId = INTERFACEID_OK;
693 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
694 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
695 ASSERT_EQ(0, ret);
696 dev = {255, 255};
697 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
698 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '7'};
699 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
700 ASSERT_NE(ret, 0);
701 }
702
703 /**
704 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3500
705 * @tc.name: testHdiUsbTransferTestIsoTransferWrite018
706 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} timeout = 50 pipe = { 1,
707 * 244 }.
708 */
709 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite018, Function | MediumTest | Level2)
710 {
711 struct UsbDev dev = dev_;
712 uint8_t interfaceId = INTERFACEID_OK;
713 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
714 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
715 ASSERT_EQ(0, ret);
716 dev = {255, 255};
717 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
718 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '8'};
719 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
720 ASSERT_NE(ret, 0);
721 }
722
723 /**
724 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3600
725 * @tc.name: testHdiUsbTransferTestIsoTransferWrite019
726 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} timeout = 100 pipe = { 1,
727 * 244 }.
728 */
729 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite019, Function | MediumTest | Level2)
730 {
731 struct UsbDev dev = dev_;
732 uint8_t interfaceId = INTERFACEID_OK;
733 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
734 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
735 ASSERT_EQ(0, ret);
736 dev = {255, 255};
737 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
738 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '1', '9'};
739 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
740 ASSERT_NE(ret, 0);
741 }
742
743 /**
744 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3700
745 * @tc.name: testHdiUsbTransferTestIsoTransferWrite020
746 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} timeout = 255 pipe = { 1,
747 * 244 }.
748 */
749 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite020, Function | MediumTest | Level2)
750 {
751 struct UsbDev dev = dev_;
752 uint8_t interfaceId = INTERFACEID_OK;
753 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
754 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
755 ASSERT_EQ(0, ret);
756 dev = {255, 255};
757 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
758 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '0'};
759 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
760 ASSERT_NE(ret, 0);
761 }
762
763 /**
764 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3800
765 * @tc.name: testHdiUsbTransferTestIsoTransferWrite021
766 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} timeout = 1 pipe = { 1, 244
767 * }.
768 */
769 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite021, Function | MediumTest | Level2)
770 {
771 struct UsbDev dev = dev_;
772 uint8_t interfaceId = INTERFACEID_OK;
773 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
774 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
775 ASSERT_EQ(0, ret);
776 dev = {0, 255};
777 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
778 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '1'};
779 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
780 ASSERT_NE(ret, 0);
781 }
782
783 /**
784 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_3900
785 * @tc.name: testHdiUsbTransferTestIsoTransferWrite022
786 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} timeout = 50 pipe = { 1, 244
787 * }.
788 */
789 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite022, Function | MediumTest | Level2)
790 {
791 struct UsbDev dev = dev_;
792 uint8_t interfaceId = INTERFACEID_OK;
793 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
794 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
795 ASSERT_EQ(0, ret);
796 dev = {0, 255};
797 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
798 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '2'};
799 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
800 ASSERT_NE(ret, 0);
801 }
802
803 /**
804 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4000
805 * @tc.name: testHdiUsbTransferTestIsoTransferWrite023
806 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} timeout = 100 pipe = { 1,
807 * 244 }.
808 */
809 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite023, Function | MediumTest | Level2)
810 {
811 struct UsbDev dev = dev_;
812 uint8_t interfaceId = INTERFACEID_OK;
813 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
814 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
815 ASSERT_EQ(0, ret);
816 dev = {0, 255};
817 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
818 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '3'};
819 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
820 ASSERT_NE(ret, 0);
821 }
822
823 /**
824 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4100
825 * @tc.name: testHdiUsbTransferTestIsoTransferWrite024
826 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} timeout = 255 pipe = { 1,
827 * 244 }.
828 */
829 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite024, Function | MediumTest | Level2)
830 {
831 struct UsbDev dev = dev_;
832 uint8_t interfaceId = INTERFACEID_OK;
833 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
834 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
835 ASSERT_EQ(0, ret);
836 dev = {0, 255};
837 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
838 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '4'};
839 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
840 ASSERT_NE(ret, 0);
841 }
842
843 /**
844 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4200
845 * @tc.name: testHdiUsbTransferTestIsoTransferWrite025
846 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} timeout = 1 pipe = { 1, 244
847 * }.
848 */
849 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite025, Function | MediumTest | Level2)
850 {
851 struct UsbDev dev = dev_;
852 uint8_t interfaceId = INTERFACEID_OK;
853 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
854 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
855 ASSERT_EQ(0, ret);
856 dev = {255, 0};
857 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
858 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '5'};
859 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
860 ASSERT_NE(ret, 0);
861 }
862
863 /**
864 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4300
865 * @tc.name: testHdiUsbTransferTestIsoTransferWrite026
866 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} timeout = 50 pipe = { 1, 244
867 * }.
868 */
869 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite026, Function | MediumTest | Level2)
870 {
871 struct UsbDev dev = dev_;
872 uint8_t interfaceId = INTERFACEID_OK;
873 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
874 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
875 ASSERT_EQ(0, ret);
876 dev = {255, 0};
877 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
878 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '6'};
879 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
880 ASSERT_NE(ret, 0);
881 }
882
883 /**
884 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4400
885 * @tc.name: testHdiUsbTransferTestIsoTransferWrite027
886 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} timeout = 100 pipe = { 1,
887 * 244 }.
888 */
889 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite027, Function | MediumTest | Level2)
890 {
891 struct UsbDev dev = dev_;
892 uint8_t interfaceId = INTERFACEID_OK;
893 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
894 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
895 ASSERT_EQ(0, ret);
896 dev = {255, 0};
897 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
898 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '7'};
899 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
900 ASSERT_NE(ret, 0);
901 }
902
903 /**
904 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4500
905 * @tc.name: testHdiUsbTransferTestIsoTransferWrite028
906 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} timeout = 255 pipe = { 1,
907 * 244 }.
908 */
909 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite028, Function | MediumTest | Level2)
910 {
911 struct UsbDev dev = dev_;
912 uint8_t interfaceId = INTERFACEID_OK;
913 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
914 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
915 ASSERT_EQ(0, ret);
916 dev = {255, 0};
917 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
918 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '8'};
919 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
920 ASSERT_NE(ret, 0);
921 }
922
923 /**
924 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4600
925 * @tc.name: testHdiUsbTransferTestIsoTransferWrite029
926 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} pointId = POINTID_BULK_IN
927 * timeout = 1.
928 */
929 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite029, Function | MediumTest | Level2)
930 {
931 struct UsbDev dev = dev_;
932 uint8_t interfaceId = INTERFACEID_OK;
933 uint8_t pointId = POINTID_BULK_IN;
934 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
935 ASSERT_EQ(0, ret);
936 dev = {255, 255};
937 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
938 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '2', '9'};
939 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
940 ASSERT_NE(0, ret);
941 }
942
943 /**
944 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4700
945 * @tc.name: testHdiUsbTransferTestIsoTransferWrite030
946 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} pointId = POINTID_BULK_IN
947 * timeout = 50.
948 */
949 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite030, Function | MediumTest | Level2)
950 {
951 struct UsbDev dev = dev_;
952 uint8_t interfaceId = INTERFACEID_OK;
953 uint8_t pointId = POINTID_BULK_IN;
954 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
955 ASSERT_EQ(0, ret);
956 dev = {255, 255};
957 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
958 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '0'};
959 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
960 ASSERT_NE(0, ret);
961 }
962
963 /**
964 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4800
965 * @tc.name: testHdiUsbTransferTestIsoTransferWrite031
966 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} pointId = POINTID_BULK_IN
967 * timeout = 100.
968 */
969 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite031, Function | MediumTest | Level2)
970 {
971 struct UsbDev dev = dev_;
972 uint8_t interfaceId = INTERFACEID_OK;
973 uint8_t pointId = POINTID_BULK_IN;
974 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
975 ASSERT_EQ(0, ret);
976 dev = {255, 255};
977 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
978 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '1'};
979 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
980 ASSERT_NE(0, ret);
981 }
982
983 /**
984 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_4900
985 * @tc.name: testHdiUsbTransferTestIsoTransferWrite032
986 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 255} pointId = POINTID_BULK_IN
987 * timeout = 255.
988 */
989 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite032, Function | MediumTest | Level2)
990 {
991 struct UsbDev dev = dev_;
992 uint8_t interfaceId = INTERFACEID_OK;
993 uint8_t pointId = POINTID_BULK_IN;
994 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
995 ASSERT_EQ(0, ret);
996 dev = {255, 255};
997 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
998 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '2'};
999 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
1000 ASSERT_NE(0, ret);
1001 }
1002
1003 /**
1004 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5000
1005 * @tc.name: testHdiUsbTransferTestIsoTransferWrite033
1006 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} pointId = POINTID_BULK_IN
1007 * timeout = 1.
1008 */
1009 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite033, Function | MediumTest | Level2)
1010 {
1011 struct UsbDev dev = dev_;
1012 uint8_t interfaceId = INTERFACEID_OK;
1013 uint8_t pointId = POINTID_BULK_IN;
1014 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1015 ASSERT_EQ(0, ret);
1016 dev = {0, 255};
1017 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1018 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '3'};
1019 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
1020 ASSERT_NE(0, ret);
1021 }
1022
1023 /**
1024 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5100
1025 * @tc.name: testHdiUsbTransferTestIsoTransferWrite034
1026 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} pointId = POINTID_BULK_IN
1027 * timeout = 50.
1028 */
1029 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite034, Function | MediumTest | Level2)
1030 {
1031 struct UsbDev dev = dev_;
1032 uint8_t interfaceId = INTERFACEID_OK;
1033 uint8_t pointId = POINTID_BULK_IN;
1034 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1035 ASSERT_EQ(0, ret);
1036 dev = {0, 255};
1037 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1038 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '4'};
1039 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
1040 ASSERT_NE(0, ret);
1041 }
1042
1043 /**
1044 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5200
1045 * @tc.name: testHdiUsbTransferTestIsoTransferWrite035
1046 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} pointId = POINTID_BULK_IN
1047 * timeout = 100.
1048 */
1049 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite035, Function | MediumTest | Level2)
1050 {
1051 struct UsbDev dev = dev_;
1052 uint8_t interfaceId = INTERFACEID_OK;
1053 uint8_t pointId = POINTID_BULK_IN;
1054 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1055 ASSERT_EQ(0, ret);
1056 dev = {0, 255};
1057 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1058 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '5'};
1059 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
1060 ASSERT_NE(0, ret);
1061 }
1062
1063 /**
1064 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5300
1065 * @tc.name: testHdiUsbTransferTestIsoTransferWrite036
1066 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {0, 255} pointId = POINTID_BULK_IN
1067 * timeout = 255.
1068 */
1069 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite036, Function | MediumTest | Level2)
1070 {
1071 struct UsbDev dev = dev_;
1072 uint8_t interfaceId = INTERFACEID_OK;
1073 uint8_t pointId = POINTID_BULK_IN;
1074 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1075 ASSERT_EQ(0, ret);
1076 dev = {0, 255};
1077 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1078 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '6'};
1079 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
1080 ASSERT_NE(0, ret);
1081 }
1082
1083 /**
1084 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5400
1085 * @tc.name: testHdiUsbTransferTestIsoTransferWrite037
1086 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} pointId = POINTID_BULK_IN
1087 * timeout = 1.
1088 */
1089 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite037, Function | MediumTest | Level2)
1090 {
1091 struct UsbDev dev = dev_;
1092 uint8_t interfaceId = INTERFACEID_OK;
1093 uint8_t pointId = POINTID_BULK_IN;
1094 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1095 ASSERT_EQ(0, ret);
1096 dev = {255, 0};
1097 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1098 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '7'};
1099 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 1, bufferData);
1100 ASSERT_NE(0, ret);
1101 }
1102
1103 /**
1104 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5500
1105 * @tc.name: testHdiUsbTransferTestIsoTransferWrite038
1106 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} pointId = POINTID_BULK_IN
1107 * timeout = 50.
1108 */
1109 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite038, Function | MediumTest | Level2)
1110 {
1111 struct UsbDev dev = dev_;
1112 uint8_t interfaceId = INTERFACEID_OK;
1113 uint8_t pointId = POINTID_BULK_IN;
1114 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1115 ASSERT_EQ(0, ret);
1116 dev = {255, 0};
1117 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1118 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '8'};
1119 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 50, bufferData);
1120 ASSERT_NE(0, ret);
1121 }
1122
1123 /**
1124 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5600
1125 * @tc.name: testHdiUsbTransferTestIsoTransferWrite039
1126 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} pointId = POINTID_BULK_IN
1127 * timeout = 100.
1128 */
1129 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite039, Function | MediumTest | Level2)
1130 {
1131 struct UsbDev dev = dev_;
1132 uint8_t interfaceId = INTERFACEID_OK;
1133 uint8_t pointId = POINTID_BULK_IN;
1134 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1135 ASSERT_EQ(0, ret);
1136 dev = {255, 0};
1137 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1138 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '3', '9'};
1139 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 100, bufferData);
1140 ASSERT_NE(0, ret);
1141 }
1142
1143 /**
1144 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5700
1145 * @tc.name: testHdiUsbTransferTestIsoTransferWrite040
1146 * @tc.desc: Writes data on a specified endpoint during isochronous transfer.dev = {255, 0} pointId = POINTID_BULK_IN
1147 * timeout = 255.
1148 */
1149 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferWrite040, Function | MediumTest | Level2)
1150 {
1151 struct UsbDev dev = dev_;
1152 uint8_t interfaceId = INTERFACEID_OK;
1153 uint8_t pointId = POINTID_BULK_IN;
1154 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1155 ASSERT_EQ(0, ret);
1156 dev = {255, 0};
1157 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1158 std::vector<uint8_t> bufferData = {'i', 's', 'o', 't', 'e', 's', 't', '0', '4', '0'};
1159 ret = g_usbInterface->IsoTransferWrite(dev, pipe, 255, bufferData);
1160 ASSERT_NE(0, ret);
1161 }
1162
1163 /**
1164 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5800
1165 * @tc.name: testHdiUsbTransferTestIsoTransferRead001
1166 * @tc.desc: Reads data on a specified endpoint during isochronous transfer.see if bufferData1 is equal to bufferData.
1167 */
1168 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestIsoTransferRead001, Function | MediumTest | Level1)
1169 {
1170 struct UsbDev dev = dev_;
1171 uint8_t interfaceId = INTERFACEID_OK;
1172 uint8_t pointId = POINTID_BULK_OUT;
1173 std::vector<uint8_t> bufferData = {'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'};
1174 std::vector<uint8_t> bufferData1(MAX_BUFFER_LENGTH);
1175 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1176 ASSERT_EQ(0, ret);
1177 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1178
1179 ret = g_usbInterface->IsoTransferWrite(dev, pipe, -1, bufferData);
1180 ASSERT_EQ(0, ret);
1181 pipe = {interfaceId, POINTID_BULK_IN};
1182 ret = g_usbInterface->IsoTransferRead(dev, pipe, -1, bufferData1);
1183 ASSERT_EQ(0, ret);
1184 for (uint8_t i = 0; i < bufferData1.size(); ++i) {
1185 std::cout << bufferData1[i] << " ";
1186 }
1187 std::cout << std::endl;
1188 }
1189
1190 /**
1191 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_5900
1192 * @tc.name: testHdiUsbTransferTestBulkRead001
1193 * @tc.desc: Reads data during isochronous bulk transfer. dev = {1, 255}.
1194 */
1195 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkRead001, Function | MediumTest | Level2)
1196 {
1197 sptr<Ashmem> ashmem;
1198 uint8_t rflg = 0;
1199 int32_t asmSize = MAX_BUFFER_LENGTH;
1200 struct UsbDev dev = dev_;
1201 uint8_t interfaceId = INTERFACEID_OK;
1202 uint8_t pointId = POINTID_BULK_OUT;
1203 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1204 ASSERT_EQ(0, ret);
1205 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1206 dev = {1, 255};
1207 (void)InitAshmemOne(ashmem, asmSize, rflg);
1208 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1209 ASSERT_NE(ret, 0);
1210 }
1211
1212 /**
1213 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6000
1214 * @tc.name: testHdiUsbTransferTestBulkRead002
1215 * @tc.desc: Reads data during isochronous bulk transfer. dev = {255, 1}.
1216 */
1217 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkRead002, Function | MediumTest | Level2)
1218 {
1219 sptr<Ashmem> ashmem;
1220 uint8_t rflg = 0;
1221 int32_t asmSize = MAX_BUFFER_LENGTH;
1222 struct UsbDev dev = dev_;
1223 uint8_t interfaceId = INTERFACEID_OK;
1224 uint8_t pointId = POINTID_BULK_OUT;
1225 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1226 ASSERT_EQ(0, ret);
1227 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1228 dev = {255, 1};
1229 (void)InitAshmemOne(ashmem, asmSize, rflg);
1230 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1231 ASSERT_NE(ret, 0);
1232 }
1233
1234 /**
1235 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6100
1236 * @tc.name: testHdiUsbTransferTestBulkRead003
1237 * @tc.desc: Reads data during isochronous bulk transfer. dev = {255, 255}.
1238 */
1239 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkRead003, Function | MediumTest | Level2)
1240 {
1241 sptr<Ashmem> ashmem;
1242 uint8_t rflg = 0;
1243 int32_t asmSize = MAX_BUFFER_LENGTH;
1244 struct UsbDev dev = dev_;
1245 uint8_t interfaceId = INTERFACEID_OK;
1246 uint8_t pointId = POINTID_BULK_OUT;
1247 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1248 ASSERT_EQ(0, ret);
1249 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1250 dev = {255, 255};
1251 (void)InitAshmemOne(ashmem, asmSize, rflg);
1252 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1253 ASSERT_NE(ret, 0);
1254 }
1255
1256 /**
1257 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6200
1258 * @tc.name: testHdiUsbTransferTestBulkRead004
1259 * @tc.desc: Reads data during isochronous bulk transfer. dev = {100, 255}.
1260 */
1261 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkRead004, Function | MediumTest | Level2)
1262 {
1263 sptr<Ashmem> ashmem;
1264 uint8_t rflg = 0;
1265 int32_t asmSize = MAX_BUFFER_LENGTH;
1266 struct UsbDev dev = dev_;
1267 uint8_t interfaceId = INTERFACEID_OK;
1268 uint8_t pointId = POINTID_BULK_OUT;
1269 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1270 ASSERT_EQ(0, ret);
1271 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1272 dev = {100, 255};
1273 (void)InitAshmemOne(ashmem, asmSize, rflg);
1274 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1275 ASSERT_NE(ret, 0);
1276 }
1277
1278 /**
1279 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6300
1280 * @tc.name: testHdiUsbTransferTestBulkRead005
1281 * @tc.desc: Reads data during isochronous bulk transfer. dev = {255, 100}.
1282 */
1283 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkRead005, Function | MediumTest | Level2)
1284 {
1285 sptr<Ashmem> ashmem;
1286 uint8_t rflg = 0;
1287 int32_t asmSize = MAX_BUFFER_LENGTH;
1288 struct UsbDev dev = dev_;
1289 uint8_t interfaceId = INTERFACEID_OK;
1290 uint8_t pointId = POINTID_BULK_OUT;
1291 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1292 ASSERT_EQ(0, ret);
1293 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1294 dev = {255, 100};
1295 (void)InitAshmemOne(ashmem, asmSize, rflg);
1296 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1297 ASSERT_NE(ret, 0);
1298 }
1299
1300 /**
1301 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6400
1302 * @tc.name: testHdiUsbTransferTestBulkWrite001
1303 * @tc.desc: Writes data during isochronous bulk transfer. dev = {1, 255}.
1304 */
1305 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkWrite001, Function | MediumTest | Level2)
1306 {
1307 sptr<Ashmem> ashmem;
1308 uint8_t rflg = 0;
1309 int32_t asmSize = MAX_BUFFER_LENGTH;
1310 struct UsbDev dev = dev_;
1311 uint8_t interfaceId = INTERFACEID_OK;
1312 uint8_t pointId = POINTID_BULK_OUT;
1313 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1314 ASSERT_EQ(0, ret);
1315 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1316 dev = {1, 255};
1317 (void)InitAshmemOne(ashmem, asmSize, rflg);
1318 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1319 ASSERT_NE(ret, 0);
1320 }
1321
1322 /**
1323 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6500
1324 * @tc.name: testHdiUsbTransferTestBulkWrite002
1325 * @tc.desc: Writes data during isochronous bulk transfer. dev = {255, 1}.
1326 */
1327 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkWrite002, Function | MediumTest | Level2)
1328 {
1329 sptr<Ashmem> ashmem;
1330 uint8_t rflg = 0;
1331 int32_t asmSize = MAX_BUFFER_LENGTH;
1332 struct UsbDev dev = dev_;
1333 uint8_t interfaceId = INTERFACEID_OK;
1334 uint8_t pointId = POINTID_BULK_OUT;
1335 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1336 ASSERT_EQ(0, ret);
1337 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1338 dev = {255, 1};
1339 (void)InitAshmemOne(ashmem, asmSize, rflg);
1340 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1341 ASSERT_NE(ret, 0);
1342 }
1343
1344 /**
1345 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6600
1346 * @tc.name: testHdiUsbTransferTestBulkWrite003
1347 * @tc.desc: Writes data during isochronous bulk transfer. dev = {255, 255}.
1348 */
1349 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkWrite003, Function | MediumTest | Level2)
1350 {
1351 sptr<Ashmem> ashmem;
1352 uint8_t rflg = 0;
1353 int32_t asmSize = MAX_BUFFER_LENGTH;
1354 struct UsbDev dev = dev_;
1355 uint8_t interfaceId = INTERFACEID_OK;
1356 uint8_t pointId = POINTID_BULK_OUT;
1357 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1358 ASSERT_EQ(0, ret);
1359 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1360 dev = {255, 255};
1361 (void)InitAshmemOne(ashmem, asmSize, rflg);
1362 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1363 ASSERT_NE(ret, 0);
1364 }
1365
1366 /**
1367 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6700
1368 * @tc.name: testHdiUsbTransferTestBulkWrite004
1369 * @tc.desc: Writes data during isochronous bulk transfer. dev = {100, 255}.
1370 */
1371 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkWrite004, Function | MediumTest | Level2)
1372 {
1373 sptr<Ashmem> ashmem;
1374 uint8_t rflg = 0;
1375 int32_t asmSize = MAX_BUFFER_LENGTH;
1376 struct UsbDev dev = dev_;
1377 uint8_t interfaceId = INTERFACEID_OK;
1378 uint8_t pointId = POINTID_BULK_OUT;
1379 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1380 ASSERT_EQ(0, ret);
1381 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1382 dev = {100, 255};
1383 (void)InitAshmemOne(ashmem, asmSize, rflg);
1384 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1385 ASSERT_NE(ret, 0);
1386 }
1387
1388 /**
1389 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6800
1390 * @tc.name: testHdiUsbTransferTestBulkWrite005
1391 * @tc.desc: Writes data during isochronous bulk transfer. dev = {255, 100}.
1392 */
1393 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestBulkWrite005, Function | MediumTest | Level2)
1394 {
1395 sptr<Ashmem> ashmem;
1396 uint8_t rflg = 0;
1397 int32_t asmSize = MAX_BUFFER_LENGTH;
1398 struct UsbDev dev = dev_;
1399 uint8_t interfaceId = INTERFACEID_OK;
1400 uint8_t pointId = POINTID_BULK_OUT;
1401 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1402 ASSERT_EQ(0, ret);
1403 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1404 dev = {255, 100};
1405 (void)InitAshmemOne(ashmem, asmSize, rflg);
1406 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1407 ASSERT_NE(ret, 0);
1408 }
1409
1410 /**
1411 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_6900
1412 * @tc.name: testHdiUsbTransferTestRegBulkCallback001
1413 * @tc.desc: Registers a callback for isochronous bulk transfer. dev = {1, 255}.
1414 */
1415 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestRegBulkCallback001, Function | MediumTest | Level2)
1416 {
1417 struct UsbDev dev = dev_;
1418 uint8_t interfaceId = INTERFACEID_OK;
1419 uint8_t pointId = POINTID_BULK_OUT;
1420 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1421 dev = {1, 255};
1422 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1423 if (usbdBulkCallback == nullptr) {
1424 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1425 exit(0);
1426 }
1427 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1428 ASSERT_NE(ret, 0);
1429 }
1430
1431 /**
1432 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_7000
1433 * @tc.name: testHdiUsbTransferTestUnRegBulkCallback001
1434 * @tc.desc: Unregisters the callback for isochronous bulk transfer. dev = {1, 255}.
1435 */
1436 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestUnRegBulkCallback001, Function | MediumTest | Level2)
1437 {
1438 struct UsbDev dev = dev_;
1439 uint8_t interfaceId = INTERFACEID_OK;
1440 uint8_t pointId = POINTID_BULK_OUT;
1441 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1442 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1443 if (usbdBulkCallback == nullptr) {
1444 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1445 exit(0);
1446 }
1447 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1448 ASSERT_EQ(ret, 0);
1449 dev = {1, 255};
1450 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1451 ASSERT_NE(ret, 0);
1452 dev = dev_;
1453 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1454 ASSERT_EQ(ret, 0);
1455 }
1456 } // namespace
1457