test: move to app directory
[dpdk.git] / app / test / test_cmdline_portlist.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4
5 #include <stdio.h>
6 #include <string.h>
7 #include <inttypes.h>
8
9 #include <cmdline_parse.h>
10 #include <cmdline_parse_portlist.h>
11
12 #include "test_cmdline.h"
13
14 struct portlist_str {
15         const char * str;
16         uint32_t portmap;
17 };
18
19 /* valid strings */
20 const struct portlist_str portlist_valid_strs[] = {
21                 {"0", 0x1U },
22                 {"0-10", 0x7FFU},
23                 {"10-20", 0x1FFC00U},
24                 {"all", UINT32_MAX},
25                 {"0,1,2,3", 0xFU},
26                 {"0,1-5", 0x3FU},
27                 {"0,0,0", 0x1U},
28                 {"31,0-10,15", 0x800087FFU},
29                 {"0000", 0x1U},
30                 {"00,01,02,03", 0xFU},
31                 {"000,001,002,003", 0xFU},
32 };
33
34 /* valid strings but with garbage at the end.
35  * these strings should still be valid because parser checks
36  * for end of token, which is either a space/tab, a newline/return,
37  * or a hash sign.
38  */
39
40 const char * portlist_garbage_strs[] = {
41                 "0-31 garbage",
42                 "0-31#garbage",
43                 "0-31\0garbage",
44                 "0-31\ngarbage",
45                 "0-31\rgarbage",
46                 "0-31\tgarbage",
47                 "0,1,2,3-31 garbage",
48                 "0,1,2,3-31#garbage",
49                 "0,1,2,3-31\0garbage",
50                 "0,1,2,3-31\ngarbage",
51                 "0,1,2,3-31\rgarbage",
52                 "0,1,2,3-31\tgarbage",
53                 "all garbage",
54                 "all#garbage",
55                 "all\0garbage",
56                 "all\ngarbage",
57                 "all\rgarbage",
58                 "all\tgarbage",
59 };
60
61 /* invalid strings */
62 const char * portlist_invalid_strs[] = {
63                 /* valid syntax, invalid chars */
64                 "A-B",
65                 "0-S",
66                 "1,2,3,4,Q",
67                 "A-4,3-15",
68                 "0-31invalid",
69                 /* valid chars, invalid syntax */
70                 "1, 2",
71                 "1- 4",
72                 ",2",
73                 ",2 ",
74                 "-1, 4",
75                 "5-1",
76                 "2-",
77                 /* misc */
78                 "-"
79                 "a",
80                 "A",
81                 ",",
82                 "#",
83                 " ",
84                 "\0",
85                 "",
86                 /* too long */
87                 "0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,"
88                 "0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,2",
89 };
90
91 #define PORTLIST_VALID_STRS_SIZE \
92         (sizeof(portlist_valid_strs) / sizeof(portlist_valid_strs[0]))
93 #define PORTLIST_GARBAGE_STRS_SIZE \
94         (sizeof(portlist_garbage_strs) / sizeof(portlist_garbage_strs[0]))
95 #define PORTLIST_INVALID_STRS_SIZE \
96         (sizeof(portlist_invalid_strs) / sizeof(portlist_invalid_strs[0]))
97
98
99
100
101 /* test invalid parameters */
102 int
103 test_parse_portlist_invalid_param(void)
104 {
105         cmdline_portlist_t result;
106         char buf[CMDLINE_TEST_BUFSIZE];
107         int ret;
108
109         memset(&buf, 0, sizeof(buf));
110         memset(&result, 0, sizeof(cmdline_portlist_t));
111
112         /* try all null */
113         ret = cmdline_parse_portlist(NULL, NULL, NULL, 0);
114         if (ret != -1) {
115                 printf("Error: parser accepted null parameters!\n");
116                 return -1;
117         }
118
119         /* try null buf */
120         ret = cmdline_parse_portlist(NULL, NULL, (void*)&result,
121                 sizeof(result));
122         if (ret != -1) {
123                 printf("Error: parser accepted null string!\n");
124                 return -1;
125         }
126
127         /* try null result */
128         ret = cmdline_parse_portlist(NULL, portlist_valid_strs[0].str, NULL, 0);
129         if (ret == -1) {
130                 printf("Error: parser rejected null result!\n");
131                 return -1;
132         }
133
134         /* token is not used in ether_parse anyway so there's no point in
135          * testing it */
136
137         /* test help function */
138
139         /* coverage! */
140         ret = cmdline_get_help_portlist(NULL, buf, sizeof(buf));
141         if (ret < 0) {
142                 printf("Error: help function failed with valid parameters!\n");
143                 return -1;
144         }
145
146         return 0;
147 }
148
149 /* test valid parameters but invalid data */
150 int
151 test_parse_portlist_invalid_data(void)
152 {
153         int ret = 0;
154         unsigned i;
155         cmdline_portlist_t result;
156
157         /* test invalid strings */
158         for (i = 0; i < PORTLIST_INVALID_STRS_SIZE; i++) {
159
160                 memset(&result, 0, sizeof(cmdline_portlist_t));
161
162                 ret = cmdline_parse_portlist(NULL, portlist_invalid_strs[i],
163                         (void*)&result, sizeof(result));
164                 if (ret != -1) {
165                         printf("Error: parsing %s succeeded!\n",
166                                         portlist_invalid_strs[i]);
167                         return -1;
168                 }
169         }
170
171         return 0;
172 }
173
174 /* test valid parameters and data */
175 int
176 test_parse_portlist_valid(void)
177 {
178         int ret = 0;
179         unsigned i;
180         cmdline_portlist_t result;
181
182         /* test full strings */
183         for (i = 0; i < PORTLIST_VALID_STRS_SIZE; i++) {
184
185                 memset(&result, 0, sizeof(cmdline_portlist_t));
186
187                 ret = cmdline_parse_portlist(NULL, portlist_valid_strs[i].str,
188                         (void*)&result, sizeof(result));
189                 if (ret < 0) {
190                         printf("Error: parsing %s failed!\n",
191                                         portlist_valid_strs[i].str);
192                         return -1;
193                 }
194                 if (result.map != portlist_valid_strs[i].portmap) {
195                         printf("Error: parsing %s failed: map mismatch!\n",
196                                         portlist_valid_strs[i].str);
197                         return -1;
198                 }
199         }
200
201         /* test garbage strings */
202         for (i = 0; i < PORTLIST_GARBAGE_STRS_SIZE; i++) {
203
204                 memset(&result, 0, sizeof(cmdline_portlist_t));
205
206                 ret = cmdline_parse_portlist(NULL, portlist_garbage_strs[i],
207                         (void*)&result, sizeof(result));
208                 if (ret < 0) {
209                         printf("Error: parsing %s failed!\n",
210                                         portlist_garbage_strs[i]);
211                         return -1;
212                 }
213                 if (result.map != UINT32_MAX) {
214                         printf("Error: parsing %s failed: map mismatch!\n",
215                                         portlist_garbage_strs[i]);
216                         return -1;
217                 }
218         }
219
220         return 0;
221 }