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