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