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 static int g_UsbFd;
22 static const string HDF_TEST_NAME = "/dev/hdf_test";
23
24 enum HdfLiteUsbRawTestCmd {
25 USB_RAW_SDK_IF_START_IO,
26 USB_RAW_SDK_IF_INIT_001_TEST,
27 USB_RAW_SDK_IF_EXIT_001_TEST,
28 USB_RAW_SDK_IF_INIT_002_TEST,
29 USB_RAW_SDK_IF_EXIT_002_TEST,
30 USB_RAW_SDK_IF_INIT_003_TEST,
31 USB_RAW_SDK_IF_INIT_004_TEST,
32 USB_RAW_SDK_IF_INIT_005_TEST,
33 USB_RAW_SDK_IF_OPEN_DEVICE_001_TEST,
34 USB_RAW_SDK_IF_OPEN_DEVICE_002_TEST,
35 USB_RAW_SDK_IF_OPEN_DEVICE_003_TEST,
36 USB_RAW_SDK_IF_OPEN_DEVICE_004_TEST,
37 USB_RAW_SDK_IF_OPEN_DEVICE_005_TEST,
38 USB_RAW_SDK_IF_OPEN_DEVICE_006_TEST,
39 USB_RAW_SDK_IF_RESET_DEVICE_001_TEST,
40 USB_RAW_SDK_IF_RESET_DEVICE_002_TEST,
41 USB_RAW_SDK_IF_CLOSE_DEVICE_001_TEST,
42 USB_RAW_SDK_IF_CLOSE_DEVICE_002_TEST,
43 USB_RAW_SDK_IF_OPEN_DEVICE_007_TEST,
44 USB_RAW_SDK_IF_GET_CONFIGURATION_001_TEST,
45 USB_RAW_SDK_IF_GET_CONFIGURATION_002_TEST,
46 USB_RAW_SDK_IF_GET_CONFIGURATION_003_TEST,
47 USB_RAW_SDK_IF_GET_CONFIGURATION_004_TEST,
48 USB_RAW_SDK_IF_GET_DEVICE_001_TEST,
49 USB_RAW_SDK_IF_GET_DEVICE_002_TEST,
50 USB_RAW_SDK_IF_GET_CONFIG_DESC_001_TEST,
51 USB_RAW_SDK_IF_GET_CONFIG_DESC_002_TEST,
52 USB_RAW_SDK_IF_GET_CONFIG_DESC_003_TEST,
53 USB_RAW_SDK_IF_GET_CONFIG_DESC_004_TEST,
54 USB_RAW_SDK_IF_SET_CONFIGURATION_001_TEST,
55 USB_RAW_SDK_IF_SET_CONFIGURATION_002_TEST,
56 USB_RAW_SDK_IF_SET_CONFIGURATION_003_TEST,
57 USB_RAW_SDK_IF_SET_CONFIGURATION_004_TEST,
58 USB_RAW_SDK_IF_SET_CONFIGURATION_005_TEST,
59 USB_RAW_SDK_IF_SET_CONFIGURATION_006_TEST,
60 USB_RAW_SDK_IF_SET_CONFIGURATION_007_TEST,
61 USB_RAW_SDK_IF_SET_CONFIGURATION_008_TEST,
62 USB_RAW_SDK_IF_GET_DEVICE_DESC_001_TEST,
63 USB_RAW_SDK_IF_GET_DEVICE_DESC_002_TEST,
64 USB_RAW_SDK_IF_GET_DEVICE_DESC_003_TEST,
65 USB_RAW_SDK_IF_GET_DEVICE_DESC_004_TEST,
66 USB_RAW_SDK_IF_GET_CONFIG_DESC_005_TEST,
67 USB_RAW_SDK_IF_GET_DEVICE_DESC_005_TEST,
68 USB_RAW_SDK_IF_CLAMIN_INTERFACE_001_TEST,
69 USB_RAW_SDK_IF_CLAMIN_INTERFACE_002_TEST,
70 USB_RAW_SDK_IF_CLAMIN_INTERFACE_003_TEST,
71 USB_RAW_SDK_IF_CLAMIN_INTERFACE_004_TEST,
72 USB_RAW_SDK_IF_CLAMIN_INTERFACE_005_TEST,
73 USB_RAW_SDK_IF_RELEASE_INTERFACE_001_TEST,
74 USB_RAW_SDK_IF_RELEASE_INTERFACE_002_TEST,
75 USB_RAW_SDK_IF_RELEASE_INTERFACE_003_TEST,
76 USB_RAW_SDK_IF_RELEASE_INTERFACE_004_TEST,
77 USB_RAW_SDK_IF_CLAMIN_INTERFACE_006_TEST,
78 USB_RAW_SDK_IF_ALLOC_REQUEST_001_TEST,
79 USB_RAW_SDK_IF_ALLOC_REQUEST_002_TEST,
80 USB_RAW_SDK_IF_ALLOC_REQUEST_003_TEST,
81 USB_RAW_SDK_IF_ALLOC_REQUEST_004_TEST,
82 USB_RAW_SDK_IF_ALLOC_REQUEST_005_TEST,
83 USB_RAW_SDK_IF_ALLOC_REQUEST_006_TEST,
84 USB_RAW_SDK_IF_ALLOC_REQUEST_007_TEST,
85 USB_RAW_SDK_IF_ALLOC_REQUEST_008_TEST,
86 USB_RAW_SDK_IF_ALLOC_REQUEST_010_TEST,
87 USB_RAW_SDK_IF_ALLOC_REQUEST_011_TEST,
88 USB_RAW_SDK_IF_FREE_REQUEST_006_TEST,
89 USB_RAW_SDK_IF_FILL_ISO_REQUEST_001_TEST,
90 USB_RAW_SDK_IF_FILL_ISO_REQUEST_002_TEST,
91 USB_RAW_SDK_IF_FILL_ISO_REQUEST_003_TEST,
92 USB_RAW_SDK_IF_FILL_ISO_REQUEST_004_TEST,
93 USB_RAW_SDK_IF_FILL_ISO_REQUEST_005_TEST,
94 USB_RAW_SDK_IF_FILL_ISO_REQUEST_006_TEST,
95 USB_RAW_SDK_IF_FREE_REQUEST_001_TEST,
96 USB_RAW_SDK_IF_FREE_REQUEST_002_TEST,
97 USB_RAW_SDK_IF_FREE_REQUEST_003_TEST,
98 USB_RAW_SDK_IF_FREE_REQUEST_004_TEST,
99 USB_RAW_SDK_IF_FREE_REQUEST_005_TEST,
100 USB_RAW_SDK_IF_ALLOC_REQUEST_009_TEST,
101 USB_RAW_SDK_IF_GET_DESCRIPTION_001_TEST,
102 USB_RAW_SDK_IF_GET_DESCRIPTION_002_TEST,
103 USB_RAW_SDK_IF_GET_DESCRIPTION_003_TEST,
104 USB_RAW_SDK_IF_GET_DESCRIPTION_004_TEST,
105 USB_RAW_SDK_IF_GET_DESCRIPTION_005_TEST,
106 USB_RAW_SDK_IF_GET_DESCRIPTION_006_TEST,
107 USB_RAW_SDK_IF_GET_DESCRIPTION_007_TEST,
108 USB_RAW_SDK_IF_GET_DESCRIPTION_008_TEST,
109 USB_RAW_SDK_IF_GET_DESCRIPTION_009_TEST,
110 USB_RAW_SDK_IF_GET_DESCRIPTION_010_TEST,
111 USB_RAW_SDK_IF_GET_DESCRIPTION_011_TEST,
112 USB_RAW_SDK_IF_GET_DESCRIPTION_012_TEST,
113 USB_RAW_SDK_IF_GET_DESCRIPTION_013_TEST,
114 USB_RAW_SDK_IF_GET_DESCRIPTION_014_TEST,
115 USB_RAW_SDK_IF_GET_DESCRIPTION_015_TEST,
116 USB_RAW_SDK_IF_GET_DESCRIPTION_016_TEST,
117 USB_RAW_SDK_IF_FILL_BULK_REQUEST_001_TEST,
118 USB_RAW_SDK_IF_FILL_BULK_REQUEST_002_TEST,
119 USB_RAW_SDK_IF_FILL_INT_REQUEST_001_TEST,
120 USB_RAW_SDK_IF_FILL_INT_REQUEST_002_TEST,
121 USB_RAW_SDK_IF_FILL_INT_REQUEST_003_TEST,
122 USB_RAW_SDK_IF_FILL_INT_REQUEST_004_TEST,
123 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_001_TEST,
124 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_002_TEST,
125 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_003_TEST,
126 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_004_TEST,
127 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_005_TEST,
128 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_006_TEST,
129 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_007_TEST,
130 USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_008_TEST,
131 USB_RAW_SDK_IF_FILL_CONTROL_SETUP_001_TEST,
132 USB_RAW_SDK_IF_FILL_CONTROL_SETUP_002_TEST,
133 USB_RAW_SDK_IF_FILL_CONTROL_SETUP_003_TEST,
134 USB_RAW_SDK_IF_FILL_CONTROL_SETUP_004_TEST,
135 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_001_TEST,
136 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_002_TEST,
137 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_003_TEST,
138 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_004_TEST,
139 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_005_TEST,
140 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_006_TEST,
141 USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_007_TEST,
142 USB_RAW_SDK_IF_SEND_BULK_REQUEST_001_TEST,
143 USB_RAW_SDK_IF_SEND_BULK_REQUEST_002_TEST,
144 USB_RAW_SDK_IF_SEND_BULK_REQUEST_003_TEST,
145 USB_RAW_SDK_IF_SEND_BULK_REQUEST_004_TEST,
146 USB_RAW_SDK_IF_SEND_BULK_REQUEST_005_TEST,
147 USB_RAW_SDK_IF_SEND_INT_REQUEST_001_TEST,
148 USB_RAW_SDK_IF_SEND_INT_REQUEST_002_TEST,
149 USB_RAW_SDK_IF_SEND_INT_REQUEST_003_TEST,
150 USB_RAW_SDK_IF_SEND_INT_REQUEST_004_TEST,
151 USB_RAW_SDK_IF_FILL_BULK_REQUEST_003_TEST,
152 USB_RAW_SDK_IF_FILL_BULK_REQUEST_004_TEST,
153 USB_RAW_SDK_IF_FILL_INT_REQUEST_005_TEST,
154 USB_RAW_SDK_IF_SUBMIT_REQUEST_001_TEST,
155 USB_RAW_SDK_IF_SUBMIT_REQUEST_002_TEST,
156 USB_RAW_SDK_IF_SUBMIT_REQUEST_003_TEST,
157 USB_RAW_SDK_IF_SUBMIT_REQUEST_004_TEST,
158 USB_RAW_SDK_IF_CANCEL_REQUEST_001_TEST,
159 USB_RAW_SDK_IF_CANCEL_REQUEST_002_TEST,
160 USB_RAW_SDK_IF_CANCEL_REQUEST_003_TEST,
161 USB_RAW_SDK_IF_CANCEL_REQUEST_004_TEST,
162 USB_RAW_SDK_IF_STOP_IO,
163
164
165 };
166
167 class HdfLiteUsbRawTest : public testing::Test {
168 public:
169 static void SetUpTestCase();
170 static void TearDownTestCase();
171 void SetUp();
172 void TearDown();
173 };
174
SetUpTestCase()175 void HdfLiteUsbRawTest::SetUpTestCase()
176 {
177 printf("raoyiming+test====SetUpTestCase====\n");
178
179 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_START_IO, -1};
180 HdfTestOpenService();
181 HdfTestSendMsgToService(&msg);
182 }
183
TearDownTestCase()184 void HdfLiteUsbRawTest::TearDownTestCase()
185 {
186 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_STOP_IO, -1};
187 HdfTestSendMsgToService(&msg);
188 HdfTestCloseService();
189 printf("raoyiming+test====TearDownTestCase====\n");
190 }
191
SetUp()192 void HdfLiteUsbRawTest::SetUp()
193 {
194
195 }
196
TearDown()197 void HdfLiteUsbRawTest::TearDown()
198 {
199
200 }
201
202 /**
203 * @tc.number : CheckRawSdkIfInit001
204 * @tc.name :
205 * @tc.type : PERF
206 * @tc.level : Level 1
207 */
208 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfInit001, TestSize.Level1)
209 {
210 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_INIT_001_TEST, -1};
211 printf("%s+++%d\n", __func__, __LINE__);
212
213 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
214 }
215
216 /**
217 * @tc.number : CheckRawSdkIfOpenDevice001
218 * @tc.name :
219 * @tc.type : PERF
220 * @tc.level : Level 1
221 */
222 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfOpenDevice007, TestSize.Level1)
223 {
224 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_OPEN_DEVICE_007_TEST, -1};
225 printf("%s+++%d\n", __func__, __LINE__);
226
227 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
228 }
229
230 /**
231 * @tc.number : CheckRawSdkIfGetConfiguration004
232 * @tc.name :
233 * @tc.type : PERF
234 * @tc.level : Level 1
235 */
236 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfGetConfiguration004, TestSize.Level1)
237 {
238 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIGURATION_004_TEST, -1};
239 printf("%s+++%d\n", __func__, __LINE__);
240
241 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
242 }
243
244 /**
245 * @tc.number : CheckRawSdkIfGetDevice002
246 * @tc.name :
247 * @tc.type : PERF
248 * @tc.level : Level 1
249 */
250 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfGetDevice002, TestSize.Level1)
251 {
252 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_DEVICE_002_TEST, -1};
253 printf("%s+++%d\n", __func__, __LINE__);
254
255 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
256 }
257
258 /**
259 * @tc.number : CheckRawSdkIfGetConfigDescriptor004
260 * @tc.name :
261 * @tc.type : PERF
262 * @tc.level : Level 1
263 */
264 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfGetConfigDescriptor004, TestSize.Level1)
265 {
266 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_GET_CONFIG_DESC_004_TEST, -1};
267 printf("%s+++%d\n", __func__, __LINE__);
268
269 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
270 }
271
272 /**
273 * @tc.number : CheckRawSdkIfSetConfiguration008
274 * @tc.name :
275 * @tc.type : PERF
276 * @tc.level : Level 1
277 */
278 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfSetConfiguration008, TestSize.Level1)
279 {
280 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SET_CONFIGURATION_008_TEST, -1};
281 printf("%s+++%d\n", __func__, __LINE__);
282
283 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
284 }
285
286 /**
287 * @tc.number : CheckRawSdkIfClaimInterface006
288 * @tc.name :
289 * @tc.type : PERFs
290 * @tc.level : Level 1
291 */
292 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfClaimInterface006, TestSize.Level1)
293 {
294 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLAMIN_INTERFACE_006_TEST, -1};
295 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
296 }
297
298 /**
299 * @tc.number : CheckRawSdkIfAllocRequest009
300 * @tc.name :
301 * @tc.type : PERFs
302 * @tc.level : Level 1
303 */
304 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfAllocRequest009, TestSize.Level1)
305 {
306 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_ALLOC_REQUEST_009_TEST, -1};
307 printf("%s+++%d\n", __func__, __LINE__);
308
309 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
310 }
311
312 /**
313 * @tc.number : CheckRawSdkIfFillBulkRequest001
314 * @tc.name :
315 * @tc.type : PERFs
316 * @tc.level : Level 1
317 */
318 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfFillBulkRequest001, TestSize.Level1)
319 {
320 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_BULK_REQUEST_001_TEST, -1};
321 printf("%s+++%d\n", __func__, __LINE__);
322
323 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
324 }
325
326 /**
327 * @tc.number : CheckRawSdkIfFillBulkRequest002
328 * @tc.name :
329 * @tc.type : PERFs
330 * @tc.level : Level 1
331 */
332 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfFillBulkRequest002, TestSize.Level1)
333 {
334 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_BULK_REQUEST_002_TEST, -1};
335 printf("%s+++%d\n", __func__, __LINE__);
336
337 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
338 }
339
340 /**
341 * @tc.number : CheckRawSdkIfFillInterruptRequest001
342 * @tc.name :
343 * @tc.type : PERFs
344 * @tc.level : Level 1
345 */
346 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfFillInterruptRequest001, TestSize.Level1)
347 {
348 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_INT_REQUEST_001_TEST, -1};
349 printf("%s+++%d\n", __func__, __LINE__);
350
351 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
352 }
353
354 /**
355 * @tc.number : CheckRawSdkIfFillControlRequest001
356 * @tc.name :
357 * @tc.type : PERFs
358 * @tc.level : Level 1
359 */
360 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfFillControlRequest001, TestSize.Level1)
361 {
362 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_001_TEST, -1};
363 printf("%s+++%d\n", __func__, __LINE__);
364
365 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
366 }
367
368 /**
369 * @tc.number : CheckRawSdkIfFillControlSetup004
370 * @tc.name :
371 * @tc.type : PERFs
372 * @tc.level : Level 1
373 */
374 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfFillControlSetup004, TestSize.Level1)
375 {
376 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FILL_CONTROL_SETUP_004_TEST, -1};
377 printf("%s+++%d\n", __func__, __LINE__);
378 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
379 }
380
381 /**
382 * @tc.number : CheckRawSdkIfSendControlRequest004
383 * @tc.name :
384 * @tc.type : PERFs
385 * @tc.level : Level 1
386 */
387 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfSendControlRequest004, TestSize.Level1)
388 {
389 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_004_TEST, -1};
390 printf("%s+++%d\n", __func__, __LINE__);
391 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
392 }
393
394 /**
395 * @tc.number : CheckRawSdkIfSendBulkRequest001
396 * @tc.name :
397 * @tc.type : PERFs
398 * @tc.level : Level 1
399 */
400 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfSendBulkRequest001, TestSize.Level1)
401 {
402 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_BULK_REQUEST_001_TEST, -1};
403 printf("%s+++%d\n", __func__, __LINE__);
404 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
405 }
406
407 /**
408 * @tc.number : CheckRawSdkIfSendBulkRequest002
409 * @tc.name :
410 * @tc.type : PERFs
411 * @tc.level : Level 1
412 */
413 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfSendBulkRequest002, TestSize.Level1)
414 {
415 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_SEND_BULK_REQUEST_002_TEST, -1};
416 printf("%s+++%d\n", __func__, __LINE__);
417 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
418 }
419
420 /**
421 * @tc.number : CheckRawSdkIfFreeRequest001
422 * @tc.name :
423 * @tc.type : PERFs
424 * @tc.level : Level 1
425 */
426 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfFreeRequest001, TestSize.Level1)
427 {
428 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_001_TEST, -1};
429 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
430 }
431
432 /**
433 * @tc.number : CheckRawSdkIfFreeRequest002
434 * @tc.name :
435 * @tc.type : PERFs
436 * @tc.level : Level 1
437 */
438 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfFreeRequest002, TestSize.Level1)
439 {
440 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_002_TEST, -1};
441 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
442 }
443
444 /**
445 * @tc.number : CheckRawSdkIfFreeRequest003
446 * @tc.name :
447 * @tc.type : PERFs
448 * @tc.level : Level 1
449 */
450 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfFreeRequest003, TestSize.Level1)
451 {
452 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_003_TEST, -1};
453 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
454 }
455
456 /**
457 * @tc.number : CheckRawSdkIfFreeRequest004
458 * @tc.name :
459 * @tc.type : PERFs
460 * @tc.level : Level 1
461 */
462 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfFreeRequest004, TestSize.Level1)
463 {
464 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_FREE_REQUEST_004_TEST, -1};
465 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
466 }
467
468 /**
469 * @tc.number : CheckRawSdkIfReleaseInterface002
470 * @tc.name :
471 * @tc.type : PERFs
472 * @tc.level : Level 1
473 */
474 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfReleaseInterface002, TestSize.Level1)
475 {
476 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RELEASE_INTERFACE_002_TEST, -1};
477 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
478 }
479
480 /**
481 * @tc.number : CheckRawSdkIfReleaseInterface004
482 * @tc.name :
483 * @tc.type : PERFs
484 * @tc.level : Level 1
485 */
486 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfReleaseInterface004, TestSize.Level1)
487 {
488 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_RELEASE_INTERFACE_004_TEST, -1};
489 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
490 }
491
492 /**
493 * @tc.number : CheckRawSdkIfCloseDevice002
494 * @tc.name :
495 * @tc.type : PERF
496 * @tc.level : Level 1
497 */
498 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfCloseDevice002, TestSize.Level1)
499 {
500 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_CLOSE_DEVICE_002_TEST, -1};
501 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
502 }
503
504 /**
505 * @tc.number : CheckRawSdkIfExit001
506 * @tc.name :
507 * @tc.type : PERF
508 * @tc.level : Level 1
509 */
510 HWTEST_F(HdfLiteUsbRawTest, CheckRawSdkIfExit001, TestSize.Level1)
511 {
512 struct HdfTestMsg msg = {TEST_USB_HOST_RAW_TYPE, USB_RAW_SDK_IF_EXIT_001_TEST, -1};
513 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
514 }
515
516