1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <iostream>
17 #include <vector>
18
19 #include "hdf_log.h"
20 #include "usbd_request_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 uint8_t INTERFACEID_OK = 1;
26 const uint32_t MAX_BUFFER_LENGTH = 255;
27 const uint8_t POINTID_DIR_IN = USB_ENDPOINT_DIR_IN | 2;
28 const uint8_t POINTID_DIR_OUT = USB_ENDPOINT_DIR_OUT | 1;
29
30 using namespace testing::ext;
31 using namespace OHOS;
32 using namespace OHOS::USB;
33 using namespace std;
34 using namespace OHOS::HDI::Usb::V1_0;
35
36 UsbDev UsbdRequestTestAdditional::dev_ = {0, 0};
37 sptr<UsbSubscriberTest> UsbdRequestTestAdditional::subscriber_ = nullptr;
38
39 namespace {
40 sptr<IUsbInterface> g_usbInterface = nullptr;
41
SetUpTestCase(void)42 void UsbdRequestTestAdditional::SetUpTestCase(void)
43 {
44 g_usbInterface = IUsbInterface::Get();
45 if (g_usbInterface == nullptr) {
46 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
47 exit(0);
48 }
49 auto ret = g_usbInterface->SetPortRole(1, 1, 1);
50 sleep(SLEEP_TIME);
51 HDF_LOGI("UsbdRequestTestAdditional::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
52 if (ret != 0) {
53 ASSERT_EQ(HDF_ERR_NOT_SUPPORT, ret);
54 } else {
55 ASSERT_EQ(0, ret);
56 }
57
58 subscriber_ = new UsbSubscriberTest();
59 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
60 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
61 exit(0);
62 }
63
64 std::cout << "please connect device, press enter to continue" << std::endl;
65 int c;
66 while ((c = getchar()) != '\n' && c != EOF) {
67 }
68 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
69
70 ret = g_usbInterface->OpenDevice(dev_);
71 HDF_LOGI("UsbdRequestTestAdditional:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
72 ASSERT_EQ(0, ret);
73 }
74
TearDownTestCase(void)75 void UsbdRequestTestAdditional::TearDownTestCase(void)
76 {
77 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
78 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
79 auto ret = g_usbInterface->CloseDevice(dev_);
80 HDF_LOGI("UsbdRequestTestAdditional:: %{public}d Close=%{public}d", __LINE__, ret);
81 ASSERT_EQ(0, ret);
82 }
83
SetUp(void)84 void UsbdRequestTestAdditional::SetUp(void) {}
85
TearDown(void)86 void UsbdRequestTestAdditional::TearDown(void) {}
87
88 /**
89 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_0100
90 * @tc.name: testHdiUsbRequestTestRequestWait001
91 * @tc.desc: Waits for the operation result of the isochronous transfer request in <b>RequestQueue</b>.
92 * (dev, waitData, bufferData, 1000).
93 */
94 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestWait001, TestSize.Level1)
95 {
96 struct UsbDev dev = dev_;
97 uint8_t pointId = POINTID_DIR_IN;
98 uint8_t interfaceId = INTERFACEID_OK;
99 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
100 ASSERT_EQ(0, ret);
101 struct UsbPipe pipe = {interfaceId, pointId};
102 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
103 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
104 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
105 ASSERT_EQ(0, ret);
106 std::vector<uint8_t> waitData(10);
107 ret = g_usbInterface->RequestWait(dev, waitData, bufferData, 1000);
108 ASSERT_EQ(0, ret);
109 }
110
111 /**
112 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_0200
113 * @tc.name: testHdiUsbRequestTestRequestWait002
114 * @tc.desc: Waits for the operation result of the isochronous transfer request in <b>RequestQueue</b>.
115 * ({1, 255}, waitData, bufferData, 1000).
116 */
117 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestWait002, TestSize.Level2)
118 {
119 struct UsbDev dev = dev_;
120 uint8_t pointId = POINTID_DIR_IN;
121 uint8_t interfaceId = INTERFACEID_OK;
122 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
123 ASSERT_EQ(0, ret);
124 struct UsbPipe pipe = {interfaceId, pointId};
125 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
126 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
127 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
128 ASSERT_EQ(0, ret);
129 std::vector<uint8_t> waitData(10);
130 dev.busNum = 1;
131 dev.devAddr = 255;
132 ret = g_usbInterface->RequestWait(dev, waitData, bufferData, 1000);
133 ASSERT_NE(0, ret);
134 }
135
136 /**
137 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_0300
138 * @tc.name: testHdiUsbRequestTestRequestWait003
139 * @tc.desc: Waits for the operation result of the isochronous transfer request in <b>RequestQueue</b>.
140 * ({255, 1}, waitData, bufferData, 1000).
141 */
142 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestWait003, TestSize.Level2)
143 {
144 struct UsbDev dev = dev_;
145 uint8_t pointId = POINTID_DIR_IN;
146 uint8_t interfaceId = INTERFACEID_OK;
147 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
148 ASSERT_EQ(0, ret);
149 struct UsbPipe pipe = {interfaceId, pointId};
150 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
151 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
152 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
153 ASSERT_EQ(0, ret);
154 std::vector<uint8_t> waitData(10);
155 dev.busNum = 255;
156 dev.devAddr = 1;
157 ret = g_usbInterface->RequestWait(dev, waitData, bufferData, 1000);
158 ASSERT_NE(0, ret);
159 }
160
161 /**
162 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_0400
163 * @tc.name: testHdiUsbRequestTestRequestQueue001
164 * @tc.desc: Sends or receives requests for isochronous transfer on a specified endpoint.
165 * clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd', ','}.
166 */
167 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestQueue001, TestSize.Level1)
168 {
169 struct UsbDev dev = dev_;
170 uint8_t interfaceId = INTERFACEID_OK;
171 uint8_t pointId = POINTID_DIR_IN;
172 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
173 ASSERT_EQ(0, ret);
174 struct UsbPipe pipe = {interfaceId, pointId};
175 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd', ','};
176 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
177 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
178 ASSERT_EQ(0, ret);
179 }
180
181 /**
182 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_0500
183 * @tc.name: testHdiUsbRequestTestRequestQueue002
184 * @tc.desc: Sends or receives requests for isochronous transfer on a specified endpoint.
185 * clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd', '!'}.
186 */
187 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestQueue002, TestSize.Level1)
188 {
189 struct UsbDev dev = dev_;
190 uint8_t interfaceId = INTERFACEID_OK;
191 uint8_t pointId = POINTID_DIR_IN;
192 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
193 ASSERT_EQ(0, ret);
194 struct UsbPipe pipe = {interfaceId, pointId};
195 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd', '!'};
196 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
197 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
198 ASSERT_EQ(0, ret);
199 }
200
201 /**
202 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_0600
203 * @tc.name: testHdiUsbRequestTestRequestQueue003
204 * @tc.desc: Sends or receives requests for isochronous transfer on a specified endpoint.
205 * clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd', '~'}.
206 */
207 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestQueue003, TestSize.Level1)
208 {
209 struct UsbDev dev = dev_;
210 uint8_t interfaceId = INTERFACEID_OK;
211 uint8_t pointId = POINTID_DIR_IN;
212 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
213 ASSERT_EQ(0, ret);
214 struct UsbPipe pipe = {interfaceId, pointId};
215 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd', '~'};
216 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
217 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
218 ASSERT_EQ(0, ret);
219 }
220
221 /**
222 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_0700
223 * @tc.name: testHdiUsbRequestTestRequestQueue004
224 * @tc.desc: Sends or receives requests for isochronous transfer on a specified endpoint.
225 * dev = {1, 255}.
226 */
227 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestQueue004, TestSize.Level2)
228 {
229 struct UsbDev dev = dev_;
230 uint8_t interfaceId = INTERFACEID_OK;
231 uint8_t pointId = POINTID_DIR_IN;
232 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
233 ASSERT_EQ(0, ret);
234 struct UsbPipe pipe = {interfaceId, pointId};
235 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
236 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
237 dev.busNum = 1;
238 dev.devAddr = 255;
239 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
240 ASSERT_NE(0, ret);
241 }
242
243 /**
244 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_0800
245 * @tc.name: testHdiUsbRequestTestRequestQueue005
246 * @tc.desc: Sends or receives requests for isochronous transfer on a specified endpoint.
247 * dev = {255, 1}.
248 */
249 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestQueue005, TestSize.Level2)
250 {
251 struct UsbDev dev = dev_;
252 uint8_t interfaceId = INTERFACEID_OK;
253 uint8_t pointId = POINTID_DIR_IN;
254 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
255 ASSERT_EQ(0, ret);
256 struct UsbPipe pipe = {interfaceId, pointId};
257 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
258 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
259 dev.busNum = 255;
260 dev.devAddr = 1;
261 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
262 ASSERT_NE(0, ret);
263 }
264
265 /**
266 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_0900
267 * @tc.name: testHdiUsbRequestTestRequestCancel001
268 * @tc.desc: Cancels the data transfer requests to be processed.
269 * pipe = {1, 255}.
270 */
271 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestCancel001, TestSize.Level1)
272 {
273 struct UsbDev dev = dev_;
274 uint8_t pointId = POINTID_DIR_OUT;
275 uint8_t interfaceId = INTERFACEID_OK;
276 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
277 ASSERT_EQ(0, ret);
278 struct UsbPipe pipe = {interfaceId, pointId};
279 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
280 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
281 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
282 ASSERT_EQ(0, ret);
283 pipe.intfId = 1;
284 pipe.endpointId = 255;
285 ret = g_usbInterface->RequestCancel(dev, pipe);
286 ASSERT_EQ(0, ret);
287 pipe = {interfaceId, pointId};
288 ret = g_usbInterface->RequestCancel(dev, pipe);
289 ASSERT_EQ(0, ret);
290 }
291
292 /**
293 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1000
294 * @tc.name: testHdiUsbRequestTestRequestCancel002
295 * @tc.desc: Cancels the data transfer requests to be processed.
296 * pipe = {255, 1}.
297 */
298 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestCancel002, TestSize.Level1)
299 {
300 struct UsbDev dev = dev_;
301 uint8_t pointId = POINTID_DIR_OUT;
302 uint8_t interfaceId = INTERFACEID_OK;
303 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
304 ASSERT_EQ(0, ret);
305 struct UsbPipe pipe = {interfaceId, pointId};
306 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
307 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
308 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
309 ASSERT_EQ(0, ret);
310 pipe.intfId = 255;
311 pipe.endpointId = 1;
312 ret = g_usbInterface->RequestCancel(dev, pipe);
313 ASSERT_NE(0, ret);
314 pipe = {interfaceId, pointId};
315 ret = g_usbInterface->RequestCancel(dev, pipe);
316 ASSERT_EQ(0, ret);
317 }
318
319 /**
320 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1100
321 * @tc.name: testHdiUsbRequestTestRequestCancel003
322 * @tc.desc: Cancels the data transfer requests to be processed.
323 * dev = {255, 1}.
324 */
325 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestCancel003, TestSize.Level2)
326 {
327 struct UsbDev dev = dev_;
328 uint8_t pointId = POINTID_DIR_OUT;
329 uint8_t interfaceId = INTERFACEID_OK;
330 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
331 ASSERT_EQ(0, ret);
332 struct UsbPipe pipe = {interfaceId, pointId};
333 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
334 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
335 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
336 ASSERT_EQ(0, ret);
337 dev.busNum = 255;
338 dev.devAddr = 1;
339 ret = g_usbInterface->RequestCancel(dev, pipe);
340 ASSERT_NE(0, ret);
341 dev = dev_;
342 ret = g_usbInterface->RequestCancel(dev, pipe);
343 ASSERT_EQ(0, ret);
344 }
345
346 /**
347 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1200
348 * @tc.name: testHdiUsbRequestTestRequestCancel004
349 * @tc.desc: Cancels the data transfer requests to be processed.
350 * dev = {1, 255}.
351 */
352 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestCancel004, TestSize.Level2)
353 {
354 struct UsbDev dev = dev_;
355 uint8_t pointId = POINTID_DIR_OUT;
356 uint8_t interfaceId = INTERFACEID_OK;
357 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
358 ASSERT_EQ(0, ret);
359 struct UsbPipe pipe = {interfaceId, pointId};
360 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
361 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
362 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
363 ASSERT_EQ(0, ret);
364 dev.busNum = 1;
365 dev.devAddr = 255;
366 ret = g_usbInterface->RequestCancel(dev, pipe);
367 ASSERT_NE(0, ret);
368 dev = dev_;
369 ret = g_usbInterface->RequestCancel(dev, pipe);
370 ASSERT_EQ(0, ret);
371 }
372
373 /**
374 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1300
375 * @tc.name: testHdiUsbRequestTestRequestCancel005
376 * @tc.desc: Cancels the data transfer requests to be processed.
377 * dev = {1, 255}. pipe = {1, 255}.
378 */
379 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestCancel005, TestSize.Level2)
380 {
381 struct UsbDev dev = dev_;
382 uint8_t pointId = POINTID_DIR_OUT;
383 uint8_t interfaceId = INTERFACEID_OK;
384 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
385 ASSERT_EQ(0, ret);
386 struct UsbPipe pipe = {interfaceId, pointId};
387 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
388 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
389 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
390 ASSERT_EQ(0, ret);
391 dev.busNum = 1;
392 dev.devAddr = 255;
393 pipe.intfId = 1;
394 pipe.endpointId = 255;
395 ret = g_usbInterface->RequestCancel(dev, pipe);
396 ASSERT_NE(0, ret);
397 dev = dev_;
398 pipe = {interfaceId, pointId};
399 ret = g_usbInterface->RequestCancel(dev, pipe);
400 ASSERT_EQ(0, ret);
401 }
402
403 /**
404 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1400
405 * @tc.name: testHdiUsbRequestTestRequestCancel006
406 * @tc.desc: Cancels the data transfer requests to be processed.
407 * dev = {255, 1}. pipe = {255, 1}.
408 */
409 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestCancel006, TestSize.Level2)
410 {
411 struct UsbDev dev = dev_;
412 uint8_t pointId = POINTID_DIR_OUT;
413 uint8_t interfaceId = INTERFACEID_OK;
414 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
415 ASSERT_EQ(0, ret);
416 struct UsbPipe pipe = {interfaceId, pointId};
417 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
418 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
419 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
420 ASSERT_EQ(0, ret);
421 dev.busNum = 255;
422 dev.devAddr = 1;
423 pipe.intfId = 255;
424 pipe.endpointId = 1;
425 ret = g_usbInterface->RequestCancel(dev, pipe);
426 ASSERT_NE(0, ret);
427 dev = dev_;
428 pipe = {interfaceId, pointId};
429 ret = g_usbInterface->RequestCancel(dev, pipe);
430 ASSERT_EQ(0, ret);
431 }
432
433 /**
434 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1500
435 * @tc.name: testHdiUsbRequestTestRequestCancel007
436 * @tc.desc: Cancels the data transfer requests to be processed.
437 * dev = {255, 255}. pipe = {255, 255}.
438 */
439 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestRequestCancel007, TestSize.Level2)
440 {
441 struct UsbDev dev = dev_;
442 uint8_t pointId = POINTID_DIR_OUT;
443 uint8_t interfaceId = INTERFACEID_OK;
444 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
445 ASSERT_EQ(0, ret);
446 struct UsbPipe pipe = {interfaceId, pointId};
447 std::vector<uint8_t> clientData = {'q', 'u', 'e', 'u', 'e', 'r', 'e', 'a', 'd'};
448 std::vector<uint8_t> bufferData(MAX_BUFFER_LENGTH);
449 ret = g_usbInterface->RequestQueue(dev, pipe, clientData, bufferData);
450 ASSERT_EQ(0, ret);
451 dev.busNum = 255;
452 dev.devAddr = 255;
453 pipe.intfId = 255;
454 pipe.endpointId = 255;
455 ret = g_usbInterface->RequestCancel(dev, pipe);
456 ASSERT_NE(0, ret);
457 dev = dev_;
458 pipe = {interfaceId, pointId};
459 ret = g_usbInterface->RequestCancel(dev, pipe);
460 ASSERT_EQ(0, ret);
461 }
462
463 /**
464 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1600
465 * @tc.name: testHdiUsbRequestTestBulkCancel001
466 * @tc.desc: Cancels the isochronous bulk transfer. dev ={1, 255}.
467 */
468 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestBulkCancel001, TestSize.Level2)
469 {
470 struct UsbDev dev = dev_;
471 uint8_t interfaceId = INTERFACEID_OK;
472 uint8_t pointId = POINTID_DIR_IN;
473 struct UsbPipe pipe = {interfaceId, pointId};
474 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
475 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
476 ASSERT_EQ(ret, 0);
477 dev = {1, 255};
478 ret = g_usbInterface->BulkCancel(dev, pipe);
479 ASSERT_NE(0, ret);
480 dev = dev_;
481 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
482 ASSERT_EQ(ret, 0);
483 }
484
485 /**
486 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1700
487 * @tc.name: testHdiUsbRequestTestBulkCancel002
488 * @tc.desc: Cancels the isochronous bulk transfer. dev ={255, 1}.
489 */
490 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestBulkCancel002, TestSize.Level2)
491 {
492 struct UsbDev dev = dev_;
493 uint8_t interfaceId = INTERFACEID_OK;
494 uint8_t pointId = POINTID_DIR_IN;
495 struct UsbPipe pipe = {interfaceId, pointId};
496 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
497 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
498 ASSERT_EQ(ret, 0);
499 dev = {255, 1};
500 ret = g_usbInterface->BulkCancel(dev, pipe);
501 ASSERT_NE(0, ret);
502 dev = dev_;
503 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
504 ASSERT_EQ(ret, 0);
505 }
506
507 /**
508 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1800
509 * @tc.name: testHdiUsbRequestTestBulkCancel003
510 * @tc.desc: Cancels the isochronous bulk transfer. dev ={255, 100}.
511 */
512 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestBulkCancel003, TestSize.Level2)
513 {
514 struct UsbDev dev = dev_;
515 uint8_t interfaceId = INTERFACEID_OK;
516 uint8_t pointId = POINTID_DIR_IN;
517 struct UsbPipe pipe = {interfaceId, pointId};
518 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
519 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
520 ASSERT_EQ(ret, 0);
521 dev = {255, 100};
522 ret = g_usbInterface->BulkCancel(dev, pipe);
523 ASSERT_NE(0, ret);
524 dev = dev_;
525 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
526 ASSERT_EQ(ret, 0);
527 }
528
529 /**
530 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityRequestAddTest_1900
531 * @tc.name: testHdiUsbRequestTestBulkCancel004
532 * @tc.desc: Cancels the isochronous bulk transfer. dev ={100, 255}.
533 */
534 HWTEST_F(UsbdRequestTestAdditional, testHdiUsbRequestTestBulkCancel004, TestSize.Level2)
535 {
536 struct UsbDev dev = dev_;
537 uint8_t interfaceId = INTERFACEID_OK;
538 uint8_t pointId = POINTID_DIR_IN;
539 struct UsbPipe pipe = {interfaceId, pointId};
540 sptr<UsbdBulkCallbackTest> usbdBulkCallback = new UsbdBulkCallbackTest();
541 auto ret = g_usbInterface->RegBulkCallback(dev, pipe, usbdBulkCallback);
542 ASSERT_EQ(ret, 0);
543 dev = {100, 255};
544 ret = g_usbInterface->BulkCancel(dev, pipe);
545 ASSERT_NE(0, ret);
546 dev = dev_;
547 ret = g_usbInterface->UnRegBulkCallback(dev, pipe);
548 ASSERT_EQ(ret, 0);
549 }
550 } // namespace
551