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