X-Git-Url: http://git.openafs.org/?p=openafs.git;a=blobdiff_plain;f=tests%2Fcmd%2Fcommand-t.c;h=a4248c23dfcefad16485b6ab8553da107c8f4d96;hp=c599f49240224bd7bc82a9c2c422c61858d24a51;hb=9376f75beca80af69c5437de4023c32646e702b8;hpb=da68fb9d1ce7adb3a800c402462b0872c769a609

diff --git a/tests/cmd/command-t.c b/tests/cmd/command-t.c
index c599f49..a4248c2 100644
--- a/tests/cmd/command-t.c
+++ b/tests/cmd/command-t.c
@@ -35,14 +35,23 @@
 
 #include <tap/basic.h>
 
+#define FLAG_OFF    0
+#define FIRST_OFF   1
+#define SECOND_OFF  2
+#define SUGAR_OFF   3
+#define FOURTH_OFF  4
+#define FIFTH_OFF   5
+#define PERHAPS_OFF 6
+#define SANITY_OFF  7
+
 static int
 testproc(struct cmd_syndesc *as, void *rock)
 {
-    is_string("foo", as->parms[0].items->data,
+    is_string("foo", as->parms[FIRST_OFF].items->data,
 	      "first option matches");
-    is_string("bar", as->parms[1].items->data,
+    is_string("bar", as->parms[SECOND_OFF].items->data,
 	      "second option matches");
-    ok(as->parms[2].items != NULL,
+    ok(as->parms[FLAG_OFF].items != NULL,
        "flag is set");
 
     return 0;
@@ -57,16 +66,16 @@ main(int argc, char **argv)
     int code;
     int tc;
     int retval;
-    char *retstring;
+    char *retstring = NULL;
 
-    plan(58);
+    plan(85);
 
     initialize_CMD_error_table();
 
     opts = cmd_CreateSyntax(NULL, testproc, NULL, NULL);
+    cmd_AddParm(opts, "-flag", CMD_FLAG, CMD_OPTIONAL, "a flag");
     cmd_AddParm(opts, "-first", CMD_SINGLE, CMD_REQUIRED, "first option");
     cmd_AddParm(opts, "-second", CMD_LIST, CMD_OPTIONAL, "second option");
-    cmd_AddParm(opts, "-flag", CMD_FLAG, CMD_OPTIONAL, "a flag");
 
     /* A simple command line */
     code = cmd_ParseLine("-first foo -second bar -flag", tv, &tc, 100);
@@ -75,9 +84,9 @@ main(int argc, char **argv)
     is_int(0, code, "dispatching simple comamnd line succeeds");
     code = cmd_Parse(tc, tv, &retopts);
     is_int(0, code, "parsing simple command line succeeds");
-    is_string("foo", retopts->parms[0].items->data, " ... 1st option matches");
-    is_string("bar", retopts->parms[1].items->data, " ... 2nd option matches");
-    ok(retopts->parms[2].items != NULL, " ... 3rd option matches");
+    is_string("foo", retopts->parms[FIRST_OFF].items->data, " ... 1st option matches");
+    is_string("bar", retopts->parms[SECOND_OFF].items->data, " ... 2nd option matches");
+    ok(retopts->parms[FLAG_OFF].items != NULL, " ... 3rd option matches");
     cmd_FreeOptions(&retopts);
     cmd_FreeArgv(tv);
 
@@ -146,6 +155,19 @@ main(int argc, char **argv)
     is_int(CMD_UNKNOWNSWITCH, code, "and fail with cmd_Parse too");
     cmd_FreeArgv(tv);
 
+    /* Check that paramaters with abbreviation disabled don't make things
+     * ambiguous */
+    cmd_AddParmAtOffset(opts, SUGAR_OFF, "-sugar", CMD_SINGLE, CMD_OPTIONAL | CMD_NOABBRV,
+			"sugar with that");
+    code = cmd_ParseLine("-fi foo -s bar -flag", tv, &tc, 100);
+    is_int(0, code, "cmd_ParseLine succeeds");
+    code = cmd_Dispatch(tc, tv);
+    is_int(0, code, "disabling specific abbreviations succeeds");
+    code = cmd_Parse(tc, tv, &retopts);
+    is_int(0, code, "and works with cmd_Parse into the bargain");
+    cmd_FreeOptions(&retopts);
+    cmd_FreeArgv(tv);
+
     /* Disable positional commands */
     cmd_DisablePositionalCommands();
     code = cmd_ParseLine("foo bar -flag", tv, &tc, 100);
@@ -172,23 +194,23 @@ main(int argc, char **argv)
     is_int(0, code, "cmd_ParseLine succeeds");
     code = cmd_Parse(tc, tv, &retopts);
     is_int(0, code, "Parsing with cmd_Parse works");
-    is_string("one", retopts->parms[0].items->data, " ... 1st option matches");
-    is_string("two", retopts->parms[1].items->data, " ... 2nd option matches");
-    ok(retopts->parms[2].items != NULL, " ... 3rd option matches");
+    is_string("one", retopts->parms[FIRST_OFF].items->data, " ... 1st option matches");
+    is_string("two", retopts->parms[SECOND_OFF].items->data, " ... 2nd option matches");
+    ok(retopts->parms[FLAG_OFF].items != NULL, " ... 3rd option matches");
 
     cmd_FreeOptions(&retopts);
     cmd_FreeArgv(tv);
     /* Try adding a couple of parameters at specific positions */
-    cmd_AddParmAtOffset(opts, "-fifth", CMD_SINGLE, CMD_OPTIONAL,
-		       "fifth option", 5);
-    cmd_AddParmAtOffset(opts, "-fourth", CMD_SINGLE, CMD_OPTIONAL,
-		       "fourth option", 4);
+    cmd_AddParmAtOffset(opts, FIFTH_OFF, "-fifth", CMD_SINGLE, CMD_OPTIONAL,
+		       "fifth option");
+    cmd_AddParmAtOffset(opts, FOURTH_OFF, "-fourth", CMD_SINGLE, CMD_OPTIONAL,
+		       "fourth option" );
     code = cmd_ParseLine("-first a -fourth b -fifth c", tv, &tc, 100);
     is_int(0, code, "cmd_ParseLine succeeds");
     code = cmd_Parse(tc, tv, &retopts);
     is_int(0, code, "parsing our new options succeeds");
-    is_string("b", retopts->parms[4].items->data, " Fourth option in right place");
-    is_string("c", retopts->parms[5].items->data, " Fifth option in right place");
+    is_string("b", retopts->parms[FOURTH_OFF].items->data, " Fourth option in right place");
+    is_string("c", retopts->parms[FIFTH_OFF].items->data, " Fifth option in right place");
     cmd_FreeOptions(&retopts);
     cmd_FreeArgv(tv);
 
@@ -197,23 +219,91 @@ main(int argc, char **argv)
     is_int(0, code, "cmd_ParseLine succeeds");
     code = cmd_Parse(tc, tv, &retopts);
 
-    code = cmd_OptionAsInt(retopts, 0, &retval);
+    code = cmd_OptionAsInt(retopts, FIRST_OFF, &retval);
     is_int(0, code, "cmd_OptionsAsInt succeeds");
     is_int(1, retval, " ... and returns correct value");
 
-    code = cmd_OptionAsString(retopts, 1, &retstring);
+    code = cmd_OptionAsString(retopts, SECOND_OFF, &retstring);
     is_int(0, code, "cmd_OptionsAsString succeeds");
     is_string("second", retstring, " ... and returns correct value");
     free(retstring);
     retstring = NULL;
 
-    code = cmd_OptionAsFlag(retopts, 2, &retval);
+    code = cmd_OptionAsFlag(retopts, FLAG_OFF, &retval);
     is_int(0, code, "cmd_OptionsAsFlag succeeds");
     ok(retval, " ... and flag is correct");
 
     cmd_FreeOptions(&retopts);
     cmd_FreeArgv(tv);
 
+    /* Add an alias */
+    code = cmd_AddParmAlias(opts, SECOND_OFF, "-twa");
+    is_int(0, code, "cmd_AddParmAlias succeeds");
+
+    code = cmd_ParseLine("-first 1 -twa tup", tv, &tc, 100);
+    is_int(0, code, "cmd_ParseLine succeeds");
+    code = cmd_Parse(tc, tv, &retopts);
+    is_int(0, code, "cmd_Parse succeeds for alias");
+    cmd_OptionAsString(retopts, SECOND_OFF, &retstring);
+    is_string("tup", retstring, " ... and we have the correct value");
+    free(retstring);
+    retstring = NULL;
+
+    cmd_FreeOptions(&retopts);
+    cmd_FreeArgv(tv);
+
+    /* Add something that can be a flag or a value, and put something after
+     * it so we can check for parse problems*/
+    cmd_AddParm(opts, "-perhaps", CMD_SINGLE_OR_FLAG, CMD_OPTIONAL,
+	        "what am I");
+    cmd_AddParm(opts, "-sanity", CMD_SINGLE, CMD_OPTIONAL, "sanity check");
+
+    /* Try using as an option */
+
+    code = cmd_ParseLine("-first 1 -perhaps 2 -sanity 3", tv, &tc, 100);
+    is_int(0, code, "cmd_ParseLine succeeds");
+    code = cmd_Parse(tc, tv, &retopts);
+    is_int(0, code, "cmd_Parse succeeds for option-as-flag as opt");
+    code = cmd_OptionAsInt(retopts, PERHAPS_OFF, &retval);
+    is_int(0, code, "cmd_OptionAsInt succeeds");
+    is_int(2, retval, " ... and we have the correct value");
+    cmd_FreeOptions(&retopts);
+    cmd_FreeArgv(tv);
+
+    /* And now, as a flag */
+
+    code = cmd_ParseLine("-first 1 -perhaps -sanity 3", tv, &tc, 100);
+    is_int(0, code, "cmd_ParseLine succeeds");
+    code = cmd_Parse(tc, tv, &retopts);
+    is_int(0, code, "cmd_Parse succeeds for option-as-flag as flag");
+    code = cmd_OptionAsInt(retopts, PERHAPS_OFF, &retval);
+    is_int(CMD_MISSING, code, " ... pulling out a value fails as expected");
+    cmd_OptionAsFlag(retopts, PERHAPS_OFF, &retval);
+    ok(retval, " ... but parsing as a flag works");
+    cmd_FreeOptions(&retopts);
+    cmd_FreeArgv(tv);
+
+    /* Check that we can produce help output */
+    code = cmd_ParseLine("-help", tv, &tc, 100);
+    is_int(0, code, "cmd_ParseLine succeeds");
+    code = cmd_Parse(tc, tv, &retopts);
+    is_int(CMD_USAGE, code, "cmd_Parse returns usage error with help output");
+    ok(retopts == NULL, " ... and options is empty");
+
+    /* Check splitting with '=' */
+
+    code = cmd_ParseLine("-first 1 -perhaps=6 -sanity=3", tv, &tc, 100);
+    is_int(0, code, "cmd_ParseLine succeeds");
+    code = cmd_Parse(tc, tv, &retopts);
+    is_int(0, code, "cmd_Parse succeeds for items split with '='");
+    code = cmd_OptionAsInt(retopts, PERHAPS_OFF, &retval);
+    is_int(0, code, "cmd_OptionAsInt succeeds");
+    is_int(6, retval, " ... and we have the correct value once");
+    code = cmd_OptionAsInt(retopts, SANITY_OFF, &retval);
+    is_int(0, code, "cmd_OptionAsInt succeeds");
+    is_int(3, retval, " ... and we have the correct value twice");
+    cmd_FreeOptions(&retopts);
+    cmd_FreeArgv(tv);
 
     return 0;
 }