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 HdfLiteUsbRawTestCmd {
24 USB_RAW_SDK_IF_START_IO,
25 USB_RAW_SDK_IF_INIT_001_TEST,
26 USB_RAW_SDK_IF_EXIT_001_TEST,
27 USB_RAW_SDK_IF_INIT_002_TEST,
28 USB_RAW_SDK_IF_EXIT_002_TEST,
29 USB_RAW_SDK_IF_INIT_003_TEST,
30 USB_RAW_SDK_IF_INIT_004_TEST,
31 USB_RAW_SDK_IF_INIT_005_TEST,
32 USB_RAW_SDK_IF_OPEN_DEVICE_001_TEST,
33 USB_RAW_SDK_IF_OPEN_DEVICE_002_TEST,
34 USB_RAW_SDK_IF_OPEN_DEVICE_003_TEST,
35 USB_RAW_SDK_IF_OPEN_DEVICE_004_TEST,
36 USB_RAW_SDK_IF_OPEN_DEVICE_005_TEST,
37 USB_RAW_SDK_IF_OPEN_DEVICE_006_TEST,
38 USB_RAW_SDK_IF_RESET_DEVICE_001_TEST,
39 USB_RAW_SDK_IF_RESET_DEVICE_002_TEST,
40 USB_RAW_SDK_IF_CLOSE_DEVICE_001_TEST,
41 USB_RAW_SDK_IF_CLOSE_DEVICE_002_TEST,
42 USB_RAW_SDK_IF_OPEN_DEVICE_007_TEST,
43 USB_RAW_SDK_IF_GET_CONFIGURATION_001_TEST,
44 USB_RAW_SDK_IF_GET_CONFIGURATION_002_TEST,
45 USB_RAW_SDK_IF_GET_CONFIGURATION_003_TEST,
46 USB_RAW_SDK_IF_GET_CONFIGURATION_004_TEST,
47 USB_RAW_SDK_IF_GET_DEVICE_001_TEST,
48 USB_RAW_SDK_IF_GET_DEVICE_002_TEST,
49 USB_RAW_SDK_IF_GET_CONFIG_DESC_001_TEST,
50 USB_RAW_SDK_IF_GET_CONFIG_DESC_002_TEST,
51 USB_RAW_SDK_IF_GET_CONFIG_DESC_003_TEST,
52 USB_RAW_SDK_IF_GET_CONFIG_DESC_004_TEST,
53 USB_RAW_SDK_IF_SET_CONFIGURATION_001_TEST,
54 USB_RAW_SDK_IF_SET_CONFIGURATION_002_TEST,
55 USB_RAW_SDK_IF_SET_CONFIGURATION_003_TEST,
56 USB_RAW_SDK_IF_SET_CONFIGURATION_004_TEST,
57 USB_RAW_SDK_IF_SET_CONFIGURATION_005_TEST,
58 USB_RAW_SDK_IF_SET_CONFIGURATION_006_TEST,
59 USB_RAW_SDK_IF_SET_CONFIGURATION_007_TEST,
60 USB_RAW_SDK_IF_SET_CONFIGURATION_008_TEST,
61 USB_RAW_SDK_IF_GET_DEVICE_DESC_001_TEST,
62 USB_RAW_SDK_IF_GET_DEVICE_DESC_002_TEST,
63 USB_RAW_SDK_IF_GET_DEVICE_DESC_003_TEST,
64 USB_RAW_SDK_IF_GET_DEVICE_DESC_004_TEST,
65 USB_RAW_SDK_IF_GET_CONFIG_DESC_005_TEST,
66 USB_RAW_SDK_IF_GET_DEVICE_DESC_005_TEST,
67 USB_RAW_SDK_IF_CLAMIN_INTERFACE_001_TEST,
68 USB_RAW_SDK_IF_CLAMIN_INTERFACE_002_TEST,
69 USB_RAW_SDK_IF_CLAMIN_INTERFACE_003_TEST,
70 USB_RAW_SDK_IF_CLAMIN_INTERFACE_004_TEST,
71 USB_RAW_SDK_IF_CLAMIN_INTERFACE_005_TEST,
72 USB_RAW_SDK_IF_RELEASE_INTERFACE_001_TEST,
73 USB_RAW_SDK_IF_RELEASE_INTERFACE_002_TEST,
74 USB_RAW_SDK_IF_RELEASE_INTERFACE_003_TEST,
75 USB_RAW_SDK_IF_RELEASE_INTERFACE_004_TEST,
76 USB_RAW_SDK_IF_CLAMIN_INTERFACE_006_TEST,
77 USB_RAW_SDK_IF_ALLOC_REQUEST_001_TEST,
78 USB_RAW_SDK_IF_ALLOC_REQUEST_002_TEST,
79 USB_RAW_SDK_IF_ALLOC_REQUEST_003_TEST,
80 USB_RAW_SDK_IF_ALLOC_REQUEST_004_TEST,
81 USB_RAW_SDK_IF_ALLOC_REQUEST_005_TEST,
82 USB_RAW_SDK_IF_ALLOC_REQUEST_006_TEST,
83 USB_RAW_SDK_IF_ALLOC_REQUEST_007_TEST,
84 USB_RAW_SDK_IF_ALLOC_REQUEST_008_TEST,
85 USB_RAW_SDK_IF_ALLOC_REQUEST_010_TEST,
86 USB_RAW_SDK_IF_ALLOC_REQUEST_011_TEST,
87 USB_RAW_SDK_IF_FREE_REQUEST_006_TEST,
88 USB_RAW_SDK_IF_FILL_ISO_REQUEST_001_TEST,
89 USB_RAW_SDK_IF_FILL_ISO_REQUEST_002_TEST,
90 USB_RAW_SDK_IF_FILL_ISO_REQUEST_003_TEST,
91 USB_RAW_SDK_IF_FILL_ISO_REQUEST_004_TEST,
92 USB_RAW_SDK_IF_FILL_ISO_REQUEST_005_TEST,
93 USB_RAW_SDK_IF_FILL_ISO_REQUEST_006_TEST,
94 USB_RAW_SDK_IF_FREE_REQUEST_001_TEST,
95 USB_RAW_SDK_IF_FREE_REQUEST_002_TEST,
96 USB_RAW_SDK_IF_FREE_REQUEST_003_TEST,
97 USB_RAW_SDK_IF_FREE_REQUEST_004_TEST,
98 USB_RAW_SDK_IF_FREE_REQUEST_005_TEST,
99 USB_RAW_SDK_IF_ALLOC_REQUEST_009_TEST,
100 USB_RAW_SDK_IF_GET_DESCRIPTION_001_TEST,
101 USB_RAW_SDK_IF_GET_DESCRIPTION_002_TEST,
102 USB_RAW_SDK_IF_GET_DESCRIPTION_003_TEST,
103 USB_RAW_SDK_IF_GET_DESCRIPTION_004_TEST,
104 USB_RAW_SDK_IF_GET_DESCRIPTION_005_TEST,
105 USB_RAW_SDK_IF_GET_DESCRIPTION_006_TEST,
106 USB_RAW_SDK_IF_GET_DESCRIPTION_007_TEST,
107 USB_RAW_SDK_IF_GET_DESCRIPTION_008_TEST,
108 USB_RAW_SDK_IF_GET_DESCRIPTION_009_TEST,
109 USB_RAW_SDK_IF_GET_DESCRIPTION_010_TEST,
110 USB_RAW_SDK_IF_GET_DESCRIPTION_011_TEST,
111 USB_RAW_SDK_IF_GET_DESCRIPTION_012_TEST,
112 USB_RAW_SDK_IF_GET_DESCRIPTION_013_TEST,
113 USB_RAW_SDK_IF_GET_DESCRIPTION_014_TEST,
114 USB_RAW_SDK_IF_GET_DESCRIPTION_015_TEST,
115 USB_RAW_SDK_IF_GET_DESCRIPTION_016_TEST,
116 USB_RAW_SDK_IF_FILL_BULK_REQUEST_001_TEST,
117 USB_RAW_SDK_IF_FILL_BULK_REQUEST_002_TEST,
118 USB_RAW_SDK_IF_FILL_INT_REQUEST_001_TEST,
119 USB_RAW_SDK_IF_FILL_INT_REQUEST_002_TEST,
120 USB_RAW_SDK_IF_FILL_INT_REQUEST_003_TEST,
121 USB_RAW_SDK_IF_FILL_INT_REQUEST_004_TEST,
122 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_001_TEST,
123 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_002_TEST,
124 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_003_TEST,
125 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_004_TEST,
126 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_005_TEST,
127 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_006_TEST,
128 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_007_TEST,
129 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_008_TEST,
130 USB_RAW_SDK_IF_FILL_CONTROL_SETUP_001_TEST,
131 USB_RAW_SDK_IF_FILL_CONTROL_SETUP_002_TEST,
132 USB_RAW_SDK_IF_FILL_CONTROL_SETUP_003_TEST,
133 USB_RAW_SDK_IF_FILL_CONTROL_SETUP_004_TEST,
134 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_001_TEST,
135 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_002_TEST,
136 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_003_TEST,
137 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_004_TEST,
138 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_005_TEST,
139 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_006_TEST,
140 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_007_TEST,
141 USB_RAW_SDK_IF_SEND_BULK_REQUEST_001_TEST,
142 USB_RAW_SDK_IF_SEND_BULK_REQUEST_002_TEST,
143 USB_RAW_SDK_IF_SEND_BULK_REQUEST_003_TEST,
144 USB_RAW_SDK_IF_SEND_BULK_REQUEST_004_TEST,
145 USB_RAW_SDK_IF_SEND_BULK_REQUEST_005_TEST,
146 USB_RAW_SDK_IF_SEND_INT_REQUEST_001_TEST,
147 USB_RAW_SDK_IF_SEND_INT_REQUEST_002_TEST,
148 USB_RAW_SDK_IF_SEND_INT_REQUEST_003_TEST,
149 USB_RAW_SDK_IF_SEND_INT_REQUEST_004_TEST,
150 USB_RAW_SDK_IF_FILL_BULK_REQUEST_003_TEST,
151 USB_RAW_SDK_IF_FILL_BULK_REQUEST_004_TEST,
152 USB_RAW_SDK_IF_FILL_INT_REQUEST_005_TEST,
153 USB_RAW_SDK_IF_SUBMIT_REQUEST_001_TEST,
154 USB_RAW_SDK_IF_SUBMIT_REQUEST_002_TEST,
155 USB_RAW_SDK_IF_SUBMIT_REQUEST_003_TEST,
156 USB_RAW_SDK_IF_SUBMIT_REQUEST_004_TEST,
157 USB_RAW_SDK_IF_CANCEL_REQUEST_001_TEST,
158 USB_RAW_SDK_IF_CANCEL_REQUEST_002_TEST,
159 USB_RAW_SDK_IF_CANCEL_REQUEST_003_TEST,
160 USB_RAW_SDK_IF_CANCEL_REQUEST_004_TEST,
161 USB_RAW_SDK_IF_STOP_IO,
162 };
163
164 class HdfUsbRawTest : public testing::Test {
165 public:
166 static void SetUpTestCase();
167 static void TearDownTestCase();
168 };
169
SetUpTestCase()170 void HdfUsbRawTest::SetUpTestCase()
171 {
172 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_START_IO, -1};
173 HdfTestOpenService();
174 HdfTestSendMsgToService(&msg);
175 }
176
TearDownTestCase()177 void HdfUsbRawTest::TearDownTestCase()
178 {
179 HdfTestCloseService();
180 }
181
182 /**
183 * @tc.number : CheckRawSdkIfInit001
184 * @tc.name :
185 * @tc.type : PERF
186 * @tc.level : Level 1
187 */
188 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfInit001, TestSize.Level1)
189 {
190 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_INIT_001_TEST, -1};
191 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
192 }
193
194 /**
195 * @tc.number : CheckRawSdkIfExit001
196 * @tc.name :
197 * @tc.type : PERF
198 * @tc.level : Level 1
199 */
200 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfExit001, TestSize.Level1)
201 {
202 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_EXIT_001_TEST, -1};
203 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
204 }
205
206 /**
207 * @tc.number : CheckRawSdkIfInit002
208 * @tc.name :
209 * @tc.type : PERF
210 * @tc.level : Level 1
211 */
212 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfInit002, TestSize.Level1)
213 {
214 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_INIT_002_TEST, -1};
215 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
216 }
217
218 /**
219 * @tc.number : CheckRawSdkIfExit002
220 * @tc.name :
221 * @tc.type : PERF
222 * @tc.level : Level 1
223 */
224 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfExit002, TestSize.Level1)
225 {
226 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_EXIT_002_TEST, -1};
227 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
228 }
229
230 /**
231 * @tc.number : CheckRawSdkIfInit003
232 * @tc.name :
233 * @tc.type : PERF
234 * @tc.level : Level 1
235 */
236 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfInit003, TestSize.Level1)
237 {
238 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_INIT_003_TEST, -1};
239 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
240 }
241
242 /**
243 * @tc.number : CheckRawSdkIfInit004
244 * @tc.name :
245 * @tc.type : PERF
246 * @tc.level : Level 1
247 */
248 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfInit004, TestSize.Level1)
249 {
250 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_INIT_004_TEST, -1};
251 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
252 }
253
254 /**
255 * @tc.number : CheckRawSdkIfInit005
256 * @tc.name :
257 * @tc.type : PERF
258 * @tc.level : Level 1
259 */
260 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfInit005, TestSize.Level1)
261 {
262 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_INIT_005_TEST, -1};
263 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
264 }
265
266 /**
267 * @tc.number : CheckRawSdkIfOpenDevice001
268 * @tc.name :
269 * @tc.type : PERF
270 * @tc.level : Level 1
271 */
272 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfOpenDevice001, TestSize.Level1)
273 {
274 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_OPEN_DEVICE_001_TEST, -1};
275 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
276 }
277
278 /**
279 * @tc.number : CheckRawSdkIfOpenDevice002
280 * @tc.name :
281 * @tc.type : PERF
282 * @tc.level : Level 1
283 */
284 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfOpenDevice002, TestSize.Level1)
285 {
286 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_OPEN_DEVICE_002_TEST, -1};
287 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
288 }
289
290 /**
291 * @tc.number : CheckRawSdkIfOpenDevice003
292 * @tc.name :
293 * @tc.type : PERF
294 * @tc.level : Level 1
295 */
296 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfOpenDevice003, TestSize.Level1)
297 {
298 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_OPEN_DEVICE_003_TEST, -1};
299 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
300 }
301
302 /**
303 * @tc.number : CheckRawSdkIfOpenDevice004
304 * @tc.name :
305 * @tc.type : PERF
306 * @tc.level : Level 1
307 */
308 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfOpenDevice004, TestSize.Level1)
309 {
310 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_OPEN_DEVICE_004_TEST, -1};
311 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
312 }
313
314 /**
315 * @tc.number : CheckRawSdkIfOpenDevice005
316 * @tc.name :
317 * @tc.type : PERF
318 * @tc.level : Level 1
319 */
320 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfOpenDevice005, TestSize.Level1)
321 {
322 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_OPEN_DEVICE_005_TEST, -1};
323 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
324 }
325
326 /**
327 * @tc.number : CheckRawSdkIfOpenDevice006
328 * @tc.name :
329 * @tc.type : PERF
330 * @tc.level : Level 1
331 */
332 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfOpenDevice006, TestSize.Level1)
333 {
334 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_OPEN_DEVICE_006_TEST, -1};
335 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
336 }
337
338 /**
339 * @tc.number : CheckRawSdkIfResetDevice001
340 * @tc.name :
341 * @tc.type : PERF
342 * @tc.level : Level 1
343 */
344 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfResetDevice001, TestSize.Level1)
345 {
346 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RESET_DEVICE_001_TEST, -1};
347 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
348 }
349
350 /**
351 * @tc.number : CheckRawSdkIfResetDevice002
352 * @tc.name :
353 * @tc.type : PERF
354 * @tc.level : Level 1
355 */
356 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfResetDevice002, TestSize.Level1)
357 {
358 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RESET_DEVICE_002_TEST, -1};
359 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
360 }
361
362 /**
363 * @tc.number : CheckRawSdkIfCloseDevice001
364 * @tc.name :
365 * @tc.type : PERF
366 * @tc.level : Level 1
367 */
368 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfCloseDevice001, TestSize.Level1)
369 {
370 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLOSE_DEVICE_001_TEST, -1};
371 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
372 }
373
374 /**
375 * @tc.number : CheckRawSdkIfCloseDevice002
376 * @tc.name :
377 * @tc.type : PERF
378 * @tc.level : Level 1
379 */
380 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfCloseDevice002, TestSize.Level1)
381 {
382 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLOSE_DEVICE_002_TEST, -1};
383 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
384 }
385
386 /**
387 * @tc.number : CheckRawSdkIfOpenDevice007
388 * @tc.name :
389 * @tc.type : PERF
390 * @tc.level : Level 1
391 */
392 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfOpenDevice007, TestSize.Level1)
393 {
394 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_OPEN_DEVICE_007_TEST, -1};
395 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
396 }
397
398 /**
399 * @tc.number : CheckRawSdkIfGetConfiguration001
400 * @tc.name :
401 * @tc.type : PERF
402 * @tc.level : Level 1
403 */
404 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetConfiguration001, TestSize.Level1)
405 {
406 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIGURATION_001_TEST, -1};
407 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
408 }
409
410 /**
411 * @tc.number : CheckRawSdkIfGetConfiguration002
412 * @tc.name :
413 * @tc.type : PERF
414 * @tc.level : Level 1
415 */
416 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetConfiguration002, TestSize.Level1)
417 {
418 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIGURATION_002_TEST, -1};
419 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
420 }
421
422 /**
423 * @tc.number : CheckRawSdkIfGetConfiguration003
424 * @tc.name :
425 * @tc.type : PERF
426 * @tc.level : Level 1
427 */
428 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetConfiguration003, TestSize.Level1)
429 {
430 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIGURATION_003_TEST, -1};
431 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
432 }
433
434 /**
435 * @tc.number : CheckRawSdkIfGetConfiguration004
436 * @tc.name :
437 * @tc.type : PERF
438 * @tc.level : Level 1
439 */
440 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetConfiguration004, TestSize.Level1)
441 {
442 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIGURATION_004_TEST, -1};
443 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
444 }
445
446 /**
447 * @tc.number : CheckRawSdkIfGetDevice001
448 * @tc.name :
449 * @tc.type : PERF
450 * @tc.level : Level 1
451 */
452 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDevice001, TestSize.Level1)
453 {
454 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DEVICE_001_TEST, -1};
455 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
456 }
457
458 /**
459 * @tc.number : CheckRawSdkIfGetDevice002
460 * @tc.name :
461 * @tc.type : PERF
462 * @tc.level : Level 1
463 */
464 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDevice002, TestSize.Level1)
465 {
466 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DEVICE_002_TEST, -1};
467 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
468 }
469
470 /**
471 * @tc.number : CheckRawSdkIfGetConfigDescriptor001
472 * @tc.name :
473 * @tc.type : PERF
474 * @tc.level : Level 1
475 */
476 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetConfigDescriptor001, TestSize.Level1)
477 {
478 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIG_DESC_001_TEST, -1};
479 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
480 }
481
482 /**
483 * @tc.number : CheckRawSdkIfGetConfigDescriptor002
484 * @tc.name :
485 * @tc.type : PERF
486 * @tc.level : Level 1
487 */
488 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetConfigDescriptor002, TestSize.Level1)
489 {
490 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIG_DESC_002_TEST, -1};
491 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
492 }
493
494 /**
495 * @tc.number : CheckRawSdkIfGetConfigDescriptor003
496 * @tc.name :
497 * @tc.type : PERF
498 * @tc.level : Level 1
499 */
500 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetConfigDescriptor003, TestSize.Level1)
501 {
502 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIG_DESC_003_TEST, -1};
503 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
504 }
505
506 /**
507 * @tc.number : CheckRawSdkIfGetConfigDescriptor004
508 * @tc.name :
509 * @tc.type : PERF
510 * @tc.level : Level 1
511 */
512 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetConfigDescriptor004, TestSize.Level1)
513 {
514 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIG_DESC_004_TEST, -1};
515 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
516 }
517
518 /**
519 * @tc.number : CheckRawSdkIfSetConfiguration001
520 * @tc.name :
521 * @tc.type : PERF
522 * @tc.level : Level 1
523 */
524 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSetConfiguration001, TestSize.Level1)
525 {
526 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SET_CONFIGURATION_001_TEST, -1};
527 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
528 }
529
530 /**
531 * @tc.number : CheckRawSdkIfSetConfiguration002
532 * @tc.name :
533 * @tc.type : PERF
534 * @tc.level : Level 1
535 */
536 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSetConfiguration002, TestSize.Level1)
537 {
538 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SET_CONFIGURATION_002_TEST, -1};
539 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
540 }
541
542 /**
543 * @tc.number : CheckRawSdkIfSetConfiguration003
544 * @tc.name :
545 * @tc.type : PERF
546 * @tc.level : Level 1
547 */
548 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSetConfiguration003, TestSize.Level1)
549 {
550 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SET_CONFIGURATION_003_TEST, -1};
551 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
552 }
553
554 /**
555 * @tc.number : CheckRawSdkIfSetConfiguration004
556 * @tc.name :
557 * @tc.type : PERF
558 * @tc.level : Level 1
559 */
560 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSetConfiguration004, TestSize.Level1)
561 {
562 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SET_CONFIGURATION_004_TEST, -1};
563 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
564 }
565
566 /**
567 * @tc.number : CheckRawSdkIfSetConfiguration005
568 * @tc.name :
569 * @tc.type : PERF
570 * @tc.level : Level 1
571 */
572 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSetConfiguration005, TestSize.Level1)
573 {
574 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SET_CONFIGURATION_005_TEST, -1};
575 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
576 }
577
578 /**
579 * @tc.number : CheckRawSdkIfSetConfiguration006
580 * @tc.name :
581 * @tc.type : PERF
582 * @tc.level : Level 1
583 */
584 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSetConfiguration006, TestSize.Level1)
585 {
586 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SET_CONFIGURATION_006_TEST, -1};
587 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
588 }
589
590 /**
591 * @tc.number : CheckRawSdkIfSetConfiguration007
592 * @tc.name :
593 * @tc.type : PERF
594 * @tc.level : Level 1
595 */
596 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSetConfiguration007, TestSize.Level1)
597 {
598 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SET_CONFIGURATION_007_TEST, -1};
599 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
600 }
601
602 /**
603 * @tc.number : CheckRawSdkIfSetConfiguration008
604 * @tc.name :
605 * @tc.type : PERF
606 * @tc.level : Level 1
607 */
608 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSetConfiguration008, TestSize.Level1)
609 {
610 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SET_CONFIGURATION_008_TEST, -1};
611 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
612 }
613
614 /**
615 * @tc.number : CheckRawSdkIfGetDeviceDescriptor001
616 * @tc.name :
617 * @tc.type : PERF
618 * @tc.level : Level 1
619 */
620 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDeviceDescriptor001, TestSize.Level1)
621 {
622 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DEVICE_DESC_001_TEST, -1};
623 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
624 }
625
626 /**
627 * @tc.number : CheckRawSdkIfGetDeviceDescriptor002
628 * @tc.name :
629 * @tc.type : PERF
630 * @tc.level : Level 1
631 */
632 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDeviceDescriptor002, TestSize.Level1)
633 {
634 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DEVICE_DESC_002_TEST, -1};
635 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
636 }
637
638 /**
639 * @tc.number : CheckRawSdkIfGetDeviceDescriptor003
640 * @tc.name :
641 * @tc.type : PERF
642 * @tc.level : Level 1
643 */
644 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDeviceDescriptor003, TestSize.Level1)
645 {
646 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DEVICE_DESC_003_TEST, -1};
647 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
648 }
649
650 /**
651 * @tc.number : CheckRawSdkIfGetDeviceDescriptor004
652 * @tc.name :
653 * @tc.type : PERF
654 * @tc.level : Level 1
655 */
656 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDeviceDescriptor004, TestSize.Level1)
657 {
658 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DEVICE_DESC_004_TEST, -1};
659 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
660 }
661
662 /**
663 * @tc.number : CheckRawSdkIfGetConfigDescriptor005
664 * @tc.name :
665 * @tc.type : PERF
666 * @tc.level : Level 1
667 */
668 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetConfigDescriptor005, TestSize.Level1)
669 {
670 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIG_DESC_005_TEST, -1};
671 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
672 }
673
674 /**
675 * @tc.number : CheckRawSdkIfGetDeviceDescriptor005
676 * @tc.name :
677 * @tc.type : PERF
678 * @tc.level : Level 1
679 */
680 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDeviceDescriptor005, TestSize.Level1)
681 {
682 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DEVICE_DESC_005_TEST, -1};
683 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
684 }
685
686 /**
687 * @tc.number : CheckRawSdkIfClaimInterface001
688 * @tc.name :
689 * @tc.type : PERFs
690 * @tc.level : Level 1
691 */
692 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfClaimInterface001, TestSize.Level1)
693 {
694 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLAMIN_INTERFACE_001_TEST, -1};
695 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
696 }
697
698 /**
699 * @tc.number : CheckRawSdkIfClaimInterface002
700 * @tc.name :
701 * @tc.type : PERFs
702 * @tc.level : Level 1
703 */
704 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfClaimInterface002, TestSize.Level1)
705 {
706 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLAMIN_INTERFACE_002_TEST, -1};
707 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
708 }
709
710 /**
711 * @tc.number : CheckRawSdkIfClaimInterface003
712 * @tc.name :
713 * @tc.type : PERFs
714 * @tc.level : Level 1
715 */
716 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfClaimInterface003, TestSize.Level1)
717 {
718 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLAMIN_INTERFACE_003_TEST, -1};
719 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
720 }
721
722 /**
723 * @tc.number : CheckRawSdkIfClaimInterface004
724 * @tc.name :
725 * @tc.type : PERFs
726 * @tc.level : Level 1
727 */
728 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfClaimInterface004, TestSize.Level1)
729 {
730 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLAMIN_INTERFACE_004_TEST, -1};
731 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
732 }
733
734 /**
735 * @tc.number : CheckRawSdkIfClaimInterface005
736 * @tc.name :
737 * @tc.type : PERFs
738 * @tc.level : Level 1
739 */
740 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfClaimInterface005, TestSize.Level1)
741 {
742 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLAMIN_INTERFACE_005_TEST, -1};
743 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
744 }
745
746 /**
747 * @tc.number : CheckRawSdkIfReleaseInterface001
748 * @tc.name :
749 * @tc.type : PERFs
750 * @tc.level : Level 1
751 */
752 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfReleaseInterface001, TestSize.Level1)
753 {
754 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RELEASE_INTERFACE_001_TEST, -1};
755 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
756 }
757
758 /**
759 * @tc.number : CheckRawSdkIfReleaseInterface002
760 * @tc.name :
761 * @tc.type : PERFs
762 * @tc.level : Level 1
763 */
764 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfReleaseInterface002, TestSize.Level1)
765 {
766 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RELEASE_INTERFACE_002_TEST, -1};
767 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
768 }
769
770 /**
771 * @tc.number : CheckRawSdkIfReleaseInterface003
772 * @tc.name :
773 * @tc.type : PERFs
774 * @tc.level : Level 1
775 */
776 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfReleaseInterface003, TestSize.Level1)
777 {
778 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RELEASE_INTERFACE_003_TEST, -1};
779 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
780 }
781
782 /**
783 * @tc.number : CheckRawSdkIfReleaseInterface004
784 * @tc.name :
785 * @tc.type : PERFs
786 * @tc.level : Level 1
787 */
788 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfReleaseInterface004, TestSize.Level1)
789 {
790 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RELEASE_INTERFACE_004_TEST, -1};
791 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
792 }
793
794 /**
795 * @tc.number : CheckRawSdkIfClaimInterface006
796 * @tc.name :
797 * @tc.type : PERFs
798 * @tc.level : Level 1
799 */
800 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfClaimInterface006, TestSize.Level1)
801 {
802 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLAMIN_INTERFACE_006_TEST, -1};
803 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
804 }
805
806 /**
807 * @tc.number : CheckRawSdkIfAllocRequest001
808 * @tc.name :
809 * @tc.type : PERFs
810 * @tc.level : Level 1
811 */
812 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest001, TestSize.Level1)
813 {
814 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_001_TEST, -1};
815 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
816 }
817
818 /**
819 * @tc.number : CheckRawSdkIfAllocRequest002
820 * @tc.name :
821 * @tc.type : PERFs
822 * @tc.level : Level 1
823 */
824 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest002, TestSize.Level1)
825 {
826 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_002_TEST, -1};
827 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
828 }
829
830 /**
831 * @tc.number : CheckRawSdkIfAllocRequest003
832 * @tc.name :
833 * @tc.type : PERFs
834 * @tc.level : Level 1
835 */
836 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest003, TestSize.Level1)
837 {
838 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_003_TEST, -1};
839 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
840 }
841
842 /**
843 * @tc.number : CheckRawSdkIfAllocRequest004
844 * @tc.name :
845 * @tc.type : PERFs
846 * @tc.level : Level 1
847 */
848 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest004, TestSize.Level1)
849 {
850 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_004_TEST, -1};
851 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
852 }
853
854 /**
855 * @tc.number : CheckRawSdkIfAllocRequest005
856 * @tc.name :
857 * @tc.type : PERFs
858 * @tc.level : Level 1
859 */
860 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest005, TestSize.Level1)
861 {
862 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_005_TEST, -1};
863 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
864 }
865 /**
866 * @tc.number : CheckRawSdkIfAllocRequest006
867 * @tc.name :
868 * @tc.type : PERFs
869 * @tc.level : Level 1
870 */
871 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest006, TestSize.Level1)
872 {
873 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_006_TEST, -1};
874 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
875 }
876 /**
877 * @tc.number : CheckRawSdkIfAllocRequest007
878 * @tc.name :
879 * @tc.type : PERFs
880 * @tc.level : Level 1
881 */
882 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest007, TestSize.Level1)
883 {
884 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_007_TEST, -1};
885 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
886 }
887
888 /**
889 * @tc.number : CheckRawSdkIfAllocRequest008
890 * @tc.name :
891 * @tc.type : PERFs
892 * @tc.level : Level 1
893 */
894 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest008, TestSize.Level1)
895 {
896 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_008_TEST, -1};
897 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
898 }
899 /**
900 * @tc.number : CheckRawSdkIfAllocRequest010
901 * @tc.name :
902 * @tc.type : PERFs
903 * @tc.level : Level 1
904 */
905 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest010, TestSize.Level1)
906 {
907 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_010_TEST, -1};
908 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
909 }
910
911 /**
912 * @tc.number : CheckRawSdkIfAllocRequest011
913 * @tc.name :
914 * @tc.type : PERFs
915 * @tc.level : Level 1
916 */
917 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest011, TestSize.Level1)
918 {
919 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_011_TEST, -1};
920 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
921 }
922
923 /**
924 * @tc.number : CheckRawSdkIfFillIsoRequest001
925 * @tc.name :
926 * @tc.type : PERFs
927 * @tc.level : Level 1
928 */
929 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillIsoRequest001, TestSize.Level1)
930 {
931 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_ISO_REQUEST_001_TEST, -1};
932 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
933 }
934
935 /**
936 * @tc.number : CheckRawSdkIfFillIsoRequest002
937 * @tc.name :
938 * @tc.type : PERFs
939 * @tc.level : Level 1
940 */
941 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillIsoRequest002, TestSize.Level1)
942 {
943 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_ISO_REQUEST_002_TEST, -1};
944 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
945 }
946
947 /**
948 * @tc.number : CheckRawSdkIfFillIsoRequest003
949 * @tc.name :
950 * @tc.type : PERFs
951 * @tc.level : Level 1
952 */
953 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillIsoRequest003, TestSize.Level1)
954 {
955 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_ISO_REQUEST_003_TEST, -1};
956 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
957 }
958
959 /**
960 * @tc.number : CheckRawSdkIfFillIsoRequest004
961 * @tc.name :
962 * @tc.type : PERFs
963 * @tc.level : Level 1
964 */
965 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillIsoRequest004, TestSize.Level1)
966 {
967 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_ISO_REQUEST_004_TEST, -1};
968 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
969 }
970 /**
971 * @tc.number : CheckRawSdkIfFillIsoRequest005
972 * @tc.name :
973 * @tc.type : PERFs
974 * @tc.level : Level 1
975 */
976 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillIsoRequest005, TestSize.Level1)
977 {
978 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_ISO_REQUEST_005_TEST, -1};
979 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
980 }
981
982 /**
983 * @tc.number : CheckRawSdkIfFillIsoRequest006
984 * @tc.name :
985 * @tc.type : PERFs
986 * @tc.level : Level 1
987 */
988 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillIsoRequest006, TestSize.Level1)
989 {
990 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_ISO_REQUEST_006_TEST, -1};
991 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
992 }
993
994 /**
995 * @tc.number : CheckRawSdkIfFreeRequest006
996 * @tc.name :
997 * @tc.type : PERFs
998 * @tc.level : Level 1
999 */
1000 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest006, TestSize.Level1)
1001 {
1002 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_006_TEST, -1};
1003 EXPECT_EQ(HDF_FAILURE, HdfTestSendMsgToService(&msg));
1004 }
1005 /**
1006 * @tc.number : CheckRawSdkIfFreeRequest001
1007 * @tc.name :
1008 * @tc.type : PERFs
1009 * @tc.level : Level 1
1010 */
1011 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest001, TestSize.Level1)
1012 {
1013 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_001_TEST, -1};
1014 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1015 }
1016
1017 /**
1018 * @tc.number : CheckRawSdkIfFreeRequest002
1019 * @tc.name :
1020 * @tc.type : PERFs
1021 * @tc.level : Level 1
1022 */
1023 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest002, TestSize.Level1)
1024 {
1025 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_002_TEST, -1};
1026 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1027 }
1028
1029 /**
1030 * @tc.number : CheckRawSdkIfFreeRequest003
1031 * @tc.name :
1032 * @tc.type : PERFs
1033 * @tc.level : Level 1
1034 */
1035 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest003, TestSize.Level1)
1036 {
1037 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_003_TEST, -1};
1038 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1039 }
1040
1041 /**
1042 * @tc.number : CheckRawSdkIfFreeRequest004
1043 * @tc.name :
1044 * @tc.type : PERFs
1045 * @tc.level : Level 1
1046 */
1047 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest004, TestSize.Level1)
1048 {
1049 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_004_TEST, -1};
1050 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1051 }
1052
1053 /**
1054 * @tc.number : CheckRawSdkIfFreeRequest005
1055 * @tc.name :
1056 * @tc.type : PERFs
1057 * @tc.level : Level 1
1058 */
1059 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest005, TestSize.Level1)
1060 {
1061 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_005_TEST, -1};
1062 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1063 }
1064
1065 /**
1066 * @tc.number : CheckRawSdkIfAllocRequest009
1067 * @tc.name :
1068 * @tc.type : PERFs
1069 * @tc.level : Level 1
1070 */
1071 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfAllocRequest009, TestSize.Level1)
1072 {
1073 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_009_TEST, -1};
1074 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1075 }
1076
1077 /**
1078 * @tc.number : CheckRawSdkIfGetDescriptor001
1079 * @tc.name :
1080 * @tc.type : PERF
1081 * @tc.level : Level 1
1082 */
1083 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor001, TestSize.Level1)
1084 {
1085 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_001_TEST, -1};
1086 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1087 }
1088
1089 /**
1090 * @tc.number : CheckRawSdkIfGetDescriptor002
1091 * @tc.name :
1092 * @tc.type : PERF
1093 * @tc.level : Level 1
1094 */
1095 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor002, TestSize.Level1)
1096 {
1097 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_002_TEST, -1};
1098 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1099 }
1100
1101 /**
1102 * @tc.number : CheckRawSdkIfGetDescriptor003
1103 * @tc.name :
1104 * @tc.type : PERF
1105 * @tc.level : Level 1
1106 */
1107 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor003, TestSize.Level1)
1108 {
1109 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_003_TEST, -1};
1110 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1111 }
1112
1113 /**
1114 * @tc.number : CheckRawSdkIfGetDescriptor004
1115 * @tc.name :
1116 * @tc.type : PERF
1117 * @tc.level : Level 1
1118 */
1119 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor004, TestSize.Level1)
1120 {
1121 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_004_TEST, -1};
1122 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1123 }
1124
1125 /**
1126 * @tc.number : CheckRawSdkIfGetDescriptor005
1127 * @tc.name :
1128 * @tc.type : PERF
1129 * @tc.level : Level 1
1130 */
1131 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor005, TestSize.Level1)
1132 {
1133 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_005_TEST, -1};
1134 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1135 }
1136
1137 /**
1138 * @tc.number : CheckRawSdkIfGetDescriptor007
1139 * @tc.name :
1140 * @tc.type : PERF
1141 * @tc.level : Level 1
1142 */
1143 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor007, TestSize.Level1)
1144 {
1145 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_007_TEST, -1};
1146 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1147 }
1148
1149 /**
1150 * @tc.number : CheckRawSdkIfGetDescriptor008
1151 * @tc.name :
1152 * @tc.type : PERF
1153 * @tc.level : Level 1
1154 */
1155 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor008, TestSize.Level1)
1156 {
1157 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_008_TEST, -1};
1158 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1159 }
1160
1161 /**
1162 * @tc.number : CheckRawSdkIfGetDescriptor009
1163 * @tc.name :
1164 * @tc.type : PERF
1165 * @tc.level : Level 1
1166 */
1167 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor009, TestSize.Level1)
1168 {
1169 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_009_TEST, -1};
1170 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1171 }
1172
1173 /**
1174 * @tc.number : CheckRawSdkIfGetDescriptor010
1175 * @tc.name :
1176 * @tc.type : PERF
1177 * @tc.level : Level 1
1178 */
1179 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor010, TestSize.Level1)
1180 {
1181 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_010_TEST, -1};
1182 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1183 }
1184
1185 /**
1186 * @tc.number : CheckRawSdkIfGetDescriptor011
1187 * @tc.name :
1188 * @tc.type : PERF
1189 * @tc.level : Level 1
1190 */
1191 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor011, TestSize.Level1)
1192 {
1193 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_011_TEST, -1};
1194 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1195 }
1196
1197 /**
1198 * @tc.number : CheckRawSdkIfGetDescriptor012
1199 * @tc.name :
1200 * @tc.type : PERF
1201 * @tc.level : Level 1
1202 */
1203 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor012, TestSize.Level1)
1204 {
1205 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_012_TEST, -1};
1206 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1207 }
1208
1209 /**
1210 * @tc.number : CheckRawSdkIfGetDescriptor013
1211 * @tc.name :
1212 * @tc.type : PERF
1213 * @tc.level : Level 1
1214 */
1215 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor013, TestSize.Level1)
1216 {
1217 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_013_TEST, -1};
1218 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1219 }
1220
1221 /**
1222 * @tc.number : CheckRawSdkIfGetDescriptor014
1223 * @tc.name :
1224 * @tc.type : PERF
1225 * @tc.level : Level 1
1226 */
1227 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor014, TestSize.Level1)
1228 {
1229 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_014_TEST, -1};
1230 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1231 }
1232
1233 /**
1234 * @tc.number : CheckRawSdkIfGetDescriptor015
1235 * @tc.name :
1236 * @tc.type : PERF
1237 * @tc.level : Level 1
1238 */
1239 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor015, TestSize.Level1)
1240 {
1241 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_015_TEST, -1};
1242 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1243 }
1244
1245 /**
1246 * @tc.number : CheckRawSdkIfGetDescriptor016
1247 * @tc.name :
1248 * @tc.type : PERF
1249 * @tc.level : Level 1
1250 */
1251 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfGetDescriptor016, TestSize.Level1)
1252 {
1253 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DESCRIPTION_016_TEST, -1};
1254 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1255 }
1256
1257 /**
1258 * @tc.number : CheckRawSdkIfFillBulkRequest001
1259 * @tc.name :
1260 * @tc.type : PERFs
1261 * @tc.level : Level 1
1262 */
1263 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillBulkRequest001, TestSize.Level1)
1264 {
1265 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_BULK_REQUEST_001_TEST, -1};
1266 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1267 }
1268
1269 /**
1270 * @tc.number : CheckRawSdkIfFillBulkRequest002
1271 * @tc.name :
1272 * @tc.type : PERFs
1273 * @tc.level : Level 1
1274 */
1275 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillBulkRequest002, TestSize.Level1)
1276 {
1277 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_BULK_REQUEST_002_TEST, -1};
1278 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1279 }
1280
1281 /**
1282 * @tc.number : CheckRawSdkIfFillInterruptRequest001
1283 * @tc.name :
1284 * @tc.type : PERFs
1285 * @tc.level : Level 1
1286 */
1287 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillInterruptRequest001, TestSize.Level1)
1288 {
1289 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_INT_REQUEST_001_TEST, -1};
1290 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1291 }
1292
1293 /**
1294 * @tc.number : CheckRawSdkIfFillInterruptRequest002
1295 * @tc.name :
1296 * @tc.type : PERFs
1297 * @tc.level : Level 1
1298 */
1299 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillInterruptRequest002, TestSize.Level1)
1300 {
1301 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_INT_REQUEST_002_TEST, -1};
1302 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1303 }
1304
1305 /**
1306 * @tc.number : CheckRawSdkIfFillInterruptRequest003
1307 * @tc.name :
1308 * @tc.type : PERFs
1309 * @tc.level : Level 1
1310 */
1311 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillInterruptRequest003, TestSize.Level1)
1312 {
1313 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_INT_REQUEST_003_TEST, -1};
1314 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1315 }
1316
1317 /**
1318 * @tc.number : CheckRawSdkIfFillInterruptRequest004
1319 * @tc.name :
1320 * @tc.type : PERFs
1321 * @tc.level : Level 1
1322 */
1323 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillInterruptRequest004, TestSize.Level1)
1324 {
1325 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_INT_REQUEST_004_TEST, -1};
1326 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1327 }
1328
1329 /**
1330 * @tc.number : CheckRawSdkIfFillControlRequest001
1331 * @tc.name :
1332 * @tc.type : PERFs
1333 * @tc.level : Level 1
1334 */
1335 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlRequest001, TestSize.Level1)
1336 {
1337 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_001_TEST, -1};
1338 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1339 }
1340
1341 /**
1342 * @tc.number : CheckRawSdkIfFillControlRequest002
1343 * @tc.name :
1344 * @tc.type : PERFs
1345 * @tc.level : Level 1
1346 */
1347 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlRequest002, TestSize.Level1)
1348 {
1349 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_002_TEST, -1};
1350 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1351 }
1352
1353 /**
1354 * @tc.number : CheckRawSdkIfFillControlRequest003
1355 * @tc.name :
1356 * @tc.type : PERFs
1357 * @tc.level : Level 1
1358 */
1359 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlRequest003, TestSize.Level1)
1360 {
1361 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_003_TEST, -1};
1362 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1363 }
1364
1365 /**
1366 * @tc.number : CheckRawSdkIfFillControlRequest004
1367 * @tc.name :
1368 * @tc.type : PERFs
1369 * @tc.level : Level 1
1370 */
1371 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlRequest004, TestSize.Level1)
1372 {
1373 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_004_TEST, -1};
1374 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1375 }
1376
1377 /**
1378 * @tc.number : CheckRawSdkIfFillControlRequest005
1379 * @tc.name :
1380 * @tc.type : PERFs
1381 * @tc.level : Level 1
1382 */
1383 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlRequest005, TestSize.Level1)
1384 {
1385 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_005_TEST, -1};
1386 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1387 }
1388
1389 /**
1390 * @tc.number : CheckRawSdkIfFillControlRequest006
1391 * @tc.name :
1392 * @tc.type : PERFs
1393 * @tc.level : Level 1
1394 */
1395 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlRequest006, TestSize.Level1)
1396 {
1397 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_006_TEST, -1};
1398 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1399 }
1400
1401 /**
1402 * @tc.number : CheckRawSdkIfFillControlRequest007
1403 * @tc.name :
1404 * @tc.type : PERFs
1405 * @tc.level : Level 1
1406 */
1407 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlRequest007, TestSize.Level1)
1408 {
1409 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_007_TEST, -1};
1410 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1411 }
1412
1413 /**
1414 * @tc.number : CheckRawSdkIfFillControlRequest008
1415 * @tc.name :
1416 * @tc.type : PERFs
1417 * @tc.level : Level 1
1418 */
1419 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlRequest008, TestSize.Level1)
1420 {
1421 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_008_TEST, -1};
1422 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1423 }
1424
1425 /**
1426 * @tc.number : CheckRawSdkIfFillControlSetup001
1427 * @tc.name :
1428 * @tc.type : PERFs
1429 * @tc.level : Level 1
1430 */
1431 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlSetup001, TestSize.Level1)
1432 {
1433 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_SETUP_001_TEST, -1};
1434 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1435 }
1436
1437 /**
1438 * @tc.number : CheckRawSdkIfFillControlSetup002
1439 * @tc.name :
1440 * @tc.type : PERFs
1441 * @tc.level : Level 1
1442 */
1443 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlSetup002, TestSize.Level1)
1444 {
1445 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_SETUP_002_TEST, -1};
1446 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1447 }
1448
1449 /**
1450 * @tc.number : CheckRawSdkIfFillControlSetup003
1451 * @tc.name :
1452 * @tc.type : PERFs
1453 * @tc.level : Level 1
1454 */
1455 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlSetup003, TestSize.Level1)
1456 {
1457 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_SETUP_003_TEST, -1};
1458 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1459 }
1460
1461 /**
1462 * @tc.number : CheckRawSdkIfFillControlSetup004
1463 * @tc.name :
1464 * @tc.type : PERFs
1465 * @tc.level : Level 1
1466 */
1467 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillControlSetup004, TestSize.Level1)
1468 {
1469 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_SETUP_004_TEST, -1};
1470 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1471 }
1472
1473 /**
1474 * @tc.number : CheckRawSdkIfSendControlRequest001
1475 * @tc.name :
1476 * @tc.type : PERFs
1477 * @tc.level : Level 1
1478 */
1479 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendControlRequest001, TestSize.Level1)
1480 {
1481 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_001_TEST, -1};
1482 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1483 }
1484
1485 /**
1486 * @tc.number : CheckRawSdkIfSendControlRequest002
1487 * @tc.name :
1488 * @tc.type : PERFs
1489 * @tc.level : Level 1
1490 */
1491 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendControlRequest002, TestSize.Level1)
1492 {
1493 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_002_TEST, -1};
1494 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1495 }
1496
1497 /**
1498 * @tc.number : CheckRawSdkIfSendControlRequest003
1499 * @tc.name :
1500 * @tc.type : PERFs
1501 * @tc.level : Level 1
1502 */
1503 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendControlRequest003, TestSize.Level1)
1504 {
1505 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_003_TEST, -1};
1506 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1507 }
1508
1509 /**
1510 * @tc.number : CheckRawSdkIfSendControlRequest005
1511 * @tc.name :
1512 * @tc.type : PERFs
1513 * @tc.level : Level 1
1514 */
1515 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendControlRequest005, TestSize.Level1)
1516 {
1517 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_005_TEST, -1};
1518 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1519 }
1520
1521 /**
1522 * @tc.number : CheckRawSdkIfSendControlRequest006
1523 * @tc.name :
1524 * @tc.type : PERFs
1525 * @tc.level : Level 1
1526 */
1527 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendControlRequest006, TestSize.Level1)
1528 {
1529 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_006_TEST, -1};
1530 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1531 }
1532
1533 /**
1534 * @tc.number : CheckRawSdkIfSendControlRequest007
1535 * @tc.name :
1536 * @tc.type : PERFs
1537 * @tc.level : Level 1
1538 */
1539 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendControlRequest007, TestSize.Level1)
1540 {
1541 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_007_TEST, -1};
1542 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1543 }
1544
1545 /**
1546 * @tc.number : CheckRawSdkIfSendBulkRequest003
1547 * @tc.name :
1548 * @tc.type : PERFs
1549 * @tc.level : Level 1
1550 */
1551 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendBulkRequest003, TestSize.Level1)
1552 {
1553 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_BULK_REQUEST_003_TEST, -1};
1554 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1555 }
1556
1557 /**
1558 * @tc.number : CheckRawSdkIfSendBulkRequest004
1559 * @tc.name :
1560 * @tc.type : PERFs
1561 * @tc.level : Level 1
1562 */
1563 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendBulkRequest004, TestSize.Level1)
1564 {
1565 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_BULK_REQUEST_004_TEST, -1};
1566 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1567 }
1568
1569 /**
1570 * @tc.number : CheckRawSdkIfSendBulkRequest005
1571 * @tc.name :
1572 * @tc.type : PERFs
1573 * @tc.level : Level 1
1574 */
1575 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendBulkRequest005, TestSize.Level1)
1576 {
1577 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_BULK_REQUEST_005_TEST, -1};
1578 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1579 }
1580
1581 /**
1582 * @tc.number : CheckRawSdkIfSendInterruptRequest002
1583 * @tc.name :
1584 * @tc.type : PERFs
1585 * @tc.level : Level 1
1586 */
1587 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendInterruptRequest002, TestSize.Level1)
1588 {
1589 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_INT_REQUEST_002_TEST, -1};
1590 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1591 }
1592
1593 /**
1594 * @tc.number : CheckRawSdkIfSendInterruptRequest003
1595 * @tc.name :
1596 * @tc.type : PERFs
1597 * @tc.level : Level 1
1598 */
1599 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendInterruptRequest003, TestSize.Level1)
1600 {
1601 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_INT_REQUEST_003_TEST, -1};
1602 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1603 }
1604
1605 /**
1606 * @tc.number : CheckRawSdkIfSendInterruptRequest004
1607 * @tc.name :
1608 * @tc.type : PERFs
1609 * @tc.level : Level 1
1610 */
1611 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSendInterruptRequest004, TestSize.Level1)
1612 {
1613 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_INT_REQUEST_004_TEST, -1};
1614 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1615 }
1616
1617 /**
1618 * @tc.number : CheckRawSdkIfFillBulkRequest003
1619 * @tc.name :
1620 * @tc.type : PERFs
1621 * @tc.level : Level 1
1622 */
1623 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillBulkRequest003, TestSize.Level1)
1624 {
1625 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_BULK_REQUEST_003_TEST, -1};
1626 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1627 }
1628
1629 /**
1630 * @tc.number : CheckRawSdkIfFillBulkRequest004
1631 * @tc.name :
1632 * @tc.type : PERFs
1633 * @tc.level : Level 1
1634 */
1635 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillBulkRequest004, TestSize.Level1)
1636 {
1637 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_BULK_REQUEST_004_TEST, -1};
1638 EXPECT_EQ(-1, HdfTestSendMsgToService(&msg));
1639 }
1640
1641 /**
1642 * @tc.number : CheckRawSdkIfFillInterruptRequest005
1643 * @tc.name :
1644 * @tc.type : PERFs
1645 * @tc.level : Level 1
1646 */
1647 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFillInterruptRequest005, TestSize.Level1)
1648 {
1649 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_INT_REQUEST_005_TEST, -1};
1650 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1651 }
1652
1653 /**
1654 * @tc.number : CheckRawSdkIfSubmitRequest001
1655 * @tc.name :
1656 * @tc.type : PERFs
1657 * @tc.level : Level 1
1658 */
1659 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSubmitRequest001, TestSize.Level1)
1660 {
1661 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SUBMIT_REQUEST_001_TEST, -1};
1662 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1663 }
1664
1665 /**
1666 * @tc.number : CheckRawSdkIfSubmitRequest002
1667 * @tc.name :
1668 * @tc.type : PERFs
1669 * @tc.level : Level 1
1670 */
1671 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSubmitRequest002, TestSize.Level1)
1672 {
1673 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SUBMIT_REQUEST_002_TEST, -1};
1674 EXPECT_EQ(-1, HdfTestSendMsgToService(&msg));
1675 }
1676
1677 /**
1678 * @tc.number : CheckRawSdkIfSubmitRequest003
1679 * @tc.name :
1680 * @tc.type : PERFs
1681 * @tc.level : Level 1
1682 */
1683 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSubmitRequest003, TestSize.Level1)
1684 {
1685 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SUBMIT_REQUEST_003_TEST, -1};
1686 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1687 }
1688
1689 /**
1690 * @tc.number : CheckRawSdkIfSubmitRequest004
1691 * @tc.name :
1692 * @tc.type : PERFs
1693 * @tc.level : Level 1
1694 */
1695 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfSubmitRequest004, TestSize.Level1)
1696 {
1697 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SUBMIT_REQUEST_004_TEST, -1};
1698 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1699 }
1700
1701 /**
1702 * @tc.number : CheckRawSdkIfCancelRequest001
1703 * @tc.name :
1704 * @tc.type : PERFs
1705 * @tc.level : Level 1
1706 */
1707 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfCancelRequest001, TestSize.Level1)
1708 {
1709 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CANCEL_REQUEST_001_TEST, -1};
1710 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1711 }
1712
1713 /**
1714 * @tc.number : CheckRawSdkIfCancelRequest002
1715 * @tc.name :
1716 * @tc.type : PERFs
1717 * @tc.level : Level 1
1718 */
1719 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfCancelRequest002, TestSize.Level1)
1720 {
1721 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CANCEL_REQUEST_002_TEST, -1};
1722 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1723 }
1724
1725 /**
1726 * @tc.number : CheckRawSdkIfCancelRequest003
1727 * @tc.name :
1728 * @tc.type : PERFs
1729 * @tc.level : Level 1
1730 */
1731 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfCancelRequest003, TestSize.Level1)
1732 {
1733 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CANCEL_REQUEST_003_TEST, -1};
1734 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1735 }
1736
1737 /**
1738 * @tc.number : CheckRawSdkIfCancelRequest004
1739 * @tc.name :
1740 * @tc.type : PERFs
1741 * @tc.level : Level 1
1742 */
1743 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfCancelRequest004, TestSize.Level1)
1744 {
1745 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CANCEL_REQUEST_004_TEST, -1};
1746 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1747 }
1748
1749 /**
1750 * @tc.number : UsbStopIo
1751 * @tc.name :
1752 * @tc.type : PERFs
1753 * @tc.level : Level 1
1754 */
1755 HWTEST_F(HdfUsbRawTest, UsbStopIo, TestSize.Level1)
1756 {
1757 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_STOP_IO, -1};
1758 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1759 }
1760
1761 /**
1762 * @tc.number : CheckRawSdkIfFreeRequest004
1763 * @tc.name :
1764 * @tc.type : PERFs
1765 * @tc.level : Level 1
1766 */
1767 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest004_close, TestSize.Level1)
1768 {
1769 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_004_TEST, -1};
1770 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1771 }
1772
1773 /**
1774 * @tc.number : CheckRawSdkIfFreeRequest003
1775 * @tc.name :
1776 * @tc.type : PERFs
1777 * @tc.level : Level 1
1778 */
1779 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest003_close, TestSize.Level1)
1780 {
1781 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_003_TEST, -1};
1782 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1783 }
1784
1785 /**
1786 * @tc.number : CheckRawSdkIfFreeRequest001
1787 * @tc.name :
1788 * @tc.type : PERFs
1789 * @tc.level : Level 1
1790 */
1791 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest001_close, TestSize.Level1)
1792 {
1793 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_001_TEST, -1};
1794 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1795 }
1796
1797 /**
1798 * @tc.number : CheckRawSdkIfFreeRequest002
1799 * @tc.name :
1800 * @tc.type : PERFs
1801 * @tc.level : Level 1
1802 */
1803 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfFreeRequest002_close, TestSize.Level1)
1804 {
1805 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_002_TEST, -1};
1806 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1807 }
1808
1809 /**
1810 * @tc.number : CheckRawSdkIfReleaseInterface004
1811 * @tc.name :
1812 * @tc.type : PERFs
1813 * @tc.level : Level 1
1814 */
1815 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfReleaseInterface004_close, TestSize.Level1)
1816 {
1817 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RELEASE_INTERFACE_004_TEST, -1};
1818 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1819 }
1820
1821 /**
1822 * @tc.number : CheckRawSdkIfReleaseInterface002
1823 * @tc.name :
1824 * @tc.type : PERFs
1825 * @tc.level : Level 1
1826 */
1827 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfReleaseInterface002_close, TestSize.Level1)
1828 {
1829 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RELEASE_INTERFACE_002_TEST, -1};
1830 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1831 }
1832
1833 /**
1834 * @tc.number : CheckRawSdkIfCloseDevice002
1835 * @tc.name :
1836 * @tc.type : PERF
1837 * @tc.level : Level 1
1838 */
1839 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfCloseDevice002_close, TestSize.Level1)
1840 {
1841 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLOSE_DEVICE_002_TEST, -1};
1842 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1843 }
1844
1845 /**
1846 * @tc.number : CheckRawSdkIfExit001
1847 * @tc.name :
1848 * @tc.type : PERF
1849 * @tc.level : Level 1
1850 */
1851 HWTEST_F(HdfUsbRawTest, CheckRawSdkIfExit001_close, TestSize.Level1)
1852 {
1853 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_EXIT_001_TEST, -1};
1854 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
1855 }
1856 }
1857