kc3-lang/libressl/tests/optionstest.c

• Show log

  Commit

• Hash : adde656b
  Author :
  Date : 2021-12-26T15:42:47
  

  Add strtonum to compat library and export it
  
  crypto library requires strtonum now, and add it to compat library.
  remove it from applications compat/ directories.
  

Download

• tests/optionstest.c

• /*	$OpenBSD: optionstest.c,v 1.8 2015/01/22 05:48:00 doug Exp $	*/
  /*
   * Copyright (c) 2014 Joel Sing <jsing@openbsd.org>
   *
   * Permission to use, copy, modify, and distribute this software for any
   * purpose with or without fee is hereby granted, provided that the above
   * copyright notice and this permission notice appear in all copies.
   *
   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   */
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  
  #include <openssl/bio.h>
  #include <openssl/conf.h>
  
  #include <apps.h>
  #include <apps.c>
  
  /* Needed to keep apps.c happy... */
  BIO *bio_err;
  CONF *config;
  
  static int argfunc(char *arg);
  static int defaultarg(int argc, char **argv, int *argsused);
  static int multiarg(int argc, char **argv, int *argsused);
  
  static struct {
  	char *arg;
  	int flag;
  } test_config;
  
  static struct option test_options[] = {
  	{
  		.name = "arg",
  		.argname = "argname",
  		.type = OPTION_ARG,
  		.opt.arg = &test_config.arg,
  	},
  	{
  		.name = "argfunc",
  		.argname = "argname",
  		.type = OPTION_ARG_FUNC,
  		.opt.argfunc = argfunc,
  	},
  	{
  		.name = "flag",
  		.type = OPTION_FLAG,
  		.opt.flag = &test_config.flag,
  	},
  	{
  		.name = "multiarg",
  		.type = OPTION_ARGV_FUNC,
  		.opt.argvfunc = multiarg,
  	},
  	{
  		.name = NULL,
  		.type = OPTION_ARGV_FUNC,
  		.opt.argvfunc = defaultarg,
  	},
  	{ NULL },
  };
  
  char *args1[] = { "opts" };
  char *args2[] = { "opts", "-arg", "arg", "-flag" };
  char *args3[] = { "opts", "-arg", "arg", "-flag", "unnamed" };
  char *args4[] = { "opts", "-arg", "arg", "unnamed", "-flag" };
  char *args5[] = { "opts", "unnamed1", "-arg", "arg", "-flag", "unnamed2" };
  char *args6[] = { "opts", "-argfunc", "arg", "-flag" };
  char *args7[] = { "opts", "-arg", "arg", "-flag", "-", "-unnamed" };
  char *args8[] = { "opts", "-arg", "arg", "-flag", "file1", "file2", "file3" };
  char *args9[] = { "opts", "-arg", "arg", "-flag", "file1", "-file2", "file3" };
  char *args10[] = { "opts", "-arg", "arg", "-flag", "-", "file1", "file2" };
  char *args11[] = { "opts", "-arg", "arg", "-flag", "-", "-file1", "-file2" };
  char *args12[] = { "opts", "-multiarg", "arg1", "arg2", "-flag", "unnamed" };
  char *args13[] = { "opts", "-multiargz", "arg1", "arg2", "-flagz", "unnamed" };
  
  struct options_test {
  	int argc;
  	char **argv;
  	enum {
  		OPTIONS_TEST_NONE,
  		OPTIONS_TEST_UNNAMED,
  		OPTIONS_TEST_ARGSUSED,
  	} type;
  	char *unnamed;
  	int used;
  	int want;
  	char *wantarg;
  	int wantflag;
  };
  
  struct options_test options_tests[] = {
  	{
  		/* Test 1 - No arguments (only program name). */
  		.argc = 1,
  		.argv = args1,
  		.type = OPTIONS_TEST_NONE,
  		.want = 0,
  		.wantarg = NULL,
  		.wantflag = 0,
  	},
  	{
  		/* Test 2 - Named arguments (unnamed not permitted). */
  		.argc = 4,
  		.argv = args2,
  		.type = OPTIONS_TEST_NONE,
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 3 - Named arguments (unnamed permitted). */
  		.argc = 4,
  		.argv = args2,
  		.type = OPTIONS_TEST_UNNAMED,
  		.unnamed = NULL,
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 4 - Named and single unnamed (unnamed not permitted). */
  		.argc = 5,
  		.argv = args3,
  		.type = OPTIONS_TEST_NONE,
  		.want = 1,
  	},
  	{
  		/* Test 5 - Named and single unnamed (unnamed permitted). */
  		.argc = 5,
  		.argv = args3,
  		.type = OPTIONS_TEST_UNNAMED,
  		.unnamed = "unnamed",
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 6 - Named and single unnamed (different sequence). */
  		.argc = 5,
  		.argv = args4,
  		.type = OPTIONS_TEST_UNNAMED,
  		.unnamed = "unnamed",
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 7 - Multiple unnamed arguments (should fail). */
  		.argc = 6,
  		.argv = args5,
  		.type = OPTIONS_TEST_UNNAMED,
  		.want = 1,
  	},
  	{
  		/* Test 8 - Function. */
  		.argc = 4,
  		.argv = args6,
  		.type = OPTIONS_TEST_NONE,
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 9 - Named and single unnamed (hyphen separated). */
  		.argc = 6,
  		.argv = args7,
  		.type = OPTIONS_TEST_UNNAMED,
  		.unnamed = "-unnamed",
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 10 - Named and multiple unnamed. */
  		.argc = 7,
  		.argv = args8,
  		.used = 4,
  		.type = OPTIONS_TEST_ARGSUSED,
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 11 - Named and multiple unnamed. */
  		.argc = 7,
  		.argv = args9,
  		.used = 4,
  		.type = OPTIONS_TEST_ARGSUSED,
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 12 - Named and multiple unnamed. */
  		.argc = 7,
  		.argv = args10,
  		.used = 5,
  		.type = OPTIONS_TEST_ARGSUSED,
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 13 - Named and multiple unnamed. */
  		.argc = 7,
  		.argv = args11,
  		.used = 5,
  		.type = OPTIONS_TEST_ARGSUSED,
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 14 - Named only. */
  		.argc = 4,
  		.argv = args2,
  		.used = 4,
  		.type = OPTIONS_TEST_ARGSUSED,
  		.want = 0,
  		.wantarg = "arg",
  		.wantflag = 1,
  	},
  	{
  		/* Test 15 - Multiple argument callback. */
  		.argc = 6,
  		.argv = args12,
  		.unnamed = "unnamed",
  		.type = OPTIONS_TEST_UNNAMED,
  		.want = 0,
  		.wantarg = NULL,
  		.wantflag = 1,
  	},
  	{
  		/* Test 16 - Multiple argument callback. */
  		.argc = 6,
  		.argv = args12,
  		.used = 5,
  		.type = OPTIONS_TEST_ARGSUSED,
  		.want = 0,
  		.wantarg = NULL,
  		.wantflag = 1,
  	},
  	{
  		/* Test 17 - Default callback. */
  		.argc = 6,
  		.argv = args13,
  		.unnamed = "unnamed",
  		.type = OPTIONS_TEST_UNNAMED,
  		.want = 0,
  		.wantarg = NULL,
  		.wantflag = 1,
  	},
  	{
  		/* Test 18 - Default callback. */
  		.argc = 6,
  		.argv = args13,
  		.used = 5,
  		.type = OPTIONS_TEST_ARGSUSED,
  		.want = 0,
  		.wantarg = NULL,
  		.wantflag = 1,
  	},
  };
  
  #define N_OPTIONS_TESTS \
      (sizeof(options_tests) / sizeof(*options_tests))
  
  static int
  argfunc(char *arg)
  {
  	test_config.arg = arg;
  	return (0);
  }
  
  static int
  defaultarg(int argc, char **argv, int *argsused)
  {
  	if (argc < 1)
  		return (1);
  
  	if (strcmp(argv[0], "-multiargz") == 0) {
  		if (argc < 3)
  			return (1);
  		*argsused = 3;
  		return (0);
  	} else if (strcmp(argv[0], "-flagz") == 0) {
  		test_config.flag = 1;
  		*argsused = 1;
  		return (0);
  	}
  
  	return (1);
  }
  
  static int
  multiarg(int argc, char **argv, int *argsused)
  {
  	if (argc < 3)
  		return (1);
  
  	*argsused = 3;
  	return (0);
  }
  
  static int
  do_options_test(int test_no, struct options_test *ot)
  {
  	int *argsused = NULL;
  	char *unnamed = NULL;
  	char **arg = NULL;
  	int used = 0;
  	int ret;
  
  	if (ot->type == OPTIONS_TEST_UNNAMED)
  		arg = &unnamed;
  	else if (ot->type == OPTIONS_TEST_ARGSUSED)
  		argsused = &used;
  
  	memset(&test_config, 0, sizeof(test_config));
  	ret = options_parse(ot->argc, ot->argv, test_options, arg, argsused);
  	if (ret != ot->want) {
  		fprintf(stderr, "FAIL: test %i options_parse() returned %i, "
  		    "want %i\n", test_no, ret, ot->want);
  		return (1);
  	}
  	if (ret != 0)
  		return (0);
  
  	if ((test_config.arg != NULL || ot->wantarg != NULL) &&
  	    (test_config.arg == NULL || ot->wantarg == NULL ||
  	     strcmp(test_config.arg, ot->wantarg) != 0)) {
  		fprintf(stderr, "FAIL: test %i got arg '%s', want '%s'\n",
  		    test_no, test_config.arg, ot->wantarg);
  		return (1);
  	}
  	if (test_config.flag != ot->wantflag) {
  		fprintf(stderr, "FAIL: test %i got flag %i, want %i\n",
  		    test_no, test_config.flag, ot->wantflag);
  		return (1);
  	}
  	if (ot->type == OPTIONS_TEST_UNNAMED &&
  	    (unnamed != NULL || ot->unnamed != NULL) &&
  	    (unnamed == NULL || ot->unnamed == NULL ||
  	     strcmp(unnamed, ot->unnamed) != 0)) {
  		fprintf(stderr, "FAIL: test %i got unnamed '%s', want '%s'\n",
  		    test_no, unnamed, ot->unnamed);
  		return (1);
  	}
  	if (ot->type == OPTIONS_TEST_ARGSUSED && used != ot->used) {
  		fprintf(stderr, "FAIL: test %i got used %i, want %i\n",
  		    test_no, used, ot->used);
  		return (1);
  	}
  
  	return (0);
  }
  
  int
  main(int argc, char **argv)
  {
  	int failed = 0;
  	size_t i;
  
  	for (i = 0; i < N_OPTIONS_TESTS; i++) {
  		printf("Test %d%s\n", (int)(i + 1), options_tests[i].want == 0 ?
  		    "" : " is expected to complain");
  		failed += do_options_test(i + 1, &options_tests[i]);
  	}
  
  	return (failed);
  }
  

Download