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 "v2_0/iusb_host_interface.h"
22 #include "v2_0/iusb_port_interface.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 PIPE_ENDPOINTID_INVALID = 244;
30 const uint8_t PIPE_INTERFACEID_INVALID = 244;
31 // data interface have 2 point : 1->bulk_out 2->bulk_in
32 const uint8_t POINTID_BULK_IN = USB_ENDPOINT_DIR_IN | 2;
33 const uint8_t POINTID_BULK_OUT = USB_ENDPOINT_DIR_OUT | 1;
34 const int32_t ASHMEM_MAX_SIZE = 1024;
35 const uint8_t SAMPLE_DATA_1 = 1;
36 const uint8_t SAMPLE_DATA_2 = 2;
37 const uint8_t SAMPLE_DATA_3 = 3;
38 const int32_t TRANSFER_TIME_OUT = 1000;
39 const int32_t CTL_VALUE = 0x100;
40
41 using namespace testing::ext;
42 using namespace OHOS;
43 using namespace OHOS::USB;
44 using namespace std;
45 using namespace OHOS::HDI::Usb::V2_0;
46
47 UsbDev UsbdTransferTest::dev_ = {0, 0};
48 sptr<UsbSubscriberTest> UsbdTransferTest::subscriber_ = nullptr;
49
50 namespace {
51 sptr<IUsbHostInterface> g_usbHostInterface = nullptr;
52 sptr<IUsbPortInterface> g_usbPortInterface = nullptr;
53
InitAshmemOne(sptr<Ashmem> & asmptr,int32_t asmSize,uint8_t rflg)54 int32_t InitAshmemOne(sptr<Ashmem> &asmptr, int32_t asmSize, uint8_t rflg)
55 {
56 asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
57 if (asmptr == nullptr) {
58 HDF_LOGE("InitAshmemOne CreateAshmem failed\n");
59 return HDF_FAILURE;
60 }
61
62 asmptr->MapReadAndWriteAshmem();
63
64 if (rflg == 0) {
65 uint8_t tdata[ASHMEM_MAX_SIZE];
66 int32_t offset = 0;
67 int32_t tlen = 0;
68
69 int32_t retSafe = memset_s(tdata, sizeof(tdata), 'Y', ASHMEM_MAX_SIZE);
70 if (retSafe != EOK) {
71 HDF_LOGE("InitAshmemOne memset_s failed\n");
72 return HDF_FAILURE;
73 }
74 while (offset < asmSize) {
75 tlen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
76 asmptr->WriteToAshmem(tdata, tlen, offset);
77 offset += tlen;
78 }
79 }
80 return HDF_SUCCESS;
81 }
82
SetUpTestCase(void)83 void UsbdTransferTest::SetUpTestCase(void)
84 {
85 g_usbHostInterface = IUsbHostInterface::Get(true);
86 g_usbPortInterface = IUsbPortInterface::Get();
87 if (g_usbHostInterface == nullptr || g_usbPortInterface == nullptr) {
88 HDF_LOGE("%{public}s:g_usbHostInterface or g_usbPortInterface is nullptr.", __func__);
89 exit(0);
90 }
91 const int32_t DEFAULT_PORT_ID = 1;
92 const int32_t DEFAULT_ROLE_HOST = 1;
93 auto ret = g_usbPortInterface->SetPortRole(DEFAULT_PORT_ID, DEFAULT_ROLE_HOST, DEFAULT_ROLE_HOST);
94 sleep(SLEEP_TIME);
95 HDF_LOGI("UsbdTransferTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
96 if (ret != 0) {
97 ASSERT_EQ(HDF_ERR_NOT_SUPPORT, ret);
98 } else {
99 ASSERT_EQ(0, ret);
100 }
101
102 subscriber_ = new UsbSubscriberTest();
103 if (subscriber_ == nullptr) {
104 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
105 exit(0);
106 }
107 if (g_usbHostInterface->BindUsbdHostSubscriber(subscriber_) != HDF_SUCCESS) {
108 HDF_LOGE("%{public}s: bind usbd subscriber_ failed\n", __func__);
109 exit(0);
110 }
111
112 std::cout << "please connect device, press enter to continue" << std::endl;
113 int c;
114 while ((c = getchar()) != '\n' && c != EOF) {}
115
116 dev_ = { subscriber_->busNum_, subscriber_->devAddr_ };
117 ret = g_usbHostInterface->OpenDevice(dev_);
118 HDF_LOGI("UsbdTransferTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
119 ASSERT_EQ(0, ret);
120 }
121
TearDownTestCase(void)122 void UsbdTransferTest::TearDownTestCase(void)
123 {
124 g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
125 dev_ = { subscriber_->busNum_, subscriber_->devAddr_ };
126 auto ret = g_usbHostInterface->CloseDevice(dev_);
127 HDF_LOGI("UsbdTransferTest:: %{public}d Close=%{public}d", __LINE__, ret);
128 ASSERT_EQ(0, ret);
129 }
130
SetUp(void)131 void UsbdTransferTest::SetUp(void) {}
132
TearDown(void)133 void UsbdTransferTest::TearDown(void) {}
134
135 /**
136 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_0100
137 * @tc.desc: Test functions to ControlTransferRead
138 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
139 * @tc.desc: Positive test: parameters correctly, standard request: get configuration
140 * @tc.type: FUNC
141 */
142 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_0100, Function | MediumTest | Level1)
143 {
144 struct UsbDev dev = dev_;
145 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
146 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
147 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
148 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0100 %{public}d ret=%{public}d", __LINE__, ret);
149 ASSERT_EQ(0, ret);
150 }
151
152 /**
153 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_0100
154 * @tc.desc: Test functions to ControlTransferRead
155 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
156 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get configuration
157 * @tc.type: FUNC
158 */
159 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_0100, Function | MediumTest | Level1)
160 {
161 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
162 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
163 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
164 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
165 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_0100 "
166 "%{public}d ret=%{public}d", __LINE__, ret);
167 ASSERT_NE(ret, 0);
168 }
169
170 /**
171 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_0200
172 * @tc.desc: Test functions to ControlTransferRead
173 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
174 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get configuration
175 * @tc.type: FUNC
176 */
177 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_0200, Function | MediumTest | Level1)
178 {
179 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
180 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
181 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
182 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
183 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_0200 "
184 "%{public}d ret=%{public}d", __LINE__, ret);
185 ASSERT_NE(ret, 0);
186 }
187
188 /**
189 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_0300
190 * @tc.desc: Test functions to ControlTransferRead
191 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
192 * @tc.desc: Positive test: parameters correctly, standard request: get descriptor(device)
193 * @tc.type: FUNC
194 */
195 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_0300, Function | MediumTest | Level1)
196 {
197 struct UsbDev dev = dev_;
198 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
199 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0,
200 TRANSFER_TIME_OUT};
201 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
202 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_0300 "
203 "%{public}d ret=%{public}d", __LINE__, ret);
204 ASSERT_EQ(0, ret);
205 }
206
207 /**
208 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_0400
209 * @tc.desc: Test functions to ControlTransferRead
210 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
211 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get descriptor(device)
212 * @tc.type: FUNC
213 */
214 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_0400, Function | MediumTest | Level1)
215 {
216 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
217 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
218 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0,
219 TRANSFER_TIME_OUT};
220 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
221 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_0400 "
222 "%{public}d ret=%{public}d", __LINE__, ret);
223 ASSERT_NE(ret, 0);
224 }
225
226 /**
227 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_0500
228 * @tc.desc: Test functions to ControlTransferRead
229 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
230 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get descriptor(device)
231 * @tc.type: FUNC
232 */
233 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_0500, Function | MediumTest | Level1)
234 {
235 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
236 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
237 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0,
238 TRANSFER_TIME_OUT};
239 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
240 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_0500 "
241 "%{public}d ret=%{public}d", __LINE__, ret);
242 ASSERT_NE(ret, 0);
243 }
244
245 /**
246 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_0600
247 * @tc.desc: Test functions to ControlTransferRead
248 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
249 * @tc.desc: Positive test: parameters correctly, standard request: get interface
250 * @tc.type: FUNC
251 */
252 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_0600, Function | MediumTest | Level1)
253 {
254 struct UsbDev dev = dev_;
255 int32_t intercafeidex = 0;
256 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
257 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE,
258 USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT};
259 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
260 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_0600 "
261 "%{public}d ret=%{public}d", __LINE__, ret);
262 ASSERT_EQ(0, ret);
263 }
264
265 /**
266 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_0700
267 * @tc.desc: Test functions to ControlTransferRead
268 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
269 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get interface
270 * @tc.type: FUNC
271 */
272 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_0700, Function | MediumTest | Level1)
273 {
274 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
275 int32_t intercafeidex = 0;
276 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
277 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE,
278 USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT};
279 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
280 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_0700 "
281 "%{public}d ret=%{public}d", __LINE__, ret);
282 ASSERT_NE(ret, 0);
283 }
284
285 /**
286 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_0800
287 * @tc.desc: Test functions to ControlTransferRead
288 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
289 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get interface
290 * @tc.type: FUNC
291 */
292 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_0800, Function | MediumTest | Level1)
293 {
294 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
295 int32_t intercafeidex = 0;
296 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
297 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE,
298 USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT};
299 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
300 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_0800 "
301 "%{public}d ret=%{public}d", __LINE__, ret);
302 ASSERT_NE(ret, 0);
303 }
304
305 /**
306 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_0900
307 * @tc.desc: Test functions to ControlTransferRead
308 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
309 * @tc.desc: Positive test: parameters correctly, standard request: get status(recipient device)
310 * @tc.type: FUNC
311 */
312 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_0900, Function | MediumTest | Level1)
313 {
314 struct UsbDev dev = dev_;
315 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
316 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, TRANSFER_TIME_OUT};
317 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
318 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_0900 "
319 "%{public}d ret=%{public}d", __LINE__, ret);
320 ASSERT_EQ(0, ret);
321 }
322
323 /**
324 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1000
325 * @tc.desc: Test functions to ControlTransferRead
326 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
327 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(device)
328 * @tc.type: FUNC
329 */
330 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1000, Function | MediumTest | Level1)
331 {
332 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
333 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
334 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, TRANSFER_TIME_OUT};
335 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
336 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1000 "
337 "%{public}d ret=%{public}d", __LINE__, ret);
338 ASSERT_NE(ret, 0);
339 }
340
341 /**
342 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1100
343 * @tc.desc: Test functions to ControlTransferRead
344 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
345 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(device)
346 * @tc.type: FUNC
347 */
348 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1100, Function | MediumTest | Level1)
349 {
350 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
351 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
352 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN, 0, 0, 0, TRANSFER_TIME_OUT};
353 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
354 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1100 "
355 "%{public}d ret=%{public}d", __LINE__, ret);
356 ASSERT_NE(ret, 0);
357 }
358
359 /**
360 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1200
361 * @tc.desc: Test functions to ControlTransferRead
362 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
363 * @tc.desc: Positive test: parameters correctly, standard request: get status(interface)
364 * @tc.type: FUNC
365 */
366 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1200, Function | MediumTest | Level1)
367 {
368 struct UsbDev dev = dev_;
369 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
370 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0,
371 TRANSFER_TIME_OUT};
372 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
373 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1200 "
374 "%{public}d ret=%{public}d", __LINE__, ret);
375 ASSERT_EQ(0, ret);
376 }
377
378 /**
379 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1300
380 * @tc.desc: Test functions to ControlTransferRead
381 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
382 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(interface)
383 * @tc.type: FUNC
384 */
385 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1300, Function | MediumTest | Level1)
386 {
387 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
388 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
389 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0,
390 TRANSFER_TIME_OUT};
391 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
392 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1300 "
393 "%{public}d ret=%{public}d", __LINE__, ret);
394 ASSERT_NE(ret, 0);
395 }
396
397 /**
398 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1400
399 * @tc.desc: Test functions to ControlTransferRead
400 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
401 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(interface)
402 * @tc.type: FUNC
403 */
404 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1400, Function | MediumTest | Level1)
405 {
406 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
407 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
408 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0,
409 TRANSFER_TIME_OUT};
410 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
411 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1400 "
412 "%{public}d ret=%{public}d", __LINE__, ret);
413 ASSERT_NE(ret, 0);
414 }
415
416 /**
417 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1500
418 * @tc.desc: Test functions to ControlTransferRead
419 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
420 * @tc.desc: Positive test: parameters correctly, standard request: get status(endpoint)
421 * @tc.type: FUNC
422 */
423 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1500, Function | MediumTest | Level1)
424 {
425 struct UsbDev dev = dev_;
426 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
427 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0,
428 TRANSFER_TIME_OUT};
429 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
430 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1500 "
431 "%{public}d ret=%{public}d", __LINE__, ret);
432 ASSERT_EQ(0, ret);
433 }
434
435 /**
436 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1600
437 * @tc.desc: Test functions to ControlTransferRead
438 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
439 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(endpoint)
440 * @tc.type: FUNC
441 */
442 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1600, Function | MediumTest | Level1)
443 {
444 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
445 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
446 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0,
447 TRANSFER_TIME_OUT};
448 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
449 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1600 "
450 "%{public}d ret=%{public}d", __LINE__, ret);
451 ASSERT_NE(ret, 0);
452 }
453
454 /**
455 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1700
456 * @tc.desc: Test functions to ControlTransferRead
457 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
458 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(endpoint)
459 * @tc.type: FUNC
460 */
461 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1700, Function | MediumTest | Level1)
462 {
463 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
464 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
465 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0,
466 TRANSFER_TIME_OUT};
467 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
468 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1700 "
469 "%{public}d ret=%{public}d", __LINE__, ret);
470 ASSERT_NE(ret, 0);
471 }
472
473 /**
474 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1800
475 * @tc.desc: Test functions to ControlTransferRead
476 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
477 * @tc.desc: Positive test: parameters correctly, standard request: sync frame
478 * @tc.type: FUNC
479 */
480 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1800, Function | MediumTest | Level1)
481 {
482 struct UsbDev dev = dev_;
483 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
484 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME,
485 0, 0, TRANSFER_TIME_OUT};
486 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
487 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1800 "
488 "%{public}d ret=%{public}d", __LINE__, ret);
489 ASSERT_EQ(0, ret);
490 }
491
492 /**
493 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_1900
494 * @tc.desc: Test functions to ControlTransferRead
495 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
496 * @tc.desc: Negative test: parameters exception, busNum error, standard request: sync frame
497 * @tc.type: FUNC
498 */
499 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_1900, Function | MediumTest | Level1)
500 {
501 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
502 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
503 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME,
504 0, 0, TRANSFER_TIME_OUT};
505 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
506 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_1900 "
507 "%{public}d ret=%{public}d", __LINE__, ret);
508 ASSERT_NE(ret, 0);
509 }
510
511 /**
512 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2000
513 * @tc.desc: Test functions to ControlTransferRead
514 * @tc.desc: int32_t ControlTransferRead(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
515 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: sync frame
516 * @tc.type: FUNC
517 */
518 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2000, Function | MediumTest | Level1)
519 {
520 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
521 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
522 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME,
523 0, 0, TRANSFER_TIME_OUT};
524 auto ret = g_usbHostInterface->ControlTransferRead(dev, ctrlparmas, bufferData);
525 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2000 "
526 "%{public}d ret=%{public}d", __LINE__, ret);
527 ASSERT_NE(ret, 0);
528 }
529
530 /**
531 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_0600
532 * @tc.desc: Test functions to ControlTransferWrite
533 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
534 * @tc.desc: Positive test: parameters correctly
535 * @tc.type: FUNC
536 */
537 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_0600, Function | MediumTest | Level1)
538 {
539 struct UsbDev dev = dev_;
540 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
541 bufferData.push_back(SAMPLE_DATA_1);
542 bufferData.push_back(SAMPLE_DATA_2);
543 bufferData.push_back(SAMPLE_DATA_3);
544 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT,
545 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
546 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
547 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0600 %{public}d ret=%{public}d", __LINE__, ret);
548 ASSERT_EQ(0, ret);
549 }
550
551 /**
552 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6100
553 * @tc.desc: Test functions to ControlTransferWrite
554 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
555 * @tc.desc: Negative test: parameters exception, busNum error
556 * @tc.type: FUNC
557 */
558 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6100, Function | MediumTest | Level1)
559 {
560 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
561 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
562 bufferData.push_back(SAMPLE_DATA_1);
563 bufferData.push_back(SAMPLE_DATA_2);
564 bufferData.push_back(SAMPLE_DATA_3);
565 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE,
566 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
567 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
568 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6100 "
569 "%{public}d ret=%{public}d", __LINE__, ret);
570 ASSERT_NE(ret, 0);
571 }
572
573 /**
574 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6200
575 * @tc.desc: Test functions to ControlTransferWrite
576 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
577 * @tc.desc: Negative test: parameters exception, devAddr error
578 * @tc.type: FUNC
579 */
580 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6200, Function | MediumTest | Level1)
581 {
582 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
583 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
584 bufferData.push_back(SAMPLE_DATA_1);
585 bufferData.push_back(SAMPLE_DATA_2);
586 bufferData.push_back(SAMPLE_DATA_3);
587 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE,
588 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
589 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
590 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6200 "
591 "%{public}d ret=%{public}d", __LINE__, ret);
592 ASSERT_NE(ret, 0);
593 }
594
595 /**
596 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6300
597 * @tc.desc: Test functions to ControlTransferWrite
598 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
599 * @tc.desc: Positive test: parameters correctly
600 * @tc.type: FUNC
601 */
602 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6300, Function | MediumTest | Level1)
603 {
604 struct UsbDev dev = dev_;
605 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
606 bufferData.push_back(SAMPLE_DATA_1);
607 bufferData.push_back(SAMPLE_DATA_2);
608 bufferData.push_back(SAMPLE_DATA_3);
609 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT,
610 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
611 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
612 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6300 "
613 "%{public}d ret=%{public}d", __LINE__, ret);
614 ASSERT_EQ(0, ret);
615 }
616
617 /**
618 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6400
619 * @tc.desc: Test functions to ControlTransferWrite
620 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
621 * @tc.desc: Negative test: parameters exception, busNum error
622 * @tc.type: FUNC
623 */
624 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6400, Function | MediumTest | Level1)
625 {
626 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
627 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
628 bufferData.push_back(SAMPLE_DATA_1);
629 bufferData.push_back(SAMPLE_DATA_2);
630 bufferData.push_back(SAMPLE_DATA_3);
631 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE,
632 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
633 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
634 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6400 "
635 "%{public}d ret=%{public}d", __LINE__, ret);
636 ASSERT_NE(ret, 0);
637 }
638
639 /**
640 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6500
641 * @tc.desc: Test functions to ControlTransferWrite
642 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
643 * @tc.desc: Negative test: parameters exception, devAddr error
644 * @tc.type: FUNC
645 */
646 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6500, Function | MediumTest | Level1)
647 {
648 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
649 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
650 bufferData.push_back(SAMPLE_DATA_1);
651 bufferData.push_back(SAMPLE_DATA_2);
652 bufferData.push_back(SAMPLE_DATA_3);
653 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE,
654 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
655 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
656 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6500 "
657 "%{public}d ret=%{public}d", __LINE__, ret);
658 ASSERT_NE(ret, 0);
659 }
660
661 /**
662 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6600
663 * @tc.desc: Test functions to ControlTransferWrite
664 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
665 * @tc.desc: Positive test: parameters correctly
666 * @tc.type: FUNC
667 */
668 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6600, Function | MediumTest | Level1)
669 {
670 struct UsbDev dev = dev_;
671 int32_t intercafeidex = 0;
672 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
673 bufferData.push_back(SAMPLE_DATA_1);
674 bufferData.push_back(SAMPLE_DATA_2);
675 bufferData.push_back(SAMPLE_DATA_3);
676 struct UsbCtrlTransfer ctrlparmas = {0, USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT};
677 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
678 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6600 "
679 "%{public}d ret=%{public}d", __LINE__, ret);
680 ASSERT_EQ(0, ret);
681 }
682
683 /**
684 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6700
685 * @tc.desc: Test functions to ControlTransferWrite
686 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
687 * @tc.desc: Negative test: parameters exception, busNum error
688 * @tc.type: FUNC
689 */
690 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6700, Function | MediumTest | Level1)
691 {
692 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
693 int32_t intercafeidex = 0;
694 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
695 bufferData.push_back(SAMPLE_DATA_1);
696 bufferData.push_back(SAMPLE_DATA_2);
697 bufferData.push_back(SAMPLE_DATA_3);
698 struct UsbCtrlTransfer ctrlparmas = {0, USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT};
699 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
700 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6700 "
701 "%{public}d ret=%{public}d", __LINE__, ret);
702 ASSERT_NE(ret, 0);
703 }
704
705 /**
706 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6800
707 * @tc.desc: Test functions to ControlTransferWrite
708 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
709 * @tc.desc: Negative test: parameters exception, devAddr error
710 * @tc.type: FUNC
711 */
712 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6800, Function | MediumTest | Level1)
713 {
714 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
715 int32_t intercafeidex = 0;
716 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
717 bufferData.push_back(SAMPLE_DATA_1);
718 bufferData.push_back(SAMPLE_DATA_2);
719 bufferData.push_back(SAMPLE_DATA_3);
720 struct UsbCtrlTransfer ctrlparmas = {0, USB_DDK_REQ_GET_INTERFACE, 0, intercafeidex, TRANSFER_TIME_OUT};
721 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
722 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6800 "
723 "%{public}d ret=%{public}d", __LINE__, ret);
724 ASSERT_NE(ret, 0);
725 }
726
727 /**
728 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6900
729 * @tc.desc: Test functions to ControlTransferWrite
730 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
731 * @tc.desc: Positive test: parameters correctly
732 * @tc.type: FUNC
733 */
734 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6900, Function | MediumTest | Level1)
735 {
736 struct UsbDev dev = dev_;
737 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
738 bufferData.push_back(SAMPLE_DATA_1);
739 bufferData.push_back(SAMPLE_DATA_2);
740 bufferData.push_back(SAMPLE_DATA_3);
741 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, USB_DDK_REQ_GET_DESCRIPTOR, 0, 0,
742 TRANSFER_TIME_OUT};
743 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
744 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6900 "
745 "%{public}d ret=%{public}d", __LINE__, ret);
746 ASSERT_EQ(0, ret);
747 }
748
749 /**
750 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7000
751 * @tc.desc: Test functions to ControlTransferWrite
752 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
753 * @tc.desc: Negative test: parameters exception, busNum error
754 * @tc.type: FUNC
755 */
756 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7000, Function | MediumTest | Level1)
757 {
758 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
759 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
760 bufferData.push_back(SAMPLE_DATA_1);
761 bufferData.push_back(SAMPLE_DATA_2);
762 bufferData.push_back(SAMPLE_DATA_3);
763 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0,
764 TRANSFER_TIME_OUT};
765 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
766 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7000 "
767 "%{public}d ret=%{public}d", __LINE__, ret);
768 ASSERT_NE(ret, 0);
769 }
770
771 /**
772 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7100
773 * @tc.desc: Test functions to ControlTransferWrite
774 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
775 * @tc.desc: Negative test: parameters exception, devAddr error
776 * @tc.type: FUNC
777 */
778 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7100, Function | MediumTest | Level1)
779 {
780 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
781 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
782 bufferData.push_back(SAMPLE_DATA_1);
783 bufferData.push_back(SAMPLE_DATA_2);
784 bufferData.push_back(SAMPLE_DATA_3);
785 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0,
786 TRANSFER_TIME_OUT};
787 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
788 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7100 "
789 "%{public}d ret=%{public}d", __LINE__, ret);
790 ASSERT_NE(ret, 0);
791 }
792
793 /**
794 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7200
795 * @tc.desc: Test functions to ControlTransferWrite
796 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
797 * @tc.desc: Positive test: parameters correctly
798 * @tc.type: FUNC
799 */
800 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7200, Function | MediumTest | Level1)
801 {
802 struct UsbDev dev = dev_;
803 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
804 bufferData.push_back(SAMPLE_DATA_1);
805 bufferData.push_back(SAMPLE_DATA_2);
806 bufferData.push_back(SAMPLE_DATA_3);
807 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, USB_DDK_REQ_GET_INTERFACE, 0, 0, TRANSFER_TIME_OUT};
808 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
809 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7200 "
810 "%{public}d ret=%{public}d", __LINE__, ret);
811 ASSERT_EQ(0, ret);
812 }
813
814 /**
815 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7300
816 * @tc.desc: Test functions to ControlTransferWrite
817 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
818 * @tc.desc: Negative test: parameters exception, busNum error
819 * @tc.type: FUNC
820 */
821 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7300, Function | MediumTest | Level1)
822 {
823 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
824 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
825 bufferData.push_back(SAMPLE_DATA_1);
826 bufferData.push_back(SAMPLE_DATA_2);
827 bufferData.push_back(SAMPLE_DATA_3);
828 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, 0, 0, 0, TRANSFER_TIME_OUT};
829 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
830 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7300 "
831 "%{public}d ret=%{public}d", __LINE__, ret);
832 ASSERT_NE(ret, 0);
833 }
834
835 /**
836 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7400
837 * @tc.desc: Test functions to ControlTransferWrite
838 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
839 * @tc.desc: Negative test: parameters exception, devAddr error
840 * @tc.type: FUNC
841 */
842 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7400, Function | MediumTest | Level1)
843 {
844 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
845 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
846 bufferData.push_back(SAMPLE_DATA_1);
847 bufferData.push_back(SAMPLE_DATA_2);
848 bufferData.push_back(SAMPLE_DATA_3);
849 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, 0, 0, 0, TRANSFER_TIME_OUT};
850 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
851 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7400 "
852 "%{public}d ret=%{public}d", __LINE__, ret);
853 ASSERT_NE(ret, 0);
854 }
855
856 /**
857 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7500
858 * @tc.desc: Test functions to ControlTransferWrite
859 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
860 * @tc.desc: Positive test: parameters correctly
861 * @tc.type: FUNC
862 */
863 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7500, Function | MediumTest | Level1)
864 {
865 struct UsbDev dev = dev_;
866 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
867 bufferData.push_back(SAMPLE_DATA_1);
868 bufferData.push_back(SAMPLE_DATA_2);
869 bufferData.push_back(SAMPLE_DATA_3);
870 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT, USB_DDK_REQ_GET_CONFIGURATION, 0, 0,
871 TRANSFER_TIME_OUT};
872 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
873 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7500 "
874 "%{public}d ret=%{public}d", __LINE__, ret);
875 ASSERT_EQ(0, ret);
876 }
877
878 /**
879 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7600
880 * @tc.desc: Test functions to ControlTransferWrite
881 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
882 * @tc.desc: Negative test: parameters exception, busNum error
883 * @tc.type: FUNC
884 */
885 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7600, Function | MediumTest | Level1)
886 {
887 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
888 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
889 bufferData.push_back(SAMPLE_DATA_1);
890 bufferData.push_back(SAMPLE_DATA_2);
891 bufferData.push_back(SAMPLE_DATA_3);
892 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0,
893 TRANSFER_TIME_OUT};
894 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
895 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7600 "
896 "%{public}d ret=%{public}d", __LINE__, ret);
897 ASSERT_NE(ret, 0);
898 }
899
900 /**
901 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7700
902 * @tc.desc: Test functions to ControlTransferWrite
903 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
904 * @tc.desc: Negative test: parameters exception, devAddr error
905 * @tc.type: FUNC
906 */
907 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7700, Function | MediumTest | Level1)
908 {
909 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
910 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
911 bufferData.push_back(SAMPLE_DATA_1);
912 bufferData.push_back(SAMPLE_DATA_2);
913 bufferData.push_back(SAMPLE_DATA_3);
914 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0,
915 TRANSFER_TIME_OUT};
916 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
917 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7700 "
918 "%{public}d ret=%{public}d", __LINE__, ret);
919 ASSERT_NE(ret, 0);
920 }
921
922 /**
923 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7800
924 * @tc.desc: Test functions to ControlTransferWrite
925 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
926 * @tc.desc: Positive test: parameters correctly
927 * @tc.type: FUNC
928 */
929 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7800, Function | MediumTest | Level1)
930 {
931 struct UsbDev dev = dev_;
932 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
933 bufferData.push_back(SAMPLE_DATA_1);
934 bufferData.push_back(SAMPLE_DATA_2);
935 bufferData.push_back(SAMPLE_DATA_3);
936 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME,
937 0, 0, TRANSFER_TIME_OUT};
938 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
939 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7800 "
940 "%{public}d ret=%{public}d", __LINE__, ret);
941 ASSERT_EQ(0, ret);
942 }
943
944 /**
945 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_7900
946 * @tc.desc: Test functions to ControlTransferWrite
947 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
948 * @tc.desc: Negative test: parameters exception, busNum error
949 * @tc.type: FUNC
950 */
951 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_7900, Function | MediumTest | Level1)
952 {
953 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
954 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
955 bufferData.push_back(SAMPLE_DATA_1);
956 bufferData.push_back(SAMPLE_DATA_2);
957 bufferData.push_back(SAMPLE_DATA_3);
958 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME,
959 0, 0, TRANSFER_TIME_OUT};
960 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
961 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_7900 "
962 "%{public}d ret=%{public}d", __LINE__, ret);
963 ASSERT_NE(ret, 0);
964 }
965
966 /**
967 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_8000
968 * @tc.desc: Test functions to ControlTransferWrite
969 * @tc.desc: int32_t ControlTransferWrite(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
970 * @tc.desc: Negative test: parameters exception, devAddr error
971 * @tc.type: FUNC
972 */
973 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_8000, Function | MediumTest | Level1)
974 {
975 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
976 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
977 bufferData.push_back(SAMPLE_DATA_1);
978 bufferData.push_back(SAMPLE_DATA_2);
979 bufferData.push_back(SAMPLE_DATA_3);
980 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME,
981 0, 0, TRANSFER_TIME_OUT};
982 auto ret = g_usbHostInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
983 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8000 "
984 "%{public}d ret=%{public}d", __LINE__, ret);
985 ASSERT_NE(ret, 0);
986 }
987
988 /**
989 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_0200
990 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
991 * std::vector<uint8_t> &data);
992 * @tc.desc: Positive test: parameters correctly
993 * @tc.type: FUNC
994 */
995 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_0200, Function | MediumTest | Level1)
996 {
997 struct UsbDev dev = dev_;
998 uint8_t interfaceId = INTERFACEID_OK;
999 uint8_t pointId = POINTID_BULK_IN;
1000 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1001 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0200 "
1002 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1003 ASSERT_EQ(0, ret);
1004 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1005 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1006 ret = g_usbHostInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1007 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0200 "
1008 "%{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
1009 ASSERT_EQ(0, ret);
1010 }
1011
1012 /**
1013 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2100
1014 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1015 * std::vector<uint8_t> &data);
1016 * @tc.desc: Negative test: parameters exception, busNum error
1017 * @tc.type: FUNC
1018 */
1019 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2100, Function | MediumTest | Level1)
1020 {
1021 struct UsbDev dev = dev_;
1022 uint8_t interfaceId = INTERFACEID_OK;
1023 uint8_t pointId = POINTID_BULK_IN;
1024 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1025 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2100 "
1026 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1027 ASSERT_EQ(0, ret);
1028 dev.busNum = BUS_NUM_INVALID;
1029 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1030 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1031 ret = g_usbHostInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1032 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2100 "
1033 "%{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
1034 ASSERT_NE(ret, 0);
1035 }
1036
1037 /**
1038 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2200
1039 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1040 * std::vector<uint8_t> &data);
1041 * @tc.desc: Negative test: parameters exception, devAddr error
1042 * @tc.type: FUNC
1043 */
1044 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2200, Function | MediumTest | Level1)
1045 {
1046 struct UsbDev dev = dev_;
1047 uint8_t interfaceId = INTERFACEID_OK;
1048 uint8_t pointId = POINTID_BULK_IN;
1049 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1050 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2200 "
1051 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1052 ASSERT_EQ(0, ret);
1053 dev.devAddr = DEV_ADDR_INVALID;
1054 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1055 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1056 ret = g_usbHostInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1057 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2200 "
1058 "%{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
1059 ASSERT_NE(ret, 0);
1060 }
1061
1062 /**
1063 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2300
1064 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1065 * std::vector<uint8_t> &data);
1066 * @tc.desc: Negative test: parameters exception, intfId error
1067 * @tc.type: FUNC
1068 */
1069 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2300, Function | MediumTest | Level1)
1070 {
1071 struct UsbDev dev = dev_;
1072 uint8_t interfaceId = INTERFACEID_OK;
1073 uint8_t pointId = POINTID_BULK_IN;
1074 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1075 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2300 "
1076 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1077 ASSERT_EQ(0, ret);
1078 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1079 pipe.intfId = PIPE_INTERFACEID_INVALID;
1080 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1081 ret = g_usbHostInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1082 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2300 "
1083 "%{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
1084 ASSERT_NE(ret, 0);
1085 }
1086
1087 /**
1088 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2400
1089 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1090 * std::vector<uint8_t> &data);
1091 * @tc.desc: Negative test: parameters exception, endpointId error
1092 * @tc.type: FUNC
1093 */
1094 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2400, Function | MediumTest | Level1)
1095 {
1096 struct UsbDev dev = dev_;
1097 uint8_t interfaceId = INTERFACEID_OK;
1098 uint8_t pointId = POINTID_BULK_IN;
1099 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1100 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2400 "
1101 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1102 ASSERT_EQ(0, ret);
1103 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1104 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
1105 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1106 ret = g_usbHostInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1107 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2400 "
1108 "%{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
1109 ASSERT_NE(ret, 0);
1110 }
1111
1112 /**
1113 * @tc.number : SUB_USB_HostManager_HDI_Func_2200
1114 * @tc.name : UsbdBulkTransferReadwithLength001
1115 * @tc.desc : Test functions to BulkTransferReadwithLength(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1116 * std::vector<uint8_t> &data)
1117 * @tc.desc : Positive test: parameters correctly
1118 * @tc.size : MediumTest
1119 * @tc.type : Function
1120 * @tc.level : Level 3
1121 */
1122 HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength001, Function | MediumTest | Level1)
1123 {
1124 struct UsbDev dev = dev_;
1125 uint8_t interfaceId = INTERFACEID_OK;
1126 uint8_t pointid = POINTID_BULK_IN;
1127 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1128 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength001 %{public}d ClaimInterface=%{public}d",
1129 __LINE__, ret);
1130 ASSERT_EQ(0, ret);
1131 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointid};
1132 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1133 ret = g_usbHostInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData);
1134 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength001 %{public}d ret=%{public}d", __LINE__, ret);
1135 ASSERT_EQ(0, ret);
1136 }
1137
1138 /**
1139 * @tc.number : SUB_USB_HostManager_HDI_Compatibility_0140
1140 * @tc.name : UsbdBulkTransferReadwithLength002
1141 * @tc.desc : Test functions to BulkTransferReadwithLength(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1142 * std::vector<uint8_t> &data)
1143 * @tc.desc : Negative test: parameters exception, busNum error
1144 * @tc.size : MediumTest
1145 * @tc.type : Function
1146 * @tc.level : Level 3
1147 */
1148 HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength002, Function | MediumTest | Level1)
1149 {
1150 struct UsbDev dev = dev_;
1151 uint8_t interfaceId = INTERFACEID_OK;
1152 uint8_t pointid = POINTID_BULK_IN;
1153 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1154 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength002 %{public}d ClaimInterface=%{public}d",
1155 __LINE__, ret);
1156 ASSERT_EQ(0, ret);
1157 dev.busNum = BUS_NUM_INVALID;
1158 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointid};
1159 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1160 ret = g_usbHostInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData);
1161 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength002 %{public}d ret=%{public}d", __LINE__, ret);
1162 ASSERT_NE(ret, 0);
1163 }
1164
1165 /**
1166 * @tc.number : SUB_USB_HostManager_HDI_Compatibility_0150
1167 * @tc.name : UsbdBulkTransferReadwithLength003
1168 * @tc.desc : Test functions to BulkTransferReadwithLength(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1169 * std::vector<uint8_t> &data)
1170 * @tc.desc : Negative test: parameters exception, devAddr error
1171 * @tc.size : MediumTest
1172 * @tc.type : Function
1173 * @tc.level : Level 3
1174 */
1175 HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength003, Function | MediumTest | Level1)
1176 {
1177 struct UsbDev dev = dev_;
1178 uint8_t interfaceId = INTERFACEID_OK;
1179 uint8_t pointid = POINTID_BULK_IN;
1180 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1181 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength003 %{public}d ClaimInterface=%{public}d",
1182 __LINE__, ret);
1183 ASSERT_EQ(0, ret);
1184 dev.devAddr = DEV_ADDR_INVALID;
1185 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointid};
1186 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1187 ret = g_usbHostInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData);
1188 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength003 %{public}d ret=%{public}d", __LINE__, ret);
1189 ASSERT_NE(ret, 0);
1190 }
1191
1192 /**
1193 * @tc.number : SUB_USB_HostManager_HDI_Compatibility_0160
1194 * @tc.name : UsbdBulkTransferReadwithLength004
1195 * @tc.desc : Test functions to BulkTransferReadwithLength(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1196 * std::vector<uint8_t> &data)
1197 * @tc.desc : Negative test: parameters exception, intfId error
1198 * @tc.size : MediumTest
1199 * @tc.type : Function
1200 * @tc.level : Level 3
1201 */
1202 HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength004, Function | MediumTest | Level1)
1203 {
1204 struct UsbDev dev = dev_;
1205 uint8_t interfaceId = INTERFACEID_OK;
1206 uint8_t pointid = POINTID_BULK_IN;
1207 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1208 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength004 %{public}d ClaimInterface=%{public}d",
1209 __LINE__, ret);
1210 ASSERT_EQ(0, ret);
1211 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointid};
1212 pipe.intfId = PIPE_INTERFACEID_INVALID;
1213 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1214 ret = g_usbHostInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData);
1215 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength004 %{public}d ret=%{public}d", __LINE__, ret);
1216 ASSERT_NE(ret, 0);
1217 }
1218
1219 /**
1220 * @tc.number : SUB_USB_HostManager_HDI_Compatibility_0170
1221 * @tc.name : UsbdBulkTransferReadwithLength005
1222 * @tc.desc : Test functions to BulkTransferReadwithLength(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1223 * std::vector<uint8_t> &data)
1224 * @tc.desc : Negative test: parameters exception, endpointId error
1225 * @tc.size : MediumTest
1226 * @tc.type : Function
1227 * @tc.level : Level 3
1228 */
1229 HWTEST_F(UsbdTransferTest, UsbdBulkTransferReadwithLength005, Function | MediumTest | Level1)
1230 {
1231 struct UsbDev dev = dev_;
1232 uint8_t interfaceId = INTERFACEID_OK;
1233 uint8_t pointid = POINTID_BULK_IN;
1234 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1235 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1236 ASSERT_EQ(0, ret);
1237 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointid};
1238 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
1239 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1240 ret = g_usbHostInterface->BulkTransferReadwithLength(dev, pipe, TRANSFER_TIME_OUT, bufferData.size(), bufferData);
1241 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferReadwithLength005 %{public}d ret=%{public}d", __LINE__, ret);
1242 ASSERT_NE(ret, 0);
1243 }
1244
1245 /**
1246 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_1100
1247 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1248 * std::vector<uint8_t> &data);
1249 * @tc.desc: Positive test: parameters correctly
1250 * @tc.type: FUNC
1251 */
1252 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_1100, Function | MediumTest | Level1)
1253 {
1254 struct UsbDev dev = dev_;
1255 uint8_t interfaceId = INTERFACEID_OK;
1256 uint8_t pointId = POINTID_BULK_OUT;
1257 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1258 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_1100 "
1259 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1260 ASSERT_EQ(0, ret);
1261 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1262 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '1'};
1263 ret = g_usbHostInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1264 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_1100 "
1265 "%{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1266 ASSERT_EQ(0, ret);
1267 }
1268
1269 /**
1270 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2500
1271 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1272 * std::vector<uint8_t> &data);
1273 * @tc.desc: Negative test: parameters exception, busNum error
1274 * @tc.type: FUNC
1275 */
1276 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2500, Function | MediumTest | Level1)
1277 {
1278 struct UsbDev dev = dev_;
1279 uint8_t interfaceId = INTERFACEID_OK;
1280 uint8_t pointId = POINTID_BULK_OUT;
1281 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1282 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2500 "
1283 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1284 ASSERT_EQ(0, ret);
1285 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1286 dev.busNum = BUS_NUM_INVALID;
1287 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '2'};
1288 ret = g_usbHostInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1289 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2500 "
1290 "%{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1291 ASSERT_NE(ret, 0);
1292 }
1293
1294 /**
1295 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2600
1296 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1297 * std::vector<uint8_t> &data);
1298 * @tc.desc: Negative test: parameters exception, devAddr error
1299 * @tc.type: FUNC
1300 */
1301 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2600, Function | MediumTest | Level1)
1302 {
1303 struct UsbDev dev = dev_;
1304 uint8_t interfaceId = INTERFACEID_OK;
1305 uint8_t pointId = POINTID_BULK_OUT;
1306 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1307 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2600 "
1308 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1309 ASSERT_EQ(0, ret);
1310 dev.devAddr = DEV_ADDR_INVALID;
1311 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1312 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '3'};
1313 ret = g_usbHostInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1314 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2600 "
1315 "%{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1316 ASSERT_NE(ret, 0);
1317 }
1318
1319 /**
1320 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2700
1321 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1322 * std::vector<uint8_t> &data);
1323 * @tc.desc: Negative test: parameters exception, intfId error
1324 * @tc.type: FUNC
1325 */
1326 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2700, Function | MediumTest | Level1)
1327 {
1328 struct UsbDev dev = dev_;
1329 uint8_t interfaceId = INTERFACEID_OK;
1330 uint8_t pointId = POINTID_BULK_OUT;
1331 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1332 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2700 "
1333 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1334 ASSERT_EQ(0, ret);
1335 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1336 pipe.intfId = PIPE_INTERFACEID_INVALID;
1337 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '4'};
1338 ret = g_usbHostInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1339 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2700 "
1340 "%{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1341 ASSERT_NE(ret, 0);
1342 }
1343
1344 /**
1345 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2800
1346 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1347 * std::vector<uint8_t> &data);
1348 * @tc.desc: Negative test: parameters exception, endpointId error
1349 * @tc.type: FUNC
1350 */
1351 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2800, Function | MediumTest | Level1)
1352 {
1353 struct UsbDev dev = dev_;
1354 uint8_t interfaceId = INTERFACEID_OK;
1355 uint8_t pointId = POINTID_BULK_OUT;
1356 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1357 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2800 "
1358 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1359 ASSERT_EQ(0, ret);
1360 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1361 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
1362 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '5'};
1363 ret = g_usbHostInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1364 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2800 "
1365 "%{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1366 ASSERT_NE(ret, 0);
1367 }
1368
1369 /**
1370 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_2900
1371 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1372 * std::vector<uint8_t> &data);
1373 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
1374 * @tc.type: FUNC
1375 */
1376 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_2900, Function | MediumTest | Level1)
1377 {
1378 struct UsbDev dev = dev_;
1379 uint8_t interfaceId = INTERFACEID_OK;
1380 uint8_t pointId = POINTID_BULK_OUT;
1381 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1382 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2900 "
1383 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1384 ASSERT_EQ(0, ret);
1385 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1386 dev.busNum = BUS_NUM_INVALID;
1387 dev.devAddr = DEV_ADDR_INVALID;
1388 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '6'};
1389 ret = g_usbHostInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1390 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_2900 "
1391 "%{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1392 ASSERT_NE(ret, 0);
1393 }
1394
1395 /**
1396 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_3000
1397 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1398 * std::vector<uint8_t> &data);
1399 * @tc.desc: Negative test: parameters exception, ClaimInterface failed first
1400 * @tc.type: FUNC
1401 */
1402 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_3000, Function | MediumTest | Level1)
1403 {
1404 struct UsbDev dev = dev_;
1405 uint8_t interfaceId = INTERFACEID_OK;
1406 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
1407 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1408 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_3000 "
1409 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1410 ASSERT_EQ(0, ret);
1411 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1412 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '7'};
1413 ret = g_usbHostInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1414 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_3000 "
1415 "%{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1416 ASSERT_NE(ret, 0);
1417 }
1418
1419 /**
1420 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_3100
1421 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1422 * std::vector<uint8_t> &data);
1423 * @tc.desc: Positive test: parameters correctly, different in timeout
1424 * @tc.type: FUNC
1425 */
1426 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_3100, Function | MediumTest | Level1)
1427 {
1428 struct UsbDev dev = dev_;
1429 uint8_t interfaceId = INTERFACEID_OK;
1430 uint8_t pointId = POINTID_BULK_OUT;
1431 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1432 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_3100 "
1433 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1434 ASSERT_EQ(0, ret);
1435 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1436 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '8'};
1437 ret = g_usbHostInterface->BulkTransferWrite(dev, pipe, -1, bufferData);
1438 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_3100 "
1439 "%{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1440 ASSERT_EQ(0, ret);
1441 }
1442
1443 /**
1444 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_0500
1445 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1446 * std::vector<uint8_t> &data);
1447 * @tc.desc: Positive test: parameters correctly
1448 * @tc.type: FUNC
1449 */
1450 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_0500, Function | MediumTest | Level1)
1451 {
1452 struct UsbDev dev = dev_;
1453 uint8_t interfaceId = INTERFACEID_OK;
1454 uint8_t pointId = POINTID_BULK_IN;
1455 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1456 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0500 "
1457 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1458 ASSERT_EQ(0, ret);
1459 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1460 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1461 ret = g_usbHostInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1462 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0500 "
1463 "%{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1464 ASSERT_EQ(0, ret);
1465 }
1466
1467 /**
1468 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5000
1469 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1470 * std::vector<uint8_t> &data);
1471 * @tc.desc: Negative test: parameters exception, busNum error
1472 * @tc.type: FUNC
1473 */
1474 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5000, Function | MediumTest | Level1)
1475 {
1476 struct UsbDev dev = dev_;
1477 uint8_t interfaceId = INTERFACEID_OK;
1478 uint8_t pointId = POINTID_BULK_IN;
1479 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5000 "
1480 "%{public}d interfaceId=%{public}d", __LINE__, interfaceId);
1481 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1482 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5000 "
1483 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1484 ASSERT_EQ(0, ret);
1485 dev.busNum = BUS_NUM_INVALID;
1486 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1487 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1488 ret = g_usbHostInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1489 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5000 "
1490 "%{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1491 ASSERT_NE(ret, 0);
1492 }
1493
1494 /**
1495 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5100
1496 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1497 * std::vector<uint8_t> &data);
1498 * @tc.desc: Negative test: parameters exception, devAddr error
1499 * @tc.type: FUNC
1500 */
1501 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5100, Function | MediumTest | Level1)
1502 {
1503 struct UsbDev dev = dev_;
1504 uint8_t interfaceId = INTERFACEID_OK;
1505 uint8_t pointId = POINTID_BULK_IN;
1506 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1507 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5100 "
1508 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1509 ASSERT_EQ(0, ret);
1510 dev.devAddr = DEV_ADDR_INVALID;
1511 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1512 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1513 ret = g_usbHostInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1514 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5100 "
1515 "%{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1516 ASSERT_NE(ret, 0);
1517 }
1518
1519 /**
1520 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5200
1521 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1522 * std::vector<uint8_t> &data);
1523 * @tc.desc: Negative test: parameters exception, intfId error
1524 * @tc.type: FUNC
1525 */
1526 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5200, Function | MediumTest | Level1)
1527 {
1528 struct UsbDev dev = dev_;
1529 uint8_t interfaceId = INTERFACEID_OK;
1530 uint8_t pointId = POINTID_BULK_IN;
1531 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1532 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5200 "
1533 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1534 ASSERT_EQ(0, ret);
1535 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1536 pipe.intfId = PIPE_INTERFACEID_INVALID;
1537 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1538 ret = g_usbHostInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1539 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5200 "
1540 "%{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1541 ASSERT_NE(ret, 0);
1542 }
1543
1544 /**
1545 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5300
1546 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1547 * std::vector<uint8_t> &data);
1548 * @tc.desc: Negative test: parameters exception, endpointId error
1549 * @tc.type: FUNC
1550 */
1551 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5300, Function | MediumTest | Level1)
1552 {
1553 struct UsbDev dev = dev_;
1554 uint8_t interfaceId = INTERFACEID_OK;
1555 uint8_t pointId = POINTID_BULK_IN;
1556 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1557 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5300 "
1558 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1559 ASSERT_EQ(0, ret);
1560 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1561 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
1562 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1563 ret = g_usbHostInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1564 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5300 "
1565 "%{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
1566 ASSERT_NE(ret, 0);
1567 }
1568
1569 /**
1570 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_1200
1571 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1572 * std::vector<uint8_t> &data);
1573 * @tc.desc: Positive test: parameters correctly
1574 * @tc.type: FUNC
1575 */
1576 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_1200, Function | MediumTest | Level1)
1577 {
1578 struct UsbDev dev = dev_;
1579 uint8_t interfaceId = INTERFACEID_OK;
1580 uint8_t pointId = POINTID_BULK_OUT;
1581 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1582 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_1200 "
1583 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1584 ASSERT_EQ(0, ret);
1585 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1586 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '1'};
1587 ret = g_usbHostInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1588 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_1200 "
1589 "%{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1590 ASSERT_EQ(0, ret);
1591 }
1592
1593 /**
1594 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5400
1595 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1596 * std::vector<uint8_t> &data);
1597 * @tc.desc: Negative test: parameters exception, busNum error
1598 * @tc.type: FUNC
1599 */
1600 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5400, Function | MediumTest | Level1)
1601 {
1602 struct UsbDev dev = dev_;
1603 uint8_t interfaceId = INTERFACEID_OK;
1604 uint8_t pointId = POINTID_BULK_OUT;
1605 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1606 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5400 "
1607 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1608 ASSERT_EQ(0, ret);
1609 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1610 dev.busNum = BUS_NUM_INVALID;
1611 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '2'};
1612 ret = g_usbHostInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1613 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5400 "
1614 "%{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1615 ASSERT_NE(ret, 0);
1616 }
1617
1618 /**
1619 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5500
1620 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1621 * std::vector<uint8_t> &data);
1622 * @tc.desc: Negative test: parameters exception, devAddr error
1623 * @tc.type: FUNC
1624 */
1625 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5500, Function | MediumTest | Level1)
1626 {
1627 struct UsbDev dev = dev_;
1628 uint8_t interfaceId = INTERFACEID_OK;
1629 uint8_t pointId = POINTID_BULK_OUT;
1630 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1631 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5500 "
1632 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1633 ASSERT_EQ(0, ret);
1634 dev.devAddr = DEV_ADDR_INVALID;
1635 uint32_t length = 100;
1636 uint8_t buffer[100] = "hello world Iso writ03";
1637 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1638 std::vector<uint8_t> bufferData = { buffer, buffer + length };
1639 ret = g_usbHostInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1640 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5500 "
1641 "%{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1642 ASSERT_NE(ret, 0);
1643 }
1644
1645 /**
1646 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5600
1647 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1648 * std::vector<uint8_t> &data);
1649 * @tc.desc: Negative test: parameters exception, intfId error
1650 * @tc.type: FUNC
1651 */
1652 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5600, Function | MediumTest | Level1)
1653 {
1654 struct UsbDev dev = dev_;
1655 uint8_t interfaceId = INTERFACEID_OK;
1656 uint8_t pointId = POINTID_BULK_OUT;
1657 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1658 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5600 "
1659 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1660 ASSERT_EQ(0, ret);
1661 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1662 pipe.intfId = PIPE_INTERFACEID_INVALID;
1663 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '4'};
1664 ret = g_usbHostInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1665 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5600 "
1666 "%{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1667 ASSERT_NE(ret, 0);
1668 }
1669
1670 /**
1671 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5700
1672 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1673 * std::vector<uint8_t> &data);
1674 * @tc.desc: Negative test: parameters exception, endpointId error
1675 * @tc.type: FUNC
1676 */
1677 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5700, Function | MediumTest | Level1)
1678 {
1679 struct UsbDev dev = dev_;
1680 uint8_t interfaceId = INTERFACEID_OK;
1681 uint8_t pointId = POINTID_BULK_OUT;
1682 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1683 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5700 "
1684 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1685 ASSERT_EQ(0, ret);
1686 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1687 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
1688 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '5'};
1689 ret = g_usbHostInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1690 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5700 "
1691 "%{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1692 ASSERT_NE(ret, 0);
1693 }
1694
1695 /**
1696 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5800
1697 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1698 * std::vector<uint8_t> &data);
1699 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
1700 * @tc.type: FUNC
1701 */
1702 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5800, Function | MediumTest | Level1)
1703 {
1704 struct UsbDev dev = dev_;
1705 uint8_t interfaceId = INTERFACEID_OK;
1706 uint8_t pointId = POINTID_BULK_OUT;
1707 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1708 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5800 "
1709 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1710 ASSERT_EQ(0, ret);
1711 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1712 dev.busNum = BUS_NUM_INVALID;
1713 dev.devAddr = DEV_ADDR_INVALID;
1714 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '6'};
1715 ret = g_usbHostInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1716 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5800 "
1717 "%{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1718 ASSERT_NE(ret, 0);
1719 }
1720
1721 /**
1722 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_5900
1723 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1724 * std::vector<uint8_t> &data);
1725 * @tc.desc: Negative test: parameters exception, endpointId error, ClaimInterface failed first
1726 * @tc.type: FUNC
1727 */
1728 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_5900, Function | MediumTest | Level1)
1729 {
1730 struct UsbDev dev = dev_;
1731 uint8_t interfaceId = INTERFACEID_OK;
1732 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
1733 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1734 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5900 "
1735 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1736 ASSERT_EQ(0, ret);
1737 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1738 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '7'};
1739 ret = g_usbHostInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1740 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_5900 "
1741 "%{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1742 ASSERT_NE(ret, 0);
1743 }
1744
1745 /**
1746 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_6000
1747 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1748 * std::vector<uint8_t> &data);
1749 * @tc.desc: Positive test: parameters correctly, different in timeout
1750 * @tc.type: FUNC
1751 */
1752 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_6000, Function | MediumTest | Level1)
1753 {
1754 struct UsbDev dev = dev_;
1755 uint8_t interfaceId = INTERFACEID_OK;
1756 uint8_t pointId = POINTID_BULK_OUT;
1757 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1758 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6000 "
1759 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1760 ASSERT_EQ(0, ret);
1761 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1762 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '8'};
1763 ret = g_usbHostInterface->IsoTransferWrite(dev, pipe, -1, bufferData);
1764 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_6000 "
1765 "%{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1766 ASSERT_EQ(0, ret);
1767 }
1768
1769 /**
1770 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_0800
1771 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1772 * @tc.desc: Positive test: parameters correctly
1773 * @tc.type: FUNC
1774 */
1775 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_0800, Function | MediumTest | Level1)
1776 {
1777 sptr<Ashmem> ashmem;
1778 uint8_t rflg = 0;
1779 int32_t asmSize = ASHMEM_MAX_SIZE;
1780 struct UsbDev dev = dev_;
1781 uint8_t interfaceId = INTERFACEID_OK;
1782 uint8_t pointId = POINTID_BULK_OUT;
1783 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1784
1785 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1786 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0800 "
1787 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1788 ASSERT_EQ(0, ret);
1789 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1790 if (usbdBulkCallback == nullptr) {
1791 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1792 exit(0);
1793 }
1794 ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1795 (void)InitAshmemOne(ashmem, asmSize, rflg);
1796 ret = g_usbHostInterface->BulkWrite(dev, pipe, ashmem);
1797 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0800 "
1798 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
1799 ASSERT_EQ(ret, 0);
1800 }
1801
1802 /**
1803 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_8500
1804 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1805 * @tc.desc: Negative test: parameters exception, busNum error
1806 * @tc.type: FUNC
1807 */
1808 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_8500, Function | MediumTest | Level1)
1809 {
1810 sptr<Ashmem> ashmem;
1811 uint8_t rflg = 0;
1812 int32_t asmSize = MAX_BUFFER_LENGTH;
1813 struct UsbDev dev = dev_;
1814 uint8_t interfaceId = INTERFACEID_OK;
1815 uint8_t pointId = POINTID_BULK_OUT;
1816 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1817 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8500 "
1818 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1819 ASSERT_EQ(0, ret);
1820 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1821 dev.busNum = BUS_NUM_INVALID;
1822 (void)InitAshmemOne(ashmem, asmSize, rflg);
1823 ret = g_usbHostInterface->BulkWrite(dev, pipe, ashmem);
1824 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8500 "
1825 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
1826 ASSERT_NE(ret, 0);
1827 }
1828
1829 /**
1830 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_8600
1831 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1832 * @tc.desc: Negative test: parameters exception, devAddr error
1833 * @tc.type: FUNC
1834 */
1835 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_8600, Function | MediumTest | Level1)
1836 {
1837 sptr<Ashmem> ashmem;
1838 uint8_t rflg = 0;
1839 int32_t asmSize = MAX_BUFFER_LENGTH;
1840 struct UsbDev dev = dev_;
1841 uint8_t interfaceId = INTERFACEID_OK;
1842 uint8_t pointId = POINTID_BULK_OUT;
1843 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1844 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8600 "
1845 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1846 ASSERT_EQ(0, ret);
1847 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1848 dev.devAddr = DEV_ADDR_INVALID;
1849 (void)InitAshmemOne(ashmem, asmSize, rflg);
1850 ret = g_usbHostInterface->BulkWrite(dev, pipe, ashmem);
1851 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8600 "
1852 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
1853 ASSERT_NE(ret, 0);
1854 }
1855
1856 /**
1857 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_8700
1858 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1859 * @tc.desc: Negative test: parameters exception, intfId error
1860 * @tc.type: FUNC
1861 */
1862 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_8700, Function | MediumTest | Level1)
1863 {
1864 sptr<Ashmem> ashmem;
1865 uint8_t rflg = 0;
1866 int32_t asmSize = MAX_BUFFER_LENGTH;
1867 struct UsbDev dev = dev_;
1868 uint8_t interfaceId = INTERFACEID_OK;
1869 uint8_t pointId = POINTID_BULK_OUT;
1870 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1871 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8700 "
1872 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1873 ASSERT_EQ(0, ret);
1874 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1875 pipe.intfId = PIPE_INTERFACEID_INVALID;
1876 (void)InitAshmemOne(ashmem, asmSize, rflg);
1877 ret = g_usbHostInterface->BulkWrite(dev, pipe, ashmem);
1878 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8700 "
1879 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
1880 ASSERT_NE(ret, 0);
1881 }
1882
1883 /**
1884 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_8800
1885 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1886 * @tc.desc: Negative test: parameters exception, endpointId error
1887 * @tc.type: FUNC
1888 */
1889 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_8800, Function | MediumTest | Level1)
1890 {
1891 sptr<Ashmem> ashmem;
1892 uint8_t rflg = 0;
1893 int32_t asmSize = MAX_BUFFER_LENGTH;
1894 struct UsbDev dev = dev_;
1895 uint8_t interfaceId = INTERFACEID_OK;
1896 uint8_t pointId = POINTID_BULK_OUT;
1897 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1898 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8800 "
1899 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1900 ASSERT_EQ(0, ret);
1901 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1902 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
1903 (void)InitAshmemOne(ashmem, asmSize, rflg);
1904 ret = g_usbHostInterface->BulkWrite(dev, pipe, ashmem);
1905 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8800 "
1906 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
1907 ASSERT_NE(ret, 0);
1908 }
1909
1910 /**
1911 * @tc.name: SUB_USB_HostManager_HDI_TranFunc_0900
1912 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1913 * @tc.desc: Positive test: parameters correctly
1914 * @tc.type: FUNC
1915 */
1916 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranFunc_0900, Function | MediumTest | Level1)
1917 {
1918 sptr<Ashmem> ashmem;
1919 uint8_t rflg = 0;
1920 int32_t asmSize = MAX_BUFFER_LENGTH;
1921 struct UsbDev dev = dev_;
1922 uint8_t interfaceId = INTERFACEID_OK;
1923 uint8_t pointId = POINTID_BULK_IN;
1924 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1925 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0900 "
1926 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1927 ASSERT_EQ(0, ret);
1928 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1929 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1930 if (usbdBulkCallback == nullptr) {
1931 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1932 exit(0);
1933 }
1934 ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1935 (void)InitAshmemOne(ashmem, asmSize, rflg);
1936 ret = g_usbHostInterface->BulkRead(dev, pipe, ashmem);
1937 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranFunc_0900 "
1938 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
1939 ASSERT_EQ(ret, 0);
1940 }
1941
1942 /**
1943 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_8900
1944 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1945 * @tc.desc: Negative test: parameters exception, busNum error
1946 * @tc.type: FUNC
1947 */
1948 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_8900, Function | MediumTest | Level1)
1949 {
1950 sptr<Ashmem> ashmem;
1951 uint8_t rflg = 0;
1952 int32_t asmSize = MAX_BUFFER_LENGTH;
1953 struct UsbDev dev = dev_;
1954 uint8_t interfaceId = INTERFACEID_OK;
1955 uint8_t pointId = POINTID_BULK_OUT;
1956 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1957 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8900 "
1958 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1959 ASSERT_EQ(0, ret);
1960 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1961 dev.busNum = BUS_NUM_INVALID;
1962 (void)InitAshmemOne(ashmem, asmSize, rflg);
1963 ret = g_usbHostInterface->BulkRead(dev, pipe, ashmem);
1964 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_8900 "
1965 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
1966 ASSERT_NE(ret, 0);
1967 }
1968
1969 /**
1970 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_9000
1971 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1972 * @tc.desc: Negative test: parameters exception, devAddr error
1973 * @tc.type: FUNC
1974 */
1975 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_9000, Function | MediumTest | Level1)
1976 {
1977 sptr<Ashmem> ashmem;
1978 uint8_t rflg = 0;
1979 int32_t asmSize = MAX_BUFFER_LENGTH;
1980 struct UsbDev dev = dev_;
1981 uint8_t interfaceId = INTERFACEID_OK;
1982 uint8_t pointId = POINTID_BULK_OUT;
1983 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
1984 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_9000 "
1985 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
1986 ASSERT_EQ(0, ret);
1987 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
1988 dev.devAddr = DEV_ADDR_INVALID;
1989 (void)InitAshmemOne(ashmem, asmSize, rflg);
1990 ret = g_usbHostInterface->BulkRead(dev, pipe, ashmem);
1991 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_9000 "
1992 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
1993 ASSERT_NE(ret, 0);
1994 }
1995
1996 /**
1997 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_9100
1998 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1999 * @tc.desc: Negative test: parameters exception, intfId error
2000 * @tc.type: FUNC
2001 */
2002 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_9100, Function | MediumTest | Level1)
2003 {
2004 sptr<Ashmem> ashmem;
2005 uint8_t rflg = 0;
2006 int32_t asmSize = MAX_BUFFER_LENGTH;
2007 struct UsbDev dev = dev_;
2008 uint8_t interfaceId = INTERFACEID_OK;
2009 uint8_t pointId = POINTID_BULK_OUT;
2010 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
2011 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_9100 "
2012 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
2013 ASSERT_EQ(0, ret);
2014 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
2015 pipe.intfId = PIPE_INTERFACEID_INVALID;
2016 (void)InitAshmemOne(ashmem, asmSize, rflg);
2017 ret = g_usbHostInterface->BulkRead(dev, pipe, ashmem);
2018 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_9100 "
2019 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
2020 ASSERT_NE(ret, 0);
2021 }
2022
2023 /**
2024 * @tc.name: SUB_USB_HostManager_HDI_TranCompatibility_9200
2025 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
2026 * @tc.desc: Negative test: parameters exception, endpointId error
2027 * @tc.type: FUNC
2028 */
2029 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_TranCompatibility_9200, Function | MediumTest | Level1)
2030 {
2031 sptr<Ashmem> ashmem;
2032 uint8_t rflg = 0;
2033 int32_t asmSize = MAX_BUFFER_LENGTH;
2034 struct UsbDev dev = dev_;
2035 uint8_t interfaceId = INTERFACEID_OK;
2036 uint8_t pointId = POINTID_BULK_OUT;
2037 auto ret = g_usbHostInterface->ClaimInterface(dev, interfaceId, 1);
2038 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_9200 "
2039 "%{public}d ClaimInterface=%{public}d", __LINE__, ret);
2040 ASSERT_EQ(0, ret);
2041 OHOS::HDI::Usb::V2_0::UsbPipe pipe = { interfaceId, pointId };
2042 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
2043 (void)InitAshmemOne(ashmem, asmSize, rflg);
2044 ret = g_usbHostInterface->BulkRead(dev, pipe, ashmem);
2045 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_TranCompatibility_9200 "
2046 "%{public}d BulkWrite=%{public}d", __LINE__, ret);
2047 ASSERT_NE(ret, 0);
2048 }
2049
2050 /**
2051 * @tc.name: SUB_USB_HostManager_HDI_Func_1200
2052 * @tc.desc: Test functions to RegBulkCallback
2053 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
2054 * @tc.desc: Positive test: parameters correctly
2055 * @tc.type: FUNC
2056 */
2057 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Func_1200, Function | MediumTest | Level1)
2058 {
2059 struct UsbDev dev = dev_;
2060 uint8_t interfaceId = INTERFACEID_OK;
2061 uint8_t pointId = POINTID_BULK_OUT;
2062 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2063 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
2064 if (usbdBulkCallback == nullptr) {
2065 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
2066 exit(0);
2067 }
2068 auto ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
2069 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Func_1200 "
2070 "%{public}d RegBulkCallback=%{public}d", __LINE__, ret);
2071 ASSERT_EQ(ret, 0);
2072 }
2073
2074 /**
2075 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6200
2076 * @tc.desc: Test functions to RegBulkCallback
2077 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
2078 * @tc.desc: Negative test: parameters exception, busNum error
2079 * @tc.type: FUNC
2080 */
2081 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6200, Function | MediumTest | Level1)
2082 {
2083 struct UsbDev dev = dev_;
2084 uint8_t interfaceId = INTERFACEID_OK;
2085 uint8_t pointId = POINTID_BULK_OUT;
2086 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2087 dev.busNum = BUS_NUM_INVALID;
2088 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
2089 if (usbdBulkCallback == nullptr) {
2090 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
2091 exit(0);
2092 }
2093 auto ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
2094 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6200 "
2095 "%{public}d RegBulkCallback=%{public}d", __LINE__, ret);
2096 ASSERT_NE(ret, 0);
2097 }
2098
2099 /**
2100 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6300
2101 * @tc.desc: Test functions to RegBulkCallback
2102 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
2103 * @tc.desc: Negative test: parameters exception, devAddr error
2104 * @tc.type: FUNC
2105 */
2106 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6300, Function | MediumTest | Level1)
2107 {
2108 struct UsbDev dev = dev_;
2109 uint8_t interfaceId = INTERFACEID_OK;
2110 uint8_t pointId = POINTID_BULK_OUT;
2111 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2112 dev.devAddr = DEV_ADDR_INVALID;
2113 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
2114 if (usbdBulkCallback == nullptr) {
2115 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
2116 exit(0);
2117 }
2118 auto ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
2119 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6300 "
2120 "%{public}d RegBulkCallback=%{public}d", __LINE__, ret);
2121 ASSERT_NE(ret, 0);
2122 }
2123
2124 /**
2125 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6400
2126 * @tc.desc: Test functions to RegBulkCallback
2127 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
2128 * @tc.desc: Negative test: parameters exception, intfId error
2129 * @tc.type: FUNC
2130 */
2131 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6400, Function | MediumTest | Level1)
2132 {
2133 struct UsbDev dev = dev_;
2134 uint8_t interfaceId = INTERFACEID_OK;
2135 uint8_t pointId = POINTID_BULK_OUT;
2136 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2137 dev.devAddr = DEV_ADDR_INVALID;
2138 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
2139 if (usbdBulkCallback == nullptr) {
2140 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
2141 exit(0);
2142 }
2143 auto ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
2144 HDF_LOGI("UsbdTransferTest::RegBulkCallback004 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
2145 ASSERT_NE(ret, 0);
2146 }
2147
2148 /**
2149 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6500
2150 * @tc.desc: Test functions to RegBulkCallback
2151 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
2152 * @tc.desc: Negative test: parameters exception, cb error
2153 * @tc.type: FUNC
2154 */
2155 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6500, Function | MediumTest | Level1)
2156 {
2157 struct UsbDev dev = dev_;
2158 uint8_t interfaceId = INTERFACEID_OK;
2159 uint8_t pointId = POINTID_BULK_OUT;
2160 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2161 auto ret = g_usbHostInterface->RegBulkCallback(dev, pipe, nullptr);
2162 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6500 "
2163 "%{public}d RegBulkCallback=%{public}d", __LINE__, ret);
2164 ASSERT_NE(ret, 0);
2165 }
2166
2167 /**
2168 * @tc.name: SUB_USB_HostManager_HDI_Func_1300
2169 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
2170 * @tc.desc: Positive test: parameters correctly
2171 * @tc.type: FUNC
2172 */
2173 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Func_1300, Function | MediumTest | Level1)
2174 {
2175 struct UsbDev dev = dev_;
2176 uint8_t interfaceId = INTERFACEID_OK;
2177 uint8_t pointId = POINTID_BULK_OUT;
2178 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2179 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
2180 if (usbdBulkCallback == nullptr) {
2181 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
2182 exit(0);
2183 }
2184 auto ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
2185 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Func_1300 "
2186 "%{public}d RegBulkCallback=%{public}d", __LINE__, ret);
2187 ASSERT_EQ(ret, 0);
2188 ret = g_usbHostInterface->UnRegBulkCallback(dev, pipe);
2189 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Func_1300 "
2190 "%{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
2191 ASSERT_EQ(ret, 0);
2192 }
2193
2194 /**
2195 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6600
2196 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
2197 * @tc.desc: Negative test: parameters exception, devAddr error
2198 * @tc.type: FUNC
2199 */
2200 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6600, Function | MediumTest | Level1)
2201 {
2202 struct UsbDev dev = dev_;
2203 uint8_t interfaceId = INTERFACEID_OK;
2204 uint8_t pointId = POINTID_BULK_OUT;
2205 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2206 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
2207 if (usbdBulkCallback == nullptr) {
2208 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
2209 exit(0);
2210 }
2211 auto ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
2212 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6600 "
2213 "%{public}d RegBulkCallback=%{public}d", __LINE__, ret);
2214 ASSERT_EQ(ret, 0);
2215 dev.devAddr = DEV_ADDR_INVALID;
2216 ret = g_usbHostInterface->UnRegBulkCallback(dev, pipe);
2217 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6600 "
2218 "%{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
2219 ASSERT_NE(ret, 0);
2220 dev = dev_;
2221 ret = g_usbHostInterface->UnRegBulkCallback(dev, pipe);
2222 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6600 "
2223 "%{public}d again UnRegBulkCallback=%{public}d", __LINE__, ret);
2224 ASSERT_EQ(ret, 0);
2225 }
2226
2227 /**
2228 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6700
2229 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
2230 * @tc.desc: Negative test: parameters exception, intfId error
2231 * @tc.type: FUNC
2232 */
2233 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6700, Function | MediumTest | Level1)
2234 {
2235 struct UsbDev dev = dev_;
2236 uint8_t interfaceId = INTERFACEID_OK;
2237 uint8_t pointId = POINTID_BULK_OUT;
2238 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2239 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
2240 if (usbdBulkCallback == nullptr) {
2241 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
2242 exit(0);
2243 }
2244 auto ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
2245 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6700 "
2246 "%{public}d RegBulkCallback=%{public}d", __LINE__, ret);
2247 ASSERT_EQ(ret, 0);
2248 dev.devAddr = DEV_ADDR_INVALID;
2249 ret = g_usbHostInterface->UnRegBulkCallback(dev, pipe);
2250 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6700 "
2251 "%{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
2252 ASSERT_NE(ret, 0);
2253 dev = dev_;
2254 ret = g_usbHostInterface->UnRegBulkCallback(dev, pipe);
2255 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6700 "
2256 "%{public}d again UnRegBulkCallback=%{public}d", __LINE__, ret);
2257 ASSERT_EQ(ret, 0);
2258 }
2259
2260 /**
2261 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6800
2262 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
2263 * @tc.desc: Positive test: call again
2264 * @tc.type: FUNC
2265 */
2266 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6800, Function | MediumTest | Level1)
2267 {
2268 struct UsbDev dev = dev_;
2269 uint8_t interfaceId = INTERFACEID_OK;
2270 uint8_t pointId = POINTID_BULK_OUT;
2271 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2272 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
2273 if (usbdBulkCallback == nullptr) {
2274 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
2275 exit(0);
2276 }
2277 auto ret = g_usbHostInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
2278 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6800 "
2279 "%{public}d RegBulkCallback=%{public}d", __LINE__, ret);
2280 ASSERT_EQ(ret, 0);
2281 ret = g_usbHostInterface->UnRegBulkCallback(dev, pipe);
2282 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6800 "
2283 "%{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
2284 ASSERT_EQ(ret, 0);
2285 ret = g_usbHostInterface->UnRegBulkCallback(dev, pipe);
2286 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6800 "
2287 "%{public}d again UnRegBulkCallback=%{public}d", __LINE__, ret);
2288 ASSERT_EQ(ret, 0);
2289 }
2290
2291 /**
2292 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6900
2293 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
2294 * @tc.desc: Positive test: no register
2295 * @tc.type: FUNC
2296 */
2297 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6900, Function | MediumTest | Level1)
2298 {
2299 struct UsbDev dev = dev_;
2300 uint8_t interfaceId = INTERFACEID_OK;
2301 uint8_t pointId = POINTID_BULK_OUT;
2302 OHOS::HDI::Usb::V2_0::UsbPipe pipe = {interfaceId, pointId};
2303 auto ret = g_usbHostInterface->UnRegBulkCallback(dev, pipe);
2304 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback005 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
2305 ASSERT_EQ(ret, 0);
2306 }
2307
2308 /**
2309 * @tc.name: SUB_USB_HostManager_HDI_Func_1000
2310 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2311 * @tc.desc: Positive test: parameters correctly
2312 * @tc.type: FUNC
2313 */
2314 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Func_1000, Function | MediumTest | Level1)
2315 {
2316 subscriber_ = new UsbSubscriberTest();
2317 if (subscriber_ == nullptr) {
2318 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2319 exit(0);
2320 }
2321 auto ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2322 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Func_1000 "
2323 "%{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
2324 ASSERT_EQ(0, ret);
2325 }
2326
2327 /**
2328 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5400
2329 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2330 * @tc.desc: Positive test: bind different
2331 * @tc.type: FUNC
2332 */
2333 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_5400, Function | MediumTest | Level1)
2334 {
2335 subscriber_ = new UsbSubscriberTest();
2336 if (subscriber_ == nullptr) {
2337 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2338 exit(0);
2339 }
2340 auto ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2341 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5400 "
2342 "%{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
2343 ASSERT_EQ(0, ret);
2344 sptr<UsbSubscriberTest> subscriber2 = new UsbSubscriberTest();
2345 if (subscriber_ == nullptr) {
2346 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2347 exit(0);
2348 }
2349 ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber2);
2350 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5400 "
2351 "%{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret);
2352 ASSERT_EQ(0, ret);
2353 }
2354
2355 /**
2356 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5500
2357 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2358 * @tc.desc: Positive test: bind same
2359 * @tc.type: FUNC
2360 */
2361 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_5500, Function | MediumTest | Level1)
2362 {
2363 subscriber_ = new UsbSubscriberTest();
2364 if (subscriber_ == nullptr) {
2365 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2366 exit(0);
2367 }
2368 auto ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2369 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5500 "
2370 "%{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
2371 ASSERT_EQ(0, ret);
2372 ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2373 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5500 "
2374 "%{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret);
2375 ASSERT_EQ(0, ret);
2376 }
2377
2378 /**
2379 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5600
2380 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2381 * @tc.desc: Positive test: bind and unbind, then bind another
2382 * @tc.type: FUNC
2383 */
2384 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_5600, Function | MediumTest | Level1)
2385 {
2386 subscriber_ = new UsbSubscriberTest();
2387 if (subscriber_ == nullptr) {
2388 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2389 exit(0);
2390 }
2391 auto ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2392 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5600 "
2393 "%{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
2394 ASSERT_EQ(0, ret);
2395 ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2396 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5600 "
2397 "%{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2398 ASSERT_EQ(0, ret);
2399 sptr<UsbSubscriberTest> subscriber2 = new UsbSubscriberTest();
2400 if (subscriber_ == nullptr) {
2401 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2402 exit(0);
2403 }
2404 ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber2);
2405 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5600 "
2406 "again %{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
2407 ASSERT_EQ(0, ret);
2408 }
2409
2410 /**
2411 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5700
2412 * @tc.desc: Test functions to int32_t BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2413 * @tc.desc: Positive test: bind again after unbind
2414 * @tc.type: FUNC
2415 */
2416 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_5700, Function | MediumTest | Level1)
2417 {
2418 subscriber_ = new UsbSubscriberTest();
2419 if (subscriber_ == nullptr) {
2420 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2421 exit(0);
2422 }
2423 auto ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2424 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5700 "
2425 "%{public}d BindUsbdSubscriber=%{public}d", __LINE__, ret);
2426 ASSERT_EQ(0, ret);
2427 ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2428 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5700 "
2429 "%{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2430 ASSERT_EQ(0, ret);
2431 ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2432 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5700 "
2433 "%{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret);
2434 ASSERT_EQ(0, ret);
2435 }
2436
2437 /**
2438 * @tc.name: SUB_USB_HostManager_HDI_Func_1100
2439 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2440 * @tc.desc: Positive test: parameters correctly
2441 * @tc.type: FUNC
2442 */
2443 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Func_1100, Function | MediumTest | Level1)
2444 {
2445 subscriber_ = new UsbSubscriberTest();
2446 if (subscriber_ == nullptr) {
2447 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2448 exit(0);
2449 }
2450 auto ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2451 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Func_1100 "
2452 "%{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret);
2453 ASSERT_EQ(0, ret);
2454 ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2455 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Func_1100 "
2456 "%{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2457 ASSERT_EQ(0, ret);
2458 }
2459
2460 /**
2461 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5800
2462 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2463 * @tc.desc: Negative test: no bind first
2464 * @tc.type: FUNC
2465 */
2466 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_5800, Function | MediumTest | Level1)
2467 {
2468 subscriber_ = new UsbSubscriberTest();
2469 if (subscriber_ == nullptr) {
2470 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2471 exit(0);
2472 }
2473 auto ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2474 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5800 "
2475 "%{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2476 ASSERT_NE(0, ret);
2477 }
2478
2479 /**
2480 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_5900
2481 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2482 * @tc.desc: Positive test: no bind first, unbind failed; then bind, unbind success
2483 * @tc.type: FUNC
2484 */
2485 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_5900, Function | MediumTest | Level1)
2486 {
2487 subscriber_ = new UsbSubscriberTest();
2488 if (subscriber_ == nullptr) {
2489 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2490 exit(0);
2491 }
2492 auto ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2493 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5900 "
2494 "%{public}d UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2495 ASSERT_NE(0, ret);
2496 ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2497 HDF_LOGI(
2498 "UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5900 %{public}d first BindUsbdSubscriber=%{public}d",
2499 __LINE__, ret);
2500 ASSERT_EQ(0, ret);
2501 ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2502 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_5900 "
2503 "%{public}d again UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2504 ASSERT_EQ(0, ret);
2505 }
2506
2507 /**
2508 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6000
2509 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2510 * @tc.desc: Negative test: call twice
2511 * @tc.type: FUNC
2512 */
2513 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6000, Function | MediumTest | Level1)
2514 {
2515 subscriber_ = new UsbSubscriberTest();
2516 if (subscriber_ == nullptr) {
2517 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2518 exit(0);
2519 }
2520 auto ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2521 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6000 "
2522 "%{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret);
2523 ASSERT_EQ(0, ret);
2524 ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2525 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6000 "
2526 "%{public}d first UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2527 ASSERT_EQ(0, ret);
2528 ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2529 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6000 "
2530 "%{public}d again UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2531 ASSERT_NE(0, ret);
2532 }
2533
2534 /**
2535 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_6100
2536 * @tc.desc: Test functions to int32_t UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2537 * @tc.desc: Positive test: test repeatedly
2538 * @tc.type: FUNC
2539 */
2540 HWTEST_F(UsbdTransferTest, SUB_USB_HostManager_HDI_Compatibility_6100, Function | MediumTest | Level1)
2541 {
2542 subscriber_ = new UsbSubscriberTest();
2543 if (subscriber_ == nullptr) {
2544 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
2545 exit(0);
2546 }
2547 auto ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2548 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6100 "
2549 "%{public}d first BindUsbdSubscriber=%{public}d", __LINE__, ret);
2550 ASSERT_EQ(0, ret);
2551 ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2552 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6100 "
2553 "%{public}d first UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2554 ASSERT_EQ(0, ret);
2555 ret = g_usbHostInterface->BindUsbdHostSubscriber(subscriber_);
2556 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6100 "
2557 "%{public}d again BindUsbdSubscriber=%{public}d", __LINE__, ret);
2558 ASSERT_EQ(0, ret);
2559 ret = g_usbHostInterface->UnbindUsbdHostSubscriber(subscriber_);
2560 HDF_LOGI("UsbdTransferTest::SUB_USB_HostManager_HDI_Compatibility_6100 "
2561 "%{public}d again UnbindUsbdSubscriber=%{public}d", __LINE__, ret);
2562 ASSERT_EQ(0, ret);
2563 }
2564 } // namespace
2565