mirror of
https://github.com/git/git
synced 2024-10-06 00:29:28 +00:00
Merge branch 'rs/parse-options-cmdmode'
parse-options improvements for OPT_CMDMODE options. * rs/parse-options-cmdmode: am: simplify --show-current-patch handling parse-options: make CMDMODE errors more precise
This commit is contained in:
commit
5f11becce0
112
builtin/am.c
112
builtin/am.c
|
@ -92,9 +92,16 @@ enum signoff_type {
|
|||
SIGNOFF_EXPLICIT /* --signoff was set on the command-line */
|
||||
};
|
||||
|
||||
enum show_patch_type {
|
||||
SHOW_PATCH_RAW = 0,
|
||||
SHOW_PATCH_DIFF = 1,
|
||||
enum resume_type {
|
||||
RESUME_FALSE = 0,
|
||||
RESUME_APPLY,
|
||||
RESUME_RESOLVED,
|
||||
RESUME_SKIP,
|
||||
RESUME_ABORT,
|
||||
RESUME_QUIT,
|
||||
RESUME_SHOW_PATCH_RAW,
|
||||
RESUME_SHOW_PATCH_DIFF,
|
||||
RESUME_ALLOW_EMPTY,
|
||||
};
|
||||
|
||||
enum empty_action {
|
||||
|
@ -2191,7 +2198,7 @@ static void am_abort(struct am_state *state)
|
|||
am_destroy(state);
|
||||
}
|
||||
|
||||
static int show_patch(struct am_state *state, enum show_patch_type sub_mode)
|
||||
static int show_patch(struct am_state *state, enum resume_type resume_mode)
|
||||
{
|
||||
struct strbuf sb = STRBUF_INIT;
|
||||
const char *patch_path;
|
||||
|
@ -2206,11 +2213,11 @@ static int show_patch(struct am_state *state, enum show_patch_type sub_mode)
|
|||
return run_command(&cmd);
|
||||
}
|
||||
|
||||
switch (sub_mode) {
|
||||
case SHOW_PATCH_RAW:
|
||||
switch (resume_mode) {
|
||||
case RESUME_SHOW_PATCH_RAW:
|
||||
patch_path = am_path(state, msgnum(state));
|
||||
break;
|
||||
case SHOW_PATCH_DIFF:
|
||||
case RESUME_SHOW_PATCH_DIFF:
|
||||
patch_path = am_path(state, "patch");
|
||||
break;
|
||||
default:
|
||||
|
@ -2257,57 +2264,25 @@ static int parse_opt_patchformat(const struct option *opt, const char *arg, int
|
|||
return 0;
|
||||
}
|
||||
|
||||
enum resume_type {
|
||||
RESUME_FALSE = 0,
|
||||
RESUME_APPLY,
|
||||
RESUME_RESOLVED,
|
||||
RESUME_SKIP,
|
||||
RESUME_ABORT,
|
||||
RESUME_QUIT,
|
||||
RESUME_SHOW_PATCH,
|
||||
RESUME_ALLOW_EMPTY,
|
||||
};
|
||||
|
||||
struct resume_mode {
|
||||
enum resume_type mode;
|
||||
enum show_patch_type sub_mode;
|
||||
};
|
||||
|
||||
static int parse_opt_show_current_patch(const struct option *opt, const char *arg, int unset)
|
||||
{
|
||||
int *opt_value = opt->value;
|
||||
struct resume_mode *resume = container_of(opt_value, struct resume_mode, mode);
|
||||
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
|
||||
if (!arg)
|
||||
*opt_value = opt->defval;
|
||||
else if (!strcmp(arg, "raw"))
|
||||
*opt_value = RESUME_SHOW_PATCH_RAW;
|
||||
else if (!strcmp(arg, "diff"))
|
||||
*opt_value = RESUME_SHOW_PATCH_DIFF;
|
||||
/*
|
||||
* Please update $__git_showcurrentpatch in git-completion.bash
|
||||
* when you add new options
|
||||
*/
|
||||
const char *valid_modes[] = {
|
||||
[SHOW_PATCH_DIFF] = "diff",
|
||||
[SHOW_PATCH_RAW] = "raw"
|
||||
};
|
||||
int new_value = SHOW_PATCH_RAW;
|
||||
|
||||
BUG_ON_OPT_NEG(unset);
|
||||
|
||||
if (arg) {
|
||||
for (new_value = 0; new_value < ARRAY_SIZE(valid_modes); new_value++) {
|
||||
if (!strcmp(arg, valid_modes[new_value]))
|
||||
break;
|
||||
}
|
||||
if (new_value >= ARRAY_SIZE(valid_modes))
|
||||
return error(_("invalid value for '%s': '%s'"),
|
||||
"--show-current-patch", arg);
|
||||
}
|
||||
|
||||
if (resume->mode == RESUME_SHOW_PATCH && new_value != resume->sub_mode)
|
||||
return error(_("options '%s=%s' and '%s=%s' "
|
||||
"cannot be used together"),
|
||||
"--show-current-patch", arg,
|
||||
"--show-current-patch", valid_modes[resume->sub_mode]);
|
||||
|
||||
resume->mode = RESUME_SHOW_PATCH;
|
||||
resume->sub_mode = new_value;
|
||||
else
|
||||
return error(_("invalid value for '%s': '%s'"),
|
||||
"--show-current-patch", arg);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -2317,7 +2292,7 @@ int cmd_am(int argc, const char **argv, const char *prefix)
|
|||
int binary = -1;
|
||||
int keep_cr = -1;
|
||||
int patch_format = PATCH_FORMAT_UNKNOWN;
|
||||
struct resume_mode resume = { .mode = RESUME_FALSE };
|
||||
enum resume_type resume_mode = RESUME_FALSE;
|
||||
int in_progress;
|
||||
int ret = 0;
|
||||
|
||||
|
@ -2388,27 +2363,27 @@ int cmd_am(int argc, const char **argv, const char *prefix)
|
|||
PARSE_OPT_NOARG),
|
||||
OPT_STRING(0, "resolvemsg", &state.resolvemsg, NULL,
|
||||
N_("override error message when patch failure occurs")),
|
||||
OPT_CMDMODE(0, "continue", &resume.mode,
|
||||
OPT_CMDMODE(0, "continue", &resume_mode,
|
||||
N_("continue applying patches after resolving a conflict"),
|
||||
RESUME_RESOLVED),
|
||||
OPT_CMDMODE('r', "resolved", &resume.mode,
|
||||
OPT_CMDMODE('r', "resolved", &resume_mode,
|
||||
N_("synonyms for --continue"),
|
||||
RESUME_RESOLVED),
|
||||
OPT_CMDMODE(0, "skip", &resume.mode,
|
||||
OPT_CMDMODE(0, "skip", &resume_mode,
|
||||
N_("skip the current patch"),
|
||||
RESUME_SKIP),
|
||||
OPT_CMDMODE(0, "abort", &resume.mode,
|
||||
OPT_CMDMODE(0, "abort", &resume_mode,
|
||||
N_("restore the original branch and abort the patching operation"),
|
||||
RESUME_ABORT),
|
||||
OPT_CMDMODE(0, "quit", &resume.mode,
|
||||
OPT_CMDMODE(0, "quit", &resume_mode,
|
||||
N_("abort the patching operation but keep HEAD where it is"),
|
||||
RESUME_QUIT),
|
||||
{ OPTION_CALLBACK, 0, "show-current-patch", &resume.mode,
|
||||
{ OPTION_CALLBACK, 0, "show-current-patch", &resume_mode,
|
||||
"(diff|raw)",
|
||||
N_("show the patch being applied"),
|
||||
PARSE_OPT_CMDMODE | PARSE_OPT_OPTARG | PARSE_OPT_NONEG | PARSE_OPT_LITERAL_ARGHELP,
|
||||
parse_opt_show_current_patch, RESUME_SHOW_PATCH },
|
||||
OPT_CMDMODE(0, "allow-empty", &resume.mode,
|
||||
parse_opt_show_current_patch, RESUME_SHOW_PATCH_RAW },
|
||||
OPT_CMDMODE(0, "allow-empty", &resume_mode,
|
||||
N_("record the empty patch as an empty commit"),
|
||||
RESUME_ALLOW_EMPTY),
|
||||
OPT_BOOL(0, "committer-date-is-author-date",
|
||||
|
@ -2463,12 +2438,12 @@ int cmd_am(int argc, const char **argv, const char *prefix)
|
|||
* intend to feed us a patch but wanted to continue
|
||||
* unattended.
|
||||
*/
|
||||
if (argc || (resume.mode == RESUME_FALSE && !isatty(0)))
|
||||
if (argc || (resume_mode == RESUME_FALSE && !isatty(0)))
|
||||
die(_("previous rebase directory %s still exists but mbox given."),
|
||||
state.dir);
|
||||
|
||||
if (resume.mode == RESUME_FALSE)
|
||||
resume.mode = RESUME_APPLY;
|
||||
if (resume_mode == RESUME_FALSE)
|
||||
resume_mode = RESUME_APPLY;
|
||||
|
||||
if (state.signoff == SIGNOFF_EXPLICIT)
|
||||
am_append_signoff(&state);
|
||||
|
@ -2482,7 +2457,7 @@ int cmd_am(int argc, const char **argv, const char *prefix)
|
|||
* stray directories.
|
||||
*/
|
||||
if (file_exists(state.dir) && !state.rebasing) {
|
||||
if (resume.mode == RESUME_ABORT || resume.mode == RESUME_QUIT) {
|
||||
if (resume_mode == RESUME_ABORT || resume_mode == RESUME_QUIT) {
|
||||
am_destroy(&state);
|
||||
am_state_release(&state);
|
||||
return 0;
|
||||
|
@ -2493,7 +2468,7 @@ int cmd_am(int argc, const char **argv, const char *prefix)
|
|||
state.dir);
|
||||
}
|
||||
|
||||
if (resume.mode)
|
||||
if (resume_mode)
|
||||
die(_("Resolve operation not in progress, we are not resuming."));
|
||||
|
||||
for (i = 0; i < argc; i++) {
|
||||
|
@ -2511,7 +2486,7 @@ int cmd_am(int argc, const char **argv, const char *prefix)
|
|||
strvec_clear(&paths);
|
||||
}
|
||||
|
||||
switch (resume.mode) {
|
||||
switch (resume_mode) {
|
||||
case RESUME_FALSE:
|
||||
am_run(&state, 0);
|
||||
break;
|
||||
|
@ -2520,7 +2495,7 @@ int cmd_am(int argc, const char **argv, const char *prefix)
|
|||
break;
|
||||
case RESUME_RESOLVED:
|
||||
case RESUME_ALLOW_EMPTY:
|
||||
am_resolve(&state, resume.mode == RESUME_ALLOW_EMPTY ? 1 : 0);
|
||||
am_resolve(&state, resume_mode == RESUME_ALLOW_EMPTY ? 1 : 0);
|
||||
break;
|
||||
case RESUME_SKIP:
|
||||
am_skip(&state);
|
||||
|
@ -2532,8 +2507,9 @@ int cmd_am(int argc, const char **argv, const char *prefix)
|
|||
am_rerere_clear();
|
||||
am_destroy(&state);
|
||||
break;
|
||||
case RESUME_SHOW_PATCH:
|
||||
ret = show_patch(&state, resume.sub_mode);
|
||||
case RESUME_SHOW_PATCH_RAW:
|
||||
case RESUME_SHOW_PATCH_DIFF:
|
||||
ret = show_patch(&state, resume_mode);
|
||||
break;
|
||||
default:
|
||||
BUG("invalid resume value");
|
||||
|
|
144
parse-options.c
144
parse-options.c
|
@ -70,42 +70,10 @@ static void fix_filename(const char *prefix, char **file)
|
|||
*file = prefix_filename_except_for_dash(prefix, *file);
|
||||
}
|
||||
|
||||
static enum parse_opt_result opt_command_mode_error(
|
||||
const struct option *opt,
|
||||
const struct option *all_opts,
|
||||
enum opt_parsed flags)
|
||||
{
|
||||
const struct option *that;
|
||||
struct strbuf that_name = STRBUF_INIT;
|
||||
|
||||
/*
|
||||
* Find the other option that was used to set the variable
|
||||
* already, and report that this is not compatible with it.
|
||||
*/
|
||||
for (that = all_opts; that->type != OPTION_END; that++) {
|
||||
if (that == opt ||
|
||||
!(that->flags & PARSE_OPT_CMDMODE) ||
|
||||
that->value != opt->value ||
|
||||
that->defval != *(int *)opt->value)
|
||||
continue;
|
||||
|
||||
if (that->long_name)
|
||||
strbuf_addf(&that_name, "--%s", that->long_name);
|
||||
else
|
||||
strbuf_addf(&that_name, "-%c", that->short_name);
|
||||
error(_("%s is incompatible with %s"),
|
||||
optname(opt, flags), that_name.buf);
|
||||
strbuf_release(&that_name);
|
||||
return PARSE_OPT_ERROR;
|
||||
}
|
||||
return error(_("%s : incompatible with something else"),
|
||||
optname(opt, flags));
|
||||
}
|
||||
|
||||
static enum parse_opt_result get_value(struct parse_opt_ctx_t *p,
|
||||
const struct option *opt,
|
||||
const struct option *all_opts,
|
||||
enum opt_parsed flags)
|
||||
static enum parse_opt_result do_get_value(struct parse_opt_ctx_t *p,
|
||||
const struct option *opt,
|
||||
enum opt_parsed flags,
|
||||
const char **argp)
|
||||
{
|
||||
const char *s, *arg;
|
||||
const int unset = flags & OPT_UNSET;
|
||||
|
@ -118,14 +86,6 @@ static enum parse_opt_result get_value(struct parse_opt_ctx_t *p,
|
|||
if (!(flags & OPT_SHORT) && p->opt && (opt->flags & PARSE_OPT_NOARG))
|
||||
return error(_("%s takes no value"), optname(opt, flags));
|
||||
|
||||
/*
|
||||
* Giving the same mode option twice, although unnecessary,
|
||||
* is not a grave error, so let it pass.
|
||||
*/
|
||||
if ((opt->flags & PARSE_OPT_CMDMODE) &&
|
||||
*(int *)opt->value && *(int *)opt->value != opt->defval)
|
||||
return opt_command_mode_error(opt, all_opts, flags);
|
||||
|
||||
switch (opt->type) {
|
||||
case OPTION_LOWLEVEL_CALLBACK:
|
||||
return opt->ll_callback(p, opt, NULL, unset);
|
||||
|
@ -200,6 +160,8 @@ static enum parse_opt_result get_value(struct parse_opt_ctx_t *p,
|
|||
p_unset = 0;
|
||||
p_arg = arg;
|
||||
}
|
||||
if (opt->flags & PARSE_OPT_CMDMODE)
|
||||
*argp = p_arg;
|
||||
if (opt->callback)
|
||||
return (*opt->callback)(opt, p_arg, p_unset) ? (-1) : 0;
|
||||
else
|
||||
|
@ -247,16 +209,91 @@ static enum parse_opt_result get_value(struct parse_opt_ctx_t *p,
|
|||
}
|
||||
}
|
||||
|
||||
struct parse_opt_cmdmode_list {
|
||||
int value, *value_ptr;
|
||||
const struct option *opt;
|
||||
const char *arg;
|
||||
enum opt_parsed flags;
|
||||
struct parse_opt_cmdmode_list *next;
|
||||
};
|
||||
|
||||
static void build_cmdmode_list(struct parse_opt_ctx_t *ctx,
|
||||
const struct option *opts)
|
||||
{
|
||||
ctx->cmdmode_list = NULL;
|
||||
|
||||
for (; opts->type != OPTION_END; opts++) {
|
||||
struct parse_opt_cmdmode_list *elem = ctx->cmdmode_list;
|
||||
int *value_ptr = opts->value;
|
||||
|
||||
if (!(opts->flags & PARSE_OPT_CMDMODE) || !value_ptr)
|
||||
continue;
|
||||
|
||||
while (elem && elem->value_ptr != value_ptr)
|
||||
elem = elem->next;
|
||||
if (elem)
|
||||
continue;
|
||||
|
||||
CALLOC_ARRAY(elem, 1);
|
||||
elem->value_ptr = value_ptr;
|
||||
elem->value = *value_ptr;
|
||||
elem->next = ctx->cmdmode_list;
|
||||
ctx->cmdmode_list = elem;
|
||||
}
|
||||
}
|
||||
|
||||
static char *optnamearg(const struct option *opt, const char *arg,
|
||||
enum opt_parsed flags)
|
||||
{
|
||||
if (flags & OPT_SHORT)
|
||||
return xstrfmt("-%c%s", opt->short_name, arg ? arg : "");
|
||||
return xstrfmt("--%s%s%s%s", flags & OPT_UNSET ? "no-" : "",
|
||||
opt->long_name, arg ? "=" : "", arg ? arg : "");
|
||||
}
|
||||
|
||||
static enum parse_opt_result get_value(struct parse_opt_ctx_t *p,
|
||||
const struct option *opt,
|
||||
enum opt_parsed flags)
|
||||
{
|
||||
const char *arg = NULL;
|
||||
enum parse_opt_result result = do_get_value(p, opt, flags, &arg);
|
||||
struct parse_opt_cmdmode_list *elem = p->cmdmode_list;
|
||||
char *opt_name, *other_opt_name;
|
||||
|
||||
for (; elem; elem = elem->next) {
|
||||
if (*elem->value_ptr == elem->value)
|
||||
continue;
|
||||
|
||||
if (elem->opt &&
|
||||
(elem->opt->flags | opt->flags) & PARSE_OPT_CMDMODE)
|
||||
break;
|
||||
|
||||
elem->opt = opt;
|
||||
elem->arg = arg;
|
||||
elem->flags = flags;
|
||||
elem->value = *elem->value_ptr;
|
||||
}
|
||||
|
||||
if (result || !elem)
|
||||
return result;
|
||||
|
||||
opt_name = optnamearg(opt, arg, flags);
|
||||
other_opt_name = optnamearg(elem->opt, elem->arg, elem->flags);
|
||||
error(_("%s is incompatible with %s"), opt_name, other_opt_name);
|
||||
free(opt_name);
|
||||
free(other_opt_name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static enum parse_opt_result parse_short_opt(struct parse_opt_ctx_t *p,
|
||||
const struct option *options)
|
||||
{
|
||||
const struct option *all_opts = options;
|
||||
const struct option *numopt = NULL;
|
||||
|
||||
for (; options->type != OPTION_END; options++) {
|
||||
if (options->short_name == *p->opt) {
|
||||
p->opt = p->opt[1] ? p->opt + 1 : NULL;
|
||||
return get_value(p, options, all_opts, OPT_SHORT);
|
||||
return get_value(p, options, OPT_SHORT);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -318,7 +355,6 @@ static enum parse_opt_result parse_long_opt(
|
|||
struct parse_opt_ctx_t *p, const char *arg,
|
||||
const struct option *options)
|
||||
{
|
||||
const struct option *all_opts = options;
|
||||
const char *arg_end = strchrnul(arg, '=');
|
||||
const struct option *abbrev_option = NULL, *ambiguous_option = NULL;
|
||||
enum opt_parsed abbrev_flags = OPT_LONG, ambiguous_flags = OPT_LONG;
|
||||
|
@ -387,7 +423,7 @@ static enum parse_opt_result parse_long_opt(
|
|||
continue;
|
||||
p->opt = rest + 1;
|
||||
}
|
||||
return get_value(p, options, all_opts, flags ^ opt_flags);
|
||||
return get_value(p, options, flags ^ opt_flags);
|
||||
}
|
||||
|
||||
if (disallow_abbreviated_options && (ambiguous_option || abbrev_option))
|
||||
|
@ -405,7 +441,7 @@ static enum parse_opt_result parse_long_opt(
|
|||
return PARSE_OPT_HELP;
|
||||
}
|
||||
if (abbrev_option)
|
||||
return get_value(p, abbrev_option, all_opts, abbrev_flags);
|
||||
return get_value(p, abbrev_option, abbrev_flags);
|
||||
return PARSE_OPT_UNKNOWN;
|
||||
}
|
||||
|
||||
|
@ -413,13 +449,11 @@ static enum parse_opt_result parse_nodash_opt(struct parse_opt_ctx_t *p,
|
|||
const char *arg,
|
||||
const struct option *options)
|
||||
{
|
||||
const struct option *all_opts = options;
|
||||
|
||||
for (; options->type != OPTION_END; options++) {
|
||||
if (!(options->flags & PARSE_OPT_NODASH))
|
||||
continue;
|
||||
if (options->short_name == arg[0] && arg[1] == '\0')
|
||||
return get_value(p, options, all_opts, OPT_SHORT);
|
||||
return get_value(p, options, OPT_SHORT);
|
||||
}
|
||||
return PARSE_OPT_ERROR;
|
||||
}
|
||||
|
@ -574,6 +608,7 @@ static void parse_options_start_1(struct parse_opt_ctx_t *ctx,
|
|||
(flags & PARSE_OPT_KEEP_ARGV0))
|
||||
BUG("Can't keep argv0 if you don't have it");
|
||||
parse_options_check(options);
|
||||
build_cmdmode_list(ctx, options);
|
||||
}
|
||||
|
||||
void parse_options_start(struct parse_opt_ctx_t *ctx,
|
||||
|
@ -1006,6 +1041,11 @@ int parse_options(int argc, const char **argv,
|
|||
precompose_argv_prefix(argc, argv, NULL);
|
||||
free_preprocessed_options(real_options);
|
||||
free(ctx.alias_groups);
|
||||
for (struct parse_opt_cmdmode_list *elem = ctx.cmdmode_list; elem;) {
|
||||
struct parse_opt_cmdmode_list *next = elem->next;
|
||||
free(elem);
|
||||
elem = next;
|
||||
}
|
||||
return parse_options_end(&ctx);
|
||||
}
|
||||
|
||||
|
|
|
@ -445,6 +445,8 @@ static inline void die_for_incompatible_opt3(int opt1, const char *opt1_name,
|
|||
|
||||
/*----- incremental advanced APIs -----*/
|
||||
|
||||
struct parse_opt_cmdmode_list;
|
||||
|
||||
/*
|
||||
* It's okay for the caller to consume argv/argc in the usual way.
|
||||
* Other fields of that structure are private to parse-options and should not
|
||||
|
@ -459,6 +461,7 @@ struct parse_opt_ctx_t {
|
|||
unsigned has_subcommands;
|
||||
const char *prefix;
|
||||
const char **alias_groups; /* must be in groups of 3 elements! */
|
||||
struct parse_opt_cmdmode_list *cmdmode_list;
|
||||
};
|
||||
|
||||
void parse_options_start(struct parse_opt_ctx_t *ctx,
|
||||
|
|
|
@ -21,6 +21,19 @@ static struct {
|
|||
int unset;
|
||||
} length_cb;
|
||||
|
||||
static int mode34_callback(const struct option *opt, const char *arg, int unset)
|
||||
{
|
||||
if (unset)
|
||||
*(int *)opt->value = 0;
|
||||
else if (!strcmp(arg, "3"))
|
||||
*(int *)opt->value = 3;
|
||||
else if (!strcmp(arg, "4"))
|
||||
*(int *)opt->value = 4;
|
||||
else
|
||||
return error("invalid value for '%s': '%s'", "--mode34", arg);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int length_callback(const struct option *opt, const char *arg, int unset)
|
||||
{
|
||||
length_cb.called = 1;
|
||||
|
@ -124,6 +137,9 @@ int cmd__parse_options(int argc, const char **argv)
|
|||
OPT_SET_INT(0, "set23", &integer, "set integer to 23", 23),
|
||||
OPT_CMDMODE(0, "mode1", &integer, "set integer to 1 (cmdmode option)", 1),
|
||||
OPT_CMDMODE(0, "mode2", &integer, "set integer to 2 (cmdmode option)", 2),
|
||||
OPT_CALLBACK_F(0, "mode34", &integer, "(3|4)",
|
||||
"set integer to 3 or 4 (cmdmode option)",
|
||||
PARSE_OPT_CMDMODE, mode34_callback),
|
||||
OPT_CALLBACK('L', "length", &integer, "str",
|
||||
"get length of <str>", length_callback),
|
||||
OPT_FILENAME('F', "file", &file, "set file to <file>"),
|
||||
|
|
|
@ -28,6 +28,7 @@ usage: test-tool parse-options <options>
|
|||
--[no-]set23 set integer to 23
|
||||
--mode1 set integer to 1 (cmdmode option)
|
||||
--mode2 set integer to 2 (cmdmode option)
|
||||
--[no-]mode34 (3|4) set integer to 3 or 4 (cmdmode option)
|
||||
-L, --[no-]length <str>
|
||||
get length of <str>
|
||||
-F, --[no-]file <file>
|
||||
|
@ -366,19 +367,41 @@ test_expect_success 'OPT_NEGBIT() works' '
|
|||
'
|
||||
|
||||
test_expect_success 'OPT_CMDMODE() works' '
|
||||
test-tool parse-options --expect="integer: 1" --mode1
|
||||
test-tool parse-options --expect="integer: 1" --mode1 &&
|
||||
test-tool parse-options --expect="integer: 3" --mode34=3
|
||||
'
|
||||
|
||||
test_expect_success 'OPT_CMDMODE() detects incompatibility' '
|
||||
test_expect_success 'OPT_CMDMODE() detects incompatibility (1)' '
|
||||
test_must_fail test-tool parse-options --mode1 --mode2 >output 2>output.err &&
|
||||
test_must_be_empty output &&
|
||||
test_i18ngrep "incompatible with --mode" output.err
|
||||
test_i18ngrep "mode1" output.err &&
|
||||
test_i18ngrep "mode2" output.err &&
|
||||
test_i18ngrep "is incompatible with" output.err
|
||||
'
|
||||
|
||||
test_expect_success 'OPT_CMDMODE() detects incompatibility with something else' '
|
||||
test_expect_success 'OPT_CMDMODE() detects incompatibility (2)' '
|
||||
test_must_fail test-tool parse-options --set23 --mode2 >output 2>output.err &&
|
||||
test_must_be_empty output &&
|
||||
test_i18ngrep "incompatible with something else" output.err
|
||||
test_i18ngrep "mode2" output.err &&
|
||||
test_i18ngrep "set23" output.err &&
|
||||
test_i18ngrep "is incompatible with" output.err
|
||||
'
|
||||
|
||||
test_expect_success 'OPT_CMDMODE() detects incompatibility (3)' '
|
||||
test_must_fail test-tool parse-options --mode2 --set23 >output 2>output.err &&
|
||||
test_must_be_empty output &&
|
||||
test_i18ngrep "mode2" output.err &&
|
||||
test_i18ngrep "set23" output.err &&
|
||||
test_i18ngrep "is incompatible with" output.err
|
||||
'
|
||||
|
||||
test_expect_success 'OPT_CMDMODE() detects incompatibility (4)' '
|
||||
test_must_fail test-tool parse-options --mode2 --mode34=3 \
|
||||
>output 2>output.err &&
|
||||
test_must_be_empty output &&
|
||||
test_i18ngrep "mode2" output.err &&
|
||||
test_i18ngrep "mode34.3" output.err &&
|
||||
test_i18ngrep "is incompatible with" output.err
|
||||
'
|
||||
|
||||
test_expect_success 'OPT_COUNTUP() with PARSE_OPT_NODASH works' '
|
||||
|
|
Loading…
Reference in a new issue