cmd: Add accessor functions for options
[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 static int
39 testproc(struct cmd_syndesc *as, void *rock)
40 {
41     is_string("foo", as->parms[0].items->data,
42               "first option matches");
43     is_string("bar", as->parms[1].items->data,
44               "second option matches");
45     ok(as->parms[2].items != NULL,
46        "flag is set");
47
48     return 0;
49 }
50
51 int
52 main(int argc, char **argv)
53 {
54     char *tv[100];
55     struct cmd_syndesc *opts;
56     struct cmd_syndesc *retopts;
57     int code;
58     int tc;
59     int retval;
60     char *retstring;
61
62     plan(58);
63
64     initialize_CMD_error_table();
65
66     opts = cmd_CreateSyntax(NULL, testproc, NULL, NULL);
67     cmd_AddParm(opts, "-first", CMD_SINGLE, CMD_REQUIRED, "first option");
68     cmd_AddParm(opts, "-second", CMD_LIST, CMD_OPTIONAL, "second option");
69     cmd_AddParm(opts, "-flag", CMD_FLAG, CMD_OPTIONAL, "a flag");
70
71     /* A simple command line */
72     code = cmd_ParseLine("-first foo -second bar -flag", tv, &tc, 100);
73     is_int(0, code, "cmd_ParseLine succeeds");
74     code = cmd_Dispatch(tc, tv);
75     is_int(0, code, "dispatching simple comamnd line succeeds");
76     code = cmd_Parse(tc, tv, &retopts);
77     is_int(0, code, "parsing simple command line succeeds");
78     is_string("foo", retopts->parms[0].items->data, " ... 1st option matches");
79     is_string("bar", retopts->parms[1].items->data, " ... 2nd option matches");
80     ok(retopts->parms[2].items != NULL, " ... 3rd option matches");
81     cmd_FreeOptions(&retopts);
82     cmd_FreeArgv(tv);
83
84     /* unknown switch */
85     code = cmd_ParseLine("-first foo -second bar -third -flag", tv, &tc, 100);
86     is_int(0, code, "cmd_ParseLine succeeds");
87     code = cmd_Dispatch(tc, tv);
88     is_int(CMD_UNKNOWNSWITCH, code, "invalid options fail as expected");
89     code = cmd_Parse(tc, tv, &retopts);
90     is_int(CMD_UNKNOWNSWITCH, code, "and still fail with cmd_Parse");
91     cmd_FreeArgv(tv);
92
93     /* missing parameter */
94     code = cmd_ParseLine("-first foo -second -flag", tv, &tc, 100);
95     is_int(0, code, "cmd_ParseLine succeeds");
96     code = cmd_Dispatch(tc, tv);
97     is_int(CMD_TOOFEW, code, "missing parameters fail as expected");
98     code = cmd_Parse(tc, tv, &retopts);
99     is_int(CMD_TOOFEW, code, "and still fail with cmd_Parse");
100     cmd_FreeArgv(tv);
101
102     /* missing option */
103     code = cmd_ParseLine("-second bar -third -flag", tv, &tc, 100);
104     is_int(0, code, "cmd_ParseLine succeeds");
105     code = cmd_Dispatch(tc, tv);
106     is_int(CMD_UNKNOWNSWITCH, code, "missing options fail as expected");
107     code = cmd_Parse(tc, tv, &retopts);
108     is_int(CMD_UNKNOWNSWITCH, code, "and still fail with cmd_Parse");
109     cmd_FreeArgv(tv);
110
111     code = cmd_ParseLine("-first foo baz -second bar -third -flag", tv, &tc, 100);
112     is_int(0, code, "cmd_ParseLine succeeds");
113     code = cmd_Dispatch(tc, tv);
114     is_int(CMD_NOTLIST, code, "too many parameters fails as expected");
115     code = cmd_Parse(tc, tv, &retopts);
116     is_int(CMD_NOTLIST, code, "and still fail with cmd_Parse");
117     cmd_FreeArgv(tv);
118
119     /* Positional parameters */
120     code = cmd_ParseLine("foo bar -flag", tv, &tc, 100);
121     is_int(0, code, "cmd_ParseLine succeeds");
122     code = cmd_Dispatch(tc, tv);
123     is_int(0, code, "dispatching positional parameters succeeds");
124     code = cmd_Parse(tc, tv, &retopts);
125     is_int(0, code, "and works with cmd_Parse");
126     cmd_FreeOptions(&retopts);
127     cmd_FreeArgv(tv);
128
129     /* Abbreviations */
130     code = cmd_ParseLine("-fi foo -s bar -flag", tv, &tc, 100);
131     is_int(0, code, "cmd_ParseLine succeeds");
132     code = cmd_Dispatch(tc, tv);
133     is_int(0, code, "dispatching abbreviations succeeds");
134     code = cmd_Parse(tc, tv, &retopts);
135     is_int(0, code, "and works with cmd_Parse");
136     cmd_FreeOptions(&retopts);
137
138     cmd_FreeArgv(tv);
139
140     /* Ambiguous */
141     code = cmd_ParseLine("-f foo -s bar -flag", tv, &tc, 100);
142     is_int(0, code, "cmd_ParseLine succeeds");
143     code = cmd_Dispatch(tc, tv);
144     is_int(CMD_UNKNOWNSWITCH, code, "ambiguous abbreviations correctly fail");
145     code = cmd_Parse(tc, tv, &retopts);
146     is_int(CMD_UNKNOWNSWITCH, code, "and fail with cmd_Parse too");
147     cmd_FreeArgv(tv);
148
149     /* Disable positional commands */
150     cmd_DisablePositionalCommands();
151     code = cmd_ParseLine("foo bar -flag", tv, &tc, 100);
152     is_int(0, code, "cmd_ParseLine succeeds");
153     code = cmd_Dispatch(tc, tv);
154     is_int(CMD_NOTLIST, code, "positional parameters can be disabled");
155     code = cmd_Parse(tc, tv, &retopts);
156     is_int(CMD_NOTLIST, code, "and fail with cmd_Parse too");
157     cmd_FreeArgv(tv);
158
159     /* Disable abbreviations */
160     cmd_DisableAbbreviations();
161     code = cmd_ParseLine("-fi foo -s bar -flag", tv, &tc, 100);
162     is_int(0, code, "cmd_ParseLine succeeds");
163     code = cmd_Dispatch(tc, tv);
164     is_int(CMD_UNKNOWNSWITCH, code, "dispatching abbreviations succeeds");
165     code = cmd_Parse(tc, tv, &retopts);
166     is_int(CMD_UNKNOWNSWITCH, code, "and fail with cmd_Parse too");
167
168     cmd_FreeArgv(tv);
169
170     /* Try the new cmd_Parse function with something different*/
171     code = cmd_ParseLine("-first one -second two -flag", tv, &tc, 100);
172     is_int(0, code, "cmd_ParseLine succeeds");
173     code = cmd_Parse(tc, tv, &retopts);
174     is_int(0, code, "Parsing with cmd_Parse works");
175     is_string("one", retopts->parms[0].items->data, " ... 1st option matches");
176     is_string("two", retopts->parms[1].items->data, " ... 2nd option matches");
177     ok(retopts->parms[2].items != NULL, " ... 3rd option matches");
178
179     cmd_FreeOptions(&retopts);
180     cmd_FreeArgv(tv);
181     /* Try adding a couple of parameters at specific positions */
182     cmd_AddParmAtOffset(opts, "-fifth", CMD_SINGLE, CMD_OPTIONAL,
183                        "fifth option", 5);
184     cmd_AddParmAtOffset(opts, "-fourth", CMD_SINGLE, CMD_OPTIONAL,
185                        "fourth option", 4);
186     code = cmd_ParseLine("-first a -fourth b -fifth c", tv, &tc, 100);
187     is_int(0, code, "cmd_ParseLine succeeds");
188     code = cmd_Parse(tc, tv, &retopts);
189     is_int(0, code, "parsing our new options succeeds");
190     is_string("b", retopts->parms[4].items->data, " Fourth option in right place");
191     is_string("c", retopts->parms[5].items->data, " Fifth option in right place");
192     cmd_FreeOptions(&retopts);
193     cmd_FreeArgv(tv);
194
195     /* Check Accessors */
196     code = cmd_ParseLine("-first 1 -second second -flag", tv, &tc, 100);
197     is_int(0, code, "cmd_ParseLine succeeds");
198     code = cmd_Parse(tc, tv, &retopts);
199
200     code = cmd_OptionAsInt(retopts, 0, &retval);
201     is_int(0, code, "cmd_OptionsAsInt succeeds");
202     is_int(1, retval, " ... and returns correct value");
203
204     code = cmd_OptionAsString(retopts, 1, &retstring);
205     is_int(0, code, "cmd_OptionsAsString succeeds");
206     is_string("second", retstring, " ... and returns correct value");
207     free(retstring);
208     retstring = NULL;
209
210     code = cmd_OptionAsFlag(retopts, 2, &retval);
211     is_int(0, code, "cmd_OptionsAsFlag succeeds");
212     ok(retval, " ... and flag is correct");
213
214     cmd_FreeOptions(&retopts);
215     cmd_FreeArgv(tv);
216
217
218     return 0;
219 }
220