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
16 #include <climits>
17 #include <iostream>
18 #include <vector>
19
20 #include "mock_linux_adapter.h"
21 #include "usb_impl.h"
22 #include "usbd_dispatcher.h"
23 #include "UsbSubscriberTest.h"
24 #include "v1_0/iusb_interface.h"
25 #include "v1_0/iusbd_bulk_callback.h"
26 #include "v1_0/usb_types.h"
27
28 using ::testing::Exactly;
29 using ::testing::Return;
30
31 using namespace std;
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 constexpr uint8_t BUS_NUM_INVALID = 255;;
39 constexpr uint8_t DEV_ADDR_INVALID = 255;
40 constexpr uint32_t MAX_BUFFER_LENGTH = 255;
41 constexpr uint8_t INTERFACEID_OK = 1;
42 constexpr uint8_t PIPE_ENDPOINTID_INVALID = 244;
43 constexpr uint8_t PIPE_INTERFACEID_INVALID = 244;
44 // data interface have 2 point : 1->bulk_out 2->bulk_in
45 constexpr uint8_t POINTID_DIR_IN = USB_ENDPOINT_DIR_IN | 2;
46 constexpr uint8_t POINTID_DIR_OUT = USB_ENDPOINT_DIR_OUT | 1;
47 constexpr int32_t ASHMEM_MAX_SIZE = 1024;
48 constexpr uint8_t BUS_NUM_OK = 6;
49 constexpr uint8_t DEV_ADDR_OK = 2;
50 constexpr int32_t TRANSFER_TIME_OUT = 1000;
51 constexpr int32_t CTL_VALUE = 0x100;
52 constexpr int32_t ACM_SET_LINE_CODING_LEN = 7;
53
54 namespace {
55 class UsbdTransferTest : public testing::Test {
56 public:
57 static void SetUpTestCase(void);
58 static void TearDownTestCase(void);
59 static UsbDev dev_;
60 };
61 class UsbdBulkCallbackTest : public OHOS::HDI::Usb::V1_0::IUsbdBulkCallback {
62 public:
63 UsbdBulkCallbackTest() = default;
64 ~UsbdBulkCallbackTest() = default;
OnBulkWriteCallback(int32_t status,int32_t actLength)65 int32_t OnBulkWriteCallback(int32_t status, int32_t actLength) override
66 {
67 return 0;
68 };
OnBulkReadCallback(int32_t status,int32_t actLength)69 int32_t OnBulkReadCallback(int32_t status, int32_t actLength) override
70 {
71 return 0;
72 };
73 };
74 sptr<IUsbInterface> g_usbInterface = nullptr;
75 UsbDev UsbdTransferTest::dev_ = {0, 0};
76
InitAshmemOne(sptr<Ashmem> & asmptr,int32_t asmSize,uint8_t rflg)77 int32_t InitAshmemOne(sptr<Ashmem> &asmptr, int32_t asmSize, uint8_t rflg)
78 {
79 asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
80 if (asmptr == nullptr) {
81 HDF_LOGE("InitAshmemOne CreateAshmem failed");
82 return HDF_FAILURE;
83 }
84
85 asmptr->MapReadAndWriteAshmem();
86
87 if (rflg == 0) {
88 uint8_t tdata[ASHMEM_MAX_SIZE];
89 int32_t offset = 0;
90 int32_t tlen = 0;
91
92 int32_t retSafe = memset_s(tdata, sizeof(tdata), 'Y', ASHMEM_MAX_SIZE);
93 if (retSafe != EOK) {
94 HDF_LOGE("InitAshmemOne memset_s failed");
95 return HDF_FAILURE;
96 }
97 while (offset < asmSize) {
98 tlen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
99 asmptr->WriteToAshmem(tdata, tlen, offset);
100 offset += tlen;
101 }
102 }
103 return HDF_SUCCESS;
104 }
105
SetUpTestCase(void)106 void UsbdTransferTest::SetUpTestCase(void)
107 {
108 struct UsbOsAdapterOps *osAdapterOps = UsbAdapterGetOps();
109 g_usbInterface = IUsbInterface::Get(true);
110 if (g_usbInterface == nullptr) {
111 HDF_LOGE("%{public}s:IUsbInterface::Get() failed", __func__);
112 exit(0);
113 }
114 sptr<UsbImpl> sp = static_cast<UsbImpl *>(g_usbInterface.GetRefPtr());
115 osAdapterOps->openDevice = FuncAdapterOpenDevice;
116 osAdapterOps->init = FuncAdapterInit;
117 osAdapterOps->getConfiguration = FuncAdapterGetConfiguration;
118 osAdapterOps->getConfigDescriptor = FuncAdapterGetConfigDescriptor;
119 osAdapterOps->urbCompleteHandle = FuncAdapterUrbCompleteHandle;
120 osAdapterOps->allocRequest = FuncAdapterAllocRequest;
121 osAdapterOps->cancelRequest = FuncAdapterCancelRequest;
122 osAdapterOps->submitRequest = FuncAdapterSubmitRequest;
123 osAdapterOps->claimInterface = FuncAdapterClaimInterface;
124 osAdapterOps->detachKernelDriverAndClaim = FuncAdapterClaimInterface;
125 osAdapterOps->freeRequest = FuncAdapterFreeRequest;
126 osAdapterOps->closeDevice = FuncAdapterCloseDevice;
127 osAdapterOps->releaseInterface = FuncAdapterReleaseInterface;
128 auto ret = UsbdDispatcher::UsbdDeviceCreateAndAttach(sp, BUS_NUM_OK, DEV_ADDR_OK);
129 ASSERT_EQ(0, ret);
130 dev_ = {BUS_NUM_OK, DEV_ADDR_OK};
131 ret = g_usbInterface->OpenDevice(dev_);
132 ASSERT_EQ(0, ret);
133 }
134
TearDownTestCase(void)135 void UsbdTransferTest::TearDownTestCase(void)
136 {
137 g_usbInterface->CloseDevice(dev_);
138 sptr<UsbImpl> sp = static_cast<UsbImpl *>(g_usbInterface.GetRefPtr());
139 UsbdDispatcher::UsbdDeviceDettach(sp, BUS_NUM_OK, DEV_ADDR_OK);
140 }
141
142 /**
143 * @tc.name: ControlTransferRead001
144 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
145 * @tc.desc: Positive test: parameters correctly, standard request: get config
146 * @tc.type: FUNC
147 */
148 HWTEST_F(UsbdTransferTest, ControlTransferRead001, TestSize.Level1)
149 {
150 struct UsbDev dev = dev_;
151 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
152 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN,
153 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
154 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
155 ASSERT_EQ(0, ret);
156 }
157
158 /**
159 * @tc.name: ControlTransferRead002
160 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
161 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get configuration
162 * @tc.type: FUNC
163 */
164 HWTEST_F(UsbdTransferTest, ControlTransferRead002, TestSize.Level1)
165 {
166 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
167 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
168 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN,
169 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
170 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
171 HDF_LOGI("UsbdTransferTest::ControlTransferRead002 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
172 ASSERT_NE(ret, 0);
173 }
174
175 /**
176 * @tc.name: ControlTransferRead003
177 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
178 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get configuration
179 * @tc.type: FUNC
180 */
181 HWTEST_F(UsbdTransferTest, ControlTransferRead003, TestSize.Level1)
182 {
183 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
184 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
185 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN,
186 USB_DDK_REQ_GET_CONFIGURATION, 0, 0, TRANSFER_TIME_OUT};
187 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
188 HDF_LOGI("UsbdTransferTest::ControlTransferRead003 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
189 ASSERT_NE(ret, 0);
190 }
191
192 /**
193 * @tc.name: ControlTransferRead004
194 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
195 * @tc.desc: Positive test: parameters correctly, standard request: get descriptor(device)
196 * @tc.type: FUNC
197 */
198 HWTEST_F(UsbdTransferTest, ControlTransferRead004, TestSize.Level1)
199 {
200 struct UsbDev dev = dev_;
201 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
202 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN,
203 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
204 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
205 HDF_LOGI("UsbdTransferTest::ControlTransferRead004 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
206 ASSERT_EQ(0, ret);
207 }
208
209 /**
210 * @tc.name: ControlTransferRead005
211 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
212 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get descriptor(device)
213 * @tc.type: FUNC
214 */
215 HWTEST_F(UsbdTransferTest, ControlTransferRead005, TestSize.Level1)
216 {
217 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
218 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
219 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN,
220 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
221 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
222 HDF_LOGI("UsbdTransferTest::ControlTransferRead005 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
223 ASSERT_NE(ret, 0);
224 }
225
226 /**
227 * @tc.name: ControlTransferRead006
228 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
229 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get descriptor(device)
230 * @tc.type: FUNC
231 */
232 HWTEST_F(UsbdTransferTest, ControlTransferRead006, TestSize.Level1)
233 {
234 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
235 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
236 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN,
237 USB_DDK_REQ_GET_DESCRIPTOR, CTL_VALUE, 0, TRANSFER_TIME_OUT};
238 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
239 HDF_LOGI("UsbdTransferTest::ControlTransferRead006 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
240 ASSERT_NE(ret, 0);
241 }
242
243 /**
244 * @tc.name: ControlTransferRead007
245 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
246 * @tc.desc: Positive test: parameters correctly, standard request: get interface
247 * @tc.type: FUNC
248 */
249 HWTEST_F(UsbdTransferTest, ControlTransferRead007, TestSize.Level1)
250 {
251 struct UsbDev dev = dev_;
252 int32_t interfaceIndex = 0;
253 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
254 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE,
255 USB_DDK_REQ_GET_INTERFACE, 0, interfaceIndex, TRANSFER_TIME_OUT};
256 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
257 HDF_LOGI("UsbdTransferTest::ControlTransferRead007 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
258 ASSERT_EQ(0, ret);
259 }
260
261 /**
262 * @tc.name: ControlTransferRead008
263 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
264 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get interface
265 * @tc.type: FUNC
266 */
267 HWTEST_F(UsbdTransferTest, ControlTransferRead008, TestSize.Level1)
268 {
269 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
270 int32_t interfaceIndex = 0;
271 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
272 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE,
273 USB_DDK_REQ_GET_INTERFACE, 0, interfaceIndex, TRANSFER_TIME_OUT};
274 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
275 HDF_LOGI("UsbdTransferTest::ControlTransferRead008 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
276 ASSERT_NE(ret, 0);
277 }
278
279 /**
280 * @tc.name: ControlTransferRead009
281 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
282 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get interface
283 * @tc.type: FUNC
284 */
285 HWTEST_F(UsbdTransferTest, ControlTransferRead009, TestSize.Level1)
286 {
287 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
288 int32_t interfaceIndex = 0;
289 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
290 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE,
291 USB_DDK_REQ_GET_INTERFACE, 0, interfaceIndex, TRANSFER_TIME_OUT};
292 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
293 HDF_LOGI("UsbdTransferTest::ControlTransferRead009 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
294 ASSERT_NE(ret, 0);
295 }
296
297 /**
298 * @tc.name: ControlTransferRead010
299 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
300 * Positive test: parameters correctly, standard request: get status(recipient device)
301 * @tc.type: FUNC
302 */
303 HWTEST_F(UsbdTransferTest, ControlTransferRead010, TestSize.Level1)
304 {
305 struct UsbDev dev = dev_;
306 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
307 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
308 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
309 HDF_LOGI("UsbdTransferTest::ControlTransferRead010 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
310 ASSERT_EQ(0, ret);
311 }
312
313 /**
314 * @tc.name: ControlTransferRead011
315 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
316 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(device)
317 * @tc.type: FUNC
318 */
319 HWTEST_F(UsbdTransferTest, ControlTransferRead011, TestSize.Level1)
320 {
321 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
322 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
323 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
324 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
325 HDF_LOGI("UsbdTransferTest::ControlTransferRead011 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
326 ASSERT_NE(ret, 0);
327 }
328
329 /**
330 * @tc.name: ControlTransferRead012
331 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
332 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(device)
333 * @tc.type: FUNC
334 */
335 HWTEST_F(UsbdTransferTest, ControlTransferRead012, TestSize.Level1)
336 {
337 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
338 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
339 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN, USB_DDK_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
340 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
341 HDF_LOGI("UsbdTransferTest::ControlTransferRead012 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
342 ASSERT_NE(ret, 0);
343 }
344
345 /**
346 * @tc.name: ControlTransferRead013
347 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
348 * Positive test: parameters correctly, standard request: get status(interface)
349 * @tc.type: FUNC
350 */
351 HWTEST_F(UsbdTransferTest, ControlTransferRead013, TestSize.Level1)
352 {
353 struct UsbDev dev = dev_;
354 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
355 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE,
356 USB_DDK_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
357 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
358 HDF_LOGI("UsbdTransferTest::ControlTransferRead013 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
359 ASSERT_EQ(0, ret);
360 }
361
362 /**
363 * @tc.name: ControlTransferRead014
364 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
365 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(interface)
366 * @tc.type: FUNC
367 */
368 HWTEST_F(UsbdTransferTest, ControlTransferRead014, TestSize.Level1)
369 {
370 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
371 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
372 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE,
373 USB_DDK_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
374 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
375 HDF_LOGI("UsbdTransferTest::ControlTransferRead014 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
376 ASSERT_NE(ret, 0);
377 }
378
379 /**
380 * @tc.name: ControlTransferRead015
381 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
382 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(interface)
383 * @tc.type: FUNC
384 */
385 HWTEST_F(UsbdTransferTest, ControlTransferRead015, TestSize.Level1)
386 {
387 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
388 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
389 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_INTERFACE,
390 USB_DDK_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
391 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
392 HDF_LOGI("UsbdTransferTest::ControlTransferRead015 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
393 ASSERT_NE(ret, 0);
394 }
395
396 /**
397 * @tc.name: ControlTransferRead016
398 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
399 * @tc.desc: Positive test: parameters correctly, standard request: get status(endpoint)
400 * @tc.type: FUNC
401 */
402 HWTEST_F(UsbdTransferTest, ControlTransferRead016, TestSize.Level1)
403 {
404 struct UsbDev dev = dev_;
405 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
406 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT,
407 USB_DDK_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
408 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
409 HDF_LOGI("UsbdTransferTest::ControlTransferRead016 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
410 ASSERT_EQ(0, ret);
411 }
412
413 /**
414 * @tc.name: ControlTransferRead017
415 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
416 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get status(endpoint)
417 * @tc.type: FUNC
418 */
419 HWTEST_F(UsbdTransferTest, ControlTransferRead017, TestSize.Level1)
420 {
421 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
422 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
423 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT,
424 USB_DDK_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
425 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
426 HDF_LOGI("UsbdTransferTest::ControlTransferRead017 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
427 ASSERT_NE(ret, 0);
428 }
429
430 /**
431 * @tc.name: ControlTransferRead018
432 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
433 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get status(endpoint)
434 * @tc.type: FUNC
435 */
436 HWTEST_F(UsbdTransferTest, ControlTransferRead018, TestSize.Level1)
437 {
438 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
439 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
440 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT,
441 USB_DDK_REQ_GET_STATUS, 0, 0, TRANSFER_TIME_OUT};
442 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
443 HDF_LOGI("UsbdTransferTest::ControlTransferRead018 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
444 ASSERT_NE(ret, 0);
445 }
446
447 /**
448 * @tc.name: ControlTransferRead019
449 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
450 * @tc.desc: Positive test: parameters correctly, standard request: sync frame
451 * @tc.type: FUNC
452 */
453 HWTEST_F(UsbdTransferTest, ControlTransferRead019, TestSize.Level1)
454 {
455 struct UsbDev dev = dev_;
456 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
457 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT,
458 USB_DDK_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT};
459 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
460 HDF_LOGI("UsbdTransferTest::ControlTransferRead019 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
461 ASSERT_EQ(0, ret);
462 }
463
464 /**
465 * @tc.name: ControlTransferRead020
466 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
467 * @tc.desc: Negative test: parameters exception, busNum error, standard request: sync frame
468 * @tc.type: FUNC
469 */
470 HWTEST_F(UsbdTransferTest, ControlTransferRead020, TestSize.Level1)
471 {
472 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
473 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
474 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT,
475 USB_DDK_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT};
476 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
477 HDF_LOGI("UsbdTransferTest::ControlTransferRead020 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
478 ASSERT_NE(ret, 0);
479 }
480
481 /**
482 * @tc.name: ControlTransferRead021
483 * @tc.desc: Test functions to ControlTransfer(const UsbDev &dev, UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
484 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: sync frame
485 * @tc.type: FUNC
486 */
487 HWTEST_F(UsbdTransferTest, ControlTransferRead021, TestSize.Level1)
488 {
489 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
490 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
491 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_IN | USB_REQUEST_TARGET_ENDPOINT,
492 USB_DDK_REQ_SYNCH_FRAME, 0, 0, TRANSFER_TIME_OUT};
493 auto ret = g_usbInterface->ControlTransferRead(dev, ctrlParmas, bufferData);
494 HDF_LOGI("UsbdTransferTest::ControlTransferRead021 %{public}d ControlTransfer=%{public}d", __LINE__, ret);
495 ASSERT_NE(ret, 0);
496 }
497
498 /**
499 * @tc.name: ControlTransferWrite001
500 * @tc.desc: Test functions to ControlTransferWrite(const UsbDev &dev,
501 * UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
502 * @tc.desc: Positive test: parameters correctly, set acm btr
503 * @tc.type: FUNC
504 */
505 HWTEST_F(UsbdTransferTest, ControlTransferWrite001, TestSize.Level1)
506 {
507 struct UsbDev dev = dev_;
508 std::vector<uint8_t> bufferData(ACM_SET_LINE_CODING_LEN);
509 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_OUT | USB_DDK_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
510 USB_DDK_CDC_REQ_SET_LINE_CODING, 0, 0, TRANSFER_TIME_OUT};
511 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlParmas, bufferData);
512 ASSERT_EQ(0, ret);
513 }
514
515 /**
516 * @tc.name: ControlTransferWrite002
517 * @tc.desc: Test functions to ControlTransferWrite(const UsbDev &dev,
518 * UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
519 * @tc.desc: Positive test: parameters correctly, set acm btr
520 * @tc.type: FUNC
521 */
522 HWTEST_F(UsbdTransferTest, ControlTransferWrite002, TestSize.Level1)
523 {
524 struct UsbDev dev = dev_;
525 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
526 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_OUT | USB_DDK_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
527 USB_DDK_CDC_REQ_SET_CONTROL_LINE_STATE, 0, 0, TRANSFER_TIME_OUT};
528 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlParmas, bufferData);
529 ASSERT_EQ(0, ret);
530 }
531
532 /**
533 * @tc.name: ControlTransferWrite003
534 * @tc.desc: Test functions to ControlTransferWrite(const UsbDev &dev,
535 * UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
536 * @tc.desc: Negative test: parameters exception, busNum error, standard request: get configuration
537 * @tc.type: FUNC
538 */
539 HWTEST_F(UsbdTransferTest, ControlTransferWrite003, TestSize.Level1)
540 {
541 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
542 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
543 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_OUT | USB_DDK_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
544 USB_DDK_CDC_REQ_SET_CONTROL_LINE_STATE, 0, 0, TRANSFER_TIME_OUT};
545 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlParmas, bufferData);
546 ASSERT_NE(0, ret);
547 }
548
549 /**
550 * @tc.name: ControlTransferWrite004
551 * @tc.desc: Test functions to ControlTransferWrite(const UsbDev &dev,
552 * UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
553 * @tc.desc: Negative test: parameters exception, devAddr && busNum error, standard request: get configuration
554 * @tc.type: FUNC
555 */
556 HWTEST_F(UsbdTransferTest, ControlTransferWrite004, TestSize.Level1)
557 {
558 struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
559 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
560 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_OUT | USB_DDK_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
561 USB_DDK_CDC_REQ_SET_CONTROL_LINE_STATE, 0, 0, TRANSFER_TIME_OUT};
562 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlParmas, bufferData);
563 ASSERT_NE(0, ret);
564 }
565
566 /**
567 * @tc.name: ControlTransferWrite005
568 * @tc.desc: Test functions to ControlTransferWrite(const UsbDev &dev,
569 * UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data);
570 * @tc.desc: Negative test: parameters exception, devAddr error, standard request: get configuration
571 * @tc.type: FUNC
572 */
573 HWTEST_F(UsbdTransferTest, ControlTransferWrite005, TestSize.Level1)
574 {
575 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
576 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
577 struct UsbCtrlTransfer ctrlParmas = {USB_ENDPOINT_DIR_OUT | USB_DDK_TYPE_CLASS | USB_REQUEST_TARGET_INTERFACE,
578 USB_DDK_CDC_REQ_SET_CONTROL_LINE_STATE, 0, 0, TRANSFER_TIME_OUT};
579 auto ret = g_usbInterface->ControlTransferWrite(dev, ctrlParmas, bufferData);
580 ASSERT_NE(0, ret);
581 }
582
583 /**
584 * @tc.name: InterruptTransferRead001
585 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
586 * std::vector<uint8_t> &data);
587 * @tc.desc: Positive test: parameters correctly
588 * @tc.type: FUNC
589 */
590 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead001, TestSize.Level1)
591 {
592 struct UsbDev dev = dev_;
593 uint8_t interfaceId = INTERFACEID_OK;
594 uint8_t pointId = POINTID_DIR_IN;
595 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
596 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
597 ASSERT_EQ(0, ret);
598 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
599 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
600 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
601 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead001 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
602 ret);
603 ASSERT_EQ(0, ret);
604 }
605
606 /**
607 * @tc.name: UsbdInterruptTransferRead002
608 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
609 * std::vector<uint8_t> &data);
610 * @tc.desc: Negative test: parameters exception, busNum error
611 * @tc.type: FUNC
612 */
613 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead002, TestSize.Level1)
614 {
615 struct UsbDev dev = dev_;
616 uint8_t interfaceId = INTERFACEID_OK;
617 uint8_t pointId = POINTID_DIR_IN;
618 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
619 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
620 ASSERT_EQ(0, ret);
621 dev.busNum = BUS_NUM_INVALID;
622 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
623 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
624 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
625 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead002 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
626 ret);
627 ASSERT_NE(ret, 0);
628 }
629
630 /**
631 * @tc.name: UsbdInterruptTransferRead003
632 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
633 * std::vector<uint8_t> &data);
634 * @tc.desc: Negative test: parameters exception, devAddr error
635 * @tc.type: FUNC
636 */
637 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead003, TestSize.Level1)
638 {
639 struct UsbDev dev = dev_;
640 uint8_t interfaceId = INTERFACEID_OK;
641 uint8_t pointId = POINTID_DIR_IN;
642 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
643 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
644 ASSERT_EQ(0, ret);
645 dev.devAddr = DEV_ADDR_INVALID;
646 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
647 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
648 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
649 ASSERT_NE(ret, 0);
650 }
651
652 /**
653 * @tc.name: UsbdInterruptTransferRead004
654 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
655 * std::vector<uint8_t> &data);
656 * @tc.desc: Negative test: parameters exception, intfId error
657 * @tc.type: FUNC
658 */
659 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead004, TestSize.Level1)
660 {
661 struct UsbDev dev = dev_;
662 uint8_t interfaceId = INTERFACEID_OK;
663 uint8_t pointId = POINTID_DIR_IN;
664 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
665 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
666 ASSERT_EQ(0, ret);
667 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {PIPE_INTERFACEID_INVALID, pointId};
668 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
669 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
670 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead004 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
671 ret);
672 ASSERT_NE(ret, 0);
673 }
674
675 /**
676 * @tc.name: UsbdInterruptTransferRead005
677 * @tc.desc: Test functions to InterruptTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
678 * std::vector<uint8_t> &data);
679 * @tc.desc: Negative test: parameters exception, endpointId error
680 * @tc.type: FUNC
681 */
682 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferRead005, TestSize.Level1)
683 {
684 struct UsbDev dev = dev_;
685 uint8_t interfaceId = INTERFACEID_OK;
686 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
687 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
688 ASSERT_EQ(0, ret);
689 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, PIPE_ENDPOINTID_INVALID};
690 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
691 ret = g_usbInterface->InterruptTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
692 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferRead005 %{public}d UsbdInterruptTransferRead=%{public}d", __LINE__,
693 ret);
694 ASSERT_NE(ret, 0);
695 }
696
697 /**
698 * @tc.name: UsbdBulkTransferRead001
699 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
700 * std::vector<uint8_t> &data);
701 * @tc.desc: Positive test: parameters correctly
702 * @tc.type: FUNC
703 */
704 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead001, TestSize.Level1)
705 {
706 struct UsbDev dev = dev_;
707 uint8_t interfaceId = INTERFACEID_OK;
708 uint8_t pointId = POINTID_DIR_IN;
709 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
710 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
711 ASSERT_EQ(0, ret);
712 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
713 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
714 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
715 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead001 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
716 ASSERT_EQ(0, ret);
717 }
718
719 /**
720 * @tc.name: UsbdBulkTransferRead002
721 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
722 * std::vector<uint8_t> &data);
723 * @tc.desc: Negative test: parameters exception, busNum error
724 * @tc.type: FUNC
725 */
726 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead002, TestSize.Level1)
727 {
728 struct UsbDev dev = dev_;
729 uint8_t interfaceId = INTERFACEID_OK;
730 uint8_t pointId = POINTID_DIR_IN;
731 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
732 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
733 ASSERT_EQ(0, ret);
734 dev.busNum = BUS_NUM_INVALID;
735 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
736 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
737 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
738 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead002 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
739 ASSERT_NE(ret, 0);
740 }
741
742 /**
743 * @tc.name: UsbdBulkTransferRead003
744 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
745 * std::vector<uint8_t> &data);
746 * @tc.desc: Negative test: parameters exception, devAddr error
747 * @tc.type: FUNC
748 */
749 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead003, TestSize.Level1)
750 {
751 struct UsbDev dev = dev_;
752 uint8_t interfaceId = INTERFACEID_OK;
753 uint8_t pointId = POINTID_DIR_IN;
754 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
755 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
756 ASSERT_EQ(0, ret);
757 dev.devAddr = DEV_ADDR_INVALID;
758 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
759 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
760 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
761 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead003 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
762 ASSERT_NE(ret, 0);
763 }
764
765 /**
766 * @tc.name: UsbdBulkTransferRead004
767 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
768 * std::vector<uint8_t> &data);
769 * @tc.desc: Negative test: parameters exception, intfId error
770 * @tc.type: FUNC
771 */
772 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead004, TestSize.Level1)
773 {
774 struct UsbDev dev = dev_;
775 uint8_t interfaceId = INTERFACEID_OK;
776 uint8_t pointId = POINTID_DIR_IN;
777 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
778 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
779 ASSERT_EQ(0, ret);
780 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
781 pipe.intfId = PIPE_INTERFACEID_INVALID;
782 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
783 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
784 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead004 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
785 ASSERT_NE(ret, 0);
786 }
787
788 /**
789 * @tc.name: UsbdBulkTransferRead005
790 * @tc.desc: Test functions to BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
791 * std::vector<uint8_t> &data);
792 * @tc.desc: Negative test: parameters exception, endpointId error
793 * @tc.type: FUNC
794 */
795 HWTEST_F(UsbdTransferTest, UsbdBulkTransferRead005, TestSize.Level1)
796 {
797 struct UsbDev dev = dev_;
798 uint8_t interfaceId = INTERFACEID_OK;
799 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
800 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
801 ASSERT_EQ(0, ret);
802 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, PIPE_ENDPOINTID_INVALID};
803 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
804 ret = g_usbInterface->BulkTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
805 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferRead005 %{public}d UsbdBulkTransferRead=%{public}d", __LINE__, ret);
806 ASSERT_NE(ret, 0);
807 }
808
809 /**
810 * @tc.name: UsbdIsoTransferRead001
811 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
812 * std::vector<uint8_t> &data);
813 * @tc.desc: Positive test: parameters correctly
814 * @tc.type: FUNC
815 */
816 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead001, TestSize.Level1)
817 {
818 struct UsbDev dev = dev_;
819 uint8_t interfaceId = INTERFACEID_OK;
820 uint8_t pointId = POINTID_DIR_IN;
821 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
822 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
823 ASSERT_EQ(0, ret);
824 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
825 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
826 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
827 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead001 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
828 ASSERT_EQ(0, ret);
829 }
830
831 /**
832 * @tc.name: UsbdIsoTransferRead002
833 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
834 * std::vector<uint8_t> &data);
835 * @tc.desc: Negative test: parameters exception, busNum error
836 * @tc.type: FUNC
837 */
838 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead002, TestSize.Level1)
839 {
840 struct UsbDev dev = dev_;
841 uint8_t interfaceId = INTERFACEID_OK;
842 uint8_t pointId = POINTID_DIR_IN;
843 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d interfaceId=%{public}d", __LINE__, interfaceId);
844 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
845 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
846 ASSERT_EQ(0, ret);
847 dev.busNum = BUS_NUM_INVALID;
848 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
849 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
850 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
851 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead002 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
852 ASSERT_NE(ret, 0);
853 }
854
855 /**
856 * @tc.name: UsbdIsoTransferRead003
857 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
858 * std::vector<uint8_t> &data);
859 * @tc.desc: Negative test: parameters exception, devAddr error
860 * @tc.type: FUNC
861 */
862 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead003, TestSize.Level1)
863 {
864 struct UsbDev dev = dev_;
865 uint8_t interfaceId = INTERFACEID_OK;
866 uint8_t pointId = POINTID_DIR_IN;
867 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
868 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
869 ASSERT_EQ(0, ret);
870 dev.devAddr = DEV_ADDR_INVALID;
871 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
872 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
873 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
874 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead003 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
875 ASSERT_NE(ret, 0);
876 }
877
878 /**
879 * @tc.name: UsbdIsoTransferRead004
880 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
881 * std::vector<uint8_t> &data);
882 * @tc.desc: Negative test: parameters exception, intfId error
883 * @tc.type: FUNC
884 */
885 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead004, TestSize.Level1)
886 {
887 struct UsbDev dev = dev_;
888 uint8_t interfaceId = INTERFACEID_OK;
889 uint8_t pointId = POINTID_DIR_IN;
890 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
891 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
892 ASSERT_EQ(0, ret);
893 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {PIPE_INTERFACEID_INVALID, pointId};
894 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
895 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
896 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead004 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
897 ASSERT_NE(ret, 0);
898 }
899
900 /**
901 * @tc.name: UsbdIsoTransferRead005
902 * @tc.desc: Test functions to IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
903 * std::vector<uint8_t> &data);
904 * @tc.desc: Negative test: parameters exception, endpointId error
905 * @tc.type: FUNC
906 */
907 HWTEST_F(UsbdTransferTest, UsbdIsoTransferRead005, TestSize.Level1)
908 {
909 struct UsbDev dev = dev_;
910 uint8_t interfaceId = INTERFACEID_OK;
911 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
912 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
913 ASSERT_EQ(0, ret);
914 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, PIPE_ENDPOINTID_INVALID};
915 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
916 ret = g_usbInterface->IsoTransferRead(dev, pipe, TRANSFER_TIME_OUT, bufferData);
917 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferRead005 %{public}d UsbdIsoTransferRead=%{public}d", __LINE__, ret);
918 ASSERT_NE(ret, 0);
919 }
920
921 /**
922 * @tc.name: UsbdBulkTransferWrite001
923 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
924 * std::vector<uint8_t> &data);
925 * @tc.desc: Positive test: parameters correctly
926 * @tc.type: FUNC
927 */
928 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite001, TestSize.Level1)
929 {
930 struct UsbDev dev = dev_;
931 uint8_t interfaceId = INTERFACEID_OK;
932 uint8_t pointId = POINTID_DIR_OUT;
933 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
934 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
935 ASSERT_EQ(0, ret);
936 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
937 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '1'};
938 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
939 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite001 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
940 ASSERT_EQ(0, ret);
941 }
942
943 /**
944 * @tc.name: UsbdBulkTransferWrite002
945 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
946 * std::vector<uint8_t> &data);
947 * @tc.desc: Negative test: parameters exception, busNum error
948 * @tc.type: FUNC
949 */
950 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite002, TestSize.Level1)
951 {
952 struct UsbDev dev = dev_;
953 uint8_t interfaceId = INTERFACEID_OK;
954 uint8_t pointId = POINTID_DIR_OUT;
955 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
956 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
957 ASSERT_EQ(0, ret);
958 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
959 dev.busNum = BUS_NUM_INVALID;
960 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '2'};
961 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
962 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite002 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
963 ASSERT_NE(ret, 0);
964 }
965
966 /**
967 * @tc.name: UsbdBulkTransferWrite003
968 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
969 * std::vector<uint8_t> &data);
970 * @tc.desc: Negative test: parameters exception, devAddr error
971 * @tc.type: FUNC
972 */
973 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite003, TestSize.Level1)
974 {
975 struct UsbDev dev = dev_;
976 uint8_t interfaceId = INTERFACEID_OK;
977 uint8_t pointId = POINTID_DIR_OUT;
978 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
979 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
980 ASSERT_EQ(0, ret);
981 dev.devAddr = DEV_ADDR_INVALID;
982 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
983 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '3'};
984 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
985 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite003 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
986 ASSERT_NE(ret, 0);
987 }
988
989 /**
990 * @tc.name: UsbdBulkTransferWrite004
991 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
992 * std::vector<uint8_t> &data);
993 * @tc.desc: Negative test: parameters exception, intfId error
994 * @tc.type: FUNC
995 */
996 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite004, TestSize.Level1)
997 {
998 struct UsbDev dev = dev_;
999 uint8_t interfaceId = INTERFACEID_OK;
1000 uint8_t pointId = POINTID_DIR_OUT;
1001 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1002 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1003 ASSERT_EQ(0, ret);
1004 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1005 pipe.intfId = PIPE_INTERFACEID_INVALID;
1006 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '4'};
1007 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1008 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite004 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1009 ASSERT_NE(ret, 0);
1010 }
1011
1012 /**
1013 * @tc.name: UsbdBulkTransferWrite005
1014 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1015 * std::vector<uint8_t> &data);
1016 * @tc.desc: Negative test: parameters exception, endpointId error
1017 * @tc.type: FUNC
1018 */
1019 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite005, TestSize.Level1)
1020 {
1021 struct UsbDev dev = dev_;
1022 uint8_t interfaceId = INTERFACEID_OK;
1023 uint8_t pointId = POINTID_DIR_OUT;
1024 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1025 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1026 ASSERT_EQ(0, ret);
1027 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1028 pipe.endpointId = PIPE_ENDPOINTID_INVALID;
1029 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '5'};
1030 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1031 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite005 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1032 ASSERT_NE(ret, 0);
1033 }
1034
1035 /**
1036 * @tc.name: UsbdBulkTransferWrite006
1037 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1038 * std::vector<uint8_t> &data);
1039 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
1040 * @tc.type: FUNC
1041 */
1042 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite006, TestSize.Level1)
1043 {
1044 struct UsbDev dev = dev_;
1045 uint8_t interfaceId = INTERFACEID_OK;
1046 uint8_t pointId = POINTID_DIR_OUT;
1047 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1048 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1049 ASSERT_EQ(0, ret);
1050 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1051 dev.busNum = BUS_NUM_INVALID;
1052 dev.devAddr = DEV_ADDR_INVALID;
1053 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '6'};
1054 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1055 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite006 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1056 ASSERT_NE(ret, 0);
1057 }
1058
1059 /**
1060 * @tc.name: UsbdBulkTransferWrite007
1061 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1062 * std::vector<uint8_t> &data);
1063 * @tc.desc: Negative test: parameters exception, ClaimInterface failed first
1064 * @tc.type: FUNC
1065 */
1066 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite007, TestSize.Level1)
1067 {
1068 struct UsbDev dev = dev_;
1069 uint8_t interfaceId = INTERFACEID_OK;
1070 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
1071 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1072 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1073 ASSERT_EQ(0, ret);
1074 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1075 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '7'};
1076 ret = g_usbInterface->BulkTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1077 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite007 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1078 ASSERT_NE(ret, 0);
1079 }
1080
1081 /**
1082 * @tc.name: UsbdBulkTransferWrite008
1083 * @tc.desc: Test functions to BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1084 * std::vector<uint8_t> &data);
1085 * @tc.desc: Positive test: parameters correctly, different in timeout
1086 * @tc.type: FUNC
1087 */
1088 HWTEST_F(UsbdTransferTest, UsbdBulkTransferWrite008, TestSize.Level1)
1089 {
1090 struct UsbDev dev = dev_;
1091 uint8_t interfaceId = INTERFACEID_OK;
1092 uint8_t pointId = POINTID_DIR_OUT;
1093 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1094 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1095 ASSERT_EQ(0, ret);
1096 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1097 std::vector<uint8_t> bufferData = {'b', 'u', 'l', 'k', 'w', 'r', 'i', 't', 'e', '0', '8'};
1098 ret = g_usbInterface->BulkTransferWrite(dev, pipe, -1, bufferData);
1099 HDF_LOGI("UsbdTransferTest::UsbdBulkTransferWrite008 %{public}d BulkTransferWrite=%{public}d", __LINE__, ret);
1100 ASSERT_EQ(0, ret);
1101 }
1102
1103 /**
1104 * @tc.name: UsbdInterruptTransferWrite001
1105 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1106 * std::vector<uint8_t> &data);
1107 * @tc.desc: Positive test: parameters correctly
1108 * @tc.type: FUNC
1109 */
1110 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite001, TestSize.Level1)
1111 {
1112 struct UsbDev dev = dev_;
1113 uint8_t interfaceId = INTERFACEID_OK;
1114 uint8_t pointId = POINTID_DIR_OUT;
1115 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1116 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1117 ASSERT_EQ(0, ret);
1118 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1119 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '1'};
1120 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1121 HDF_LOGI(
1122 "UsbdTransferTest::UsbdInterruptTransferWrite001 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
1123 ASSERT_EQ(0, ret);
1124 }
1125
1126 /**
1127 * @tc.name: UsbdInterruptTransferWrite002
1128 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1129 * std::vector<uint8_t> &data);
1130 * @tc.desc: Negative test: parameters exception, busNum error
1131 * @tc.type: FUNC
1132 */
1133 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite002, TestSize.Level1)
1134 {
1135 struct UsbDev dev = dev_;
1136 uint8_t interfaceId = INTERFACEID_OK;
1137 uint8_t pointId = POINTID_DIR_OUT;
1138 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1139 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1140 ASSERT_EQ(0, ret);
1141 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1142 dev.busNum = BUS_NUM_INVALID;
1143 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '2'};
1144 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1145 HDF_LOGI(
1146 "UsbdTransferTest::UsbdInterruptTransferWrite002 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
1147 ASSERT_NE(ret, 0);
1148 }
1149
1150 /**
1151 * @tc.name: UsbdInterruptTransferWrite003
1152 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1153 * std::vector<uint8_t> &data);
1154 * @tc.desc: Negative test: parameters exception, devAddr error
1155 * @tc.type: FUNC
1156 */
1157 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite003, TestSize.Level1)
1158 {
1159 struct UsbDev dev = dev_;
1160 uint8_t interfaceId = INTERFACEID_OK;
1161 uint8_t pointId = POINTID_DIR_OUT;
1162 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1163 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1164 ASSERT_EQ(0, ret);
1165 dev.devAddr = DEV_ADDR_INVALID;
1166 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1167 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '3'};
1168 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1169 HDF_LOGI(
1170 "UsbdTransferTest::UsbdInterruptTransferWrite003 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
1171 ASSERT_NE(ret, 0);
1172 }
1173
1174 /**
1175 * @tc.name: UsbdInterruptTransferWrite004
1176 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1177 * std::vector<uint8_t> &data);
1178 * @tc.desc: Negative test: parameters exception, intfId error
1179 * @tc.type: FUNC
1180 */
1181 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite004, TestSize.Level1)
1182 {
1183 struct UsbDev dev = dev_;
1184 uint8_t interfaceId = INTERFACEID_OK;
1185 uint8_t pointId = POINTID_DIR_OUT;
1186 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1187 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1188 ASSERT_EQ(0, ret);
1189 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {PIPE_INTERFACEID_INVALID, pointId};
1190 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '4'};
1191 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1192 HDF_LOGI(
1193 "UsbdTransferTest::UsbdInterruptTransferWrite004 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
1194 ASSERT_NE(ret, 0);
1195 }
1196
1197 /**
1198 * @tc.name: UsbdInterruptTransferWrite005
1199 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1200 * std::vector<uint8_t> &data);
1201 * @tc.desc: Negative test: parameters exception, endpointId error
1202 * @tc.type: FUNC
1203 */
1204 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite005, TestSize.Level1)
1205 {
1206 struct UsbDev dev = dev_;
1207 uint8_t interfaceId = INTERFACEID_OK;
1208 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1209 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1210 ASSERT_EQ(0, ret);
1211 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, PIPE_ENDPOINTID_INVALID};
1212 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '5'};
1213 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1214 HDF_LOGI(
1215 "UsbdTransferTest::UsbdInterruptTransferWrite005 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
1216 ASSERT_NE(ret, 0);
1217 }
1218
1219 /**
1220 * @tc.name: UsbdInterruptTransferWrite006
1221 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1222 * std::vector<uint8_t> &data);
1223 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
1224 * @tc.type: FUNC
1225 */
1226 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite006, TestSize.Level1)
1227 {
1228 struct UsbDev dev = dev_;
1229 uint8_t interfaceId = INTERFACEID_OK;
1230 uint8_t pointId = POINTID_DIR_OUT;
1231 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1232 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1233 ASSERT_EQ(0, ret);
1234 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1235 dev.busNum = BUS_NUM_INVALID;
1236 dev.devAddr = DEV_ADDR_INVALID;
1237 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '6'};
1238 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1239 HDF_LOGI(
1240 "UsbdTransferTest::UsbdInterruptTransferWrite006 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
1241 ASSERT_NE(ret, 0);
1242 }
1243
1244 /**
1245 * @tc.name: UsbdInterruptTransferWrite007
1246 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1247 * std::vector<uint8_t> &data);
1248 * @tc.desc: Negative test: parameters exception, ClaimInterface failed first
1249 * @tc.type: FUNC
1250 */
1251 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite007, TestSize.Level1)
1252 {
1253 struct UsbDev dev = dev_;
1254 uint8_t interfaceId = INTERFACEID_OK;
1255 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
1256 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1257 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1258 ASSERT_EQ(0, ret);
1259 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1260 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '7'};
1261 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1262 HDF_LOGI(
1263 "UsbdTransferTest::UsbdInterruptTransferWrite007 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
1264 ASSERT_NE(ret, 0);
1265 }
1266
1267 /**
1268 * @tc.name: UsbdInterruptTransferWrite008
1269 * @tc.desc: Test functions to InterruptTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1270 * std::vector<uint8_t> &data);
1271 * Positive test: parameters correctly, different in timeout
1272 * @tc.type: FUNC
1273 */
1274 HWTEST_F(UsbdTransferTest, UsbdInterruptTransferWrite008, TestSize.Level1)
1275 {
1276 struct UsbDev dev = dev_;
1277 uint8_t interfaceId = INTERFACEID_OK;
1278 uint8_t pointId = POINTID_DIR_OUT;
1279 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1280 HDF_LOGI("UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1281 ASSERT_EQ(0, ret);
1282 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1283 std::vector<uint8_t> bufferData = {'i', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '8'};
1284 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, -1, bufferData);
1285 HDF_LOGI(
1286 "UsbdTransferTest::UsbdInterruptTransferWrite008 %{public}d InterruptTransferWrite=%{public}d", __LINE__, ret);
1287 ASSERT_EQ(0, ret);
1288 }
1289
1290 /**
1291 * @tc.name: UsbdIsoTransferWrite001
1292 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1293 * std::vector<uint8_t> &data);
1294 * @tc.desc: Positive test: parameters correctly
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite001, TestSize.Level1)
1298 {
1299 struct UsbDev dev = dev_;
1300 uint8_t interfaceId = INTERFACEID_OK;
1301 uint8_t pointId = POINTID_DIR_OUT;
1302 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1303 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1304 ASSERT_EQ(0, ret);
1305 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1306 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '1'};
1307 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1308 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite001 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1309 ASSERT_EQ(0, ret);
1310 }
1311
1312 /**
1313 * @tc.name: UsbdIsoTransferWrite002
1314 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1315 * std::vector<uint8_t> &data);
1316 * @tc.desc: Negative test: parameters exception, busNum error
1317 * @tc.type: FUNC
1318 */
1319 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite002, TestSize.Level1)
1320 {
1321 struct UsbDev dev = dev_;
1322 uint8_t interfaceId = INTERFACEID_OK;
1323 uint8_t pointId = POINTID_DIR_OUT;
1324 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1325 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1326 ASSERT_EQ(0, ret);
1327 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1328 dev.busNum = BUS_NUM_INVALID;
1329 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '2'};
1330 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1331 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite002 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1332 ASSERT_NE(ret, 0);
1333 }
1334
1335 /**
1336 * @tc.name: UsbdIsoTransferWrite003
1337 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1338 * std::vector<uint8_t> &data);
1339 * @tc.desc: Negative test: parameters exception, devAddr error
1340 * @tc.type: FUNC
1341 */
1342 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite003, TestSize.Level1)
1343 {
1344 struct UsbDev dev = dev_;
1345 uint8_t interfaceId = INTERFACEID_OK;
1346 uint8_t pointId = POINTID_DIR_OUT;
1347 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1348 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1349 ASSERT_EQ(0, ret);
1350 dev.devAddr = DEV_ADDR_INVALID;
1351 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1352 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '3'};
1353 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1354 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite003 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1355 ASSERT_NE(ret, 0);
1356 }
1357
1358 /**
1359 * @tc.name: UsbdIsoTransferWrite004
1360 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1361 * std::vector<uint8_t> &data);
1362 * @tc.desc: Negative test: parameters exception, intfId error
1363 * @tc.type: FUNC
1364 */
1365 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite004, TestSize.Level1)
1366 {
1367 struct UsbDev dev = dev_;
1368 uint8_t interfaceId = INTERFACEID_OK;
1369 uint8_t pointId = POINTID_DIR_OUT;
1370 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1371 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1372 ASSERT_EQ(0, ret);
1373 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {PIPE_INTERFACEID_INVALID, pointId};
1374 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '4'};
1375 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1376 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite004 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1377 ASSERT_NE(ret, 0);
1378 }
1379
1380 /**
1381 * @tc.name: UsbdIsoTransferWrite005
1382 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1383 * std::vector<uint8_t> &data);
1384 * @tc.desc: Negative test: parameters exception, endpointId error
1385 * @tc.type: FUNC
1386 */
1387 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite005, TestSize.Level1)
1388 {
1389 struct UsbDev dev = dev_;
1390 uint8_t interfaceId = INTERFACEID_OK;
1391 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1392 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1393 ASSERT_EQ(0, ret);
1394 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, PIPE_ENDPOINTID_INVALID};
1395 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '5'};
1396 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1397 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite005 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1398 ASSERT_NE(ret, 0);
1399 }
1400
1401 /**
1402 * @tc.name: UsbdIsoTransferWrite006
1403 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1404 * std::vector<uint8_t> &data);
1405 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
1406 * @tc.type: FUNC
1407 */
1408 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite006, TestSize.Level1)
1409 {
1410 struct UsbDev dev = dev_;
1411 uint8_t interfaceId = INTERFACEID_OK;
1412 uint8_t pointId = POINTID_DIR_OUT;
1413 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1414 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite006 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1415 ASSERT_EQ(0, ret);
1416 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1417 dev.busNum = BUS_NUM_INVALID;
1418 dev.devAddr = DEV_ADDR_INVALID;
1419 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '6'};
1420 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1421 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite006 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1422 ASSERT_NE(ret, 0);
1423 }
1424
1425 /**
1426 * @tc.name: UsbdIsoTransferWrite007
1427 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1428 * std::vector<uint8_t> &data);
1429 * @tc.desc: Negative test: parameters exception, endpointId error, ClaimInterface failed first
1430 * @tc.type: FUNC
1431 */
1432 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite007, TestSize.Level1)
1433 {
1434 struct UsbDev dev = dev_;
1435 uint8_t interfaceId = INTERFACEID_OK;
1436 uint8_t pointId = PIPE_ENDPOINTID_INVALID;
1437 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1438 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite007 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1439 ASSERT_EQ(0, ret);
1440 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1441 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '7'};
1442 ret = g_usbInterface->IsoTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
1443 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite007 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1444 ASSERT_NE(ret, 0);
1445 }
1446
1447 /**
1448 * @tc.name: UsbdIsoTransferWrite008
1449 * @tc.desc: Test functions to IsoTransferWrite(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
1450 * std::vector<uint8_t> &data);
1451 * @tc.desc: Positive test: parameters correctly, different in timeout
1452 * @tc.type: FUNC
1453 */
1454 HWTEST_F(UsbdTransferTest, UsbdIsoTransferWrite008, TestSize.Level1)
1455 {
1456 struct UsbDev dev = dev_;
1457 uint8_t interfaceId = INTERFACEID_OK;
1458 uint8_t pointId = POINTID_DIR_OUT;
1459 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1460 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1461 ASSERT_EQ(0, ret);
1462 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1463 std::vector<uint8_t> bufferData = {'i', 's', 'o', 'w', 'r', 'i', 't', 'e', '0', '8'};
1464 ret = g_usbInterface->IsoTransferWrite(dev, pipe, -1, bufferData);
1465 HDF_LOGI("UsbdTransferTest::UsbdIsoTransferWrite008 %{public}d IsoTransferWrite=%{public}d", __LINE__, ret);
1466 ASSERT_EQ(0, ret);
1467 }
1468
1469 /**
1470 * @tc.name: BulkWrite001
1471 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1472 * @tc.desc: Positive test: parameters correctly
1473 * @tc.type: FUNC
1474 */
1475 HWTEST_F(UsbdTransferTest, BulkWrite001, TestSize.Level1)
1476 {
1477 sptr<Ashmem> ashmem;
1478 uint8_t rflg = 0;
1479 int32_t asmSize = MAX_BUFFER_LENGTH;
1480 struct UsbDev dev = dev_;
1481 uint8_t interfaceId = INTERFACEID_OK;
1482 uint8_t pointId = POINTID_DIR_IN;
1483 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1484 HDF_LOGI("UsbdTransferTest::BulkWrite001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1485 ASSERT_EQ(0, ret);
1486 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1487 (void)InitAshmemOne(ashmem, asmSize, rflg);
1488 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1489 HDF_LOGI("UsbdTransferTest::BulkWrite001 %{public}d BulkWrite=%{public}d", __LINE__, ret);
1490 ASSERT_EQ(ret, 0);
1491 }
1492
1493 /**
1494 * @tc.name: BulkWrite002
1495 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1496 * @tc.desc: Negative test: parameters exception, busNum error
1497 * @tc.type: FUNC
1498 */
1499 HWTEST_F(UsbdTransferTest, BulkWrite002, TestSize.Level1)
1500 {
1501 sptr<Ashmem> ashmem;
1502 uint8_t rflg = 0;
1503 int32_t asmSize = MAX_BUFFER_LENGTH;
1504 struct UsbDev dev = dev_;
1505 uint8_t interfaceId = INTERFACEID_OK;
1506 uint8_t pointId = POINTID_DIR_OUT;
1507 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1508 HDF_LOGI("UsbdTransferTest::BulkWrite002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1509 ASSERT_EQ(0, ret);
1510 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1511 dev.busNum = BUS_NUM_INVALID;
1512 (void)InitAshmemOne(ashmem, asmSize, rflg);
1513 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1514 HDF_LOGI("UsbdTransferTest::BulkWrite002 %{public}d BulkWrite=%{public}d", __LINE__, ret);
1515 ASSERT_NE(ret, 0);
1516 }
1517
1518 /**
1519 * @tc.name: BulkWrite003
1520 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1521 * @tc.desc: Negative test: parameters exception, devAddr error
1522 * @tc.type: FUNC
1523 */
1524 HWTEST_F(UsbdTransferTest, BulkWrite003, TestSize.Level1)
1525 {
1526 sptr<Ashmem> ashmem;
1527 uint8_t rflg = 0;
1528 int32_t asmSize = MAX_BUFFER_LENGTH;
1529 struct UsbDev dev = dev_;
1530 uint8_t interfaceId = INTERFACEID_OK;
1531 uint8_t pointId = POINTID_DIR_OUT;
1532 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1533 HDF_LOGI("UsbdTransferTest::BulkWrite003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1534 ASSERT_EQ(0, ret);
1535 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1536 dev.devAddr = DEV_ADDR_INVALID;
1537 (void)InitAshmemOne(ashmem, asmSize, rflg);
1538 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1539 HDF_LOGI("UsbdTransferTest::BulkWrite003 %{public}d BulkWrite=%{public}d", __LINE__, ret);
1540 ASSERT_NE(ret, 0);
1541 }
1542
1543 /**
1544 * @tc.name: BulkWrite004
1545 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1546 * @tc.desc: Negative test: parameters exception, intfId error
1547 * @tc.type: FUNC
1548 */
1549 HWTEST_F(UsbdTransferTest, BulkWrite004, TestSize.Level1)
1550 {
1551 sptr<Ashmem> ashmem;
1552 uint8_t rflg = 0;
1553 int32_t asmSize = MAX_BUFFER_LENGTH;
1554 struct UsbDev dev = dev_;
1555 uint8_t interfaceId = INTERFACEID_OK;
1556 uint8_t pointId = POINTID_DIR_OUT;
1557 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1558 HDF_LOGI("UsbdTransferTest::BulkWrite004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1559 ASSERT_EQ(0, ret);
1560 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {PIPE_INTERFACEID_INVALID, pointId};
1561 (void)InitAshmemOne(ashmem, asmSize, rflg);
1562 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1563 HDF_LOGI("UsbdTransferTest::BulkWrite004 %{public}d BulkWrite=%{public}d", __LINE__, ret);
1564 ASSERT_NE(ret, 0);
1565 }
1566
1567 /**
1568 * @tc.name: BulkWrite005
1569 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1570 * @tc.desc: Negative test: parameters exception, endpointId error
1571 * @tc.type: FUNC
1572 */
1573 HWTEST_F(UsbdTransferTest, BulkWrite005, TestSize.Level1)
1574 {
1575 sptr<Ashmem> ashmem;
1576 uint8_t rflg = 0;
1577 int32_t asmSize = MAX_BUFFER_LENGTH;
1578 struct UsbDev dev = dev_;
1579 uint8_t interfaceId = INTERFACEID_OK;
1580 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1581 HDF_LOGI("UsbdTransferTest::BulkWrite005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1582 ASSERT_EQ(0, ret);
1583 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, PIPE_ENDPOINTID_INVALID};
1584 (void)InitAshmemOne(ashmem, asmSize, rflg);
1585 ret = g_usbInterface->BulkWrite(dev, pipe, ashmem);
1586 HDF_LOGI("UsbdTransferTest::BulkWrite005 %{public}d BulkWrite=%{public}d", __LINE__, ret);
1587 ASSERT_NE(ret, 0);
1588 }
1589
1590 /**
1591 * @tc.name: BulkRead001
1592 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1593 * @tc.desc: Positive test: parameters correctly
1594 * @tc.type: FUNC
1595 */
1596 HWTEST_F(UsbdTransferTest, BulkRead001, TestSize.Level1)
1597 {
1598 sptr<Ashmem> ashmem;
1599 uint8_t rflg = 0;
1600 int32_t asmSize = MAX_BUFFER_LENGTH;
1601 struct UsbDev dev = dev_;
1602 uint8_t interfaceId = INTERFACEID_OK;
1603 uint8_t pointId = POINTID_DIR_IN;
1604 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1605 HDF_LOGI("UsbdTransferTest::BulkRead001 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1606 ASSERT_EQ(0, ret);
1607 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1608 (void)InitAshmemOne(ashmem, asmSize, rflg);
1609 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1610 HDF_LOGI("UsbdTransferTest::BulkRead001 %{public}d BulkRead=%{public}d", __LINE__, ret);
1611 ASSERT_EQ(ret, 0);
1612 }
1613
1614 /**
1615 * @tc.name: BulkRead002
1616 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1617 * @tc.desc: Negative test: parameters exception, busNum error
1618 * @tc.type: FUNC
1619 */
1620 HWTEST_F(UsbdTransferTest, BulkRead002, TestSize.Level1)
1621 {
1622 sptr<Ashmem> ashmem;
1623 uint8_t rflg = 0;
1624 int32_t asmSize = MAX_BUFFER_LENGTH;
1625 struct UsbDev dev = dev_;
1626 uint8_t interfaceId = INTERFACEID_OK;
1627 uint8_t pointId = POINTID_DIR_OUT;
1628 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1629 HDF_LOGI("UsbdTransferTest::BulkRead002 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1630 ASSERT_EQ(0, ret);
1631 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1632 dev.busNum = BUS_NUM_INVALID;
1633 (void)InitAshmemOne(ashmem, asmSize, rflg);
1634 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1635 HDF_LOGI("UsbdTransferTest::BulkRead002 %{public}d BulkRead=%{public}d", __LINE__, ret);
1636 ASSERT_NE(ret, 0);
1637 }
1638
1639 /**
1640 * @tc.name: BulkRead003
1641 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1642 * @tc.desc: Negative test: parameters exception, devAddr error
1643 * @tc.type: FUNC
1644 */
1645 HWTEST_F(UsbdTransferTest, BulkRead003, TestSize.Level1)
1646 {
1647 sptr<Ashmem> ashmem;
1648 uint8_t rflg = 0;
1649 int32_t asmSize = MAX_BUFFER_LENGTH;
1650 struct UsbDev dev = dev_;
1651 uint8_t interfaceId = INTERFACEID_OK;
1652 uint8_t pointId = POINTID_DIR_OUT;
1653 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1654 HDF_LOGI("UsbdTransferTest::BulkRead003 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1655 ASSERT_EQ(0, ret);
1656 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1657 dev.devAddr = DEV_ADDR_INVALID;
1658 (void)InitAshmemOne(ashmem, asmSize, rflg);
1659 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1660 HDF_LOGI("UsbdTransferTest::BulkRead003 %{public}d BulkRead=%{public}d", __LINE__, ret);
1661 ASSERT_NE(ret, 0);
1662 }
1663
1664 /**
1665 * @tc.name: BulkRead004
1666 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1667 * @tc.desc: Negative test: parameters exception, intfId error
1668 * @tc.type: FUNC
1669 */
1670 HWTEST_F(UsbdTransferTest, BulkRead004, TestSize.Level1)
1671 {
1672 sptr<Ashmem> ashmem;
1673 uint8_t rflg = 0;
1674 int32_t asmSize = MAX_BUFFER_LENGTH;
1675 struct UsbDev dev = dev_;
1676 uint8_t interfaceId = INTERFACEID_OK;
1677 uint8_t pointId = POINTID_DIR_OUT;
1678 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1679 HDF_LOGI("UsbdTransferTest::BulkRead004 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1680 ASSERT_EQ(0, ret);
1681 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {PIPE_INTERFACEID_INVALID, pointId};
1682 (void)InitAshmemOne(ashmem, asmSize, rflg);
1683 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1684 HDF_LOGI("UsbdTransferTest::BulkRead004 %{public}d BulkRead=%{public}d", __LINE__, ret);
1685 ASSERT_NE(ret, 0);
1686 }
1687
1688 /**
1689 * @tc.name: BulkRead005
1690 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
1691 * @tc.desc: Negative test: parameters exception, endpointId error
1692 * @tc.type: FUNC
1693 */
1694 HWTEST_F(UsbdTransferTest, BulkRead005, TestSize.Level1)
1695 {
1696 sptr<Ashmem> ashmem;
1697 uint8_t rflg = 0;
1698 int32_t asmSize = MAX_BUFFER_LENGTH;
1699 struct UsbDev dev = dev_;
1700 uint8_t interfaceId = INTERFACEID_OK;
1701 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
1702 HDF_LOGI("UsbdTransferTest::BulkRead005 %{public}d ClaimInterface=%{public}d", __LINE__, ret);
1703 ASSERT_EQ(0, ret);
1704 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, PIPE_ENDPOINTID_INVALID};
1705 (void)InitAshmemOne(ashmem, asmSize, rflg);
1706 ret = g_usbInterface->BulkRead(dev, pipe, ashmem);
1707 HDF_LOGI("UsbdTransferTest::BulkRead005 %{public}d BulkRead=%{public}d", __LINE__, ret);
1708 ASSERT_NE(ret, 0);
1709 }
1710
1711 /**
1712 * @tc.name: RegBulkCallback001
1713 * @tc.desc: Test functions to RegBulkCallback
1714 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
1715 * @tc.desc: Positive test: parameters correctly
1716 * @tc.type: FUNC
1717 */
1718 HWTEST_F(UsbdTransferTest, RegBulkCallback001, TestSize.Level1)
1719 {
1720 struct UsbDev dev = dev_;
1721 uint8_t interfaceId = INTERFACEID_OK;
1722 uint8_t pointId = POINTID_DIR_OUT;
1723 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1724 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1725 if (usbdBulkCallback == nullptr) {
1726 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1727 exit(0);
1728 }
1729 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1730 HDF_LOGI("UsbdTransferTest::RegBulkCallback001 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1731 ASSERT_EQ(ret, 0);
1732 }
1733
1734 /**
1735 * @tc.name: RegBulkCallback002
1736 * @tc.desc: Test functions to RegBulkCallback
1737 * @tc.desc: int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
1738 * @tc.desc: Negative test: parameters exception, busNum error
1739 * @tc.type: FUNC
1740 */
1741 HWTEST_F(UsbdTransferTest, RegBulkCallback002, TestSize.Level1)
1742 {
1743 struct UsbDev dev = dev_;
1744 uint8_t interfaceId = INTERFACEID_OK;
1745 uint8_t pointId = POINTID_DIR_OUT;
1746 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1747 dev.busNum = BUS_NUM_INVALID;
1748 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1749 if (usbdBulkCallback == nullptr) {
1750 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1751 exit(0);
1752 }
1753 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1754 HDF_LOGI("UsbdTransferTest::RegBulkCallback002 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1755 ASSERT_NE(ret, 0);
1756 }
1757
1758 /**
1759 * @tc.name: RegBulkCallback003
1760 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe,
1761 * const sptr<IUsbdBulkCallback> &cb)
1762 * @tc.desc: Negative test: parameters exception, devAddr error
1763 * @tc.type: FUNC
1764 */
1765 HWTEST_F(UsbdTransferTest, RegBulkCallback003, TestSize.Level1)
1766 {
1767 struct UsbDev dev = dev_;
1768 uint8_t interfaceId = INTERFACEID_OK;
1769 uint8_t pointId = POINTID_DIR_OUT;
1770 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1771 dev.devAddr = DEV_ADDR_INVALID;
1772 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1773 if (usbdBulkCallback == nullptr) {
1774 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1775 exit(0);
1776 }
1777 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1778 HDF_LOGI("UsbdTransferTest::RegBulkCallback003 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1779 ASSERT_NE(ret, 0);
1780 }
1781
1782 /**
1783 * @tc.name: RegBulkCallback004
1784 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe,
1785 * const sptr<IUsbdBulkCallback> &cb)
1786 * @tc.desc: Negative test: parameters exception, intfId error
1787 * @tc.type: FUNC
1788 */
1789 HWTEST_F(UsbdTransferTest, RegBulkCallback004, TestSize.Level1)
1790 {
1791 struct UsbDev dev = dev_;
1792 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {PIPE_INTERFACEID_INVALID, POINTID_DIR_OUT};
1793 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1794 if (usbdBulkCallback == nullptr) {
1795 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1796 exit(0);
1797 }
1798 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1799 HDF_LOGI("UsbdTransferTest::RegBulkCallback004 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1800 ASSERT_NE(ret, 0);
1801 }
1802
1803 /**
1804 * @tc.name: RegBulkCallback005
1805 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe,
1806 * const sptr<IUsbdBulkCallback> &cb)
1807 * @tc.desc: Negative test: parameters exception, cb error
1808 * @tc.type: FUNC
1809 */
1810 HWTEST_F(UsbdTransferTest, RegBulkCallback005, TestSize.Level1)
1811 {
1812 struct UsbDev dev = dev_;
1813 uint8_t interfaceId = INTERFACEID_OK;
1814 uint8_t pointId = POINTID_DIR_OUT;
1815 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1816 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, nullptr);
1817 HDF_LOGI("UsbdTransferTest::RegBulkCallback005 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1818 ASSERT_NE(ret, 0);
1819 }
1820
1821 /**
1822 * @tc.name: UnRegBulkCallback001
1823 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
1824 * @tc.desc: Positive test: parameters correctly
1825 * @tc.type: FUNC
1826 */
1827 HWTEST_F(UsbdTransferTest, UnRegBulkCallback001, TestSize.Level1)
1828 {
1829 struct UsbDev dev = dev_;
1830 uint8_t interfaceId = INTERFACEID_OK;
1831 uint8_t pointId = POINTID_DIR_OUT;
1832 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1833 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1834 if (usbdBulkCallback == nullptr) {
1835 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1836 exit(0);
1837 }
1838 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1839 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback001 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1840 ASSERT_EQ(ret, 0);
1841 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1842 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback001 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1843 ASSERT_EQ(ret, 0);
1844 }
1845
1846 /**
1847 * @tc.name: UnRegBulkCallback002
1848 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
1849 * @tc.desc: Negative test: parameters exception, devAddr error
1850 * @tc.type: FUNC
1851 */
1852 HWTEST_F(UsbdTransferTest, UnRegBulkCallback002, TestSize.Level1)
1853 {
1854 struct UsbDev dev = dev_;
1855 uint8_t interfaceId = INTERFACEID_OK;
1856 uint8_t pointId = POINTID_DIR_OUT;
1857 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1858 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1859 if (usbdBulkCallback == nullptr) {
1860 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1861 exit(0);
1862 }
1863 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1864 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback002 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1865 ASSERT_EQ(ret, 0);
1866 dev.devAddr = DEV_ADDR_INVALID;
1867 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1868 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback002 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1869 ASSERT_NE(ret, 0);
1870 dev = dev_;
1871 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1872 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback002 %{public}d again UnRegBulkCallback=%{public}d", __LINE__, ret);
1873 ASSERT_EQ(ret, 0);
1874 }
1875
1876 /**
1877 * @tc.name: UnRegBulkCallback003
1878 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
1879 * @tc.desc: Negative test: parameters exception, intfId error
1880 * @tc.type: FUNC
1881 */
1882 HWTEST_F(UsbdTransferTest, UnRegBulkCallback003, TestSize.Level1)
1883 {
1884 struct UsbDev dev = dev_;
1885 uint8_t interfaceId = INTERFACEID_OK;
1886 uint8_t pointId = POINTID_DIR_OUT;
1887 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1888 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1889 if (usbdBulkCallback == nullptr) {
1890 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1891 exit(0);
1892 }
1893 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1894 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback003 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1895 ASSERT_EQ(ret, 0);
1896 pipe.intfId = PIPE_INTERFACEID_INVALID;
1897 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1898 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback003 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1899 ASSERT_NE(ret, 0);
1900 pipe = {interfaceId, pointId};
1901 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1902 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback003 %{public}d again UnRegBulkCallback=%{public}d", __LINE__, ret);
1903 ASSERT_EQ(ret, 0);
1904 }
1905
1906 /**
1907 * @tc.name: UnRegBulkCallback004
1908 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
1909 * @tc.desc: Positive test: call again
1910 * @tc.type: FUNC
1911 */
1912 HWTEST_F(UsbdTransferTest, UnRegBulkCallback004, TestSize.Level1)
1913 {
1914 struct UsbDev dev = dev_;
1915 uint8_t interfaceId = INTERFACEID_OK;
1916 uint8_t pointId = POINTID_DIR_OUT;
1917 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1918 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
1919 if (usbdBulkCallback == nullptr) {
1920 HDF_LOGE("%{public}s:UsbdBulkCallbackTest new failed.", __func__);
1921 exit(0);
1922 }
1923 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
1924 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback004 %{public}d RegBulkCallback=%{public}d", __LINE__, ret);
1925 ASSERT_EQ(ret, 0);
1926 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1927 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback004 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1928 ASSERT_EQ(ret, 0);
1929 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1930 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback004 %{public}d again UnRegBulkCallback=%{public}d", __LINE__, ret);
1931 ASSERT_EQ(ret, 0);
1932 }
1933
1934 /**
1935 * @tc.name: UnRegBulkCallback005
1936 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
1937 * @tc.desc: Positive test: no register
1938 * @tc.type: FUNC
1939 */
1940 HWTEST_F(UsbdTransferTest, UnRegBulkCallback005, TestSize.Level1)
1941 {
1942 struct UsbDev dev = dev_;
1943 uint8_t interfaceId = INTERFACEID_OK;
1944 uint8_t pointId = POINTID_DIR_OUT;
1945 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
1946 auto ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
1947 HDF_LOGI("UsbdTransferTest::UnRegBulkCallback005 %{public}d UnRegBulkCallback=%{public}d", __LINE__, ret);
1948 ASSERT_EQ(ret, 0);
1949 }
1950 } // namespace
1951