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