1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <iostream>
16 #include <vector>
17
18 #include "hdf_log.h"
19 #include "securec.h"
20 #include "usbd_transfer_test.h"
21 #include "v1_0/iusb_interface.h"
22 #include "v1_0/usb_types.h"
23
24 const int SLEEP_TIME = 3;
25 const uint32_t MAX_BUFFER_LENGTH = 255;
26 const uint8_t SAMPLE_DATA_1 = 1;
27 const uint8_t SAMPLE_DATA_2 = 2;
28 const uint8_t SAMPLE_DATA_3 = 3;
29 const int32_t TRANSFER_TIME_OUT = 1000;
30 const int32_t CTL_VALUE = 0x100;
31
32 using namespace testing::ext;
33 using namespace OHOS;
34 using namespace OHOS::USB;
35 using namespace std;
36 using namespace OHOS::HDI::Usb::V1_0;
37
38 UsbDev UsbdTransferTestAdditional::dev_ = {0, 0};
39 sptr<UsbSubscriberTest> UsbdTransferTestAdditional::subscriber_ = nullptr;
40
41 namespace {
42 sptr<IUsbInterface> g_usbInterface = nullptr;
43
SwitchErrCode(int32_t ret)44 int32_t SwitchErrCode(int32_t ret)
45 {
46 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
47 }
48
SetUpTestCase(void)49 void UsbdTransferTestAdditional::SetUpTestCase(void)
50 {
51 g_usbInterface = IUsbInterface::Get();
52 if (g_usbInterface == nullptr) {
53 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
54 exit(0);
55 }
56 const int32_t DEFAULT_PORT_ID = 1;
57 const int32_t DEFAULT_ROLE_HOST = 1;
58 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, DEFAULT_ROLE_HOST, DEFAULT_ROLE_HOST);
59 sleep(SLEEP_TIME);
60 HDF_LOGI("UsbdTransferTestAdditional::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
61 ret = SwitchErrCode(ret);
62 ASSERT_EQ(0, ret);
63 if (ret != 0) {
64 exit(0);
65 }
66
67 subscriber_ = new UsbSubscriberTest();
68 if (subscriber_ == nullptr) {
69 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
70 exit(0);
71 }
72 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
73 HDF_LOGE("%{public}s: bind usbd subscriber_ failed\n", __func__);
74 exit(0);
75 }
76
77 std::cout << "please connect device, press enter to continue" << std::endl;
78 int c;
79 while ((c = getchar()) != '\n' && c != EOF) {
80 }
81
82 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
83 ret = g_usbInterface->OpenDevice(dev_);
84 HDF_LOGI("UsbdTransferTestAdditional:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
85 ASSERT_EQ(0, ret);
86 }
87
TearDownTestCase(void)88 void UsbdTransferTestAdditional::TearDownTestCase(void)
89 {
90 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
91 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
92 auto ret = g_usbInterface->CloseDevice(dev_);
93 HDF_LOGI("UsbdTransferTestAdditional:: %{public}d Close=%{public}d", __LINE__, ret);
94 ASSERT_EQ(0, ret);
95 }
96
SetUp(void)97 void UsbdTransferTestAdditional::SetUp(void) {}
98
TearDown(void)99 void UsbdTransferTestAdditional::TearDown(void) {}
100
101 /**
102 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_2100
103 * @tc.name: testHdiUsbTransferTestControlTransferWrite001
104 * @tc.desc: Performs control transfer for endpoint 0 of the device.
105 * dev = (0,255). ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, 0, 0, TRANSFER_TIME_OUT).
106 */
107 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite001, TestSize.Level2)
108 {
109 struct UsbDev dev = {0, 255};
110 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
111 bufferData.push_back(SAMPLE_DATA_1);
112 bufferData.push_back(SAMPLE_DATA_2);
113 bufferData.push_back(SAMPLE_DATA_3);
114 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, 0, 0, TRANSFER_TIME_OUT};
115 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
116 ASSERT_NE(ret, 0);
117 }
118
119 /**
120 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_2200
121 * @tc.name: testHdiUsbTransferTestControlTransferWrite002
122 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,255).
123 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR, 0, 0, TRANSFER_TIME_OUT).
124 */
125 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite002, TestSize.Level2)
126 {
127 struct UsbDev dev = {0, 255};
128 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
129 bufferData.push_back(SAMPLE_DATA_1);
130 bufferData.push_back(SAMPLE_DATA_2);
131 bufferData.push_back(SAMPLE_DATA_3);
132 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR,
133 0, 0, TRANSFER_TIME_OUT};
134 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
135 ASSERT_NE(ret, 0);
136 }
137
138 /**
139 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_2300
140 * @tc.name: testHdiUsbTransferTestControlTransferWrite003
141 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,255).
142 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_CONFIGURATION, 0, 0,
143 * TRANSFER_TIME_OUT).
144 */
145 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite003, TestSize.Level2)
146 {
147 struct UsbDev dev = {0, 255};
148 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
149 bufferData.push_back(SAMPLE_DATA_1);
150 bufferData.push_back(SAMPLE_DATA_2);
151 bufferData.push_back(SAMPLE_DATA_3);
152 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE,
153 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
154 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
155 ASSERT_NE(ret, 0);
156 }
157
158 /**
159 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_2400
160 * @tc.name: testHdiUsbTransferTestControlTransferWrite004
161 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,255).
162 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE, 0, 0, TRANSFER_TIME_OUT).
163 */
164 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite004, TestSize.Level2)
165 {
166 struct UsbDev dev = {0, 255};
167 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
168 bufferData.push_back(SAMPLE_DATA_1);
169 bufferData.push_back(SAMPLE_DATA_2);
170 bufferData.push_back(SAMPLE_DATA_3);
171 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE, 0,
172 0, TRANSFER_TIME_OUT};
173 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
174 ASSERT_NE(ret, 0);
175 }
176
177 /**
178 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_2500
179 * @tc.name: testHdiUsbTransferTestControlTransferWrite005
180 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,255).
181 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT).
182 */
183 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite005, TestSize.Level2)
184 {
185 struct UsbDev dev = {0, 255};
186 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
187 bufferData.push_back(SAMPLE_DATA_1);
188 bufferData.push_back(SAMPLE_DATA_2);
189 bufferData.push_back(SAMPLE_DATA_3);
190 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME, 0,
191 0, TRANSFER_TIME_OUT};
192 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
193 ASSERT_NE(ret, 0);
194 }
195
196 /**
197 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_2600
198 * @tc.name: testHdiUsbTransferTestControlTransferWrite006
199 * @tc.desc: Performs control transfer for endpoint 0 of the device.
200 * dev = (255,0). ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, 0, 0, TRANSFER_TIME_OUT).
201 */
202 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite006, TestSize.Level2)
203 {
204 struct UsbDev dev = {255, 0};
205 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
206 bufferData.push_back(SAMPLE_DATA_1);
207 bufferData.push_back(SAMPLE_DATA_2);
208 bufferData.push_back(SAMPLE_DATA_3);
209 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, 0, 0, TRANSFER_TIME_OUT};
210 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
211 ASSERT_NE(ret, 0);
212 }
213
214 /**
215 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_2700
216 * @tc.name: testHdiUsbTransferTestControlTransferWrite007
217 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,0).
218 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR, 0, 0, TRANSFER_TIME_OUT).
219 */
220 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite007, TestSize.Level2)
221 {
222 struct UsbDev dev = {255, 0};
223 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
224 bufferData.push_back(SAMPLE_DATA_1);
225 bufferData.push_back(SAMPLE_DATA_2);
226 bufferData.push_back(SAMPLE_DATA_3);
227 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR,
228 0, 0, TRANSFER_TIME_OUT};
229 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
230 ASSERT_NE(ret, 0);
231 }
232
233 /**
234 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_2800
235 * @tc.name: testHdiUsbTransferTestControlTransferWrite008
236 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,0).
237 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_CONFIGURATION, 0, 0,
238 * TRANSFER_TIME_OUT).
239 */
240 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite008, TestSize.Level2)
241 {
242 struct UsbDev dev = {255, 0};
243 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
244 bufferData.push_back(SAMPLE_DATA_1);
245 bufferData.push_back(SAMPLE_DATA_2);
246 bufferData.push_back(SAMPLE_DATA_3);
247 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE,
248 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
249 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
250 ASSERT_NE(ret, 0);
251 }
252
253 /**
254 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_2900
255 * @tc.name: testHdiUsbTransferTestControlTransferWrite009
256 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,0).
257 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE, 0, 0, TRANSFER_TIME_OUT).
258 */
259 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite009, TestSize.Level2)
260 {
261 struct UsbDev dev = {255, 0};
262 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
263 bufferData.push_back(SAMPLE_DATA_1);
264 bufferData.push_back(SAMPLE_DATA_2);
265 bufferData.push_back(SAMPLE_DATA_3);
266 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE, 0,
267 0, TRANSFER_TIME_OUT};
268 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
269 ASSERT_NE(ret, 0);
270 }
271
272 /**
273 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3000
274 * @tc.name: testHdiUsbTransferTestControlTransferWrite010
275 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,0).
276 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT).
277 */
278 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite010, TestSize.Level2)
279 {
280 struct UsbDev dev = {255, 0};
281 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
282 bufferData.push_back(SAMPLE_DATA_1);
283 bufferData.push_back(SAMPLE_DATA_2);
284 bufferData.push_back(SAMPLE_DATA_3);
285 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME, 0,
286 0, TRANSFER_TIME_OUT};
287 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
288 ASSERT_NE(ret, 0);
289 }
290
291 /**
292 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3100
293 * @tc.name: testHdiUsbTransferTestControlTransferWrite011
294 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
295 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0, TRANSFER_TIME_OUT).
296 */
297 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite011, TestSize.Level2)
298 {
299 struct UsbDev dev = {255, 255};
300 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
301 bufferData.push_back(SAMPLE_DATA_1);
302 bufferData.push_back(SAMPLE_DATA_2);
303 bufferData.push_back(SAMPLE_DATA_3);
304 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 0, 0, 0,
305 TRANSFER_TIME_OUT};
306 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
307 ASSERT_NE(ret, 0);
308 }
309
310 /**
311 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3200
312 * @tc.name: testHdiUsbTransferTestControlTransferWrite012
313 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
314 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_GET_DESCRIPTOR, 0, 0,
315 * TRANSFER_TIME_OUT).
316 */
317 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite012, TestSize.Level2)
318 {
319 struct UsbDev dev = {255, 255};
320 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
321 bufferData.push_back(SAMPLE_DATA_1);
322 bufferData.push_back(SAMPLE_DATA_2);
323 bufferData.push_back(SAMPLE_DATA_3);
324 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE,
325 USB_DDK_REQ_GET_DESCRIPTOR, 0, 0, TRANSFER_TIME_OUT};
326 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
327 ASSERT_NE(ret, 0);
328 }
329
330 /**
331 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3300
332 * @tc.name: testHdiUsbTransferTestControlTransferWrite013
333 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
334 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_GET_CONFIGURATION, 0, 0,
335 * TRANSFER_TIME_OUT).
336 */
337 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite013, TestSize.Level2)
338 {
339 struct UsbDev dev = {255, 255};
340 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
341 bufferData.push_back(SAMPLE_DATA_1);
342 bufferData.push_back(SAMPLE_DATA_2);
343 bufferData.push_back(SAMPLE_DATA_3);
344 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE,
345 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
346 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
347 ASSERT_NE(ret, 0);
348 }
349
350 /**
351 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3400
352 * @tc.name: testHdiUsbTransferTestControlTransferWrite014
353 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
354 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_GET_INTERFACE, 0, 0,
355 * TRANSFER_TIME_OUT).
356 */
357 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite014, TestSize.Level2)
358 {
359 struct UsbDev dev = {255, 255};
360 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
361 bufferData.push_back(SAMPLE_DATA_1);
362 bufferData.push_back(SAMPLE_DATA_2);
363 bufferData.push_back(SAMPLE_DATA_3);
364 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_GET_INTERFACE,
365 0, 0, TRANSFER_TIME_OUT};
366 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
367 ASSERT_NE(ret, 0);
368 }
369
370 /**
371 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3500
372 * @tc.name: testHdiUsbTransferTestControlTransferWrite015
373 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
374 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_SYNCH_FRAME, 0, 0,
375 * TRANSFER_TIME_OUT).
376 */
377 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite015, TestSize.Level2)
378 {
379 struct UsbDev dev = {255, 255};
380 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
381 bufferData.push_back(SAMPLE_DATA_1);
382 bufferData.push_back(SAMPLE_DATA_2);
383 bufferData.push_back(SAMPLE_DATA_3);
384 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_SYNCH_FRAME,
385 0, 0, TRANSFER_TIME_OUT};
386 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
387 ASSERT_NE(ret, 0);
388 }
389
390 /**
391 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3600
392 * @tc.name: testHdiUsbTransferTestControlTransferWrite016
393 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
394 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0, TRANSFER_TIME_OUT).
395 */
396 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite016, TestSize.Level2)
397 {
398 struct UsbDev dev = {255, 255};
399 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
400 bufferData.push_back(SAMPLE_DATA_1);
401 bufferData.push_back(SAMPLE_DATA_2);
402 bufferData.push_back(SAMPLE_DATA_3);
403 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, 0, 0, 0,
404 TRANSFER_TIME_OUT};
405 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
406 ASSERT_NE(ret, 0);
407 }
408
409 /**
410 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3700
411 * @tc.name: testHdiUsbTransferTestControlTransferWrite017
412 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
413 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_GET_DESCRIPTOR, 0, 0,
414 * TRANSFER_TIME_OUT).
415 */
416 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite017, TestSize.Level2)
417 {
418 struct UsbDev dev = {255, 255};
419 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
420 bufferData.push_back(SAMPLE_DATA_1);
421 bufferData.push_back(SAMPLE_DATA_2);
422 bufferData.push_back(SAMPLE_DATA_3);
423 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_GET_DESCRIPTOR,
424 0, 0, TRANSFER_TIME_OUT};
425 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
426 ASSERT_NE(ret, 0);
427 }
428
429 /**
430 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3800
431 * @tc.name: testHdiUsbTransferTestControlTransferWrite018
432 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
433 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_GET_CONFIGURATION, 0, 0,
434 * TRANSFER_TIME_OUT).
435 */
436 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite018, TestSize.Level2)
437 {
438 struct UsbDev dev = {255, 255};
439 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
440 bufferData.push_back(SAMPLE_DATA_1);
441 bufferData.push_back(SAMPLE_DATA_2);
442 bufferData.push_back(SAMPLE_DATA_3);
443 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT,
444 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
445 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
446 ASSERT_NE(ret, 0);
447 }
448
449 /**
450 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_3900
451 * @tc.name: testHdiUsbTransferTestControlTransferWrite019
452 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
453 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_GET_INTERFACE, 0, 0,
454 * TRANSFER_TIME_OUT).
455 */
456 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite019, TestSize.Level2)
457 {
458 struct UsbDev dev = {255, 255};
459 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
460 bufferData.push_back(SAMPLE_DATA_1);
461 bufferData.push_back(SAMPLE_DATA_2);
462 bufferData.push_back(SAMPLE_DATA_3);
463 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_GET_INTERFACE,
464 0, 0, TRANSFER_TIME_OUT};
465 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
466 ASSERT_NE(ret, 0);
467 }
468
469 /**
470 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4000
471 * @tc.name: testHdiUsbTransferTestControlTransferWrite020
472 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
473 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, 0, 0,
474 * TRANSFER_TIME_OUT).
475 */
476 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite020, TestSize.Level2)
477 {
478 struct UsbDev dev = {255, 255};
479 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
480 bufferData.push_back(SAMPLE_DATA_1);
481 bufferData.push_back(SAMPLE_DATA_2);
482 bufferData.push_back(SAMPLE_DATA_3);
483 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, 0,
484 0, TRANSFER_TIME_OUT};
485 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
486 ASSERT_NE(ret, 0);
487 }
488
489 /**
490 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4100
491 * @tc.name: testHdiUsbTransferTestControlTransferWrite021
492 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
493 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, 0, 0, 0, TRANSFER_TIME_OUT).
494 */
495 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite021, TestSize.Level2)
496 {
497 struct UsbDev dev = {255, 255};
498 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
499 bufferData.push_back(SAMPLE_DATA_1);
500 bufferData.push_back(SAMPLE_DATA_2);
501 bufferData.push_back(SAMPLE_DATA_3);
502 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, 0, 0, 0, TRANSFER_TIME_OUT};
503 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
504 ASSERT_NE(ret, 0);
505 }
506
507 /**
508 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4200
509 * @tc.name: testHdiUsbTransferTestControlTransferWrite022
510 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
511 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_DESCRIPTOR, 0, 0, TRANSFER_TIME_OUT).
512 */
513 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite022, TestSize.Level2)
514 {
515 struct UsbDev dev = {255, 255};
516 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
517 bufferData.push_back(SAMPLE_DATA_1);
518 bufferData.push_back(SAMPLE_DATA_2);
519 bufferData.push_back(SAMPLE_DATA_3);
520 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_DESCRIPTOR, 0,
521 0, TRANSFER_TIME_OUT};
522 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
523 ASSERT_NE(ret, 0);
524 }
525
526 /**
527 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4300
528 * @tc.name: testHdiUsbTransferTestControlTransferWrite023
529 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
530 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_CONFIGURATION, 0, 0,
531 * TRANSFER_TIME_OUT).
532 */
533 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite023, TestSize.Level2)
534 {
535 struct UsbDev dev = {255, 255};
536 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
537 bufferData.push_back(SAMPLE_DATA_1);
538 bufferData.push_back(SAMPLE_DATA_2);
539 bufferData.push_back(SAMPLE_DATA_3);
540 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_CONFIGURATION,
541 0, 0, TRANSFER_TIME_OUT};
542 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
543 ASSERT_NE(ret, 0);
544 }
545
546 /**
547 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4400
548 * @tc.name: testHdiUsbTransferTestControlTransferWrite024
549 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
550 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_INTERFACE, 0, 0,
551 * TRANSFER_TIME_OUT).
552 */
553 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite024, TestSize.Level2)
554 {
555 struct UsbDev dev = {255, 255};
556 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
557 bufferData.push_back(SAMPLE_DATA_1);
558 bufferData.push_back(SAMPLE_DATA_2);
559 bufferData.push_back(SAMPLE_DATA_3);
560 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_INTERFACE, 0,
561 0, TRANSFER_TIME_OUT};
562 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
563 ASSERT_NE(ret, 0);
564 }
565
566 /**
567 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4500
568 * @tc.name: testHdiUsbTransferTestControlTransferWrite025
569 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
570 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_SYNCH_FRAME, 0, 0,
571 * TRANSFER_TIME_OUT).
572 */
573 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite025, TestSize.Level2)
574 {
575 struct UsbDev dev = {255, 255};
576 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
577 bufferData.push_back(SAMPLE_DATA_1);
578 bufferData.push_back(SAMPLE_DATA_2);
579 bufferData.push_back(SAMPLE_DATA_3);
580 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_SYNCH_FRAME, 0, 0,
581 TRANSFER_TIME_OUT};
582 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
583 ASSERT_NE(ret, 0);
584 }
585
586 /**
587 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4600
588 * @tc.name: testHdiUsbTransferTestControlTransferWrite026
589 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
590 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, 0, 0, TRANSFER_TIME_OUT).
591 */
592 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite026, TestSize.Level2)
593 {
594 struct UsbDev dev = {255, 255};
595 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
596 bufferData.push_back(SAMPLE_DATA_1);
597 bufferData.push_back(SAMPLE_DATA_2);
598 bufferData.push_back(SAMPLE_DATA_3);
599 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, 0, 0, TRANSFER_TIME_OUT};
600 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
601 ASSERT_NE(ret, 0);
602 }
603
604 /**
605 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4700
606 * @tc.name: testHdiUsbTransferTestControlTransferWrite027
607 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
608 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR, 0, 0, TRANSFER_TIME_OUT).
609 */
610 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite027, TestSize.Level2)
611 {
612 struct UsbDev dev = {255, 255};
613 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
614 bufferData.push_back(SAMPLE_DATA_1);
615 bufferData.push_back(SAMPLE_DATA_2);
616 bufferData.push_back(SAMPLE_DATA_3);
617 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR,
618 0, 0, TRANSFER_TIME_OUT};
619 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
620 ASSERT_NE(ret, 0);
621 }
622
623 /**
624 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4800
625 * @tc.name: testHdiUsbTransferTestControlTransferWrite028
626 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
627 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_CONFIGURATION, 0, 0,
628 * TRANSFER_TIME_OUT).
629 */
630 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite028, TestSize.Level2)
631 {
632 struct UsbDev dev = {255, 255};
633 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
634 bufferData.push_back(SAMPLE_DATA_1);
635 bufferData.push_back(SAMPLE_DATA_2);
636 bufferData.push_back(SAMPLE_DATA_3);
637 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE,
638 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
639 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
640 ASSERT_NE(ret, 0);
641 }
642
643 /**
644 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_4900
645 * @tc.name: testHdiUsbTransferTestControlTransferWrite029
646 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
647 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE, 0, 0,
648 * TRANSFER_TIME_OUT).
649 */
650 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite029, TestSize.Level2)
651 {
652 struct UsbDev dev = {255, 255};
653 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
654 bufferData.push_back(SAMPLE_DATA_1);
655 bufferData.push_back(SAMPLE_DATA_2);
656 bufferData.push_back(SAMPLE_DATA_3);
657 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE, 0,
658 0, TRANSFER_TIME_OUT};
659 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
660 ASSERT_NE(ret, 0);
661 }
662
663 /**
664 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5000
665 * @tc.name: testHdiUsbTransferTestControlTransferWrite030
666 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
667 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME, 0, 0,
668 * TRANSFER_TIME_OUT).
669 */
670 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite030, TestSize.Level2)
671 {
672 struct UsbDev dev = {255, 255};
673 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
674 bufferData.push_back(SAMPLE_DATA_1);
675 bufferData.push_back(SAMPLE_DATA_2);
676 bufferData.push_back(SAMPLE_DATA_3);
677 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME, 0,
678 0, TRANSFER_TIME_OUT};
679 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
680 ASSERT_NE(ret, 0);
681 }
682
683 /**
684 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5100
685 * @tc.name: testHdiUsbTransferTestControlTransferWrite031
686 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
687 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, CTL_VALUE, 0, TRANSFER_TIME_OUT).
688 */
689 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite031, TestSize.Level2)
690 {
691 struct UsbDev dev = {255, 255};
692 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
693 bufferData.push_back(SAMPLE_DATA_1);
694 bufferData.push_back(SAMPLE_DATA_2);
695 bufferData.push_back(SAMPLE_DATA_3);
696 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, CTL_VALUE, 0,
697 TRANSFER_TIME_OUT};
698 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
699 ASSERT_NE(ret, 0);
700 }
701
702 /**
703 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5200
704 * @tc.name: testHdiUsbTransferTestControlTransferWrite032
705 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
706 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0,
707 * TRANSFER_TIME_OUT).
708 */
709 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite032, TestSize.Level2)
710 {
711 struct UsbDev dev = {255, 255};
712 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
713 bufferData.push_back(SAMPLE_DATA_1);
714 bufferData.push_back(SAMPLE_DATA_2);
715 bufferData.push_back(SAMPLE_DATA_3);
716 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR,
717 CTL_VALUE, 0, TRANSFER_TIME_OUT};
718 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
719 ASSERT_NE(ret, 0);
720 }
721
722 /**
723 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5300
724 * @tc.name: testHdiUsbTransferTestControlTransferWrite033
725 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
726 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_CONFIGURATION, CTL_VALUE, 0,
727 * TRANSFER_TIME_OUT).
728 */
729 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite033, TestSize.Level2)
730 {
731 struct UsbDev dev = {255, 255};
732 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
733 bufferData.push_back(SAMPLE_DATA_1);
734 bufferData.push_back(SAMPLE_DATA_2);
735 bufferData.push_back(SAMPLE_DATA_3);
736 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE,
737 USB_DDK_REQ_GET_CONFIGURATION, CTL_VALUE, 0, TRANSFER_TIME_OUT};
738 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
739 ASSERT_NE(ret, 0);
740 }
741
742 /**
743 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5400
744 * @tc.name: testHdiUsbTransferTestControlTransferWrite034
745 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
746 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE, CTL_VALUE, 0,
747 * TRANSFER_TIME_OUT).
748 */
749 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite034, TestSize.Level2)
750 {
751 struct UsbDev dev = {255, 255};
752 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
753 bufferData.push_back(SAMPLE_DATA_1);
754 bufferData.push_back(SAMPLE_DATA_2);
755 bufferData.push_back(SAMPLE_DATA_3);
756 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE,
757 CTL_VALUE, 0, TRANSFER_TIME_OUT};
758 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
759 ASSERT_NE(ret, 0);
760 }
761
762 /**
763 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5500
764 * @tc.name: testHdiUsbTransferTestControlTransferWrite035
765 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
766 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME, CTL_VALUE, 0,
767 * TRANSFER_TIME_OUT).
768 */
769 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite035, TestSize.Level2)
770 {
771 struct UsbDev dev = {255, 255};
772 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
773 bufferData.push_back(SAMPLE_DATA_1);
774 bufferData.push_back(SAMPLE_DATA_2);
775 bufferData.push_back(SAMPLE_DATA_3);
776 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME,
777 CTL_VALUE, 0, TRANSFER_TIME_OUT};
778 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
779 ASSERT_NE(ret, 0);
780 }
781
782 /**
783 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5600
784 * @tc.name: testHdiUsbTransferTestControlTransferWrite036
785 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
786 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 0, CTL_VALUE, 0, TRANSFER_TIME_OUT).
787 */
788 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite036, TestSize.Level2)
789 {
790 struct UsbDev dev = {255, 255};
791 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
792 bufferData.push_back(SAMPLE_DATA_1);
793 bufferData.push_back(SAMPLE_DATA_2);
794 bufferData.push_back(SAMPLE_DATA_3);
795 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, 0, CTL_VALUE, 0,
796 TRANSFER_TIME_OUT};
797 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
798 ASSERT_NE(ret, 0);
799 }
800
801 /**
802 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5700
803 * @tc.name: testHdiUsbTransferTestControlTransferWrite037
804 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
805 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0,
806 * TRANSFER_TIME_OUT).
807 */
808 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite037, TestSize.Level2)
809 {
810 struct UsbDev dev = {255, 255};
811 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
812 bufferData.push_back(SAMPLE_DATA_1);
813 bufferData.push_back(SAMPLE_DATA_2);
814 bufferData.push_back(SAMPLE_DATA_3);
815 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE,
816 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
817 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
818 ASSERT_NE(ret, 0);
819 }
820
821 /**
822 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5800
823 * @tc.name: testHdiUsbTransferTestControlTransferWrite038
824 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
825 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_GET_CONFIGURATION, CTL_VALUE, 0,
826 * TRANSFER_TIME_OUT).
827 */
828 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite038, TestSize.Level2)
829 {
830 struct UsbDev dev = {255, 255};
831 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
832 bufferData.push_back(SAMPLE_DATA_1);
833 bufferData.push_back(SAMPLE_DATA_2);
834 bufferData.push_back(SAMPLE_DATA_3);
835 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE,
836 USB_DDK_REQ_GET_CONFIGURATION, CTL_VALUE, 0, TRANSFER_TIME_OUT};
837 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
838 ASSERT_NE(ret, 0);
839 }
840
841 /**
842 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_5900
843 * @tc.name: testHdiUsbTransferTestControlTransferWrite039
844 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
845 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_GET_INTERFACE, CTL_VALUE, 0,
846 * TRANSFER_TIME_OUT).
847 */
848 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite039, TestSize.Level2)
849 {
850 struct UsbDev dev = {255, 255};
851 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
852 bufferData.push_back(SAMPLE_DATA_1);
853 bufferData.push_back(SAMPLE_DATA_2);
854 bufferData.push_back(SAMPLE_DATA_3);
855 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_GET_INTERFACE,
856 CTL_VALUE, 0, TRANSFER_TIME_OUT};
857 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
858 ASSERT_NE(ret, 0);
859 }
860
861 /**
862 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6000
863 * @tc.name: testHdiUsbTransferTestControlTransferWrite040
864 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
865 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_SYNCH_FRAME, CTL_VALUE, 0,
866 * TRANSFER_TIME_OUT).
867 */
868 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite040, TestSize.Level2)
869 {
870 struct UsbDev dev = {255, 255};
871 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
872 bufferData.push_back(SAMPLE_DATA_1);
873 bufferData.push_back(SAMPLE_DATA_2);
874 bufferData.push_back(SAMPLE_DATA_3);
875 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_INTERFACE, USB_DDK_REQ_SYNCH_FRAME,
876 CTL_VALUE, 0, TRANSFER_TIME_OUT};
877 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
878 ASSERT_NE(ret, 0);
879 }
880
881 /**
882 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6100
883 * @tc.name: testHdiUsbTransferTestControlTransferWrite041
884 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
885 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, 0, CTL_VALUE, 0, TRANSFER_TIME_OUT).
886 */
887 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite041, TestSize.Level2)
888 {
889 struct UsbDev dev = {255, 255};
890 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
891 bufferData.push_back(SAMPLE_DATA_1);
892 bufferData.push_back(SAMPLE_DATA_2);
893 bufferData.push_back(SAMPLE_DATA_3);
894 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, 0, CTL_VALUE, 0,
895 TRANSFER_TIME_OUT};
896 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
897 ASSERT_NE(ret, 0);
898 }
899
900 /**
901 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6200
902 * @tc.name: testHdiUsbTransferTestControlTransferWrite042
903 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
904 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0,
905 * TRANSFER_TIME_OUT).
906 */
907 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite042, TestSize.Level2)
908 {
909 struct UsbDev dev = {255, 255};
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, USB_DDK_REQ_GET_DESCRIPTOR,
915 CTL_VALUE, 0, TRANSFER_TIME_OUT};
916 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
917 ASSERT_NE(ret, 0);
918 }
919
920 /**
921 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6300
922 * @tc.name: testHdiUsbTransferTestControlTransferWrite043
923 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
924 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_GET_CONFIGURATION, CTL_VALUE, 0,
925 * TRANSFER_TIME_OUT).
926 */
927 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite043, TestSize.Level2)
928 {
929 struct UsbDev dev = {255, 255};
930 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
931 bufferData.push_back(SAMPLE_DATA_1);
932 bufferData.push_back(SAMPLE_DATA_2);
933 bufferData.push_back(SAMPLE_DATA_3);
934 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT,
935 USB_DDK_REQ_GET_CONFIGURATION, CTL_VALUE, 0, TRANSFER_TIME_OUT};
936 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
937 ASSERT_NE(ret, 0);
938 }
939
940 /**
941 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6400
942 * @tc.name: testHdiUsbTransferTestControlTransferWrite044
943 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
944 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_GET_INTERFACE, CTL_VALUE, 0,
945 * TRANSFER_TIME_OUT).
946 */
947 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite044, TestSize.Level2)
948 {
949 struct UsbDev dev = {255, 255};
950 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
951 bufferData.push_back(SAMPLE_DATA_1);
952 bufferData.push_back(SAMPLE_DATA_2);
953 bufferData.push_back(SAMPLE_DATA_3);
954 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_GET_INTERFACE,
955 CTL_VALUE, 0, TRANSFER_TIME_OUT};
956 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
957 ASSERT_NE(ret, 0);
958 }
959
960 /**
961 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6500
962 * @tc.name: testHdiUsbTransferTestControlTransferWrite045
963 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
964 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME, CTL_VALUE, 0,
965 * TRANSFER_TIME_OUT).
966 */
967 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite045, TestSize.Level2)
968 {
969 struct UsbDev dev = {255, 255};
970 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
971 bufferData.push_back(SAMPLE_DATA_1);
972 bufferData.push_back(SAMPLE_DATA_2);
973 bufferData.push_back(SAMPLE_DATA_3);
974 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_ENDPOINT, USB_DDK_REQ_SYNCH_FRAME,
975 CTL_VALUE, 0, TRANSFER_TIME_OUT};
976 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
977 ASSERT_NE(ret, 0);
978 }
979
980 /**
981 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6600
982 * @tc.name: testHdiUsbTransferTestControlTransferWrite046
983 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
984 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, 0, CTL_VALUE, 0,TRANSFER_TIME_OUT).
985 */
986 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite046, TestSize.Level2)
987 {
988 struct UsbDev dev = {255, 255};
989 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
990 bufferData.push_back(SAMPLE_DATA_1);
991 bufferData.push_back(SAMPLE_DATA_2);
992 bufferData.push_back(SAMPLE_DATA_3);
993 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, 0, CTL_VALUE, 0,
994 TRANSFER_TIME_OUT};
995 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
996 ASSERT_NE(ret, 0);
997 }
998
999 /**
1000 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6700
1001 * @tc.name: testHdiUsbTransferTestControlTransferWrite047
1002 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
1003 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE,
1004 * 0,TRANSFER_TIME_OUT).
1005 */
1006 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite047, TestSize.Level2)
1007 {
1008 struct UsbDev dev = {255, 255};
1009 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1010 bufferData.push_back(SAMPLE_DATA_1);
1011 bufferData.push_back(SAMPLE_DATA_2);
1012 bufferData.push_back(SAMPLE_DATA_3);
1013 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_DESCRIPTOR,
1014 CTL_VALUE, 0, TRANSFER_TIME_OUT};
1015 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
1016 ASSERT_NE(ret, 0);
1017 }
1018
1019 /**
1020 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6800
1021 * @tc.name: testHdiUsbTransferTestControlTransferWrite048
1022 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
1023 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_CONFIGURATION, CTL_VALUE,
1024 * 0,TRANSFER_TIME_OUT).
1025 */
1026 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite048, TestSize.Level2)
1027 {
1028 struct UsbDev dev = {255, 255};
1029 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1030 bufferData.push_back(SAMPLE_DATA_1);
1031 bufferData.push_back(SAMPLE_DATA_2);
1032 bufferData.push_back(SAMPLE_DATA_3);
1033 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_CONFIGURATION,
1034 CTL_VALUE, 0, TRANSFER_TIME_OUT};
1035 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
1036 ASSERT_NE(ret, 0);
1037 }
1038
1039 /**
1040 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_6900
1041 * @tc.name: testHdiUsbTransferTestControlTransferWrite049
1042 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
1043 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_INTERFACE, CTL_VALUE,
1044 * 0,TRANSFER_TIME_OUT).
1045 */
1046 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite049, TestSize.Level2)
1047 {
1048 struct UsbDev dev = {255, 255};
1049 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1050 bufferData.push_back(SAMPLE_DATA_1);
1051 bufferData.push_back(SAMPLE_DATA_2);
1052 bufferData.push_back(SAMPLE_DATA_3);
1053 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_GET_INTERFACE,
1054 CTL_VALUE, 0, TRANSFER_TIME_OUT};
1055 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
1056 ASSERT_NE(ret, 0);
1057 }
1058
1059 /**
1060 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_7000
1061 * @tc.name: testHdiUsbTransferTestControlTransferWrite050
1062 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (255,255).
1063 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_SYNCH_FRAME, CTL_VALUE,
1064 * 0,TRANSFER_TIME_OUT).
1065 */
1066 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite050, TestSize.Level2)
1067 {
1068 struct UsbDev dev = {255, 255};
1069 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1070 bufferData.push_back(SAMPLE_DATA_1);
1071 bufferData.push_back(SAMPLE_DATA_2);
1072 bufferData.push_back(SAMPLE_DATA_3);
1073 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_OTHER, USB_DDK_REQ_SYNCH_FRAME,
1074 CTL_VALUE, 0, TRANSFER_TIME_OUT};
1075 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
1076 ASSERT_NE(ret, 0);
1077 }
1078
1079 /**
1080 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_7100
1081 * @tc.name: testHdiUsbTransferTestControlTransferWrite051
1082 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,255).
1083 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, CTL_VALUE, 0, TRANSFER_TIME_OUT).
1084 */
1085 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite051, TestSize.Level2)
1086 {
1087 struct UsbDev dev = {0, 255};
1088 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1089 bufferData.push_back(SAMPLE_DATA_1);
1090 bufferData.push_back(SAMPLE_DATA_2);
1091 bufferData.push_back(SAMPLE_DATA_3);
1092 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, 0, CTL_VALUE, 0,
1093 TRANSFER_TIME_OUT};
1094 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
1095 ASSERT_NE(ret, 0);
1096 }
1097
1098 /**
1099 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_7200
1100 * @tc.name: testHdiUsbTransferTestControlTransferWrite052
1101 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,255).
1102 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0,
1103 * TRANSFER_TIME_OUT).
1104 */
1105 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite052, TestSize.Level2)
1106 {
1107 struct UsbDev dev = {0, 255};
1108 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1109 bufferData.push_back(SAMPLE_DATA_1);
1110 bufferData.push_back(SAMPLE_DATA_2);
1111 bufferData.push_back(SAMPLE_DATA_3);
1112 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_DESCRIPTOR,
1113 CTL_VALUE, 0, TRANSFER_TIME_OUT};
1114 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
1115 ASSERT_NE(ret, 0);
1116 }
1117
1118 /**
1119 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_7300
1120 * @tc.name: testHdiUsbTransferTestControlTransferWrite053
1121 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,255).
1122 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_CONFIGURATION, CTL_VALUE, 0,
1123 * TRANSFER_TIME_OUT).
1124 */
1125 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite053, TestSize.Level2)
1126 {
1127 struct UsbDev dev = {0, 255};
1128 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1129 bufferData.push_back(SAMPLE_DATA_1);
1130 bufferData.push_back(SAMPLE_DATA_2);
1131 bufferData.push_back(SAMPLE_DATA_3);
1132 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE,
1133 USB_DDK_REQ_GET_CONFIGURATION, CTL_VALUE, 0, TRANSFER_TIME_OUT};
1134 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
1135 ASSERT_NE(ret, 0);
1136 }
1137
1138 /**
1139 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_7400
1140 * @tc.name: testHdiUsbTransferTestControlTransferWrite054
1141 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,255).
1142 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE, CTL_VALUE, 0,
1143 * TRANSFER_TIME_OUT).
1144 */
1145 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite054, TestSize.Level2)
1146 {
1147 struct UsbDev dev = {0, 255};
1148 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1149 bufferData.push_back(SAMPLE_DATA_1);
1150 bufferData.push_back(SAMPLE_DATA_2);
1151 bufferData.push_back(SAMPLE_DATA_3);
1152 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_GET_INTERFACE,
1153 CTL_VALUE, 0, TRANSFER_TIME_OUT};
1154 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
1155 ASSERT_NE(ret, 0);
1156 }
1157
1158 /**
1159 * @tc.number: SUB_Driver_Usb_TransferTest_ControlTransferWrite_7500
1160 * @tc.name: testHdiUsbTransferTestControlTransferWrite055
1161 * @tc.desc: Performs control transfer for endpoint 0 of the device. dev = (0,255).
1162 * ctrlparmas = (USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME, CTL_VALUE, 0,
1163 * TRANSFER_TIME_OUT).
1164 */
1165 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestControlTransferWrite055, TestSize.Level2)
1166 {
1167 struct UsbDev dev = {0, 255};
1168 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
1169 bufferData.push_back(SAMPLE_DATA_1);
1170 bufferData.push_back(SAMPLE_DATA_2);
1171 bufferData.push_back(SAMPLE_DATA_3);
1172 struct UsbCtrlTransfer ctrlparmas = {USB_ENDPOINT_DIR_OUT | USB_REQUEST_TARGET_DEVICE, USB_DDK_REQ_SYNCH_FRAME,
1173 CTL_VALUE, 0, TRANSFER_TIME_OUT};
1174 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlparmas, bufferData);
1175 ASSERT_NE(ret, 0);
1176 }
1177
1178 } // namespace
1179