1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <iostream>
18
19 #include "UsbSubscriberTest.h"
20 #include "hdf_log.h"
21 #include "usbd_request_test.h"
22 #include "v1_0/iusb_interface.h"
23 #include "v1_0/usb_types.h"
24
25 using OHOS::HDI::Usb::V1_0::UsbDev;
26 using namespace testing::ext;
27 using namespace OHOS;
28 using namespace OHOS::USB;
29 using namespace std;
30 using namespace OHOS::HDI::Usb::V1_0;
31
32 namespace {
33
34 const int SLEEP_TIME = 3;
35
36 class UsbdInterfaceTestAdditional : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42
43 static UsbDev dev_;
44 static OHOS::sptr<OHOS::USB::UsbSubscriberTest> subscriber_;
45 };
46 UsbDev UsbdInterfaceTestAdditional::dev_ = {0, 0};
47 OHOS::sptr<OHOS::USB::UsbSubscriberTest> UsbdInterfaceTestAdditional::subscriber_ = nullptr;
48
49 sptr<IUsbInterface> g_usbInterface = nullptr;
50
51
SetUpTestCase(void)52 void UsbdInterfaceTestAdditional::SetUpTestCase(void)
53 {
54 g_usbInterface = IUsbInterface::Get();
55 if (g_usbInterface == nullptr) {
56 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
57 exit(0);
58 }
59 auto ret = g_usbInterface->SetPortRole(1, 1, 1);
60 sleep(SLEEP_TIME);
61 HDF_LOGI("UsbdInterfaceTestAdditional::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
62 if (ret != 0) {
63 ASSERT_EQ(HDF_ERR_NOT_SUPPORT, ret);
64 } else {
65 ASSERT_EQ(0, ret);
66 }
67
68 subscriber_ = new UsbSubscriberTest();
69 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
70 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
71 exit(0);
72 }
73
74 std::cout << "please connect device, press enter to continue" << std::endl;
75 int c;
76 while ((c = getchar()) != '\n' && c != EOF) {
77 }
78 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
79
80 ret = g_usbInterface->OpenDevice(dev_);
81 ASSERT_EQ(0, ret);
82 HDF_LOGI("UsbdInterfaceTestAdditional:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
83 ret = g_usbInterface->ClaimInterface(dev_, 1, 1);
84 ASSERT_EQ(0, ret);
85 }
86
TearDownTestCase(void)87 void UsbdInterfaceTestAdditional::TearDownTestCase(void)
88 {
89 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
90 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
91 auto ret = g_usbInterface->CloseDevice(dev_);
92 HDF_LOGI("UsbdInterfaceTestAdditional:: %{public}d Close=%{public}d", __LINE__, ret);
93 ASSERT_EQ(0, ret);
94 }
95
SetUp(void)96 void UsbdInterfaceTestAdditional::SetUp(void) {}
97
TearDown(void)98 void UsbdInterfaceTestAdditional::TearDown(void) {}
99
100 /**
101 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_0900
102 * @tc.name: testHdiUsbRequestTestSetInterface001
103 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,0},255,0).
104 */
105 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface001, TestSize.Level2)
106 {
107 int32_t interfaceId = 255;
108 uint8_t altIndex = 0;
109 struct UsbDev dev = dev_;
110 dev.busNum = 255;
111 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
112 ASSERT_NE(ret, 0);
113 }
114
115 /**
116 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1000
117 * @tc.name: testHdiUsbRequestTestSetInterface002
118 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,0},255,255).
119 */
120 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface002, TestSize.Level2)
121 {
122 int32_t interfaceId = 255;
123 uint8_t altIndex = 255;
124 struct UsbDev dev = dev_;
125 dev.busNum = 255;
126 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
127 ASSERT_NE(ret, 0);
128 }
129
130 /**
131 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1100
132 * @tc.name: testHdiUsbRequestTestSetInterface003
133 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,0},0,0).
134 */
135 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface003, TestSize.Level2)
136 {
137 int32_t interfaceId = 0;
138 uint8_t altIndex = 0;
139 struct UsbDev dev = dev_;
140 dev.busNum = 255;
141 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
142 ASSERT_NE(ret, 0);
143 }
144
145 /**
146 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1200
147 * @tc.name: testHdiUsbRequestTestSetInterface004
148 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,0},0,1).
149 */
150 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface004, TestSize.Level2)
151 {
152 int32_t interfaceId = 0;
153 uint8_t altIndex = 1;
154 struct UsbDev dev = dev_;
155 dev.busNum = 255;
156 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
157 ASSERT_NE(ret, 0);
158 }
159
160 /**
161 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1300
162 * @tc.name: testHdiUsbRequestTestSetInterface005
163 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,0},0,255).
164 */
165 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface005, TestSize.Level2)
166 {
167 int32_t interfaceId = 0;
168 uint8_t altIndex = 255;
169 struct UsbDev dev = dev_;
170 dev.busNum = 255;
171 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
172 ASSERT_NE(ret, 0);
173 }
174
175 /**
176 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1400
177 * @tc.name: testHdiUsbRequestTestSetInterface006
178 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,0},1,1).
179 */
180 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface006, TestSize.Level2)
181 {
182 int32_t interfaceId = 1;
183 uint8_t altIndex = 1;
184 struct UsbDev dev = dev_;
185 dev.busNum = 255;
186 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
187 ASSERT_NE(ret, 0);
188 }
189
190 /**
191 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1500
192 * @tc.name: testHdiUsbRequestTestSetInterface007
193 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,0},1,255).
194 */
195 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface007, TestSize.Level2)
196 {
197 int32_t interfaceId = 1;
198 uint8_t altIndex = 255;
199 struct UsbDev dev = dev_;
200 dev.busNum = 255;
201 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
202 ASSERT_NE(ret, 0);
203 }
204
205 /**
206 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1600
207 * @tc.name: testHdiUsbRequestTestSetInterface008
208 * @tc.desc: Sets the alternate settings for the specified USB interface. ({100,255},0,0).
209 */
210 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface008, TestSize.Level2)
211 {
212 int32_t interfaceId = 0;
213 uint8_t altIndex = 0;
214 struct UsbDev dev = dev_;
215 dev.busNum = 100;
216 dev.devAddr = 255;
217 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
218 ASSERT_NE(ret, 0);
219 }
220
221 /**
222 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1700
223 * @tc.name: testHdiUsbRequestTestSetInterface009
224 * @tc.desc: Sets the alternate settings for the specified USB interface. ({100,255},0,1).
225 */
226 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface009, TestSize.Level2)
227 {
228 int32_t interfaceId = 0;
229 uint8_t altIndex = 1;
230 struct UsbDev dev = dev_;
231 dev.busNum = 100;
232 dev.devAddr = 255;
233 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
234 ASSERT_NE(ret, 0);
235 }
236
237 /**
238 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1800
239 * @tc.name: testHdiUsbRequestTestSetInterface010
240 * @tc.desc: Sets the alternate settings for the specified USB interface. ({100,255},0,255).
241 */
242 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface010, TestSize.Level2)
243 {
244 int32_t interfaceId = 0;
245 uint8_t altIndex = 255;
246 struct UsbDev dev = dev_;
247 dev.busNum = 100;
248 dev.devAddr = 255;
249 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
250 ASSERT_NE(ret, 0);
251 }
252
253 /**
254 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_1900
255 * @tc.name: testHdiUsbRequestTestSetInterface011
256 * @tc.desc: Sets the alternate settings for the specified USB interface. ({100,255},1,0).
257 */
258 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface011, TestSize.Level2)
259 {
260 int32_t interfaceId = 1;
261 uint8_t altIndex = 0;
262 struct UsbDev dev = dev_;
263 dev.busNum = 100;
264 dev.devAddr = 255;
265 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
266 ASSERT_NE(ret, 0);
267 }
268
269 /**
270 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2000
271 * @tc.name: testHdiUsbRequestTestSetInterface012
272 * @tc.desc: Sets the alternate settings for the specified USB interface. ({100,255},1,1).
273 */
274 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface012, TestSize.Level2)
275 {
276 int32_t interfaceId = 1;
277 uint8_t altIndex = 1;
278 struct UsbDev dev = dev_;
279 dev.busNum = 100;
280 dev.devAddr = 255;
281 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
282 ASSERT_NE(ret, 0);
283 }
284
285 /**
286 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2100
287 * @tc.name: testHdiUsbRequestTestSetInterface013
288 * @tc.desc: Sets the alternate settings for the specified USB interface. ({100,0},1,255).
289 */
290 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface013, TestSize.Level2)
291 {
292 int32_t interfaceId = 1;
293 uint8_t altIndex = 255;
294 struct UsbDev dev = dev_;
295 dev.busNum = 100;
296 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
297 ASSERT_NE(ret, 0);
298 }
299
300 /**
301 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2200
302 * @tc.name: testHdiUsbRequestTestSetInterface014
303 * @tc.desc: Sets the alternate settings for the specified USB interface. ({100,0},255,0).
304 */
305 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface014, TestSize.Level2)
306 {
307 int32_t interfaceId = 255;
308 uint8_t altIndex = 0;
309 struct UsbDev dev = dev_;
310 dev.busNum = 100;
311 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
312 ASSERT_NE(ret, 0);
313 }
314
315 /**
316 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2300
317 * @tc.name: testHdiUsbRequestTestSetInterface015
318 * @tc.desc: Sets the alternate settings for the specified USB interface. ({100,0},255,1).
319 */
320 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface015, TestSize.Level2)
321 {
322 int32_t interfaceId = 255;
323 uint8_t altIndex = 1;
324 struct UsbDev dev = dev_;
325 dev.busNum = 100;
326 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
327 ASSERT_NE(ret, 0);
328 }
329
330 /**
331 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2400
332 * @tc.name: testHdiUsbRequestTestSetInterface016
333 * @tc.desc: Sets the alternate settings for the specified USB interface. ({100,0},255,255).
334 */
335 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface016, TestSize.Level2)
336 {
337 int32_t interfaceId = 255;
338 uint8_t altIndex = 255;
339 struct UsbDev dev = dev_;
340 dev.busNum = 100;
341 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
342 ASSERT_NE(ret, 0);
343 }
344
345 /**
346 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2500
347 * @tc.name: testHdiUsbRequestTestSetInterface017
348 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,100},255,10).
349 */
350 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface017, TestSize.Level2)
351 {
352 int32_t interfaceId = 255;
353 uint8_t altIndex = 10;
354 struct UsbDev dev = dev_;
355 dev.devAddr = 100;
356 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
357 ASSERT_NE(ret, 0);
358 }
359
360 /**
361 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2600
362 * @tc.name: testHdiUsbRequestTestSetInterface018
363 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,100},10,255).
364 */
365 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface018, TestSize.Level2)
366 {
367 int32_t interfaceId = 10;
368 uint8_t altIndex = 255;
369 struct UsbDev dev = dev_;
370 dev.devAddr = 100;
371 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
372 ASSERT_NE(ret, 0);
373 }
374
375 /**
376 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2700
377 * @tc.name: testHdiUsbRequestTestSetInterface019
378 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,100},0,255).
379 */
380 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface019, TestSize.Level2)
381 {
382 int32_t interfaceId = 0;
383 uint8_t altIndex = 255;
384 struct UsbDev dev = dev_;
385 dev.devAddr = 100;
386 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
387 ASSERT_NE(ret, 0);
388 }
389
390 /**
391 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2800
392 * @tc.name: testHdiUsbRequestTestSetInterface020
393 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,100},100,255).
394 */
395 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface020, TestSize.Level2)
396 {
397 int32_t interfaceId = 100;
398 uint8_t altIndex = 255;
399 struct UsbDev dev = dev_;
400 dev.devAddr = 100;
401 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
402 ASSERT_NE(ret, 0);
403 }
404
405 /**
406 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_2900
407 * @tc.name: testHdiUsbRequestTestSetInterface021
408 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,100},255,100).
409 */
410 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface021, TestSize.Level2)
411 {
412 int32_t interfaceId = 255;
413 uint8_t altIndex = 100;
414 struct UsbDev dev = dev_;
415 dev.devAddr = 100;
416 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
417 ASSERT_NE(ret, 0);
418 }
419
420 /**
421 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3000
422 * @tc.name: testHdiUsbRequestTestSetInterface022
423 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,100},1,255).
424 */
425 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface022, TestSize.Level2)
426 {
427 int32_t interfaceId = 1;
428 uint8_t altIndex = 255;
429 struct UsbDev dev = dev_;
430 dev.devAddr = 100;
431 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
432 ASSERT_NE(ret, 0);
433 }
434
435 /**
436 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3100
437 * @tc.name: testHdiUsbRequestTestSetInterface023
438 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,100},255,0).
439 */
440 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface023, TestSize.Level2)
441 {
442 int32_t interfaceId = 255;
443 uint8_t altIndex = 0;
444 struct UsbDev dev = dev_;
445 dev.devAddr = 100;
446 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
447 ASSERT_NE(ret, 0);
448 }
449
450 /**
451 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3200
452 * @tc.name: testHdiUsbRequestTestSetInterface024
453 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,100},255,1).
454 */
455 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface024, TestSize.Level2)
456 {
457 int32_t interfaceId = 255;
458 uint8_t altIndex = 1;
459 struct UsbDev dev = dev_;
460 dev.devAddr = 100;
461 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
462 ASSERT_NE(ret, 0);
463 }
464
465 /**
466 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3300
467 * @tc.name: testHdiUsbRequestTestSetInterface025
468 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,100},255,255).
469 */
470 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface025, TestSize.Level2)
471 {
472 int32_t interfaceId = 255;
473 uint8_t altIndex = 255;
474 struct UsbDev dev = dev_;
475 dev.devAddr = 100;
476 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
477 ASSERT_NE(ret, 0);
478 }
479
480 /**
481 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3400
482 * @tc.name: testHdiUsbRequestTestSetInterface026
483 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,255},1,0).
484 */
485 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface026, TestSize.Level2)
486 {
487 int32_t interfaceId = 1;
488 uint8_t altIndex = 0;
489 struct UsbDev dev = dev_;
490 dev.devAddr = 255;
491 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
492 ASSERT_NE(ret, 0);
493 }
494
495 /**
496 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3500
497 * @tc.name: testHdiUsbRequestTestSetInterface027
498 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,255},1,1).
499 */
500 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface027, TestSize.Level2)
501 {
502 int32_t interfaceId = 1;
503 uint8_t altIndex = 1;
504 struct UsbDev dev = dev_;
505 dev.devAddr = 255;
506 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
507 ASSERT_NE(ret, 0);
508 }
509
510 /**
511 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3600
512 * @tc.name: testHdiUsbRequestTestSetInterface028
513 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,255},0,0).
514 */
515 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface028, TestSize.Level2)
516 {
517 int32_t interfaceId = 0;
518 uint8_t altIndex = 0;
519 struct UsbDev dev = dev_;
520 dev.devAddr = 255;
521 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
522 ASSERT_NE(ret, 0);
523 }
524
525 /**
526 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3700
527 * @tc.name: testHdiUsbRequestTestSetInterface029
528 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,255},0,1).
529 */
530 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface029, TestSize.Level2)
531 {
532 int32_t interfaceId = 0;
533 uint8_t altIndex = 1;
534 struct UsbDev dev = dev_;
535 dev.devAddr = 255;
536 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
537 ASSERT_NE(ret, 0);
538 }
539
540 /**
541 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3800
542 * @tc.name: testHdiUsbRequestTestSetInterface030
543 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,255},0,255).
544 */
545 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface030, TestSize.Level2)
546 {
547 int32_t interfaceId = 0;
548 uint8_t altIndex = 255;
549 struct UsbDev dev = dev_;
550 dev.devAddr = 255;
551 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
552 ASSERT_NE(ret, 0);
553 }
554
555 /**
556 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_3900
557 * @tc.name: testHdiUsbRequestTestSetInterface031
558 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,255},255,0).
559 */
560 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface031, TestSize.Level2)
561 {
562 int32_t interfaceId = 255;
563 uint8_t altIndex = 0;
564 struct UsbDev dev = dev_;
565 dev.devAddr = 255;
566 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
567 ASSERT_NE(ret, 0);
568 }
569
570 /**
571 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4000
572 * @tc.name: testHdiUsbRequestTestSetInterface032
573 * @tc.desc: Sets the alternate settings for the specified USB interface. ({0,255},255,1).
574 */
575 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface032, TestSize.Level2)
576 {
577 int32_t interfaceId = 255;
578 uint8_t altIndex = 1;
579 struct UsbDev dev = dev_;
580 dev.devAddr = 255;
581 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
582 ASSERT_NE(ret, 0);
583 }
584
585 /**
586 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4100
587 * @tc.name: testHdiUsbRequestTestSetInterface033
588 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,255},1,1).
589 */
590 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface033, TestSize.Level2)
591 {
592 int32_t interfaceId = 1;
593 uint8_t altIndex = 1;
594 struct UsbDev dev = dev_;
595 dev.busNum = 255;
596 dev.devAddr = 255;
597 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
598 ASSERT_NE(ret, 0);
599 }
600
601 /**
602 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4200
603 * @tc.name: testHdiUsbRequestTestSetInterface034
604 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,255},1,255).
605 */
606 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface034, TestSize.Level2)
607 {
608 int32_t interfaceId = 1;
609 uint8_t altIndex = 255;
610 struct UsbDev dev = dev_;
611 dev.busNum = 255;
612 dev.devAddr = 255;
613 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
614 ASSERT_NE(ret, 0);
615 }
616
617 /**
618 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4300
619 * @tc.name: testHdiUsbRequestTestSetInterface035
620 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,255},0,0).
621 */
622 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface035, TestSize.Level2)
623 {
624 int32_t interfaceId = 0;
625 uint8_t altIndex = 0;
626 struct UsbDev dev = dev_;
627 dev.busNum = 255;
628 dev.devAddr = 255;
629 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
630 ASSERT_NE(ret, 0);
631 }
632
633 /**
634 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4400
635 * @tc.name: testHdiUsbRequestTestSetInterface036
636 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,255},0,1).
637 */
638 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface036, TestSize.Level2)
639 {
640 int32_t interfaceId = 0;
641 uint8_t altIndex = 1;
642 struct UsbDev dev = dev_;
643 dev.busNum = 255;
644 dev.devAddr = 255;
645 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
646 ASSERT_NE(ret, 0);
647 }
648
649 /**
650 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4500
651 * @tc.name: testHdiUsbRequestTestSetInterface037
652 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,255},0,255).
653 */
654 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface037, TestSize.Level2)
655 {
656 int32_t interfaceId = 0;
657 uint8_t altIndex = 255;
658 struct UsbDev dev = dev_;
659 dev.busNum = 255;
660 dev.devAddr = 255;
661 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
662 ASSERT_NE(ret, 0);
663 }
664
665 /**
666 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4600
667 * @tc.name: testHdiUsbRequestTestSetInterface038
668 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,255},255,0).
669 */
670 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface038, TestSize.Level2)
671 {
672 int32_t interfaceId = 255;
673 uint8_t altIndex = 0;
674 struct UsbDev dev = dev_;
675 dev.busNum = 255;
676 dev.devAddr = 255;
677 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
678 ASSERT_NE(ret, 0);
679 }
680
681 /**
682 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4700
683 * @tc.name: testHdiUsbRequestTestSetInterface039
684 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,255},255,1).
685 */
686 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface039, TestSize.Level2)
687 {
688 int32_t interfaceId = 255;
689 uint8_t altIndex = 1;
690 struct UsbDev dev = dev_;
691 dev.busNum = 255;
692 dev.devAddr = 255;
693 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
694 ASSERT_NE(ret, 0);
695 }
696
697 /**
698 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4800
699 * @tc.name: testHdiUsbRequestTestSetInterface040
700 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,0},255,100).
701 */
702 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface040, TestSize.Level2)
703 {
704 int32_t interfaceId = 255;
705 uint8_t altIndex = 100;
706 struct UsbDev dev = dev_;
707 dev.busNum = 1;
708 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
709 ASSERT_NE(ret, 0);
710 }
711
712 /**
713 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_4900
714 * @tc.name: testHdiUsbRequestTestSetInterface041
715 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,0},100,255).
716 */
717 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface041, TestSize.Level2)
718 {
719 int32_t interfaceId = 100;
720 uint8_t altIndex = 255;
721 struct UsbDev dev = dev_;
722 dev.busNum = 1;
723 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
724 ASSERT_NE(ret, 0);
725 }
726
727 /**
728 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5000
729 * @tc.name: testHdiUsbRequestTestSetInterface042
730 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,0},0,255).
731 */
732 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface042, TestSize.Level2)
733 {
734 int32_t interfaceId = 0;
735 uint8_t altIndex = 255;
736 struct UsbDev dev = dev_;
737 dev.busNum = 1;
738 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
739 ASSERT_NE(ret, 0);
740 }
741
742 /**
743 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5100
744 * @tc.name: testHdiUsbRequestTestSetInterface043
745 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,0},10,255).
746 */
747 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface043, TestSize.Level2)
748 {
749 int32_t interfaceId = 10;
750 uint8_t altIndex = 255;
751 struct UsbDev dev = dev_;
752 dev.busNum = 1;
753 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
754 ASSERT_NE(ret, 0);
755 }
756
757 /**
758 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5200
759 * @tc.name: testHdiUsbRequestTestSetInterface044
760 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,0},255,10).
761 */
762 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface044, TestSize.Level2)
763 {
764 int32_t interfaceId = 255;
765 uint8_t altIndex = 10;
766 struct UsbDev dev = dev_;
767 dev.busNum = 1;
768 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
769 ASSERT_NE(ret, 0);
770 }
771
772 /**
773 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5300
774 * @tc.name: testHdiUsbRequestTestSetInterface045
775 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,0},1,255).
776 */
777 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface045, TestSize.Level2)
778 {
779 int32_t interfaceId = 1;
780 uint8_t altIndex = 255;
781 struct UsbDev dev = dev_;
782 dev.busNum = 1;
783 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
784 ASSERT_NE(ret, 0);
785 }
786
787 /**
788 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5400
789 * @tc.name: testHdiUsbRequestTestSetInterface046
790 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,0},255,0).
791 */
792 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface046, TestSize.Level2)
793 {
794 int32_t interfaceId = 255;
795 uint8_t altIndex = 0;
796 struct UsbDev dev = dev_;
797 dev.busNum = 1;
798 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
799 ASSERT_NE(ret, 0);
800 }
801
802 /**
803 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5500
804 * @tc.name: testHdiUsbRequestTestSetInterface047
805 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,0},255,1).
806 */
807 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface047, TestSize.Level2)
808 {
809 int32_t interfaceId = 255;
810 uint8_t altIndex = 1;
811 struct UsbDev dev = dev_;
812 dev.busNum = 1;
813 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
814 ASSERT_NE(ret, 0);
815 }
816
817 /**
818 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5600
819 * @tc.name: testHdiUsbRequestTestSetInterface048
820 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,0},255,255).
821 */
822 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface048, TestSize.Level2)
823 {
824 int32_t interfaceId = 255;
825 uint8_t altIndex = 255;
826 struct UsbDev dev = dev_;
827 dev.busNum = 1;
828 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
829 ASSERT_NE(ret, 0);
830 }
831
832 /**
833 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5700
834 * @tc.name: testHdiUsbRequestTestSetInterface049
835 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,1},255,100).
836 */
837 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface049, TestSize.Level2)
838 {
839 int32_t interfaceId = 255;
840 uint8_t altIndex = 100;
841 struct UsbDev dev = dev_;
842 dev.busNum = 1;
843 dev.devAddr = 1;
844 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
845 ASSERT_NE(ret, 0);
846 }
847
848 /**
849 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5800
850 * @tc.name: testHdiUsbRequestTestSetInterface050
851 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,1},100,255).
852 */
853 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface050, TestSize.Level2)
854 {
855 int32_t interfaceId = 100;
856 uint8_t altIndex = 255;
857 struct UsbDev dev = dev_;
858 dev.busNum = 1;
859 dev.devAddr = 1;
860 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
861 ASSERT_NE(ret, 0);
862 }
863
864 /**
865 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_5900
866 * @tc.name: testHdiUsbRequestTestSetInterface051
867 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,1},0,255).
868 */
869 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface051, TestSize.Level2)
870 {
871 int32_t interfaceId = 0;
872 uint8_t altIndex = 255;
873 struct UsbDev dev = dev_;
874 dev.busNum = 1;
875 dev.devAddr = 1;
876 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
877 ASSERT_NE(ret, 0);
878 }
879
880 /**
881 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6000
882 * @tc.name: testHdiUsbRequestTestSetInterface052
883 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,1},10,255).
884 */
885 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface052, TestSize.Level2)
886 {
887 int32_t interfaceId = 10;
888 uint8_t altIndex = 255;
889 struct UsbDev dev = dev_;
890 dev.busNum = 1;
891 dev.devAddr = 1;
892 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
893 ASSERT_NE(ret, 0);
894 }
895
896 /**
897 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6100
898 * @tc.name: testHdiUsbRequestTestSetInterface053
899 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,1},255,10).
900 */
901 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface053, TestSize.Level2)
902 {
903 int32_t interfaceId = 255;
904 uint8_t altIndex = 10;
905 struct UsbDev dev = dev_;
906 dev.busNum = 1;
907 dev.devAddr = 1;
908 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
909 ASSERT_NE(ret, 0);
910 }
911
912 /**
913 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6200
914 * @tc.name: testHdiUsbRequestTestSetInterface054
915 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,1},1,255).
916 */
917 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface054, TestSize.Level2)
918 {
919 int32_t interfaceId = 1;
920 uint8_t altIndex = 255;
921 struct UsbDev dev = dev_;
922 dev.busNum = 1;
923 dev.devAddr = 1;
924 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
925 ASSERT_NE(ret, 0);
926 }
927
928 /**
929 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6300
930 * @tc.name: testHdiUsbRequestTestSetInterface055
931 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,1},255,0).
932 */
933 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface055, TestSize.Level2)
934 {
935 int32_t interfaceId = 255;
936 uint8_t altIndex = 0;
937 struct UsbDev dev = dev_;
938 dev.busNum = 1;
939 dev.devAddr = 1;
940 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
941 ASSERT_NE(ret, 0);
942 }
943
944 /**
945 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6400
946 * @tc.name: testHdiUsbRequestTestSetInterface056
947 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,1},255,1).
948 */
949 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface056, TestSize.Level2)
950 {
951 int32_t interfaceId = 255;
952 uint8_t altIndex = 1;
953 struct UsbDev dev = dev_;
954 dev.busNum = 1;
955 dev.devAddr = 1;
956 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
957 ASSERT_NE(ret, 0);
958 }
959
960 /**
961 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6500
962 * @tc.name: testHdiUsbRequestTestSetInterface057
963 * @tc.desc: Sets the alternate settings for the specified USB interface. ({1,1},255,255).
964 */
965 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface057, TestSize.Level2)
966 {
967 int32_t interfaceId = 255;
968 uint8_t altIndex = 255;
969 struct UsbDev dev = dev_;
970 dev.busNum = 1;
971 dev.devAddr = 1;
972 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
973 ASSERT_NE(ret, 0);
974 }
975
976 /**
977 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6600
978 * @tc.name: testHdiUsbRequestTestSetInterface058
979 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,100},0,0).
980 */
981 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface058, TestSize.Level2)
982 {
983 int32_t interfaceId = 0;
984 uint8_t altIndex = 0;
985 struct UsbDev dev = dev_;
986 dev.busNum = 255;
987 dev.devAddr = 100;
988 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
989 ASSERT_NE(ret, 0);
990 }
991
992 /**
993 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6700
994 * @tc.name: testHdiUsbRequestTestSetInterface059
995 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,100},0,1).
996 */
997 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface059, TestSize.Level2)
998 {
999 int32_t interfaceId = 0;
1000 uint8_t altIndex = 1;
1001 struct UsbDev dev = dev_;
1002 dev.busNum = 255;
1003 dev.devAddr = 100;
1004 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
1005 ASSERT_NE(ret, 0);
1006 }
1007
1008 /**
1009 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6800
1010 * @tc.name: testHdiUsbRequestTestSetInterface060
1011 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,100},0,255).
1012 */
1013 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface060, TestSize.Level2)
1014 {
1015 int32_t interfaceId = 0;
1016 uint8_t altIndex = 255;
1017 struct UsbDev dev = dev_;
1018 dev.busNum = 255;
1019 dev.devAddr = 100;
1020 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
1021 ASSERT_NE(ret, 0);
1022 }
1023
1024 /**
1025 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_6900
1026 * @tc.name: testHdiUsbRequestTestSetInterface061
1027 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,100},1,0).
1028 */
1029 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface061, TestSize.Level2)
1030 {
1031 int32_t interfaceId = 1;
1032 uint8_t altIndex = 0;
1033 struct UsbDev dev = dev_;
1034 dev.busNum = 255;
1035 dev.devAddr = 100;
1036 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
1037 ASSERT_NE(ret, 0);
1038 }
1039
1040 /**
1041 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_7000
1042 * @tc.name: testHdiUsbRequestTestSetInterface062
1043 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,100},1,1).
1044 */
1045 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface062, TestSize.Level2)
1046 {
1047 int32_t interfaceId = 1;
1048 uint8_t altIndex = 1;
1049 struct UsbDev dev = dev_;
1050 dev.busNum = 255;
1051 dev.devAddr = 100;
1052 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
1053 ASSERT_NE(ret, 0);
1054 }
1055
1056 /**
1057 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_7100
1058 * @tc.name: testHdiUsbRequestTestSetInterface063
1059 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,100},1,255).
1060 */
1061 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface063, TestSize.Level2)
1062 {
1063 int32_t interfaceId = 1;
1064 uint8_t altIndex = 255;
1065 struct UsbDev dev = dev_;
1066 dev.busNum = 255;
1067 dev.devAddr = 100;
1068 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
1069 ASSERT_NE(ret, 0);
1070 }
1071
1072 /**
1073 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_7200
1074 * @tc.name: testHdiUsbRequestTestSetInterface064
1075 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,100},255,0).
1076 */
1077 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface064, TestSize.Level2)
1078 {
1079 int32_t interfaceId = 255;
1080 uint8_t altIndex = 0;
1081 struct UsbDev dev = dev_;
1082 dev.busNum = 255;
1083 dev.devAddr = 100;
1084 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
1085 ASSERT_NE(ret, 0);
1086 }
1087
1088 /**
1089 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_7300
1090 * @tc.name: testHdiUsbRequestTestSetInterface065
1091 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,100},255,1).
1092 */
1093 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface065, TestSize.Level2)
1094 {
1095 int32_t interfaceId = 255;
1096 uint8_t altIndex = 1;
1097 struct UsbDev dev = dev_;
1098 dev.busNum = 255;
1099 dev.devAddr = 100;
1100 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
1101 ASSERT_NE(ret, 0);
1102 }
1103
1104 /**
1105 * @tc.number: SUB_Driver_Usb_RequestTest_SetInterface_7400
1106 * @tc.name: testHdiUsbRequestTestSetInterface066
1107 * @tc.desc: Sets the alternate settings for the specified USB interface. ({255,100},255,255).
1108 */
1109 HWTEST_F(UsbdInterfaceTestAdditional, testHdiUsbRequestTestSetInterface066, TestSize.Level2)
1110 {
1111 int32_t interfaceId = 255;
1112 uint8_t altIndex = 255;
1113 struct UsbDev dev = dev_;
1114 dev.busNum = 255;
1115 dev.devAddr = 100;
1116 auto ret = g_usbInterface->SetInterface(dev, interfaceId, altIndex);
1117 ASSERT_NE(ret, 0);
1118 }
1119
1120 } // namespace