1 /*
2 * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include <cstdint>
10 #include <cstdio>
11 #include <cstdlib>
12 #include <fcntl.h>
13 #include <gtest/gtest.h>
14 #include <string>
15 #include <unistd.h>
16 #include "hdf_uhdf_test.h"
17 #include "hdf_io_service_if.h"
18
19 using namespace testing::ext;
20
21 #define HDF_TEST_NAME "/dev/hdf_test"
22 namespace {
23 enum HdfLiteUsbTestCmd {
24 USB_WRITE_TEST = 0,
25 USB_HOSTSDK_INIT_001_TEST,
26 USB_HOSTSDK_EXIT_001_TEST,
27 USB_HOSTSDK_INIT_002_TEST,
28 USB_HOSTSDK_EXIT_002_TEST,
29 USB_HOSTSDK_INIT_003_TEST,
30 USB_HOSTSDK_INIT_004_TEST,
31 USB_HOSTSDK_INIT_005_TEST,
32 USB_HOSTSDK_CLAIM_INTERFACE_001_TEST,
33 USB_HOSTSDK_RELEASE_INTERFACE_001_TEST,
34 USB_HOSTSDK_CLAIM_INTERFACE_002_TEST,
35 USB_HOSTSDK_RELEASE_INTERFACE_002_TEST,
36 USB_HOSTSDK_CLAIM_INTERFACE_003_TEST,
37 USB_HOSTSDK_RELEASE_INTERFACE_003_TEST,
38 USB_HOSTSDK_CLAIM_INTERFACE_004_TEST,
39 USB_HOSTSDK_CLAIM_INTERFACE_005_TEST,
40 USB_HOSTSDK_CLAIM_INTERFACE_006_TEST,
41 USB_HOSTSDK_OPEN_INTERFACE_001_TEST,
42 USB_HOSTSDK_CLOSE_INTERFACE_001_TEST,
43 USB_HOSTSDK_OPEN_INTERFACE_002_TEST,
44 USB_HOSTSDK_CLOSE_INTERFACE_002_TEST,
45 USB_HOSTSDK_OPEN_INTERFACE_003_TEST,
46 USB_HOSTSDK_CLOSE_INTERFACE_003_TEST,
47 USB_HOSTSDK_OPEN_INTERFACE_004_TEST,
48 USB_HOSTSDK_OPEN_INTERFACE_005_TEST,
49 USB_HOSTSDK_CLOSE_INTERFACE_005_TEST,
50 USB_HOSTSDK_OPEN_INTERFACE_006_TEST,
51 USB_HOSTSDK_SELECT_INTERFACE_001_TEST,
52 USB_HOSTSDK_SELECT_INTERFACE_002_TEST,
53 USB_HOSTSDK_SELECT_INTERFACE_003_TEST,
54 USB_HOSTSDK_SELECT_INTERFACE_004_TEST,
55 USB_HOSTSDK_SELECT_INTERFACE_005_TEST,
56 USB_HOSTSDK_SELECT_INTERFACE_006_TEST,
57 USB_HOSTSDK_CLAIM_INTERFACE_007_TEST,
58 USB_HOSTSDK_CLAIM_INTERFACE_008_TEST,
59 USB_HOSTSDK_GET_PIPE_001_TEST,
60 USB_HOSTSDK_GET_PIPE_002_TEST,
61 USB_HOSTSDK_GET_PIPE_003_TEST,
62 USB_HOSTSDK_GET_PIPE_004_TEST,
63 USB_HOSTSDK_GET_PIPE_005_TEST,
64 USB_HOSTSDK_GET_PIPE_006_TEST,
65 USB_HOSTSDK_GET_PIPE_007_TEST,
66 USB_HOSTSDK_GET_PIPE_008_TEST,
67 USB_HOSTSDK_ALLOC_REQUEST_001_TEST,
68 USB_HOSTSDK_ALLOC_REQUEST_002_TEST,
69 USB_HOSTSDK_FREE_REQUEST_001_TEST,
70 USB_HOSTSDK_ALLOC_REQUEST_003_TEST,
71 USB_HOSTSDK_ALLOC_REQUEST_004_TEST,
72 USB_HOSTSDK_FREE_REQUEST_002_TEST,
73 USB_HOSTSDK_ALLOC_REQUEST_005_TEST,
74 USB_HOSTSDK_ALLOC_REQUEST_006_TEST,
75 USB_HOSTSDK_FREE_REQUEST_003_TEST,
76 USB_HOSTSDK_ALLOC_REQUEST_007_TEST,
77 USB_HOSTSDK_ALLOC_REQUEST_008_TEST,
78 USB_HOSTSDK_ALLOC_REQUEST_010_TEST,
79 USB_HOSTSDK_ALLOC_REQUEST_011_TEST,
80 USB_HOSTSDK_FREE_REQUEST_006_TEST,
81 USB_HOSTSDK_FILL_ISO_REQUEST_001_TEST,
82 USB_HOSTSDK_FILL_ISO_REQUEST_002_TEST,
83 USB_HOSTSDK_FILL_ISO_REQUEST_003_TEST,
84 USB_HOSTSDK_FILL_ISO_REQUEST_004_TEST,
85 USB_HOSTSDK_FILL_ISO_REQUEST_005_TEST,
86 USB_HOSTSDK_FILL_ISO_REQUEST_006_TEST,
87 USB_HOSTSDK_FREE_REQUEST_004_TEST,
88 USB_HOSTSDK_ALLOC_REQUEST_009_TEST,
89 USB_HOSTSDK_FILL_REQUEST_001_TEST,
90 USB_HOSTSDK_FILL_REQUEST_002_TEST,
91 USB_HOSTSDK_FILL_REQUEST_003_TEST,
92 USB_HOSTSDK_FILL_REQUEST_004_TEST,
93 USB_HOSTSDK_SUBMIT_REQUEST_SYNC_001_TEST,
94 USB_HOSTSDK_SUBMIT_REQUEST_SYNC_002_TEST,
95 USB_HOSTSDK_SUBMIT_REQUEST_SYNC_003_TEST,
96 USB_HOSTSDK_SUBMIT_REQUEST_SYNC_004_TEST,
97 USB_HOSTSDK_FILL_REQUEST_005_TEST,
98 USB_HOSTSDK_FILL_REQUEST_006_TEST,
99 USB_HOSTSDK_FILL_REQUEST_007_TEST,
100 USB_HOSTSDK_FILL_REQUEST_008_TEST,
101 USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_001_TEST,
102 USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_001_TEST,
103 USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_002_TEST,
104 USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_002_TEST,
105 USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_003_TEST,
106 USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_003_TEST,
107 USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_004_TEST,
108 USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_004_TEST,
109 USB_HOSTSDK_CLEAR_INTERFACE_HALT_002_TEST,
110 USB_HOSTSDK_CLEAR_INTERFACE_HALT_003_TEST,
111 USB_HOSTSDK_CLEAR_INTERFACE_HALT_004_TEST,
112 USB_HOSTSDK_REMOVE_INTERFACE_001_TEST,
113 USB_HOSTSDK_ADD_INTERFACE_001_TEST,
114 USB_HOSTSDK_REMOVE_INTERFACE_002_TEST,
115 USB_HOSTSDK_ADD_INTERFACE_002_TEST,
116 USB_HOSTSDK_REMOVE_INTERFACE_003_TEST,
117 USB_HOSTSDK_ADD_INTERFACE_003_TEST,
118 USB_HOSTSDK_CLOSE_INTERFACE_006_TEST,
119 };
120
121 class HdfUsbTest : public testing::Test {
122 public:
123 static void SetUpTestCase();
124 static void TearDownTestCase();
125 };
126
SetUpTestCase()127 void HdfUsbTest::SetUpTestCase()
128 {
129 HdfTestOpenService();
130 }
131
TearDownTestCase()132 void HdfUsbTest::TearDownTestCase()
133 {
134 HdfTestCloseService();
135 }
136
137 /**
138 * @tc.number : CheckHostSdkIfInit001
139 * @tc.name :
140 * @tc.type : PERF
141 * @tc.level : Level 1
142 */
143 HWTEST_F(HdfUsbTest, CheckHostSdkIfInit001, TestSize.Level1)
144 {
145 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_INIT_001_TEST, -1};
146 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
147 }
148
149 /**
150 * @tc.number : CheckHostSdkIfExit001
151 * @tc.name :
152 * @tc.type : PERF
153 * @tc.level : Level 1
154 */
155 HWTEST_F(HdfUsbTest, CheckHostSdkIfExit001, TestSize.Level1)
156 {
157 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_EXIT_001_TEST, -1};
158 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
159 }
160
161 /**
162 * @tc.number : CheckHostSdkIfInit002
163 * @tc.name :
164 * @tc.type : PERF
165 * @tc.level : Level 1
166 */
167 HWTEST_F(HdfUsbTest, CheckHostSdkIfInit002, TestSize.Level1)
168 {
169 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_INIT_002_TEST, -1};
170 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
171 }
172
173 /**
174 * @tc.number : CheckHostSdkIfExit002
175 * @tc.name :
176 * @tc.type : PERF
177 * @tc.level : Level 1
178 */
179 HWTEST_F(HdfUsbTest, CheckHostSdkIfExit002, TestSize.Level1)
180 { struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_EXIT_002_TEST, -1};
181 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
182 }
183
184 /**
185 * @tc.number : CheckHostSdkIfInit003
186 * @tc.name :
187 * @tc.type : PERF
188 * @tc.level : Level 1
189 */
190 HWTEST_F(HdfUsbTest, CheckHostSdkIfInit003, TestSize.Level1)
191 {
192 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_INIT_003_TEST, -1};
193 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
194 }
195
196 /**
197 * @tc.number : CheckHostSdkIfInit004
198 * @tc.name :
199 * @tc.type : PERF
200 * @tc.level : Level 1
201 */
202 HWTEST_F(HdfUsbTest, CheckHostSdkIfInit004, TestSize.Level1)
203 {
204 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_INIT_004_TEST, -1};
205 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
206 }
207
208 /**
209 * @tc.number : CheckHostSdkIfInit005
210 * @tc.name :
211 * @tc.type : PERF
212 * @tc.level : Level 1
213 */
214 HWTEST_F(HdfUsbTest, CheckHostSdkIfInit005, TestSize.Level1)
215 {
216 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_INIT_005_TEST, -1};
217 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
218 }
219
220 /**
221 * @tc.number : CheckHostSdkIfClaimInterface001
222 * @tc.name :
223 * @tc.type : PERF
224 * @tc.level : Level 1
225 */
226 HWTEST_F(HdfUsbTest, CheckHostSdkIfClaimInterface001, TestSize.Level1)
227 {
228 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_001_TEST, -1};
229 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
230 }
231
232 /**
233 * @tc.number : CheckHostSdkIfReleaseInterface001
234 * @tc.name :
235 * @tc.type : PERF
236 * @tc.level : Level 1
237 */
238 HWTEST_F(HdfUsbTest, CheckHostSdkIfReleaseInterface001, TestSize.Level1)
239 {
240 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_RELEASE_INTERFACE_001_TEST, -1};
241 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
242 }
243
244 /**
245 * @tc.number : CheckHostSdkIfClaimInterface002
246 * @tc.name :
247 * @tc.type : PERF
248 * @tc.level : Level 1
249 */
250 HWTEST_F(HdfUsbTest, CheckHostSdkIfClaimInterface002, TestSize.Level1)
251 {
252 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_002_TEST, -1};
253 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
254 }
255
256 /**
257 * @tc.number : CheckHostSdkIfReleaseInterface002
258 * @tc.name :
259 * @tc.type : PERF
260 * @tc.level : Level 1
261 */
262 HWTEST_F(HdfUsbTest, CheckHostSdkIfReleaseInterface002, TestSize.Level1)
263 {
264 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_RELEASE_INTERFACE_002_TEST, -1};
265 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
266 }
267
268 /**
269 * @tc.number : CheckHostSdkIfClaimInterface003
270 * @tc.name :
271 * @tc.type : PERF
272 * @tc.level : Level 1
273 */
274 HWTEST_F(HdfUsbTest, CheckHostSdkIfClaimInterface003, TestSize.Level1)
275 {
276 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_003_TEST, -1};
277 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
278 }
279
280 /**
281 * @tc.number : CheckHostSdkIfReleaseInterface003
282 * @tc.name :
283 * @tc.type : PERF
284 * @tc.level : Level 1
285 */
286 HWTEST_F(HdfUsbTest, CheckHostSdkIfReleaseInterface003, TestSize.Level1)
287 {
288 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_RELEASE_INTERFACE_003_TEST, -1};
289 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
290 }
291
292 /**
293 * @tc.number : CheckHostSdkIfClaimInterface004
294 * @tc.name :
295 * @tc.type : PERF
296 * @tc.level : Level 1
297 */
298 HWTEST_F(HdfUsbTest, CheckHostSdkIfClaimInterface004, TestSize.Level1)
299 {
300 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_004_TEST, -1};
301 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
302 }
303
304 /**
305 * @tc.number : CheckHostSdkIfClaimInterface005
306 * @tc.name :
307 * @tc.type : PERF
308 * @tc.level : Level 1
309 */
310 HWTEST_F(HdfUsbTest, CheckHostSdkIfClaimInterface005, TestSize.Level1)
311 {
312 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_005_TEST, -1};
313 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
314 }
315
316 /**
317 * @tc.number : CheckHostSdkIfClaimInterface006
318 * @tc.name :
319 * @tc.type : PERF
320 * @tc.level : Level 1
321 */
322 HWTEST_F(HdfUsbTest, CheckHostSdkIfClaimInterface006, TestSize.Level1)
323 {
324 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_006_TEST, -1};
325 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
326 }
327
328 /**
329 * @tc.number : CheckHostSdkIfOpenInterface001
330 * @tc.name :
331 * @tc.type : PERF
332 * @tc.level : Level 1
333 */
334 HWTEST_F(HdfUsbTest, CheckHostSdkIfOpenInterface001, TestSize.Level1)
335 {
336 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_OPEN_INTERFACE_001_TEST, -1};
337 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
338 }
339
340 /**
341 * @tc.number : CheckHostSdkIfCloseInterface001
342 * @tc.name :
343 * @tc.type : PERF
344 * @tc.level : Level 1
345 */
346 HWTEST_F(HdfUsbTest, CheckHostSdkIfCloseInterface001, TestSize.Level1)
347 {
348 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLOSE_INTERFACE_001_TEST, -1};
349 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
350 }
351
352 /**
353 * @tc.number : CheckHostSdkIfOpenInterface002
354 * @tc.name :
355 * @tc.type : PERF
356 * @tc.level : Level 1
357 */
358 HWTEST_F(HdfUsbTest, CheckHostSdkIfOpenInterface002, TestSize.Level1)
359 {
360 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_OPEN_INTERFACE_002_TEST, -1};
361 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
362 }
363
364 /**
365 * @tc.number : CheckHostSdkIfCloseInterface002
366 * @tc.name :
367 * @tc.type : PERF
368 * @tc.level : Level 1
369 */
370 HWTEST_F(HdfUsbTest, CheckHostSdkIfCloseInterface002, TestSize.Level1)
371 {
372 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLOSE_INTERFACE_002_TEST, -1};
373 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
374 }
375
376 /**
377 * @tc.number : CheckHostSdkIfOpenInterface003
378 * @tc.name :
379 * @tc.type : PERF
380 * @tc.level : Level 1
381 */
382 HWTEST_F(HdfUsbTest, CheckHostSdkIfOpenInterface003, TestSize.Level1)
383 {
384 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_OPEN_INTERFACE_003_TEST, -1};
385 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
386 }
387
388 /**
389 * @tc.number : CheckHostSdkIfCloseInterface003
390 * @tc.name :
391 * @tc.type : PERF
392 * @tc.level : Level 1
393 */
394 HWTEST_F(HdfUsbTest, CheckHostSdkIfCloseInterface003, TestSize.Level1)
395 {
396 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLOSE_INTERFACE_003_TEST, -1};
397 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
398 }
399
400 /**
401 * @tc.number : CheckHostSdkIfOpenInterface004
402 * @tc.name :
403 * @tc.type : PERF
404 * @tc.level : Level 1
405 */
406 HWTEST_F(HdfUsbTest, CheckHostSdkIfOpenInterface004, TestSize.Level1)
407 {
408 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_OPEN_INTERFACE_004_TEST, -1};
409 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
410 }
411
412 /**
413 * @tc.number : CheckHostSdkIfOpenInterface005
414 * @tc.name :
415 * @tc.type : PERF
416 * @tc.level : Level 1
417 */
418 HWTEST_F(HdfUsbTest, CheckHostSdkIfOpenInterface005, TestSize.Level1)
419 {
420 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_OPEN_INTERFACE_005_TEST, -1};
421 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
422 }
423
424 /**
425 * @tc.number : CheckHostSdkIfCloseInterface005
426 * @tc.name :
427 * @tc.type : PERF
428 * @tc.level : Level 1
429 */
430 HWTEST_F(HdfUsbTest, CheckHostSdkIfCloseInterface005, TestSize.Level1)
431 {
432 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLOSE_INTERFACE_005_TEST, -1};
433 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
434 }
435
436 /**
437 * @tc.number : CheckHostSdkIfOpenInterface006
438 * @tc.name :
439 * @tc.type : PERF
440 * @tc.level : Level 1
441 */
442 HWTEST_F(HdfUsbTest, CheckHostSdkIfOpenInterface006, TestSize.Level1)
443 {
444 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_OPEN_INTERFACE_006_TEST, -1};
445 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
446 }
447
448 /**
449 * @tc.number : CheckHostSdkIfSelectInterfaceSetting001
450 * @tc.name :
451 * @tc.type : PERF
452 * @tc.level : Level 1
453 */
454 HWTEST_F(HdfUsbTest, CheckHostSdkIfSelectInterfaceSetting001, TestSize.Level1)
455 {
456 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SELECT_INTERFACE_001_TEST, -1};
457 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
458 }
459
460 /**
461 * @tc.number : CheckHostSdkIfSelectInterfaceSetting002
462 * @tc.name :
463 * @tc.type : PERF
464 * @tc.level : Level 1
465 */
466 HWTEST_F(HdfUsbTest, CheckHostSdkIfSelectInterfaceSetting002, TestSize.Level1)
467 {
468 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SELECT_INTERFACE_002_TEST, -1};
469 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
470 }
471
472 /**
473 * @tc.number : CheckHostSdkIfSelectInterfaceSetting003
474 * @tc.name :
475 * @tc.type : PERF
476 * @tc.level : Level 1
477 */
478 HWTEST_F(HdfUsbTest, CheckHostSdkIfSelectInterfaceSetting003, TestSize.Level1)
479 {
480 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SELECT_INTERFACE_003_TEST, -1};
481 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
482 }
483
484 /**
485 * @tc.number : CheckHostSdkIfSelectInterfaceSetting004
486 * @tc.name :
487 * @tc.type : PERF
488 * @tc.level : Level 1
489 */
490 HWTEST_F(HdfUsbTest, CheckHostSdkIfSelectInterfaceSetting004, TestSize.Level1)
491 {
492 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SELECT_INTERFACE_004_TEST, -1};
493 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
494 }
495
496 /**
497 * @tc.number : CheckHostSdkIfSelectInterfaceSetting005
498 * @tc.name :
499 * @tc.type : PERF
500 * @tc.level : Level 1
501 */
502 HWTEST_F(HdfUsbTest, CheckHostSdkIfSelectInterfaceSetting005, TestSize.Level1)
503 {
504 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SELECT_INTERFACE_005_TEST, -1};
505 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
506 }
507
508 /**
509 * @tc.number : CheckHostSdkIfSelectInterfaceSetting006
510 * @tc.name :
511 * @tc.type : PERF
512 * @tc.level : Level 1
513 */
514 HWTEST_F(HdfUsbTest, CheckHostSdkIfSelectInterfaceSetting006, TestSize.Level1)
515 {
516 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SELECT_INTERFACE_006_TEST, -1};
517 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
518 }
519
520 /**
521 * @tc.number : CheckHostSdkIfClaimInterface007
522 * @tc.name :
523 * @tc.type : PERF
524 * @tc.level : Level 1
525 */
526 HWTEST_F(HdfUsbTest, CheckHostSdkIfClaimInterface007, TestSize.Level1)
527 {
528 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_007_TEST, -1};
529 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
530 }
531
532 /**
533 * @tc.number : CheckHostSdkIfClaimInterface008
534 * @tc.name :
535 * @tc.type : PERF
536 * @tc.level : Level 1
537 */
538 HWTEST_F(HdfUsbTest, CheckHostSdkIfClaimInterface008, TestSize.Level1)
539 {
540 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_008_TEST, -1};
541 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
542 }
543
544 /**
545 * @tc.number : CheckHostSdkIfGetPipe001
546 * @tc.name :
547 * @tc.type : PERF
548 * @tc.level : Level 1
549 */
550 HWTEST_F(HdfUsbTest, CheckHostSdkIfGetPipe001, TestSize.Level1)
551 {
552 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_001_TEST, -1};
553 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
554 }
555
556 /**
557 * @tc.number : CheckHostSdkIfGetPipe002
558 * @tc.name :
559 * @tc.type : PERF
560 * @tc.level : Level 1
561 */
562 HWTEST_F(HdfUsbTest, CheckHostSdkIfGetPipe002, TestSize.Level1)
563 {
564 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_002_TEST, -1};
565 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
566 }
567
568 /**
569 * @tc.number : CheckHostSdkIfGetPipe003
570 * @tc.name :
571 * @tc.type : PERF
572 * @tc.level : Level 1
573 */
574 HWTEST_F(HdfUsbTest, CheckHostSdkIfGetPipe003, TestSize.Level1)
575 {
576 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_003_TEST, -1};
577 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
578 }
579
580 /**
581 * @tc.number : CheckHostSdkIfGetPipe004
582 * @tc.name :
583 * @tc.type : PERF
584 * @tc.level : Level 1
585 */
586 HWTEST_F(HdfUsbTest, CheckHostSdkIfGetPipe004, TestSize.Level1)
587 {
588 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_004_TEST, -1};
589 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
590 }
591
592 /**
593 * @tc.number : CheckHostSdkIfGetPipe005
594 * @tc.name :
595 * @tc.type : PERF
596 * @tc.level : Level 1
597 */
598 HWTEST_F(HdfUsbTest, CheckHostSdkIfGetPipe005, TestSize.Level1)
599 {
600 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_005_TEST, -1};
601 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
602 }
603
604 /**
605 * @tc.number : CheckHostSdkIfGetPipe006
606 * @tc.name :
607 * @tc.type : PERF
608 * @tc.level : Level 1
609 */
610 HWTEST_F(HdfUsbTest, CheckHostSdkIfGetPipe006, TestSize.Level1)
611 {
612 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_006_TEST, -1};
613 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
614 }
615
616 /**
617 * @tc.number : CheckHostSdkIfGetPipe007
618 * @tc.name :
619 * @tc.type : PERF
620 * @tc.level : Level 1
621 */
622 HWTEST_F(HdfUsbTest, CheckHostSdkIfGetPipe007, TestSize.Level1)
623 {
624 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_007_TEST, -1};
625 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
626 }
627
628 /**
629 * @tc.number : CheckHostSdkIfGetPipe008
630 * @tc.name :
631 * @tc.type : PERF
632 * @tc.level : Level 1
633 */
634 HWTEST_F(HdfUsbTest, CheckHostSdkIfGetPipe008, TestSize.Level1)
635 {
636 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_008_TEST, -1};
637 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
638 }
639
640 /**
641 * @tc.number : CheckHostSdkIfAllocRequest001
642 * @tc.name :
643 * @tc.type : PERF
644 * @tc.level : Level 1
645 */
646 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest001, TestSize.Level1)
647 {
648 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_001_TEST, -1};
649 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
650 }
651
652 /**
653 * @tc.number : CheckHostSdkIfAllocRequest002
654 * @tc.name :
655 * @tc.type : PERF
656 * @tc.level : Level 1
657 */
658 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest002, TestSize.Level1)
659 {
660 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_002_TEST, -1};
661 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
662 }
663
664 /**
665 * @tc.number : CheckHostSdkIfFreeRequest001
666 * @tc.name :
667 * @tc.type : PERF
668 * @tc.level : Level 1
669 */
670 HWTEST_F(HdfUsbTest, CheckHostSdkIfFreeRequest001, TestSize.Level1)
671 {
672 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FREE_REQUEST_001_TEST, -1};
673 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
674 }
675
676 /**
677 * @tc.number : CheckHostSdkIfAllocRequest003
678 * @tc.name :
679 * @tc.type : PERF
680 * @tc.level : Level 1
681 */
682 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest003, TestSize.Level1)
683 {
684 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_003_TEST, -1};
685 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
686 }
687
688 /**
689 * @tc.number : CheckHostSdkIfAllocRequest004
690 * @tc.name :
691 * @tc.type : PERF
692 * @tc.level : Level 1
693 */
694 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest004, TestSize.Level1)
695 {
696 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_004_TEST, -1};
697 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
698 }
699
700 /**
701 * @tc.number : CheckHostSdkIfFreeRequest002
702 * @tc.name :
703 * @tc.type : PERF
704 * @tc.level : Level 1
705 */
706 HWTEST_F(HdfUsbTest, CheckHostSdkIfFreeRequest002, TestSize.Level1)
707 {
708 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FREE_REQUEST_002_TEST, -1};
709 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
710 }
711
712 /**
713 * @tc.number : CheckHostSdkIfAllocRequest005
714 * @tc.name :
715 * @tc.type : PERF
716 * @tc.level : Level 1
717 */
718 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest005, TestSize.Level1)
719 {
720 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_005_TEST, -1};
721 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
722 }
723
724 /**
725 * @tc.number : CheckHostSdkIfAllocRequest006
726 * @tc.name :
727 * @tc.type : PERF
728 * @tc.level : Level 1
729 */
730 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest006, TestSize.Level1)
731 {
732 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_006_TEST, -1};
733 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
734 }
735 /**
736 * @tc.number : CheckRawSdkIfAllocRequest010
737 * @tc.name :
738 * @tc.type : PERFs
739 * @tc.level : Level 1
740 */
741 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest010, TestSize.Level1)
742 {
743 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_010_TEST, -1};
744 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
745 }
746
747 /**
748 * @tc.number : CheckRawSdkIfAllocRequest011
749 * @tc.name :
750 * @tc.type : PERFs
751 * @tc.level : Level 1
752 */
753 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest011, TestSize.Level1)
754 {
755 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_011_TEST, -1};
756 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
757 }
758
759 /**
760 * @tc.number : CheckRawSdkIfFillIsoRequest001
761 * @tc.name :
762 * @tc.type : PERFs
763 * @tc.level : Level 1
764 */
765 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillIsoRequest001, TestSize.Level1)
766 {
767 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_ISO_REQUEST_001_TEST, -1};
768 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
769 }
770
771 /**
772 * @tc.number : CheckRawSdkIfFillIsoRequest002
773 * @tc.name :
774 * @tc.type : PERFs
775 * @tc.level : Level 1
776 */
777 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillIsoRequest002, TestSize.Level1)
778 {
779 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_ISO_REQUEST_002_TEST, -1};
780 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
781 }
782
783 /**
784 * @tc.number : CheckRawSdkIfFillIsoRequest003
785 * @tc.name :
786 * @tc.type : PERFs
787 * @tc.level : Level 1
788 */
789 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillIsoRequest003, TestSize.Level1)
790 {
791 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_ISO_REQUEST_003_TEST, -1};
792 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
793 }
794
795 /**
796 * @tc.number : CheckRawSdkIfFillIsoRequest004
797 * @tc.name :
798 * @tc.type : PERFs
799 * @tc.level : Level 1
800 */
801 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillIsoRequest004, TestSize.Level1)
802 {
803 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_ISO_REQUEST_004_TEST, -1};
804 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
805 }
806 /**
807 * @tc.number : CheckRawSdkIfFillIsoRequest005
808 * @tc.name :
809 * @tc.type : PERFs
810 * @tc.level : Level 1
811 */
812 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillIsoRequest005, TestSize.Level1)
813 {
814 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_ISO_REQUEST_005_TEST, -1};
815 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
816 }
817
818 /**
819 * @tc.number : CheckRawSdkIfFillIsoRequest006
820 * @tc.name :
821 * @tc.type : PERFs
822 * @tc.level : Level 1
823 */
824 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillIsoRequest006, TestSize.Level1)
825 {
826 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_ISO_REQUEST_006_TEST, -1};
827 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
828 }
829
830 /**
831 * @tc.number : CheckRawSdkIfFreeRequest006
832 * @tc.name :
833 * @tc.type : PERFs
834 * @tc.level : Level 1
835 */
836 HWTEST_F(HdfUsbTest, CheckHostSdkIfFreeRequest006, TestSize.Level1)
837 {
838 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FREE_REQUEST_006_TEST, -1};
839 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
840 }
841
842 /**
843 * @tc.number : CheckHostSdkIfFreeRequest003
844 * @tc.name :
845 * @tc.type : PERF
846 * @tc.level : Level 1
847 */
848 HWTEST_F(HdfUsbTest, CheckHostSdkIfFreeRequest003, TestSize.Level1)
849 {
850 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FREE_REQUEST_003_TEST, -1};
851 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
852 }
853
854 /**
855 * @tc.number : CheckHostSdkIfAllocRequest007
856 * @tc.name :
857 * @tc.type : PERF
858 * @tc.level : Level 1
859 */
860 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest007, TestSize.Level1)
861 {
862 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_007_TEST, -1};
863 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
864 }
865
866 /**
867 * @tc.number : CheckHostSdkIfAllocRequest008
868 * @tc.name :
869 * @tc.type : PERF
870 * @tc.level : Level 1
871 */
872 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest008, TestSize.Level1)
873 {
874 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_008_TEST, -1};
875 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
876 }
877
878 /**
879 * @tc.number : CheckHostSdkIfFreeRequest004
880 * @tc.name :
881 * @tc.type : PERF
882 * @tc.level : Level 1
883 */
884 HWTEST_F(HdfUsbTest, CheckHostSdkIfFreeRequest004, TestSize.Level1)
885 {
886 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FREE_REQUEST_004_TEST, -1};
887 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
888 }
889
890 /**
891 * @tc.number : CheckHostSdkIfAllocRequest009
892 * @tc.name :
893 * @tc.type : PERF
894 * @tc.level : Level 1
895 */
896 HWTEST_F(HdfUsbTest, CheckHostSdkIfAllocRequest009, TestSize.Level1)
897 {
898 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_009_TEST, -1};
899 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
900 }
901
902 /**
903 * @tc.number : CheckHostSdkIfFillRequest001
904 * @tc.name :
905 * @tc.type : PERF
906 * @tc.level : Level 1
907 */
908 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillRequest001, TestSize.Level1)
909 {
910 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_001_TEST, -1};
911 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
912 }
913
914 /**
915 * @tc.number : CheckHostSdkIfFillRequest002
916 * @tc.name :
917 * @tc.type : PERF
918 * @tc.level : Level 1
919 */
920 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillRequest002, TestSize.Level1)
921 {
922 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_002_TEST, -1};
923 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
924 }
925
926 /**
927 * @tc.number : CheckHostSdkIfFillRequest003
928 * @tc.name :
929 * @tc.type : PERF
930 * @tc.level : Level 1
931 */
932 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillRequest003, TestSize.Level1)
933 {
934 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_003_TEST, -1};
935 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
936 }
937
938 /**
939 * @tc.number : CheckHostSdkIfFillRequest004
940 * @tc.name :
941 * @tc.type : PERF
942 * @tc.level : Level 1
943 */
944 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillRequest004, TestSize.Level1)
945 {
946 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_004_TEST, -1};
947 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
948 }
949
950 /**
951 * @tc.number : CheckHostSdkIfFillRequest005
952 * @tc.name :
953 * @tc.type : PERF
954 * @tc.level : Level 1
955 */
956 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillRequest005, TestSize.Level1)
957 {
958 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_005_TEST, -1};
959 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
960 }
961
962 /**
963 * @tc.number : CheckHostSdkIfFillRequest006
964 * @tc.name :
965 * @tc.type : PERF
966 * @tc.level : Level 1
967 */
968 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillRequest006, TestSize.Level1)
969 {
970 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_006_TEST, -1};
971 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
972 }
973
974 /**
975 * @tc.number : CheckHostSdkIfFillRequest007
976 * @tc.name :
977 * @tc.type : PERF
978 * @tc.level : Level 1
979 */
980 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillRequest007, TestSize.Level1)
981 {
982 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_007_TEST, -1};
983 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
984 }
985
986 /**
987 * @tc.number : CheckHostSdkIfFillRequest008
988 * @tc.name :
989 * @tc.type : PERF
990 * @tc.level : Level 1
991 */
992 HWTEST_F(HdfUsbTest, CheckHostSdkIfFillRequest008, TestSize.Level1)
993 {
994 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_008_TEST, -1};
995 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
996 }
997
998
999 /**
1000 * @tc.number : CheckHostSdkIfSubmitRequestAsync001
1001 * @tc.name :
1002 * @tc.type : PERF
1003 * @tc.level : Level 1
1004 */
1005 HWTEST_F(HdfUsbTest, CheckHostSdkIfSubmitRequestAsync001, TestSize.Level1)
1006 {
1007 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_001_TEST, -1};
1008 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1009 }
1010
1011 /**
1012 * @tc.number : CheckHostSdkIfCancelRequest001
1013 * @tc.name :
1014 * @tc.type : PERF
1015 * @tc.level : Level 1
1016 */
1017 HWTEST_F(HdfUsbTest, CheckHostSdkIfCancelRequest001, TestSize.Level1)
1018 {
1019 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_001_TEST, -1};
1020 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1021 }
1022
1023 /**
1024 * @tc.number : CheckHostSdkIfSubmitRequestAsync002
1025 * @tc.name :
1026 * @tc.type : PERF
1027 * @tc.level : Level 1
1028 */
1029 HWTEST_F(HdfUsbTest, CheckHostSdkIfSubmitRequestAsync002, TestSize.Level1)
1030 {
1031 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_002_TEST, -1};
1032 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1033 }
1034
1035 /**
1036 * @tc.number : CheckHostSdkIfCancelRequest002
1037 * @tc.name :
1038 * @tc.type : PERF
1039 * @tc.level : Level 1
1040 */
1041 HWTEST_F(HdfUsbTest, CheckHostSdkIfCancelRequest002, TestSize.Level1)
1042 {
1043 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_002_TEST, -1};
1044 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1045 }
1046
1047 /**
1048 * @tc.number : CheckHostSdkIfSubmitRequestAsync003
1049 * @tc.name :
1050 * @tc.type : PERF
1051 * @tc.level : Level 1
1052 */
1053 HWTEST_F(HdfUsbTest, CheckHostSdkIfSubmitRequestAsync003, TestSize.Level1)
1054 {
1055 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_003_TEST, -1};
1056 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1057 }
1058
1059 /**
1060 * @tc.number : CheckHostSdkIfCancelRequest003
1061 * @tc.name :
1062 * @tc.type : PERF
1063 * @tc.level : Level 1
1064 */
1065 HWTEST_F(HdfUsbTest, CheckHostSdkIfCancelRequest003, TestSize.Level1)
1066 {
1067 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_003_TEST, -1};
1068 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1069 }
1070
1071 /**
1072 * @tc.number : CheckHostSdkIfSubmitRequestAsync004
1073 * @tc.name :
1074 * @tc.type : PERF
1075 * @tc.level : Level 1
1076 */
1077 HWTEST_F(HdfUsbTest, CheckHostSdkIfSubmitRequestAsync004, TestSize.Level1)
1078 {
1079 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_004_TEST, -1};
1080 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1081 }
1082
1083 /**
1084 * @tc.number : CheckHostSdkIfCancelRequest004
1085 * @tc.name :
1086 * @tc.type : PERF
1087 * @tc.level : Level 1
1088 */
1089 HWTEST_F(HdfUsbTest, CheckHostSdkIfCancelRequest004, TestSize.Level1)
1090 {
1091 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_004_TEST, -1};
1092 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1093 }
1094
1095 /**
1096 * @tc.number : CheckHostSdkIfClearInterfaceHalt002
1097 * @tc.name :
1098 * @tc.type : PERF
1099 * @tc.level : Level 1
1100 */
1101 HWTEST_F(HdfUsbTest, CheckHostSdkIfClearInterfaceHalt002, TestSize.Level1)
1102 {
1103 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLEAR_INTERFACE_HALT_002_TEST, -1};
1104 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1105 }
1106
1107 /**
1108 * @tc.number : CheckHostSdkIfClearInterfaceHalt003
1109 * @tc.name :
1110 * @tc.type : PERF
1111 * @tc.level : Level 1
1112 */
1113 HWTEST_F(HdfUsbTest, CheckHostSdkIfClearInterfaceHalt003, TestSize.Level1)
1114 {
1115 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLEAR_INTERFACE_HALT_003_TEST, -1};
1116 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1117 }
1118
1119 /**
1120 * @tc.number : CheckHostSdkIfClearInterfaceHalt004
1121 * @tc.name :
1122 * @tc.type : PERF
1123 * @tc.level : Level 1
1124 */
1125 HWTEST_F(HdfUsbTest, CheckHostSdkIfClearInterfaceHalt004, TestSize.Level1)
1126 {
1127 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLEAR_INTERFACE_HALT_004_TEST, -1};
1128 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1129 }
1130
1131 /**
1132 * @tc.number : CheckHostSdkIfRemoveInterface001
1133 * @tc.name :
1134 * @tc.type : PERF
1135 * @tc.level : Level 1
1136 */
1137 HWTEST_F(HdfUsbTest, CheckHostSdkIfRemoveInterface001, TestSize.Level1)
1138 {
1139 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_REMOVE_INTERFACE_001_TEST, -1};
1140 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1141 }
1142
1143 /**
1144 * @tc.number : CheckHostSdkIfAddInterface001
1145 * @tc.name :
1146 * @tc.type : PERF
1147 * @tc.level : Level 1
1148 */
1149 HWTEST_F(HdfUsbTest, CheckHostSdkIfAddInterface001, TestSize.Level1)
1150 {
1151 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ADD_INTERFACE_001_TEST, -1};
1152 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1153 }
1154
1155 /**
1156 * @tc.number : CheckHostSdkIfRemoveInterface002
1157 * @tc.name :
1158 * @tc.type : PERF
1159 * @tc.level : Level 1
1160 */
1161 HWTEST_F(HdfUsbTest, CheckHostSdkIfRemoveInterface002, TestSize.Level1)
1162 {
1163 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_REMOVE_INTERFACE_002_TEST, -1};
1164 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1165 }
1166
1167 /**
1168 * @tc.number : CheckHostSdkIfAddInterface002
1169 * @tc.name :
1170 * @tc.type : PERF
1171 * @tc.level : Level 1
1172 */
1173 HWTEST_F(HdfUsbTest, CheckHostSdkIfAddInterface002, TestSize.Level1)
1174 {
1175 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ADD_INTERFACE_002_TEST, -1};
1176 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1177 }
1178
1179 /**
1180 * @tc.number : CheckHostSdkIfRemoveInterface003
1181 * @tc.name :
1182 * @tc.type : PERF
1183 * @tc.level : Level 1
1184 */
1185 HWTEST_F(HdfUsbTest, CheckHostSdkIfRemoveInterface003, TestSize.Level1)
1186 {
1187 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_REMOVE_INTERFACE_003_TEST, -1};
1188 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1189 }
1190
1191 /**
1192 * @tc.number : CheckHostSdkIfAddInterface003
1193 * @tc.name :
1194 * @tc.type : PERF
1195 * @tc.level : Level 1
1196 */
1197 HWTEST_F(HdfUsbTest, CheckHostSdkIfAddInterface003, TestSize.Level1)
1198 {
1199 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ADD_INTERFACE_003_TEST, -1};
1200 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1201 }
1202
1203 /**
1204 * @tc.number : CheckHostSdkIfCloseInterface006
1205 * @tc.name :
1206 * @tc.type : PERF
1207 * @tc.level : Level 1
1208 */
1209 HWTEST_F(HdfUsbTest, CheckHostSdkIfCloseInterface006, TestSize.Level1)
1210 {
1211 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLOSE_INTERFACE_006_TEST, -1};
1212 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1213 }
1214 }
1215