tests: Add missing va_end in cmd/command-t
[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 <tests/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 static void
63 checkList(struct cmd_item *list, ...)
64 {
65     va_list ap;
66     char *el;
67
68     va_start(ap, list);
69     el = va_arg(ap, char *);
70     while (el != NULL && list != NULL) {
71        is_string(el, list->data, "list element matches");
72        list = list->next;
73        el = va_arg(ap, char *);
74     }
75     va_end(ap);
76
77     if (el == NULL && list == NULL) {
78         ok(1, "List has correct number of elements");
79     } else if (el == NULL) {
80         ok(0, "List has too many elements");
81     } else if (list == NULL) {
82         ok(0, "List has too few elements");
83     }
84 }
85
86 int
87 main(int argc, char **argv)
88 {
89     char *tv[100];
90     struct cmd_syndesc *opts;
91     struct cmd_syndesc *retopts;
92     struct cmd_item *list;
93     int code;
94     int tc;
95     int retval;
96     char *path;
97     char *retstring = NULL;
98
99     plan(109);
100
101     initialize_CMD_error_table();
102
103     opts = cmd_CreateSyntax(NULL, testproc, NULL, 0, NULL);
104     cmd_AddParm(opts, "-flag", CMD_FLAG, CMD_OPTIONAL, "a flag");
105     cmd_AddParm(opts, "-first", CMD_SINGLE, CMD_REQUIRED, "first option");
106     cmd_AddParm(opts, "-second", CMD_LIST, CMD_OPTIONAL, "second option");
107
108     /* A simple command line */
109     code = cmd_ParseLine("-first foo -second bar -flag", tv, &tc, 100);
110     is_int(0, code, "cmd_ParseLine succeeds");
111     code = cmd_Dispatch(tc, tv);
112     is_int(0, code, "dispatching simple comamnd line succeeds");
113     code = cmd_Parse(tc, tv, &retopts);
114     is_int(0, code, "parsing simple command line succeeds");
115     is_string("foo", retopts->parms[copt_first].items->data,
116               " ... 1st option matches");
117     is_string("bar", retopts->parms[copt_second].items->data,
118               " ... 2nd option matches");
119     ok(retopts->parms[copt_flag].items != NULL, " ... 3rd option matches");
120     cmd_FreeOptions(&retopts);
121     cmd_FreeArgv(tv);
122
123     /* unknown switch */
124     code = cmd_ParseLine("-first foo -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_UNKNOWNSWITCH, code, "invalid options fail as expected");
128     code = cmd_Parse(tc, tv, &retopts);
129     is_int(CMD_UNKNOWNSWITCH, code, "and still fail with cmd_Parse");
130     cmd_FreeArgv(tv);
131
132     /* missing parameter */
133     code = cmd_ParseLine("-first foo -second -flag", tv, &tc, 100);
134     is_int(0, code, "cmd_ParseLine succeeds");
135     code = cmd_Dispatch(tc, tv);
136     is_int(CMD_TOOFEW, code, "missing parameters fail as expected");
137     code = cmd_Parse(tc, tv, &retopts);
138     is_int(CMD_TOOFEW, code, "and still fail with cmd_Parse");
139     cmd_FreeArgv(tv);
140
141     /* missing option */
142     code = cmd_ParseLine("-second bar -third -flag", tv, &tc, 100);
143     is_int(0, code, "cmd_ParseLine succeeds");
144     code = cmd_Dispatch(tc, tv);
145     is_int(CMD_UNKNOWNSWITCH, code, "missing options fail as expected");
146     code = cmd_Parse(tc, tv, &retopts);
147     is_int(CMD_UNKNOWNSWITCH, code, "and still fail with cmd_Parse");
148     cmd_FreeArgv(tv);
149
150     code = cmd_ParseLine("-first foo baz -second bar -third -flag", tv, &tc, 100);
151     is_int(0, code, "cmd_ParseLine succeeds");
152     code = cmd_Dispatch(tc, tv);
153     is_int(CMD_NOTLIST, code, "too many parameters fails as expected");
154     code = cmd_Parse(tc, tv, &retopts);
155     is_int(CMD_NOTLIST, code, "and still fail with cmd_Parse");
156     cmd_FreeArgv(tv);
157
158     /* Positional parameters */
159     code = cmd_ParseLine("foo bar -flag", tv, &tc, 100);
160     is_int(0, code, "cmd_ParseLine succeeds");
161     code = cmd_Dispatch(tc, tv);
162     is_int(0, code, "dispatching positional parameters succeeds");
163     code = cmd_Parse(tc, tv, &retopts);
164     is_int(0, code, "and works with cmd_Parse");
165     cmd_FreeOptions(&retopts);
166     cmd_FreeArgv(tv);
167
168     /* Abbreviations */
169     code = cmd_ParseLine("-fi foo -s bar -flag", tv, &tc, 100);
170     is_int(0, code, "cmd_ParseLine succeeds");
171     code = cmd_Dispatch(tc, tv);
172     is_int(0, code, "dispatching abbreviations succeeds");
173     code = cmd_Parse(tc, tv, &retopts);
174     is_int(0, code, "and works with cmd_Parse");
175     cmd_FreeOptions(&retopts);
176
177     cmd_FreeArgv(tv);
178
179     /* Ambiguous */
180     code = cmd_ParseLine("-f foo -s bar -flag", tv, &tc, 100);
181     is_int(0, code, "cmd_ParseLine succeeds");
182     code = cmd_Dispatch(tc, tv);
183     is_int(CMD_UNKNOWNSWITCH, code, "ambiguous abbreviations correctly fail");
184     code = cmd_Parse(tc, tv, &retopts);
185     is_int(CMD_UNKNOWNSWITCH, code, "and fail with cmd_Parse too");
186     cmd_FreeArgv(tv);
187
188     /* Check that paramaters with abbreviation disabled don't make things
189      * ambiguous */
190     cmd_AddParmAtOffset(opts, copt_sugar, "-sugar", CMD_SINGLE,
191                         CMD_OPTIONAL | CMD_NOABBRV, "sugar with that");
192     code = cmd_ParseLine("-fi foo -s bar -flag", tv, &tc, 100);
193     is_int(0, code, "cmd_ParseLine succeeds");
194     code = cmd_Dispatch(tc, tv);
195     is_int(0, code, "disabling specific abbreviations succeeds");
196     code = cmd_Parse(tc, tv, &retopts);
197     is_int(0, code, "and works with cmd_Parse into the bargain");
198     cmd_FreeOptions(&retopts);
199     cmd_FreeArgv(tv);
200
201     /* Disable positional commands */
202     cmd_DisablePositionalCommands();
203     code = cmd_ParseLine("foo bar -flag", tv, &tc, 100);
204     is_int(0, code, "cmd_ParseLine succeeds");
205     code = cmd_Dispatch(tc, tv);
206     is_int(CMD_NOTLIST, code, "positional parameters can be disabled");
207     code = cmd_Parse(tc, tv, &retopts);
208     is_int(CMD_NOTLIST, code, "and fail with cmd_Parse too");
209     cmd_FreeArgv(tv);
210
211     /* Disable abbreviations */
212     cmd_DisableAbbreviations();
213     code = cmd_ParseLine("-fi foo -s bar -flag", tv, &tc, 100);
214     is_int(0, code, "cmd_ParseLine succeeds");
215     code = cmd_Dispatch(tc, tv);
216     is_int(CMD_UNKNOWNSWITCH, code, "dispatching abbreviations succeeds");
217     code = cmd_Parse(tc, tv, &retopts);
218     is_int(CMD_UNKNOWNSWITCH, code, "and fail with cmd_Parse too");
219
220     cmd_FreeArgv(tv);
221
222     /* Try the new cmd_Parse function with something different*/
223     code = cmd_ParseLine("-first one -second two -flag", tv, &tc, 100);
224     is_int(0, code, "cmd_ParseLine succeeds");
225     code = cmd_Parse(tc, tv, &retopts);
226     is_int(0, code, "Parsing with cmd_Parse works");
227     is_string("one", retopts->parms[copt_first].items->data,
228               " ... 1st option matches");
229     is_string("two", retopts->parms[copt_second].items->data,
230               " ... 2nd option matches");
231     ok(retopts->parms[copt_flag].items != NULL,
232               " ... 3rd option matches");
233
234     cmd_FreeOptions(&retopts);
235     cmd_FreeArgv(tv);
236     /* Try adding a couple of parameters at specific positions */
237     cmd_AddParmAtOffset(opts, copt_fifth, "-fifth", CMD_SINGLE, CMD_OPTIONAL,
238                        "fifth option");
239     cmd_AddParmAtOffset(opts, copt_fourth, "-fourth", CMD_SINGLE, CMD_OPTIONAL,
240                        "fourth option" );
241     code = cmd_ParseLine("-first a -fourth b -fifth c", tv, &tc, 100);
242     is_int(0, code, "cmd_ParseLine succeeds");
243     code = cmd_Parse(tc, tv, &retopts);
244     is_int(0, code, "parsing our new options succeeds");
245     is_string("b", retopts->parms[copt_fourth].items->data,
246               " Fourth option in right place");
247     is_string("c", retopts->parms[copt_fifth].items->data,
248               " Fifth option in right place");
249     cmd_FreeOptions(&retopts);
250     cmd_FreeArgv(tv);
251
252     /* Check Accessors */
253     code = cmd_ParseLine("-first 1 -second second -flag", tv, &tc, 100);
254     is_int(0, code, "cmd_ParseLine succeeds");
255     code = cmd_Parse(tc, tv, &retopts);
256
257     code = cmd_OptionAsInt(retopts, copt_first, &retval);
258     is_int(0, code, "cmd_OptionsAsInt succeeds");
259     is_int(1, retval, " ... and returns correct value");
260     ok(cmd_OptionPresent(retopts, copt_first),
261        " ... and is marked as present");
262
263     code = cmd_OptionAsString(retopts, copt_second, &retstring);
264     is_int(0, code, "cmd_OptionsAsString succeeds");
265     is_string("second", retstring, " ... and returns correct value");
266     free(retstring);
267     retstring = NULL;
268     ok(cmd_OptionPresent(retopts, copt_second),
269        " ... and is marked as present");
270
271     code = cmd_OptionAsFlag(retopts, copt_flag, &retval);
272     is_int(0, code, "cmd_OptionsAsFlag succeeds");
273     ok(retval, " ... and flag is correct");
274     ok(cmd_OptionPresent(retopts, copt_flag),
275        " ... and is marked as present");
276
277     ok(!cmd_OptionPresent(retopts, copt_sugar),
278        "Missing option is marked as such");
279
280     cmd_FreeOptions(&retopts);
281     cmd_FreeArgv(tv);
282
283     /* Add an alias */
284     code = cmd_AddParmAlias(opts, copt_second, "-twa");
285     is_int(0, code, "cmd_AddParmAlias succeeds");
286
287     code = cmd_ParseLine("-first 1 -twa tup", tv, &tc, 100);
288     is_int(0, code, "cmd_ParseLine succeeds");
289     code = cmd_Parse(tc, tv, &retopts);
290     is_int(0, code, "cmd_Parse succeeds for alias");
291     cmd_OptionAsString(retopts, copt_second, &retstring);
292     is_string("tup", retstring, " ... and we have the correct value");
293     free(retstring);
294     retstring = NULL;
295
296     cmd_FreeOptions(&retopts);
297     cmd_FreeArgv(tv);
298
299     /* Add something that can be a flag or a value, and put something after
300      * it so we can check for parse problems*/
301     cmd_AddParm(opts, "-perhaps", CMD_SINGLE_OR_FLAG, CMD_OPTIONAL,
302                 "what am I");
303     cmd_AddParm(opts, "-sanity", CMD_SINGLE, CMD_OPTIONAL, "sanity check");
304
305     /* Try using as an option */
306
307     code = cmd_ParseLine("-first 1 -perhaps 2 -sanity 3", tv, &tc, 100);
308     is_int(0, code, "cmd_ParseLine succeeds");
309     code = cmd_Parse(tc, tv, &retopts);
310     is_int(0, code, "cmd_Parse succeeds for option-as-flag as opt");
311     code = cmd_OptionAsInt(retopts, copt_perhaps, &retval);
312     is_int(0, code, "cmd_OptionAsInt succeeds");
313     is_int(2, retval, " ... and we have the correct value");
314     cmd_FreeOptions(&retopts);
315     cmd_FreeArgv(tv);
316
317     /* And now, as a flag */
318
319     code = cmd_ParseLine("-first 1 -perhaps -sanity 3", tv, &tc, 100);
320     is_int(0, code, "cmd_ParseLine succeeds");
321     code = cmd_Parse(tc, tv, &retopts);
322     is_int(0, code, "cmd_Parse succeeds for option-as-flag as flag");
323     code = cmd_OptionAsInt(retopts, copt_perhaps, &retval);
324     is_int(CMD_MISSING, code, " ... pulling out a value fails as expected");
325     cmd_OptionAsFlag(retopts, copt_perhaps, &retval);
326     ok(retval, " ... but parsing as a flag works");
327     cmd_FreeOptions(&retopts);
328     cmd_FreeArgv(tv);
329
330     /* Check that we can produce help output */
331     code = cmd_ParseLine("-help", tv, &tc, 100);
332     is_int(0, code, "cmd_ParseLine succeeds");
333     code = cmd_Parse(tc, tv, &retopts);
334     is_int(CMD_HELP, code, "cmd_Parse returns help indicator with help output");
335     ok(retopts == NULL, " ... and options is empty");
336
337     /* Check splitting with '=' */
338
339     code = cmd_ParseLine("-first 1 -perhaps=6 -sanity=3", tv, &tc, 100);
340     is_int(0, code, "cmd_ParseLine succeeds");
341     code = cmd_Parse(tc, tv, &retopts);
342     is_int(0, code, "cmd_Parse succeeds for items split with '='");
343     code = cmd_OptionAsInt(retopts, copt_perhaps, &retval);
344     is_int(0, code, "cmd_OptionAsInt succeeds");
345     is_int(6, retval, " ... and we have the correct value once");
346     code = cmd_OptionAsInt(retopts, copt_sanity, &retval);
347     is_int(0, code, "cmd_OptionAsInt succeeds");
348     is_int(3, retval, " ... and we have the correct value twice");
349     cmd_FreeOptions(&retopts);
350     cmd_FreeArgv(tv);
351
352     /* Check list behaviour */
353     code = cmd_ParseLine("-first 1 -second one two three", tv, &tc, 100);
354     is_int(0, code, "cmd_ParseLine succeeds");
355     code = cmd_Parse(tc, tv, &retopts);
356     is_int(0, code, "cmd_Parse succeeds for a list");
357     code = cmd_OptionAsList(retopts, copt_second, &list);
358     is_int(0, code, "cmd_OptionAsList succeeds");
359     checkList(list, "one", "two", "three", NULL);
360     cmd_FreeOptions(&retopts);
361     cmd_FreeArgv(tv);
362
363     /* Now, try adding a configuration file into the mix */
364     if (getenv("C_TAP_SOURCE") == NULL)
365         path = strdup("test1.conf");
366     else {
367         if (asprintf(&path, "%s/cmd/test1.conf", getenv("C_TAP_SOURCE")) < 0)
368             path = NULL;
369     }
370     if (path != NULL) {
371         cmd_SetCommandName("test");
372         code = cmd_OpenConfigFile(path);
373         is_int(0, code, "cmd_OpenConfigFile succeeds");
374     } else {
375         skip("no memory to build config file path");
376     }
377
378     code = cmd_ParseLine("-first 1", tv, &tc, 100);
379     is_int(0, code, "cmd_ParseLine succeeds");
380     code = cmd_Parse(tc, tv, &retopts);
381     is_int(0, code, "cmd_Parse succeeds when we have a config file");
382     code = cmd_OptionAsInt(retopts, copt_perhaps, &retval);
383     is_int(0, code, "cmd_OptionsAsInt succeeds");
384     is_int(10, retval, " ... and we have the correct value for perhaps");
385     code = cmd_OptionAsString(retopts, copt_sanity, &retstring);
386     is_int(0, code, "cmd_OptionAsString succeeds");
387     is_string("testing", retstring,
388               " ... and we have the correct value for sanity");
389
390     /* Check breaking up a list of options */
391     code = cmd_OptionAsList(retopts, copt_second, &list);
392     is_int(0, code, "cmd_OptionAsList succeeds");
393     checkList(list, "one", "two", "three", "four", NULL);
394
395     return 0;
396 }
397