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 HdfLiteUsbTestCmd {
25 USB_WRITE_TEST = 0,
26 USB_HOSTSDK_INIT_001_TEST,
27 Usb_HOSTSDK_EXIT_001_TEST,
28 USB_HOSTSDK_INIT_002_TEST,
29 USB_HOSTSDK_EXIT_002_TEST,
30 USB_HOSTSDK_INIT_003_TEST,
31 USB_HOSTSDK_INIT_004_TEST,
32 USB_HOSTSDK_INIT_005_TEST,
33 USB_HOSTSDK_CLAIM_INTERFACE_001_TEST,
34 USB_HOSTSDK_RELEASE_INTERFACE_001_TEST,
35 USB_HOSTSDK_CLAIM_INTERFACE_002_TEST,
36 USB_HOSTSDK_RELEASE_INTERFACE_002_TEST,
37 USB_HOSTSDK_CLAIM_INTERFACE_003_TEST,
38 USB_HOSTSDK_RELEASE_INTERFACE_003_TEST,
39 USB_HOSTSDK_CLAIM_INTERFACE_004_TEST,
40 USB_HOSTSDK_CLAIM_INTERFACE_005_TEST,
41 USB_HOSTSDK_CLAIM_INTERFACE_006_TEST,
42 USB_HOSTSDK_OPEN_INTERFACE_001_TEST,
43 USB_HOSTSDK_CLOSE_INTERFACE_001_TEST,
44 USB_HOSTSDK_OPEN_INTERFACE_002_TEST,
45 USB_HOSTSDK_CLOSE_INTERFACE_002_TEST,
46 USB_HOSTSDK_OPEN_INTERFACE_003_TEST,
47 USB_HOSTSDK_CLOSE_INTERFACE_003_TEST,
48 USB_HOSTSDK_OPEN_INTERFACE_004_TEST,
49 USB_HOSTSDK_OPEN_INTERFACE_005_TEST,
50 USB_HOSTSDK_CLOSE_INTERFACE_005_TEST,
51 USB_HOSTSDK_OPEN_INTERFACE_006_TEST,
52 USB_HOSTSDK_SELECT_INTERFACE_001_TEST,
53 USB_HOSTSDK_SELECT_INTERFACE_002_TEST,
54 USB_HOSTSDK_SELECT_INTERFACE_003_TEST,
55 USB_HOSTSDK_SELECT_INTERFACE_004_TEST,
56 USB_HOSTSDK_SELECT_INTERFACE_005_TEST,
57 USB_HOSTSDK_SELECT_INTERFACE_006_TEST,
58 USB_HOSTSDK_CLAIM_INTERFACE_007_TEST,
59 USB_HOSTSDK_CLAIM_INTERFACE_008_TEST,
60 USB_HOSTSDK_GET_PIPE_001_TEST,
61 USB_HOSTSDK_GET_PIPE_002_TEST,
62 USB_HOSTSDK_GET_PIPE_003_TEST,
63 USB_HOSTSDK_GET_PIPE_004_TEST,
64 USB_HOSTSDK_GET_PIPE_005_TEST,
65 USB_HOSTSDK_GET_PIPE_006_TEST,
66 USB_HOSTSDK_GET_PIPE_007_TEST,
67 USB_HOSTSDK_GET_PIPE_008_TEST,
68 USB_HOSTSDK_ALLOC_REQUEST_001_TEST,
69 USB_HOSTSDK_ALLOC_REQUEST_002_TEST,
70 USB_HOSTSDK_FREE_REQUEST_001_TEST,
71 USB_HOSTSDK_ALLOC_REQUEST_003_TEST,
72 USB_HOSTSDK_ALLOC_REQUEST_004_TEST,
73 USB_HOSTSDK_FREE_REQUEST_002_TEST,
74 USB_HOSTSDK_ALLOC_REQUEST_005_TEST,
75 USB_HOSTSDK_ALLOC_REQUEST_006_TEST,
76 USB_HOSTSDK_FREE_REQUEST_003_TEST,
77 USB_HOSTSDK_ALLOC_REQUEST_007_TEST,
78 USB_HOSTSDK_ALLOC_REQUEST_008_TEST,
79
80 USB_HOSTSDK_ALLOC_REQUEST_010_TEST,
81 USB_HOSTSDK_ALLOC_REQUEST_011_TEST,
82 USB_HOSTSDK_FREE_REQUEST_006_TEST,
83 USB_HOSTSDK_FILL_ISO_REQUEST_001_TEST,
84 USB_HOSTSDK_FILL_ISO_REQUEST_002_TEST,
85 USB_HOSTSDK_FILL_ISO_REQUEST_003_TEST,
86 USB_HOSTSDK_FILL_ISO_REQUEST_004_TEST,
87 USB_HOSTSDK_FILL_ISO_REQUEST_005_TEST,
88 USB_HOSTSDK_FILL_ISO_REQUEST_006_TEST,
89
90 USB_HOSTSDK_FREE_REQUEST_004_TEST,
91 USB_HOSTSDK_ALLOC_REQUEST_009_TEST,
92 USB_HOSTSDK_FILL_REQUEST_001_TEST,
93 USB_HOSTSDK_FILL_REQUEST_002_TEST,
94 USB_HOSTSDK_FILL_REQUEST_003_TEST,
95 USB_HOSTSDK_FILL_REQUEST_004_TEST,
96 USB_HOSTSDK_SUBMIT_REQUEST_SYNC_001_TEST,
97 USB_HOSTSDK_SUBMIT_REQUEST_SYNC_002_TEST,
98 USB_HOSTSDK_SUBMIT_REQUEST_SYNC_003_TEST,
99 USB_HOSTSDK_SUBMIT_REQUEST_SYNC_004_TEST,
100 USB_HOSTSDK_FILL_REQUEST_005_TEST,
101 USB_HOSTSDK_FILL_REQUEST_006_TEST,
102 USB_HOSTSDK_FILL_REQUEST_007_TEST,
103 USB_HOSTSDK_FILL_REQUEST_008_TEST,
104 USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_001_TEST,
105 USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_001_TEST,
106 USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_002_TEST,
107 USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_002_TEST,
108 USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_003_TEST,
109 USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_003_TEST,
110 USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_004_TEST,
111 USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_004_TEST,
112 USB_HOSTSDK_CLEAR_INTERFACE_HALT_002_TEST,
113 USB_HOSTSDK_CLEAR_INTERFACE_HALT_003_TEST,
114 USB_HOSTSDK_CLEAR_INTERFACE_HALT_004_TEST,
115 USB_HOSTSDK_REMOVE_INTERFACE_001_TEST,
116 USB_HOSTSDK_ADD_INTERFACE_001_TEST,
117 USB_HOSTSDK_REMOVE_INTERFACE_002_TEST,
118 USB_HOSTSDK_ADD_INTERFACE_002_TEST,
119 USB_HOSTSDK_REMOVE_INTERFACE_003_TEST,
120 USB_HOSTSDK_ADD_INTERFACE_003_TEST,
121 USB_HOSTSDK_CLOSE_INTERFACE_006_TEST,
122 };
123
124 class HdfLiteUsbTest : public testing::Test {
125 public:
126 static void SetUpTestCase();
127 static void TearDownTestCase();
128 void SetUp();
129 void TearDown();
130 };
131
SetUpTestCase()132 void HdfLiteUsbTest::SetUpTestCase()
133 {
134 HdfTestOpenService();
135 }
136
TearDownTestCase()137 void HdfLiteUsbTest::TearDownTestCase()
138 {
139 HdfTestCloseService();
140 }
141
SetUp()142 void HdfLiteUsbTest::SetUp()
143 {
144 }
145
TearDown()146 void HdfLiteUsbTest::TearDown()
147 {
148 }
149 /**
150 * @tc.number : CheckHostSdkIfInit001
151 * @tc.name :
152 * @tc.type : PERF
153 * @tc.level : Level 1
154 */
155 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfInit001, TestSize.Level1)
156 {
157 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_INIT_001_TEST, -1};
158 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
159 }
160
161 /**
162 * @tc.number : CheckHostSdkIfClaimInterface006
163 * @tc.name :
164 * @tc.type : PERF
165 * @tc.level : Level 1
166 */
167 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfClaimInterface006, TestSize.Level1)
168 {
169 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_006_TEST, -1};
170 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
171 }
172
173 /**
174 * @tc.number : CheckHostSdkIfOpenInterface006
175 * @tc.name :
176 * @tc.type : PERF
177 * @tc.level : Level 1
178 */
179 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfOpenInterface006, TestSize.Level1)
180 {
181 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_OPEN_INTERFACE_006_TEST, -1};
182 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
183 }
184
185 /**
186 * @tc.number : CheckHostSdkIfSelectInterfaceSetting006
187 * @tc.name :
188 * @tc.type : PERF
189 * @tc.level : Level 1
190 */
191 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfSelectInterfaceSetting006, TestSize.Level1)
192 {
193 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SELECT_INTERFACE_006_TEST, -1};
194 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
195 }
196
197
198 /**
199 * @tc.number : CheckHostSdkIfClaimInterface007
200 * @tc.name :
201 * @tc.type : PERF
202 * @tc.level : Level 1
203 */
204 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfClaimInterface007, TestSize.Level1)
205 {
206 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_007_TEST, -1};
207 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
208 }
209
210 /**
211 * @tc.number : CheckHostSdkIfClaimInterface008
212 * @tc.name :
213 * @tc.type : PERF
214 * @tc.level : Level 1
215 */
216 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfClaimInterface008, TestSize.Level1)
217 {
218 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLAIM_INTERFACE_008_TEST, -1};
219 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
220 }
221
222 /**
223 * @tc.number : CheckHostSdkIfGetPipe002
224 * @tc.name :
225 * @tc.type : PERF
226 * @tc.level : Level 1
227 */
228 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfGetPipe002, TestSize.Level1)
229 {
230 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_002_TEST, -1};
231 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
232 }
233
234 /**
235 * @tc.number : CheckHostSdkIfGetPipe004
236 * @tc.name :
237 * @tc.type : PERF
238 * @tc.level : Level 1
239 */
240 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfGetPipe004, TestSize.Level1)
241 {
242 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_004_TEST, -1};
243 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
244 }
245
246 /**
247 * @tc.number : CheckHostSdkIfGetPipe006
248 * @tc.name :
249 * @tc.type : PERF
250 * @tc.level : Level 1
251 */
252 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfGetPipe006, TestSize.Level1)
253 {
254 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_006_TEST, -1};
255 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
256 }
257
258 /**
259 * @tc.number : CheckHostSdkIfGetPipe008
260 * @tc.name :
261 * @tc.type : PERF
262 * @tc.level : Level 1
263 */
264 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfGetPipe008, TestSize.Level1)
265 {
266 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_GET_PIPE_008_TEST, -1};
267 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
268 }
269
270 /**
271 * @tc.number : CheckHostSdkIfAllocRequest009
272 * @tc.name :
273 * @tc.type : PERF
274 * @tc.level : Level 1
275 */
276 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfAllocRequest009, TestSize.Level1)
277 {
278 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_ALLOC_REQUEST_009_TEST, -1};
279 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
280 }
281
282 /**
283 * @tc.number : CheckHostSdkIfFillRequest001
284 * @tc.name :
285 * @tc.type : PERF
286 * @tc.level : Level 1
287 */
288 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfFillRequest001, TestSize.Level1)
289 {
290 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_001_TEST, -1};
291 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
292 }
293
294 /**
295 * @tc.number : CheckHostSdkIfFillRequest002
296 * @tc.name :
297 * @tc.type : PERF
298 * @tc.level : Level 1
299 */
300 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfFillRequest002, TestSize.Level1)
301 {
302 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_002_TEST, -1};
303 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
304 }
305
306 /**
307 * @tc.number : CheckHostSdkIfFillRequest003
308 * @tc.name :
309 * @tc.type : PERF
310 * @tc.level : Level 1
311 */
312 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfFillRequest003, TestSize.Level1)
313 {
314 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_003_TEST, -1};
315 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
316 }
317
318 /**
319 * @tc.number : CheckHostSdkIfFillRequest004
320 * @tc.name :
321 * @tc.type : PERF
322 * @tc.level : Level 1
323 */
324 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfFillRequest004, TestSize.Level1)
325 {
326 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FILL_REQUEST_004_TEST, -1};
327 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
328 }
329
330 /**
331 * @tc.number : CheckHostSdkIfSubmitRequestSync003
332 * @tc.name :
333 * @tc.type : PERF
334 * @tc.level : Level 1
335 */
336 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfSubmitRequestSync003, TestSize.Level1)
337 {
338 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_REQUEST_SYNC_003_TEST, -1};
339 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
340 }
341
342 /**
343 * @tc.number : CheckHostSdkIfSubmitRequestSync002
344 * @tc.name :
345 * @tc.type : PERF
346 * @tc.level : Level 1
347 */
348 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfSubmitRequestSync002, TestSize.Level1)
349 {
350 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_REQUEST_SYNC_002_TEST, -1};
351 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
352 }
353
354 /**
355 * @tc.number : CheckHostSdkIfSubmitRequestSync001
356 * @tc.name :
357 * @tc.type : PERF
358 * @tc.level : Level 1
359 */
360 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfSubmitRequestSync001, TestSize.Level1)
361 {
362 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_REQUEST_SYNC_001_TEST, -1};
363 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
364 }
365
366 /**
367 * @tc.number : CheckHostSdkIfSubmitRequestSync004
368 * @tc.name :
369 * @tc.type : PERF
370 * @tc.level : Level 1
371 */
372 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfSubmitRequestSync004, TestSize.Level1)
373 {
374 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_SUBMIT_REQUEST_SYNC_004_TEST, -1};
375 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
376 }
377
378 /**
379 * @tc.number : CheckHostSdkIfFreeRequest001
380 * @tc.name :
381 * @tc.type : PERF
382 * @tc.level : Level 1
383 */
384 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfFreeRequest001, TestSize.Level1)
385 {
386 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FREE_REQUEST_001_TEST, -1};
387 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
388 }
389
390 /**
391 * @tc.number : CheckHostSdkIfFreeRequest002
392 * @tc.name :
393 * @tc.type : PERF
394 * @tc.level : Level 1
395 */
396 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfFreeRequest002, TestSize.Level1)
397 {
398 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FREE_REQUEST_002_TEST, -1};
399 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
400 }
401
402 /**
403 * @tc.number : CheckHostSdkIfFreeRequest003
404 * @tc.name :
405 * @tc.type : PERF
406 * @tc.level : Level 1
407 */
408 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfFreeRequest003, TestSize.Level1)
409 {
410 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FREE_REQUEST_003_TEST, -1};
411 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
412 }
413
414 /**
415 * @tc.number : CheckHostSdkIfFreeRequest004
416 * @tc.name :
417 * @tc.type : PERF
418 * @tc.level : Level 1
419 */
420 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfFreeRequest004, TestSize.Level1)
421 {
422 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_FREE_REQUEST_004_TEST, -1};
423 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
424 }
425
426 /**
427 * @tc.number : CheckHostSdkIfCloseInterface001
428 * @tc.name :
429 * @tc.type : PERF
430 * @tc.level : Level 1
431 */
432 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfCloseInterface001, TestSize.Level1)
433 {
434 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLOSE_INTERFACE_001_TEST, -1};
435 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
436 }
437
438 /**
439 * @tc.number : CheckHostSdkIfCloseInterface002
440 * @tc.name :
441 * @tc.type : PERF
442 * @tc.level : Level 1
443 */
444 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfCloseInterface002, TestSize.Level1)
445 {
446 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLOSE_INTERFACE_002_TEST, -1};
447 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
448 }
449
450 /**
451 * @tc.number : CheckHostSdkIfCloseInterface003
452 * @tc.name :
453 * @tc.type : PERF
454 * @tc.level : Level 1
455 */
456 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfCloseInterface003, TestSize.Level1)
457 {
458 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_CLOSE_INTERFACE_003_TEST, -1};
459 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
460 }
461
462 /**
463 * @tc.number : CheckHostSdkIfReleaseInterface001
464 * @tc.name :
465 * @tc.type : PERF
466 * @tc.level : Level 1
467 */
468 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfReleaseInterface001, TestSize.Level1)
469 {
470 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_RELEASE_INTERFACE_001_TEST, -1};
471 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
472 }
473
474 /**
475 * @tc.number : CheckHostSdkIfReleaseInterface002
476 * @tc.name :
477 * @tc.type : PERF
478 * @tc.level : Level 1
479 */
480 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfReleaseInterface002, TestSize.Level1)
481 {
482 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_RELEASE_INTERFACE_002_TEST, -1};
483 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
484 }
485
486 /**
487 * @tc.number : CheckHostSdkIfReleaseInterface003
488 * @tc.name :
489 * @tc.type : PERF
490 * @tc.level : Level 1
491 */
492 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfReleaseInterface003, TestSize.Level1)
493 {
494 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, USB_HOSTSDK_RELEASE_INTERFACE_003_TEST, -1};
495 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
496 }
497
498 /**
499 * @tc.number : CheckHostSdkIfExit001
500 * @tc.name :
501 * @tc.type : PERF
502 * @tc.level : Level 1
503 */
504 HWTEST_F(HdfLiteUsbTest, CheckHostSdkIfExit001, TestSize.Level1)
505 {
506 struct HdfTestMsg msg = {TEST_USB_HOST_TYPE, Usb_HOSTSDK_EXIT_001_TEST, -1};
507 EXPECT_EQ(0, HdfTestSendMsgToService(&msg));
508 }
509