t/helper/test-parse-options.c - jrn/git - Git at Google

 #include "test-tool.h"
 #include "parse-options.h"
 #include "strbuf.h"
 #include "string-list.h"
 #include "trace2.h"

 static int boolean = 0;
 static int integer = 0;
 static unsigned long magnitude = 0;
 static timestamp_t timestamp;
 static int abbrev = 7;
 static int verbose = -1; /* unspecified */
 static int dry_run = 0, quiet = 0;
 static char *string = NULL;
 static char *file = NULL;
 static int ambiguous;

 static struct {
 	int called;
 	const char *arg;
 	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;
 	length_cb.arg = arg;
 	length_cb.unset = unset;

 	if (unset)
 		return 1; /* do not support unset */

 	*(int *)opt->value = strlen(arg);
 	return 0;
 }

 static int number_callback(const struct option *opt, const char *arg, int unset)
 {
 	BUG_ON_OPT_NEG(unset);
 	*(int *)opt->value = strtol(arg, NULL, 10);
 	return 0;
 }

 static int collect_expect(const struct option *opt, const char *arg, int unset)
 {
 	struct string_list *expect;
 	struct string_list_item *item;
 	struct strbuf label = STRBUF_INIT;
 	const char *colon;

 	if (!arg || unset)
 		die("malformed --expect option");

 	expect = (struct string_list *)opt->value;
 	colon = strchr(arg, ':');
 	if (!colon)
 		die("malformed --expect option, lacking a colon");
 	strbuf_add(&label, arg, colon - arg);
 	item = string_list_insert(expect, strbuf_detach(&label, NULL));
 	if (item->util)
 		die("malformed --expect option, duplicate %s", label.buf);
 	item->util = (void *)arg;
 	return 0;
 }

 __attribute__((format (printf,3,4)))
 static void show(struct string_list *expect, int *status, const char *fmt, ...)
 {
 	struct string_list_item *item;
 	struct strbuf buf = STRBUF_INIT;
 	va_list args;

 	va_start(args, fmt);
 	strbuf_vaddf(&buf, fmt, args);
 	va_end(args);

 	if (!expect->nr)
 		printf("%s\n", buf.buf);
 	else {
 		char *colon = strchr(buf.buf, ':');
 		if (!colon)
 			die("malformed output format, output lacking colon: %s", fmt);
 		*colon = '\0';
 		item = string_list_lookup(expect, buf.buf);
 		*colon = ':';
 		if (!item)
 			; /* not among entries being checked */
 		else {
 			if (strcmp((const char *)item->util, buf.buf)) {
 				printf("-%s\n", (char *)item->util);
 				printf("+%s\n", buf.buf);
 				*status = 1;
 			}
 		}
 	}
 	strbuf_release(&buf);
 }

 int cmd__parse_options(int argc, const char **argv)
 {
 	const char *prefix = "prefix/";
 	const char *usage[] = {
 		"test-tool parse-options <options>",
 		"",
 		"A helper function for the parse-options API.",
 		NULL
 	};
 	struct string_list expect = STRING_LIST_INIT_NODUP;
 	struct string_list list = STRING_LIST_INIT_NODUP;

 	struct option options[] = {
 		OPT_BOOL(0, "yes", &boolean, "get a boolean"),
 		OPT_BOOL('D', "no-doubt", &boolean, "begins with 'no-'"),
 		{ OPTION_SET_INT, 'B', "no-fear", &boolean, NULL,
 		  "be brave", PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, 1 },
 		OPT_COUNTUP('b', "boolean", &boolean, "increment by one"),
 		OPT_BIT('4', "or4", &boolean,
 			"bitwise-or boolean with ...0100", 4),
 		OPT_NEGBIT(0, "neg-or4", &boolean, "same as --no-or4", 4),
 		OPT_GROUP(""),
 		OPT_INTEGER('i', "integer", &integer, "get a integer"),
 		OPT_INTEGER('j', NULL, &integer, "get a integer, too"),
 		OPT_MAGNITUDE('m', "magnitude", &magnitude, "get a magnitude"),
 		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>"),
 		OPT_GROUP("String options"),
 		OPT_STRING('s', "string", &string, "string", "get a string"),
 		OPT_STRING(0, "string2", &string, "str", "get another string"),
 		OPT_STRING(0, "st", &string, "st", "get another string (pervert ordering)"),
 		OPT_STRING('o', NULL, &string, "str", "get another string"),
 		OPT_NOOP_NOARG(0, "obsolete"),
 		OPT_SET_INT_F(0, "longhelp", &integer, "help text of this entry\n"
 			      "spans multiple lines", 0, PARSE_OPT_NONEG),
 		OPT_STRING_LIST(0, "list", &list, "str", "add str to list"),
 		OPT_GROUP("Magic arguments"),
 		OPT_NUMBER_CALLBACK(&integer, "set integer to NUM",
 			number_callback),
 		{ OPTION_COUNTUP, '+', NULL, &boolean, NULL, "same as -b",
 		  PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH },
 		{ OPTION_COUNTUP, 0, "ambiguous", &ambiguous, NULL,
 		  "positive ambiguity", PARSE_OPT_NOARG | PARSE_OPT_NONEG },
 		{ OPTION_COUNTUP, 0, "no-ambiguous", &ambiguous, NULL,
 		  "negative ambiguity", PARSE_OPT_NOARG | PARSE_OPT_NONEG },
 		OPT_GROUP("Standard options"),
 		OPT__ABBREV(&abbrev),
 		OPT__VERBOSE(&verbose, "be verbose"),
 		OPT__DRY_RUN(&dry_run, "dry run"),
 		OPT__QUIET(&quiet, "be quiet"),
 		OPT_CALLBACK(0, "expect", &expect, "string",
 			     "expected output in the variable dump",
 			     collect_expect),
 		OPT_GROUP("Alias"),
 		OPT_STRING('A', "alias-source", &string, "string", "get a string"),
 		OPT_ALIAS('Z', "alias-target", "alias-source"),
 		OPT_END(),
 	};
 	int i;
 	int ret = 0;

 	trace2_cmd_name("_parse_");

 	argc = parse_options(argc, (const char **)argv, prefix, options, usage, 0);

 	if (length_cb.called) {
 		const char *arg = length_cb.arg;
 		int unset = length_cb.unset;
 		show(&expect, &ret, "Callback: \"%s\", %d",
 		     (arg ? arg : "not set"), unset);
 	}
 	show(&expect, &ret, "boolean: %d", boolean);
 	show(&expect, &ret, "integer: %d", integer);
 	show(&expect, &ret, "magnitude: %lu", magnitude);
 	show(&expect, &ret, "timestamp: %"PRItime, timestamp);
 	show(&expect, &ret, "string: %s", string ? string : "(not set)");
 	show(&expect, &ret, "abbrev: %d", abbrev);
 	show(&expect, &ret, "verbose: %d", verbose);
 	show(&expect, &ret, "quiet: %d", quiet);
 	show(&expect, &ret, "dry run: %s", dry_run ? "yes" : "no");
 	show(&expect, &ret, "file: %s", file ? file : "(not set)");

 	for (i = 0; i < list.nr; i++)
 		show(&expect, &ret, "list: %s", list.items[i].string);

 	for (i = 0; i < argc; i++)
 		show(&expect, &ret, "arg %02d: %s", i, argv[i]);

 	expect.strdup_strings = 1;
 	string_list_clear(&expect, 0);
 	string_list_clear(&list, 0);

 	return ret;
 }

 static void print_args(int argc, const char **argv)
 {
 	int i;
 	for (i = 0; i < argc; i++)
 		printf("arg %02d: %s\n", i, argv[i]);
 }

 static int parse_options_flags__cmd(int argc, const char **argv,
 				    enum parse_opt_flags test_flags)
 {
 	const char *usage[] = {
 		"<...> cmd [options]",
 		NULL
 	};
 	int opt = 0;
 	const struct option options[] = {
 		OPT_INTEGER('o', "opt", &opt, "an integer option"),
 		OPT_END()
 	};

 	argc = parse_options(argc, argv, NULL, options, usage, test_flags);

 	printf("opt: %d\n", opt);
 	print_args(argc, argv);

 	return 0;
 }

 static enum parse_opt_flags test_flags = 0;
 static const struct option test_flag_options[] = {
 	OPT_GROUP("flag-options:"),
 	OPT_BIT(0, "keep-dashdash", &test_flags,
 		"pass PARSE_OPT_KEEP_DASHDASH to parse_options()",
 		PARSE_OPT_KEEP_DASHDASH),
 	OPT_BIT(0, "stop-at-non-option", &test_flags,
 		"pass PARSE_OPT_STOP_AT_NON_OPTION to parse_options()",
 		PARSE_OPT_STOP_AT_NON_OPTION),
 	OPT_BIT(0, "keep-argv0", &test_flags,
 		"pass PARSE_OPT_KEEP_ARGV0 to parse_options()",
 		PARSE_OPT_KEEP_ARGV0),
 	OPT_BIT(0, "keep-unknown-opt", &test_flags,
 		"pass PARSE_OPT_KEEP_UNKNOWN_OPT to parse_options()",
 		PARSE_OPT_KEEP_UNKNOWN_OPT),
 	OPT_BIT(0, "no-internal-help", &test_flags,
 		"pass PARSE_OPT_NO_INTERNAL_HELP to parse_options()",
 		PARSE_OPT_NO_INTERNAL_HELP),
 	OPT_BIT(0, "subcommand-optional", &test_flags,
 		"pass PARSE_OPT_SUBCOMMAND_OPTIONAL to parse_options()",
 		PARSE_OPT_SUBCOMMAND_OPTIONAL),
 	OPT_END()
 };

 int cmd__parse_options_flags(int argc, const char **argv)
 {
 	const char *usage[] = {
 		"test-tool parse-options-flags [flag-options] cmd [options]",
 		NULL
 	};

 	argc = parse_options(argc, argv, NULL, test_flag_options, usage,
 			     PARSE_OPT_STOP_AT_NON_OPTION);

 	if (!argc || strcmp(argv[0], "cmd")) {
 		error("'cmd' is mandatory");
 		usage_with_options(usage, test_flag_options);
 	}

 	return parse_options_flags__cmd(argc, argv, test_flags);
 }

 static int subcmd_one(int argc, const char **argv, const char *prefix UNUSED)
 {
 	printf("fn: subcmd_one\n");
 	print_args(argc, argv);
 	return 0;
 }

 static int subcmd_two(int argc, const char **argv, const char *prefix UNUSED)
 {
 	printf("fn: subcmd_two\n");
 	print_args(argc, argv);
 	return 0;
 }

 static int parse_subcommand__cmd(int argc, const char **argv,
 				 enum parse_opt_flags test_flags)
 {
 	const char *usage[] = {
 		"<...> cmd subcmd-one",
 		"<...> cmd subcmd-two",
 		NULL
 	};
 	parse_opt_subcommand_fn *fn = NULL;
 	int opt = 0;
 	struct option options[] = {
 		OPT_SUBCOMMAND("subcmd-one", &fn, subcmd_one),
 		OPT_SUBCOMMAND("subcmd-two", &fn, subcmd_two),
 		OPT_INTEGER('o', "opt", &opt, "an integer option"),
 		OPT_END()
 	};

 	if (test_flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)
 		fn = subcmd_one;
 	argc = parse_options(argc, argv, NULL, options, usage, test_flags);

 	printf("opt: %d\n", opt);

 	return fn(argc, argv, NULL);
 }

 int cmd__parse_subcommand(int argc, const char **argv)
 {
 	const char *usage[] = {
 		"test-tool parse-subcommand [flag-options] cmd <subcommand>",
 		NULL
 	};

 	argc = parse_options(argc, argv, NULL, test_flag_options, usage,
 			     PARSE_OPT_STOP_AT_NON_OPTION);

 	if (!argc || strcmp(argv[0], "cmd")) {
 		error("'cmd' is mandatory");
 		usage_with_options(usage, test_flag_options);
 	}

 	return parse_subcommand__cmd(argc, argv, test_flags);
 }
	#include "test-tool.h"
	#include "parse-options.h"
	#include "strbuf.h"
	#include "string-list.h"
	#include "trace2.h"

	static int boolean = 0;
	static int integer = 0;
	static unsigned long magnitude = 0;
	static timestamp_t timestamp;
	static int abbrev = 7;
	static int verbose = -1; /* unspecified */
	static int dry_run = 0, quiet = 0;
	static char *string = NULL;
	static char *file = NULL;
	static int ambiguous;

	static struct {
	int called;
	const char *arg;
	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;
	length_cb.arg = arg;
	length_cb.unset = unset;

	if (unset)
	return 1; /* do not support unset */

	(int )opt->value = strlen(arg);
	return 0;
	}

	static int number_callback(const struct option opt, const char arg, int unset)
	{
	BUG_ON_OPT_NEG(unset);
	(int )opt->value = strtol(arg, NULL, 10);
	return 0;
	}

	static int collect_expect(const struct option opt, const char arg, int unset)
	{
	struct string_list *expect;
	struct string_list_item *item;
	struct strbuf label = STRBUF_INIT;
	const char *colon;

	if (!arg \|\| unset)
	die("malformed --expect option");

	expect = (struct string_list *)opt->value;
	colon = strchr(arg, ':');
	if (!colon)
	die("malformed --expect option, lacking a colon");
	strbuf_add(&label, arg, colon - arg);
	item = string_list_insert(expect, strbuf_detach(&label, NULL));
	if (item->util)
	die("malformed --expect option, duplicate %s", label.buf);
	item->util = (void *)arg;
	return 0;
	}

	__attribute__((format (printf,3,4)))
	static void show(struct string_list expect, int status, const char *fmt, ...)
	{
	struct string_list_item *item;
	struct strbuf buf = STRBUF_INIT;
	va_list args;

	va_start(args, fmt);
	strbuf_vaddf(&buf, fmt, args);
	va_end(args);

	if (!expect->nr)
	printf("%s\n", buf.buf);
	else {
	char *colon = strchr(buf.buf, ':');
	if (!colon)
	die("malformed output format, output lacking colon: %s", fmt);
	*colon = '\0';
	item = string_list_lookup(expect, buf.buf);
	*colon = ':';
	if (!item)
	; /* not among entries being checked */
	else {
	if (strcmp((const char *)item->util, buf.buf)) {
	printf("-%s\n", (char *)item->util);
	printf("+%s\n", buf.buf);
	*status = 1;
	}
	}
	}
	strbuf_release(&buf);
	}

	int cmd__parse_options(int argc, const char **argv)
	{
	const char *prefix = "prefix/";
	const char *usage[] = {
	"test-tool parse-options <options>",
	"",
	"A helper function for the parse-options API.",
	NULL
	};
	struct string_list expect = STRING_LIST_INIT_NODUP;
	struct string_list list = STRING_LIST_INIT_NODUP;

	struct option options[] = {
	OPT_BOOL(0, "yes", &boolean, "get a boolean"),
	OPT_BOOL('D', "no-doubt", &boolean, "begins with 'no-'"),
	{ OPTION_SET_INT, 'B', "no-fear", &boolean, NULL,
	"be brave", PARSE_OPT_NOARG \| PARSE_OPT_NONEG, NULL, 1 },
	OPT_COUNTUP('b', "boolean", &boolean, "increment by one"),
	OPT_BIT('4', "or4", &boolean,
	"bitwise-or boolean with ...0100", 4),
	OPT_NEGBIT(0, "neg-or4", &boolean, "same as --no-or4", 4),
	OPT_GROUP(""),
	OPT_INTEGER('i', "integer", &integer, "get a integer"),
	OPT_INTEGER('j', NULL, &integer, "get a integer, too"),
	OPT_MAGNITUDE('m', "magnitude", &magnitude, "get a magnitude"),
	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>"),
	OPT_GROUP("String options"),
	OPT_STRING('s', "string", &string, "string", "get a string"),
	OPT_STRING(0, "string2", &string, "str", "get another string"),
	OPT_STRING(0, "st", &string, "st", "get another string (pervert ordering)"),
	OPT_STRING('o', NULL, &string, "str", "get another string"),
	OPT_NOOP_NOARG(0, "obsolete"),
	OPT_SET_INT_F(0, "longhelp", &integer, "help text of this entry\n"
	"spans multiple lines", 0, PARSE_OPT_NONEG),
	OPT_STRING_LIST(0, "list", &list, "str", "add str to list"),
	OPT_GROUP("Magic arguments"),
	OPT_NUMBER_CALLBACK(&integer, "set integer to NUM",
	number_callback),
	{ OPTION_COUNTUP, '+', NULL, &boolean, NULL, "same as -b",
	PARSE_OPT_NOARG \| PARSE_OPT_NONEG \| PARSE_OPT_NODASH },
	{ OPTION_COUNTUP, 0, "ambiguous", &ambiguous, NULL,
	"positive ambiguity", PARSE_OPT_NOARG \| PARSE_OPT_NONEG },
	{ OPTION_COUNTUP, 0, "no-ambiguous", &ambiguous, NULL,
	"negative ambiguity", PARSE_OPT_NOARG \| PARSE_OPT_NONEG },
	OPT_GROUP("Standard options"),
	OPT__ABBREV(&abbrev),
	OPT__VERBOSE(&verbose, "be verbose"),
	OPT__DRY_RUN(&dry_run, "dry run"),
	OPT__QUIET(&quiet, "be quiet"),
	OPT_CALLBACK(0, "expect", &expect, "string",
	"expected output in the variable dump",
	collect_expect),
	OPT_GROUP("Alias"),
	OPT_STRING('A', "alias-source", &string, "string", "get a string"),
	OPT_ALIAS('Z', "alias-target", "alias-source"),
	OPT_END(),
	};
	int i;
	int ret = 0;

	trace2_cmd_name("_parse_");

	argc = parse_options(argc, (const char **)argv, prefix, options, usage, 0);

	if (length_cb.called) {
	const char *arg = length_cb.arg;
	int unset = length_cb.unset;
	show(&expect, &ret, "Callback: \"%s\", %d",
	(arg ? arg : "not set"), unset);
	}
	show(&expect, &ret, "boolean: %d", boolean);
	show(&expect, &ret, "integer: %d", integer);
	show(&expect, &ret, "magnitude: %lu", magnitude);
	show(&expect, &ret, "timestamp: %"PRItime, timestamp);
	show(&expect, &ret, "string: %s", string ? string : "(not set)");
	show(&expect, &ret, "abbrev: %d", abbrev);
	show(&expect, &ret, "verbose: %d", verbose);
	show(&expect, &ret, "quiet: %d", quiet);
	show(&expect, &ret, "dry run: %s", dry_run ? "yes" : "no");
	show(&expect, &ret, "file: %s", file ? file : "(not set)");

	for (i = 0; i < list.nr; i++)
	show(&expect, &ret, "list: %s", list.items[i].string);

	for (i = 0; i < argc; i++)
	show(&expect, &ret, "arg %02d: %s", i, argv[i]);

	expect.strdup_strings = 1;
	string_list_clear(&expect, 0);
	string_list_clear(&list, 0);

	return ret;
	}

	static void print_args(int argc, const char **argv)
	{
	int i;
	for (i = 0; i < argc; i++)
	printf("arg %02d: %s\n", i, argv[i]);
	}

	static int parse_options_flags__cmd(int argc, const char **argv,
	enum parse_opt_flags test_flags)
	{
	const char *usage[] = {
	"<...> cmd [options]",
	NULL
	};
	int opt = 0;
	const struct option options[] = {
	OPT_INTEGER('o', "opt", &opt, "an integer option"),
	OPT_END()
	};

	argc = parse_options(argc, argv, NULL, options, usage, test_flags);

	printf("opt: %d\n", opt);
	print_args(argc, argv);

	return 0;
	}

	static enum parse_opt_flags test_flags = 0;
	static const struct option test_flag_options[] = {
	OPT_GROUP("flag-options:"),
	OPT_BIT(0, "keep-dashdash", &test_flags,
	"pass PARSE_OPT_KEEP_DASHDASH to parse_options()",
	PARSE_OPT_KEEP_DASHDASH),
	OPT_BIT(0, "stop-at-non-option", &test_flags,
	"pass PARSE_OPT_STOP_AT_NON_OPTION to parse_options()",
	PARSE_OPT_STOP_AT_NON_OPTION),
	OPT_BIT(0, "keep-argv0", &test_flags,
	"pass PARSE_OPT_KEEP_ARGV0 to parse_options()",
	PARSE_OPT_KEEP_ARGV0),
	OPT_BIT(0, "keep-unknown-opt", &test_flags,
	"pass PARSE_OPT_KEEP_UNKNOWN_OPT to parse_options()",
	PARSE_OPT_KEEP_UNKNOWN_OPT),
	OPT_BIT(0, "no-internal-help", &test_flags,
	"pass PARSE_OPT_NO_INTERNAL_HELP to parse_options()",
	PARSE_OPT_NO_INTERNAL_HELP),
	OPT_BIT(0, "subcommand-optional", &test_flags,
	"pass PARSE_OPT_SUBCOMMAND_OPTIONAL to parse_options()",
	PARSE_OPT_SUBCOMMAND_OPTIONAL),
	OPT_END()
	};

	int cmd__parse_options_flags(int argc, const char **argv)
	{
	const char *usage[] = {
	"test-tool parse-options-flags [flag-options] cmd [options]",
	NULL
	};

	argc = parse_options(argc, argv, NULL, test_flag_options, usage,
	PARSE_OPT_STOP_AT_NON_OPTION);

	if (!argc \|\| strcmp(argv[0], "cmd")) {
	error("'cmd' is mandatory");
	usage_with_options(usage, test_flag_options);
	}

	return parse_options_flags__cmd(argc, argv, test_flags);
	}

	static int subcmd_one(int argc, const char *argv, const char prefix UNUSED)
	{
	printf("fn: subcmd_one\n");
	print_args(argc, argv);
	return 0;
	}

	static int subcmd_two(int argc, const char *argv, const char prefix UNUSED)
	{
	printf("fn: subcmd_two\n");
	print_args(argc, argv);
	return 0;
	}

	static int parse_subcommand__cmd(int argc, const char **argv,
	enum parse_opt_flags test_flags)
	{
	const char *usage[] = {
	"<...> cmd subcmd-one",
	"<...> cmd subcmd-two",
	NULL
	};
	parse_opt_subcommand_fn *fn = NULL;
	int opt = 0;
	struct option options[] = {
	OPT_SUBCOMMAND("subcmd-one", &fn, subcmd_one),
	OPT_SUBCOMMAND("subcmd-two", &fn, subcmd_two),
	OPT_INTEGER('o', "opt", &opt, "an integer option"),
	OPT_END()
	};

	if (test_flags & PARSE_OPT_SUBCOMMAND_OPTIONAL)
	fn = subcmd_one;
	argc = parse_options(argc, argv, NULL, options, usage, test_flags);

	printf("opt: %d\n", opt);

	return fn(argc, argv, NULL);
	}

	int cmd__parse_subcommand(int argc, const char **argv)
	{
	const char *usage[] = {
	"test-tool parse-subcommand [flag-options] cmd <subcommand>",
	NULL
	};

	argc = parse_options(argc, argv, NULL, test_flag_options, usage,
	PARSE_OPT_STOP_AT_NON_OPTION);

	if (!argc \|\| strcmp(argv[0], "cmd")) {
	error("'cmd' is mandatory");
	usage_with_options(usage, test_flag_options);
	}

	return parse_subcommand__cmd(argc, argv, test_flags);
	}