tests: Use enum rather than #defines for tests
[openafs.git] / tests / cmd / command-t.c
1 /*
2  * Copyright (c) 2010 Your File System Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR `AS IS'' AND ANY EXPRESS OR
14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 /*
26  * Test the command line parsing library
27  */
28
29 #include <afsconfig.h>
30 #include <afs/param.h>
31
32 #include <roken.h>
33
34 #include <afs/cmd.h>
35
36 #include <tap/basic.h>
37
38 enum cmdOptions {
39    copt_flag = 0,
40    copt_first,
41    copt_second,
42    copt_sugar,
43    copt_fourth,
44    copt_fifth,
45    copt_perhaps,
46    copt_sanity
47 };
48
49 static int
50 testproc(struct cmd_syndesc *as, void *rock)
51 {
52     is_string("foo", as->parms[copt_first].items->data,
53               "first option matches");
54     is_string("bar", as->parms[copt_second].items->data,
55               "second option matches");
56     ok(as->parms[copt_flag].items != NULL,
57        "flag is set");
58
59     return 0;
60 }
61
62 int
63 main(int argc, char **argv)
64 {
65     char *tv[100];
66     struct cmd_syndesc *opts;
67     struct cmd_syndesc *retopts;
68     int code;
69     int tc;
70     int retval;
71     char *retstring = NULL;
72
73     plan(85);
74
75     initialize_CMD_error_table();
76
77     opts = cmd_CreateSyntax(NULL, testproc, NULL, NULL);
78     cmd_AddParm(opts, "-flag", CMD_FLAG, CMD_OPTIONAL, "a flag");
79     cmd_AddParm(opts, "-first", CMD_SINGLE, CMD_REQUIRED, "first option");
80     cmd_AddParm(opts, "-second", CMD_LIST, CMD_OPTIONAL, "second option");
81
82     /* A simple command line */
83     code = cmd_ParseLine("-first foo -second bar -flag", tv, &tc, 100);
84     is_int(0, code, "cmd_ParseLine succeeds");
85     code = cmd_Dispatch(tc, tv);
86     is_int(0, code, "dispatching simple comamnd line succeeds");
87     code = cmd_Parse(tc, tv, &retopts);
88     is_int(0, code, "parsing simple command line succeeds");
89     is_string("foo", retopts->parms[copt_first].items->data,
90               " ... 1st option matches");
91     is_string("bar", retopts->parms[copt_second].items->data,
92               " ... 2nd option matches");
93     ok(retopts->parms[copt_flag].items != NULL, " ... 3rd option matches");
94     cmd_FreeOptions(&retopts);
95     cmd_FreeArgv(tv);
96
97     /* unknown switch */
98     code = cmd_ParseLine("-first foo -second bar -third -flag", tv, &tc, 100);
99     is_int(0, code, "cmd_ParseLine succeeds");
100     code = cmd_Dispatch(tc, tv);
101     is_int(CMD_UNKNOWNSWITCH, code, "invalid options fail as expected");
102     code = cmd_Parse(tc, tv, &retopts);
103     is_int(CMD_UNKNOWNSWITCH, code, "and still fail with cmd_Parse");
104     cmd_FreeArgv(tv);
105
106     /* missing parameter */
107     code = cmd_ParseLine("-first foo -second -flag", tv, &tc, 100);
108     is_int(0, code, "cmd_ParseLine succeeds");
109     code = cmd_Dispatch(tc, tv);
110     is_int(CMD_TOOFEW, code, "missing parameters fail as expected");
111     code = cmd_Parse(tc, tv, &retopts);
112     is_int(CMD_TOOFEW, code, "and still fail with cmd_Parse");
113     cmd_FreeArgv(tv);
114
115     /* missing option */
116     code = cmd_ParseLine("-second bar -third -flag", tv, &tc, 100);
117     is_int(0, code, "cmd_ParseLine succeeds");
118     code = cmd_Dispatch(tc, tv);
119     is_int(CMD_UNKNOWNSWITCH, code, "missing options fail as expected");
120     code = cmd_Parse(tc, tv, &retopts);
121     is_int(CMD_UNKNOWNSWITCH, code, "and still fail with cmd_Parse");
122     cmd_FreeArgv(tv);
123
124     code = cmd_ParseLine("-first foo baz -second bar -third -flag", tv, &tc, 100);
125     is_int(0, code, "cmd_ParseLine succeeds");
126     code = cmd_Dispatch(tc, tv);
127     is_int(CMD_NOTLIST, code, "too many parameters fails as expected");
128     code = cmd_Parse(tc, tv, &retopts);
129     is_int(CMD_NOTLIST, code, "and still fail with cmd_Parse");
130     cmd_FreeArgv(tv);
131
132     /* Positional parameters */
133     code = cmd_ParseLine("foo bar -flag", tv, &tc, 100);
134     is_int(0, code, "cmd_ParseLine succeeds");
135     code = cmd_Dispatch(tc, tv);
136     is_int(0, code, "dispatching positional parameters succeeds");
137     code = cmd_Parse(tc, tv, &retopts);
138     is_int(0, code, "and works with cmd_Parse");
139     cmd_FreeOptions(&retopts);
140     cmd_FreeArgv(tv);
141
142     /* Abbreviations */
143     code = cmd_ParseLine("-fi foo -s bar -flag", tv, &tc, 100);
144     is_int(0, code, "cmd_ParseLine succeeds");
145     code = cmd_Dispatch(tc, tv);
146     is_int(0, code, "dispatching abbreviations succeeds");
147     code = cmd_Parse(tc, tv, &retopts);
148     is_int(0, code, "and works with cmd_Parse");
149     cmd_FreeOptions(&retopts);
150
151     cmd_FreeArgv(tv);
152
153     /* Ambiguous */
154     code = cmd_ParseLine("-f foo -s bar -flag", tv, &tc, 100);
155     is_int(0, code, "cmd_ParseLine succeeds");
156     code = cmd_Dispatch(tc, tv);
157     is_int(CMD_UNKNOWNSWITCH, code, "ambiguous abbreviations correctly fail");
158     code = cmd_Parse(tc, tv, &retopts);
159     is_int(CMD_UNKNOWNSWITCH, code, "and fail with cmd_Parse too");
160     cmd_FreeArgv(tv);
161
162     /* Check that paramaters with abbreviation disabled don't make things
163      * ambiguous */
164     cmd_AddParmAtOffset(opts, copt_sugar, "-sugar", CMD_SINGLE,
165                         CMD_OPTIONAL | CMD_NOABBRV, "sugar with that");
166     code = cmd_ParseLine("-fi foo -s bar -flag", tv, &tc, 100);
167     is_int(0, code, "cmd_ParseLine succeeds");
168     code = cmd_Dispatch(tc, tv);
169     is_int(0, code, "disabling specific abbreviations succeeds");
170     code = cmd_Parse(tc, tv, &retopts);
171     is_int(0, code, "and works with cmd_Parse into the bargain");
172     cmd_FreeOptions(&retopts);
173     cmd_FreeArgv(tv);
174
175     /* Disable positional commands */
176     cmd_DisablePositionalCommands();
177     code = cmd_ParseLine("foo bar -flag", tv, &tc, 100);
178     is_int(0, code, "cmd_ParseLine succeeds");
179     code = cmd_Dispatch(tc, tv);
180     is_int(CMD_NOTLIST, code, "positional parameters can be disabled");
181     code = cmd_Parse(tc, tv, &retopts);
182     is_int(CMD_NOTLIST, code, "and fail with cmd_Parse too");
183     cmd_FreeArgv(tv);
184
185     /* Disable abbreviations */
186     cmd_DisableAbbreviations();
187     code = cmd_ParseLine("-fi foo -s bar -flag", tv, &tc, 100);
188     is_int(0, code, "cmd_ParseLine succeeds");
189     code = cmd_Dispatch(tc, tv);
190     is_int(CMD_UNKNOWNSWITCH, code, "dispatching abbreviations succeeds");
191     code = cmd_Parse(tc, tv, &retopts);
192     is_int(CMD_UNKNOWNSWITCH, code, "and fail with cmd_Parse too");
193
194     cmd_FreeArgv(tv);
195
196     /* Try the new cmd_Parse function with something different*/
197     code = cmd_ParseLine("-first one -second two -flag", tv, &tc, 100);
198     is_int(0, code, "cmd_ParseLine succeeds");
199     code = cmd_Parse(tc, tv, &retopts);
200     is_int(0, code, "Parsing with cmd_Parse works");
201     is_string("one", retopts->parms[copt_first].items->data,
202               " ... 1st option matches");
203     is_string("two", retopts->parms[copt_second].items->data,
204               " ... 2nd option matches");
205     ok(retopts->parms[copt_flag].items != NULL, " ... 3rd option matches");
206
207     cmd_FreeOptions(&retopts);
208     cmd_FreeArgv(tv);
209     /* Try adding a couple of parameters at specific positions */
210     cmd_AddParmAtOffset(opts, copt_fifth, "-fifth", CMD_SINGLE, CMD_OPTIONAL,
211                        "fifth option");
212     cmd_AddParmAtOffset(opts, copt_fourth, "-fourth", CMD_SINGLE, CMD_OPTIONAL,
213                        "fourth option" );
214     code = cmd_ParseLine("-first a -fourth b -fifth c", tv, &tc, 100);
215     is_int(0, code, "cmd_ParseLine succeeds");
216     code = cmd_Parse(tc, tv, &retopts);
217     is_int(0, code, "parsing our new options succeeds");
218     is_string("b", retopts->parms[copt_fourth].items->data,
219               " Fourth option in right place");
220     is_string("c", retopts->parms[copt_fifth].items->data,
221               " Fifth option in right place");
222     cmd_FreeOptions(&retopts);
223     cmd_FreeArgv(tv);
224
225     /* Check Accessors */
226     code = cmd_ParseLine("-first 1 -second second -flag", tv, &tc, 100);
227     is_int(0, code, "cmd_ParseLine succeeds");
228     code = cmd_Parse(tc, tv, &retopts);
229
230     code = cmd_OptionAsInt(retopts, copt_first, &retval);
231     is_int(0, code, "cmd_OptionsAsInt succeeds");
232     is_int(1, retval, " ... and returns correct value");
233
234     code = cmd_OptionAsString(retopts, copt_second, &retstring);
235     is_int(0, code, "cmd_OptionsAsString succeeds");
236     is_string("second", retstring, " ... and returns correct value");
237     free(retstring);
238     retstring = NULL;
239
240     code = cmd_OptionAsFlag(retopts, copt_flag, &retval);
241     is_int(0, code, "cmd_OptionsAsFlag succeeds");
242     ok(retval, " ... and flag is correct");
243
244     cmd_FreeOptions(&retopts);
245     cmd_FreeArgv(tv);
246
247     /* Add an alias */
248     code = cmd_AddParmAlias(opts, copt_second, "-twa");
249     is_int(0, code, "cmd_AddParmAlias succeeds");
250
251     code = cmd_ParseLine("-first 1 -twa tup", tv, &tc, 100);
252     is_int(0, code, "cmd_ParseLine succeeds");
253     code = cmd_Parse(tc, tv, &retopts);
254     is_int(0, code, "cmd_Parse succeeds for alias");
255     cmd_OptionAsString(retopts, copt_second, &retstring);
256     is_string("tup", retstring, " ... and we have the correct value");
257     free(retstring);
258     retstring = NULL;
259
260     cmd_FreeOptions(&retopts);
261     cmd_FreeArgv(tv);
262
263     /* Add something that can be a flag or a value, and put something after
264      * it so we can check for parse problems*/
265     cmd_AddParm(opts, "-perhaps", CMD_SINGLE_OR_FLAG, CMD_OPTIONAL,
266                 "what am I");
267     cmd_AddParm(opts, "-sanity", CMD_SINGLE, CMD_OPTIONAL, "sanity check");
268
269     /* Try using as an option */
270
271     code = cmd_ParseLine("-first 1 -perhaps 2 -sanity 3", tv, &tc, 100);
272     is_int(0, code, "cmd_ParseLine succeeds");
273     code = cmd_Parse(tc, tv, &retopts);
274     is_int(0, code, "cmd_Parse succeeds for option-as-flag as opt");
275     code = cmd_OptionAsInt(retopts, copt_perhaps, &retval);
276     is_int(0, code, "cmd_OptionAsInt succeeds");
277     is_int(2, retval, " ... and we have the correct value");
278     cmd_FreeOptions(&retopts);
279     cmd_FreeArgv(tv);
280
281     /* And now, as a flag */
282
283     code = cmd_ParseLine("-first 1 -perhaps -sanity 3", tv, &tc, 100);
284     is_int(0, code, "cmd_ParseLine succeeds");
285     code = cmd_Parse(tc, tv, &retopts);
286     is_int(0, code, "cmd_Parse succeeds for option-as-flag as flag");
287     code = cmd_OptionAsInt(retopts, copt_perhaps, &retval);
288     is_int(CMD_MISSING, code, " ... pulling out a value fails as expected");
289     cmd_OptionAsFlag(retopts, copt_perhaps, &retval);
290     ok(retval, " ... but parsing as a flag works");
291     cmd_FreeOptions(&retopts);
292     cmd_FreeArgv(tv);
293
294     /* Check that we can produce help output */
295     code = cmd_ParseLine("-help", tv, &tc, 100);
296     is_int(0, code, "cmd_ParseLine succeeds");
297     code = cmd_Parse(tc, tv, &retopts);
298     is_int(CMD_USAGE, code, "cmd_Parse returns usage error with help output");
299     ok(retopts == NULL, " ... and options is empty");
300
301     /* Check splitting with '=' */
302
303     code = cmd_ParseLine("-first 1 -perhaps=6 -sanity=3", tv, &tc, 100);
304     is_int(0, code, "cmd_ParseLine succeeds");
305     code = cmd_Parse(tc, tv, &retopts);
306     is_int(0, code, "cmd_Parse succeeds for items split with '='");
307     code = cmd_OptionAsInt(retopts, copt_perhaps, &retval);
308     is_int(0, code, "cmd_OptionAsInt succeeds");
309     is_int(6, retval, " ... and we have the correct value once");
310     code = cmd_OptionAsInt(retopts, copt_sanity, &retval);
311     is_int(0, code, "cmd_OptionAsInt succeeds");
312     is_int(3, retval, " ... and we have the correct value twice");
313     cmd_FreeOptions(&retopts);
314     cmd_FreeArgv(tv);
315
316     return 0;
317 }
318