| /************************************************************************ |
| * |
| * 0.cmdopts.cpp - test exercising the rw_runopts() and rw_setopts() |
| * utility functions |
| * |
| * $Id$ |
| * |
| ************************************************************************ |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 2005-2006 Rogue Wave Software. |
| * |
| **************************************************************************/ |
| |
| #include <rw_cmdopt.h> |
| |
| #include <stdio.h> |
| #include <string.h> |
| |
| // global buffer containing the names of all callbacks (along with |
| // their arguments) called in response to each invocation to rw_runopts() |
| static char argstr [4096]; |
| |
| // the maximum number of callbacks to be invoked by a single call |
| // to rw_runopts() |
| #define MAXCALLBACKS 32 |
| |
| // the values to be returned by each callback |
| static int retvals [MAXCALLBACKS]; |
| |
| // the cumulative number of callback invocations |
| static size_t ncalls; |
| |
| // the exit status of the whole test |
| static int exit_status; |
| |
| // the current line number |
| static int current_line; |
| |
| /**************************************************************************/ |
| |
| // prints its arguments in a human-readable form to buf |
| static int |
| pargs (char *buf, const char *funcname, int argc, char *argv []) |
| { |
| _RWSTD_ASSERT (0 != buf); |
| |
| char* next = buf + strlen (buf); |
| |
| if ('\0' != *buf) { |
| next [0] = ';'; |
| next [1] = '\0'; |
| ++next; |
| } |
| |
| if (funcname) |
| next += sprintf (next, "%s(%d,{", funcname, argc); |
| else |
| next += sprintf (next, "%d,{", argc); |
| |
| for (int i = 0; i < argc; ++i) { |
| |
| if (argv [i]) |
| next += sprintf (next, "\"%s\"", argv [i]); |
| else { |
| strcpy (next, "(null)"); |
| next += strlen (next); |
| } |
| |
| if (i + 1 < argc) { |
| next [0] = ','; |
| next [1] = '\0'; |
| ++next; |
| } |
| } |
| |
| next [0] = '}'; |
| next [1] = ')'; |
| next [2] = '\0'; |
| |
| // verify that the number of calls hasn't exceeded the size |
| // of the array of return values |
| _RWSTD_ASSERT (ncalls < MAXCALLBACKS); |
| |
| return retvals [ncalls]; |
| } |
| |
| /**************************************************************************/ |
| |
| static int |
| callback_imp (const char *cbname, int argc, char *argv[]) |
| { |
| const int status = pargs (argstr, cbname, argc, argv); |
| |
| ++ncalls; |
| |
| return status; |
| } |
| |
| |
| static int |
| foo (int argc, char *argv[]) |
| { |
| return callback_imp ("foo", argc, argv); |
| } |
| |
| |
| static int |
| bar (int argc, char *argv[]) |
| { |
| return callback_imp ("bar", argc, argv); |
| } |
| |
| static int |
| err (int argc, char *argv[]) |
| { |
| return callback_imp ("ERR", argc, argv); |
| } |
| |
| /**************************************************************************/ |
| |
| typedef int (cbfun_t)(int, char*[]); |
| |
| static int opt_counts [4]; |
| |
| // hackery to allow passing int* and cbfun_t* in the same argument |
| static const union { |
| int *pint; |
| cbfun_t *pfun; |
| int ival; |
| } cntptrs [] = { |
| { opt_counts + 0 }, |
| { opt_counts + 1 }, |
| { opt_counts + 2 }, |
| { opt_counts + 3 } |
| }; |
| |
| /**************************************************************************/ |
| |
| static void |
| test_opts (const char *expect, |
| int get_exp, |
| char *argv [], |
| int set_exp, |
| const char *argspec, |
| cbfun_t *f0, |
| cbfun_t *f1 = 0, |
| cbfun_t *f2 = 0, |
| cbfun_t *f3 = 0) |
| { |
| argstr [0] = '\0'; |
| |
| // reset all previously set options |
| rw_setopts (0, 0); |
| |
| // set new options |
| const int set_res = rw_setopts (argspec, f0, f1, f2, f3); |
| |
| if (set_res != set_exp) { |
| |
| // convert function pointers to void pointers |
| // to avoid compiler error and warnings |
| union { |
| cbfun_t *pfun; |
| void *pvoid; |
| } uptr[] = { |
| { f0 }, { f1 }, { f2 }, { f3 } |
| }; |
| |
| fprintf (stderr, |
| "line %d: rw_setopts (\"%s\", %p, %p, %p, %p) == %d, got %d\n", |
| current_line, argspec, |
| uptr [0].pvoid, uptr [1].pvoid, uptr [2].pvoid, uptr [3].pvoid, |
| set_exp, set_res); |
| |
| exit_status = 1; |
| } |
| |
| argstr [0] = '\0'; |
| |
| // compute the value of argc from argv |
| int argc = 0; |
| for (; argv [argc]; ++argc); |
| |
| // reset the number of callback invocations |
| ncalls = 0; |
| |
| // reset the option counters |
| memset (opt_counts, 0, sizeof opt_counts); |
| |
| const int get_res = rw_runopts (argc, argv); |
| |
| if (get_res != get_exp) { |
| |
| static char tmp [4096]; |
| |
| tmp [0] = '\0'; |
| pargs (tmp, 0, argc, argv); |
| |
| fprintf (stderr, |
| "line %d: rw_runopts (%s) == %d, got %d\n", |
| current_line, tmp, get_exp, get_res); |
| |
| exit_status = 1; |
| } |
| |
| if (strchr (expect, '#')) { |
| // when the expected result string contains the pound sign, |
| // treat the arguments as pointers to integers as opposed |
| // to pointers to callback functions and format the actual |
| // result as a sequence of integers at the given addresses |
| |
| if (f0 == cntptrs [0].pfun) { |
| sprintf (argstr + strlen (argstr), |
| "%s%d", *argstr ? "; #" : "#", opt_counts [0]); |
| |
| if (f1 == cntptrs [1].pfun) { |
| sprintf (argstr + strlen (argstr), |
| ",%d", opt_counts [1]); |
| |
| if (f2 == cntptrs [2].pfun) { |
| sprintf (argstr + strlen (argstr), |
| ",%d", opt_counts [2]); |
| |
| if (f3 == cntptrs [3].pfun) { |
| sprintf (argstr + strlen (argstr), |
| ",%d", opt_counts [3]); |
| } |
| } |
| } |
| } |
| } |
| |
| if (strcmp (argstr, expect)) { |
| fprintf (stderr, |
| "line %d: \"%s\" != \"%s\"\n", |
| current_line, argstr, expect); |
| |
| exit_status = 1; |
| } |
| } |
| |
| /**************************************************************************/ |
| |
| static char** |
| mkargv (const char *s0, |
| const char *s1 = 0, |
| const char *s2 = 0, |
| const char *s3 = 0, |
| const char *s4 = 0, |
| const char *s5 = 0, |
| const char *s6 = 0, |
| const char *s7 = 0, |
| const char *s8 = 0, |
| const char *s9 = 0) |
| { |
| static char argbuf [10][1024]; |
| static char* argv [10]; |
| |
| argv [0] = s0 ? strcpy (argbuf [0], s0) : 0; |
| argv [1] = s1 ? strcpy (argbuf [1], s1) : 0; |
| argv [2] = s2 ? strcpy (argbuf [2], s2) : 0; |
| argv [3] = s3 ? strcpy (argbuf [3], s3) : 0; |
| argv [4] = s4 ? strcpy (argbuf [4], s4) : 0; |
| argv [5] = s5 ? strcpy (argbuf [5], s5) : 0; |
| argv [6] = s6 ? strcpy (argbuf [6], s6) : 0; |
| argv [7] = s7 ? strcpy (argbuf [7], s7) : 0; |
| argv [8] = s8 ? strcpy (argbuf [8], s8) : 0; |
| argv [9] = s9 ? strcpy (argbuf [9], s9) : 0; |
| |
| return argv; |
| } |
| |
| /**************************************************************************/ |
| |
| // convenience macros for brevity |
| |
| #define A mkargv |
| #define B bar |
| #define F foo |
| #define E err |
| #define C0 cntptrs [0].pfun |
| #define C1 cntptrs [1].pfun |
| #define C2 cntptrs [2].pfun |
| #define C3 cntptrs [3].pfun |
| #define N(n) make_arg (n) |
| #define T (current_line = __LINE__), test_opts |
| |
| /**************************************************************************/ |
| |
| static void |
| test_unknown_options () |
| { |
| // +--------- expected result string (formatted by callbacks) |
| // | +----- expected value returned from rw_runopts() |
| // | | +-- second argument to rw_runopts() (argv) |
| // | | | |
| // | | | +---------- expected rw_setopts() result |
| // | | | | +------- rw_setopts() first argument |
| // | | | | | +-- rw_setopts() callbacks... |
| // | | | | | | |
| // V V V V V V |
| T ("", 0, A (""), 0, "", 0); |
| |
| // exercise setting up the "unknown option" handler |
| T ("", 0, A (""), 1, "-", 0); |
| T ("", 0, A (""), 1, "-", E); |
| |
| // exercise invoking the "unknown option" handler |
| T ("ERR(1,{\"-x\"})", 0, A ("-x"), 2, "- f", E, F); |
| T ("ERR(2,{\"-x\",\"-y\"});" |
| "foo(1,{\"-y\"})", 0, A ("-x","-y"), 2, "- y", E, F); |
| |
| retvals [0] = 1; |
| T ("ERR(2,{\"-x\",\"-y\"})", 1, A ("-x","-y"), 2, "- y", E, F); |
| |
| retvals [0] = 0; |
| retvals [1] = 2; |
| T ("foo(2,{\"-x\",\"-y\"});" |
| "ERR(1,{\"-y\"})", 2, A ("-x","-y"), 2, "- x", E, F); |
| T ("foo(3,{\"-x\",\"-y\",\"-x\"});" |
| "ERR(2,{\"-y\",\"-x\"})", 2, A ("-x","-y", "-x"), 2, "- x", E, F); |
| retvals [1] = 0; |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_counted_options () |
| { |
| // exercise options with a counter instead of a callback |
| T ("#1", 0, A ("-b"), 1, "b#", C0); |
| T ("#1", 0, A ("--cc"), 1, "|-cc#", C0); |
| T ("#2", 0, A ("-d", "-d"), 1, "d#", C0); |
| T ("#2", 0, A ("-e", "--ee"), 1, "e|-ee#", C0); |
| T ("#3", 0, A ("-e", "-e", "-e"), 1, "e#", C0); |
| T ("#1,2", 0, A ("-f", "-g", "-g"), 2, "f# g#", C0, C1); |
| |
| // exercise counted options with a numerical argument |
| T ("#0", 0, A ("--n=0"), 1, "|-n#", C0); |
| T ("#1", 0, A ("--n=1"), 1, "|-n#", C0); |
| T ("#1", 0, A ("--n=+1"), 1, "|-n#", C0); |
| T ("#-1", 0, A ("--n=-1"), 1, "|-n#", C0); |
| T ("#2", 0, A ("--n=+2"), 1, "|-n#", C0); |
| T ("#-2", 0, A ("--n=-2"), 1, "|-n#", C0); |
| T ("#12345", 0, A ("--n=+12345"), 1, "|-n#", C0); |
| T ("#-12346", 0, A ("--n=-12346"), 1, "|-n#", C0); |
| |
| // exercise counted options with a restricted numerical argument |
| T ("#0", 0, A ("--n=0"), 1, "|-n#0", C0); |
| T ("#1", 0, A ("--n=1"), 1, "|-n#0", C0); |
| T ("#1", 0, A ("--n=1"), 1, "|-n#1", C0); |
| T ("#2", 0, A ("--n=2"), 1, "|-n#1", C0); |
| T ("#1", 0, A ("--n=+1"), 1, "|-n#+1", C0); |
| T ("#-1", 0, A ("--n=-1"), 1, "|-n#-1", C0); |
| T ("#0", 0, A ("--n=0"), 1, "|-n#-1", C0); |
| T ("#1", 0, A ("--n=1"), 1, "|-n#-1", C0); |
| T ("#123", 0, A ("--n=+123"), 1, "|-n#+123", C0); |
| T ("#124", 0, A ("--n=+124"), 1, "|-n#+123", C0); |
| T ("#-125", 0, A ("--n=-125"), 1, "|-n#-125", C0); |
| T ("#-126", 0, A ("--n=-126"), 1, "|-n#-127", C0); |
| |
| T ("#0", 0, A ("--n=0"), 1, "|-n#0-1", C0); |
| T ("#1", 0, A ("--n=1"), 1, "|-n#0-1", C0); |
| |
| T ("#0", 0, A ("--n=0"), 1, "|-n#-1-0", C0); |
| |
| // same as above but with an out of range argument |
| T ("", 1, A ("--n=1"), 1, "|-n#-1-0", C0); |
| T ("", 1, A ("--n=-1"), 1, "|-n#0", C0); |
| T ("", 1, A ("--n=0"), 1, "|-n#1", C0); |
| T ("", 1, A ("--n=1"), 1, "|-n#2", C0); |
| T ("", 1, A ("--n=+2"), 1, "|-n#+3", C0); |
| |
| T ("", 1, A ("--n=-1"), 1, "|-n#0-1", C0); |
| T ("", 1, A ("--n=+2"), 1, "|-n#0-1", C0); |
| T ("", 1, A ("--n=-11"), 1, "|-n#-10--5", C0); |
| T ("", 1, A ("--n=-4"), 1, "|-n#-10--5", C0); |
| T ("", 1, A ("--n=-11"), 1, "|-n#-1-1", C0); |
| T ("", 1, A ("--n=-1"), 1, "|-n#0-32", C0); |
| T ("", 1, A ("--n=33"), 1, "|-n#0-32", C0); |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_tristate () |
| { |
| // +-- expected result string |
| // | +-- expected return value from rw_getopts() |
| // | | +-- command line arguments |
| // | | | +-- number of directives |
| // | | | | +-- cmdopt specification |
| // | | | | | +-- counter |
| // | | | | | | |
| // V V V V V V |
| T ("#1", 0, A ("--enable-foo"), 1, "|-foo~", C0); |
| T ("#1", 0, A ("--use-foo"), 1, "|-foo~", C0); |
| T ("#1", 0, A ("--with-foo"), 1, "|-foo~", C0); |
| T ("#-1", 0, A ("--disable-foo"), 1, "|-foo~", C0); |
| T ("#-1", 0, A ("--no-foo"), 1, "|-foo~", C0); |
| T ("#-1", 0, A ("--without-foo"), 1, "|-foo~", C0); |
| |
| // the same tristate can be repeated any number of times |
| T ("#1", 0, A ("--enable-foo", "--use-foo"), 1, "|-foo~", C0); |
| T ("#-1", 0, A ("--no-foo", "--without-foo"), 1, "|-foo~", C0); |
| |
| // the last tristate wins |
| T ("#-1", 0, A ("--use-foo", "--no-foo"), 1, "|-foo~", C0); |
| T ("#1", 0, A ("--no-foo", "--use-foo"), 1, "|-foo~", C0); |
| |
| ////////////////////////////////////////////////////////////////// |
| |
| // set bits using a bitmap |
| T ("#1", 0, A ("--enable-foo"), 1, "|-foo~:0", C0); |
| T ("#1", 0, A ("--enable-foo"), 1, "|-foo~:1", C0); |
| T ("#2", 0, A ("--enable-foo"), 1, "|-foo~:2", C0); |
| T ("#3", 0, A ("--enable-foo"), 1, "|-foo~:3", C0); |
| T ("#4", 0, A ("--enable-foo"), 1, "|-foo~:4", C0); |
| |
| // unset bits using a bitmap |
| T ("#-2", 0, A ("--disable-foo"), 1, "|-foo~:1", C0); |
| T ("#-3", 0, A ("--disable-foo"), 1, "|-foo~:2", C0); |
| T ("#-4", 0, A ("--disable-foo"), 1, "|-foo~:3", C0); |
| T ("#-5", 0, A ("--disable-foo"), 1, "|-foo~:4", C0); |
| |
| // set bits in word 2 |
| T ("#0,1", 0, A ("--enable-bar"), 1, "|-bar~32:0", C0, C1); |
| T ("#0,1", 0, A ("--enable-bar"), 1, "|-bar~32:1", C0, C1); |
| T ("#0,2", 0, A ("--enable-bar"), 1, "|-bar~32:2", C0, C1); |
| T ("#0,3", 0, A ("--enable-bar"), 1, "|-bar~32:3", C0, C1); |
| T ("#0,4", 0, A ("--enable-bar"), 1, "|-bar~32:4", C0, C1); |
| |
| // enable bits 0 through 4 in C0 one at a time |
| T ("#1", 0, A ("--with-0"), 4, "|-0~0 |-1~1 |-2~2 |-3~3", C0, C0, C0, C0); |
| T ("#2", 0, A ("--with-1"), 4, "|-0~0 |-1~1 |-2~2 |-3~3", C0, C0, C0, C0); |
| T ("#4", 0, A ("--with-2"), 4, "|-0~0 |-1~1 |-2~2 |-3~3", C0, C0, C0, C0); |
| T ("#8", 0, A ("--with-3"), 4, "|-0~0 |-1~1 |-2~2 |-3~3", C0, C0, C0, C0); |
| |
| // enable multiple bits 0 through 4 in C0 simultaneously |
| T ("#3", 0, A ("--with-0", "--with-1"), |
| 4, "|-0~0 |-1~1 |-2~2 |-3~3", C0, C0, C0, C0); |
| |
| T ("#7", 0, A ("--with-0", "--with-1", "--with-2"), |
| 4, "|-0~0 |-1~1 |-2~2 |-3~3", C0, C0, C0, C0); |
| |
| T ("#15", 0, A ("--with-0", "--with-1", "--with-2", "--with-3"), |
| 4, "|-0~0 |-1~1 |-2~2 |-3~3", C0, C0, C0, C0); |
| |
| // specify bit value |
| T ("#1", 0, A ("--with-0"), |
| 4, "|-0~0:1 |-1~1:1 |-2~2:1 |-3~3:1", C0, C0, C0, C0); |
| |
| T ("#2", 0, A ("--with-1"), |
| 4, "|-0~0:1 |-1~1:1 |-2~2:1 |-3~3:1", C0, C0, C0, C0); |
| |
| T ("#4", 0, A ("--with-2"), |
| 4, "|-0~0:1 |-1~1:1 |-2~2:1 |-3~3:1", C0, C0, C0, C0); |
| |
| T ("#8", 0, A ("--with-3"), |
| 4, "|-0~0:1 |-1~1:1 |-2~2:1 |-3~3:1", C0, C0, C0, C0); |
| |
| T ("#3", 0, A ("--with-0", "--with-1"), |
| 4, "|-0~0:1 |-1~1:1 |-2~2:1 |-3~3:1", C0, C0, C0, C0); |
| |
| T ("#7", 0, A ("--with-0", "--with-1", "--with-2"), |
| 4, "|-0~0:1 |-1~1:1 |-2~2:1 |-3~3:1", C0, C0, C0, C0); |
| |
| T ("#15", 0, A ("--with-0", "--with-1", "--with-2", "--with-3"), |
| 4, "|-0~0:1 |-1~1:1 |-2~2:1 |-3~3:1", C0, C0, C0, C0); |
| |
| T ("#-1073741824", |
| 0, A ("--enable-f30"), |
| 3, "|-f30~30:3 |-f28~28:2 |-f26~26:2", C0, C0, C0); |
| |
| T ("#-2147483648", |
| 0, A ("--enable-f30"), |
| 3, "|-f30~30:2 |-f28~28:2 |-f26~26:2", C0, C0, C0); |
| |
| T ("#-1610612736", |
| 0, A ("--enable-f30","--enable-f28"), |
| 3, "|-f30~30:2 |-f28~28:2 |-f26~26:2", C0, C0, C0); |
| |
| T ("#-1476395008", |
| 0, A ("--enable-f30","--enable-f28","--enable-f26"), |
| 3, "|-f30~30:2 |-f28~28:2 |-f26~26:2", C0, C0, C0); |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_optional_argument () |
| { |
| // exercise an option with an optional argument |
| T ("foo(1,{\"-a\"})", 0, A ("-a"), 1, "a:", F); |
| T ("foo(1,{\"-a\"})", 0, A ("-a"), 1, "a:", F); |
| T ("foo(2,{\"-a\",\"x\"})", 0, A ("-a", "x"), 1, "a:", F); |
| T ("foo(1,{\"-ay\"})", 0, A ("-ay"), 1, "a:", F); |
| T ("foo(1,{\"-axyz\"})", 0, A ("-axyz"), 1, "a:", F); |
| T ("foo(1,{\"--a\"})", 0, A ("--a"), 1, "|-a:", F); |
| T ("ERR(1,{\"--ab\"})", 0, A ("--ab"), 2, "- |-a:", E, F); |
| |
| // exercise the processing of two optional command line options |
| T ("foo(2,{\"-a\",\"-b\"});" |
| "bar(1,{\"-b\"})", |
| 0, A ("-a", "-b"), 2, "a: b", F, B); |
| |
| T ("foo(3,{\"-a\",\"x\",\"-b\"});" |
| "bar(1,{\"-b\"})", |
| 0, A ("-a", "x", "-b"), 2, "a: b", F, B); |
| |
| // exercise optional restricted numeric argument |
| T ("foo(2,{\"-n\",\"0\"})", 0, A ("-n", "0"), 1, "n:0", F); |
| T ("foo(2,{\"-n\",\"+1\"})", 0, A ("-n", "+1"), 1, "n:1", F); |
| T ("foo(2,{\"-n\",\"+2\"})", 0, A ("-n", "+2"), 1, "n:+2", F); |
| T ("foo(2,{\"-n\",\"\\-2\"})", 0, A ("-n", "\\-2"), 1, "n:-3", F); |
| T ("foo(2,{\"-n\",\"\\-0\"})", 0, A ("-n", "\\-0"), 1, "n:-3-0", F); |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_required_argument () |
| { |
| // exercise the processing of an option with a required argument |
| |
| // the equals sign missing |
| T ("ERR(1,{\"--a\"})", 0, A ("--a"), 2, "- |-a=", E, F); |
| |
| // required argument empty |
| T ("foo(1,{\"--a=\"})", 0, A ("--a="), 1, "|-a=", F); |
| |
| // required argument contains funky characters |
| T ("foo(1,{\"--a=1\"})", 0, A ("--a=1"), 1, "|-a=", F); |
| T ("foo(1,{\"--b=1-\"})", 0, A ("--b=1-"), 1, "|-b=", F); |
| T ("foo(1,{\"--c=-2\"})", 0, A ("--c=-2"), 1, "|-c=", F); |
| T ("foo(1,{\"--d=1-2\"})", 0, A ("--d=1-2"), 1, "|-d=", F); |
| T ("foo(1,{\"--e=-1=2\"})", 0, A ("--e=-1=2"), 1, "|-e=", F); |
| T ("foo(1,{\"--f=-1=-2\"})", 0, A ("--f=-1=-2"), 1, "|-f=", F); |
| T ("foo(1,{\"--g=2,3\"})", 0, A ("--g=2,3"), 1, "|-g=", F); |
| T ("foo(1,{\"--h=3:4\"})", 0, A ("--h=3:4"), 1, "|-h=", F); |
| T ("foo(1,{\"--i=\"j\"\"})", 0, A ("--i=\"j\""), 1, "|-i=", F); |
| |
| // exercise restricted numeric argument |
| T ("foo(1,{\"--a=1\"})", 0, A ("--a=1"), 1, "|-a=0", F); |
| T ("foo(1,{\"--a=1\"})", 0, A ("--a=1"), 1, "|-a=1", F); |
| T ("foo(1,{\"--a=2\"})", 0, A ("--a=2"), 1, "|-a=2", F); |
| T ("foo(1,{\"--a=3\"})", 0, A ("--a=3"), 1, "|-a=3-4", F); |
| T ("foo(1,{\"--a=5\"})", 0, A ("--a=5"), 1, "|-a=4-5", F); |
| |
| T ("", 1, A ("--a=1"), 1, "|-a=2", F); |
| T ("", 1, A ("--a=2"), 1, "|-a=0-1", F); |
| T ("", 1, A ("--a=-1"), 1, "|-a=1-2", F); |
| T ("", 1, A ("--a=+123"), 1, "|-a=+2-3", F); |
| |
| } |
| |
| /**************************************************************************/ |
| |
| static void |
| test_repeated_options () |
| { |
| // exercise repeated options |
| // only the first occurrence of each command line option |
| // causes an invocation of the callback, all subsequent |
| // ones will be ignored by default |
| T ("foo(2,{\"-a\",\"-a\"})", 0, A ("-a", "-a"), 1, "a", F); |
| |
| // unlimited number of invocations |
| T ("foo(2,{\"-a\",\"-a\"});" |
| "foo(1,{\"-a\"})", |
| 0, A ("-a", "-a"), 1, "a@*", F); |
| |
| // no invocation (option is disabled) |
| T ("", 0, A ("-a"), 1, "a@0", F); |
| T ("", 0, A ("-a", "-a"), 1, "a@0", F); |
| |
| T ("bar(1,{\"-b\"})", 0, A ("-a", "-a", "-b"), 2, "a@0 b", F, B); |
| T ("bar(2,{\"-b\",\"-a\"})", 0, A ("-a", "-b", "-a"), 2, "a@0 b", F, B); |
| |
| T ("bar(3,{\"-b\",\"-a\",\"-b\"})", |
| 0, A ("-b", "-a", "-b"), 2, "b a@0", B, F); |
| |
| T ("bar(4,{\"-b\",\"-a\",\"-b\",\"-a\"})", |
| 0, A ("-b", "-a", "-b", "-a"), 2, "b a@0", B, F); |
| |
| // at most one invocation (default) |
| T ("foo(2,{\"-a\",\"-a\"})", 0, A ("-a", "-a"), 1, "a@1", F); |
| T ("foo(2,{\"-a\",\"-a\"})", 0, A ("-a", "-a"), 1, "a@1", F); |
| |
| // at most two invocations |
| T ("foo(2,{\"-a\",\"-a\"});" |
| "foo(1,{\"-a\"})", |
| 0, A ("-a", "-a"), 1, "a@2", F); |
| |
| T ("foo(3,{\"-a\",\"-a\",\"-a\"});" |
| "foo(2,{\"-a\",\"-a\"})", |
| 0, A ("-a", "-a", "-a"), 1, "a@2", F); |
| |
| // inverted option (callback invoked iff option is not specified) |
| T ("", 0, A ("-i"), 1, "i!", F); |
| T ("foo(0,{})", 0, A (""), 1, "i!", F); |
| T ("", 0, A ("--j"), 1, "i|-j!", F); |
| |
| T ("foo(1,{\"-k\"});" |
| "foo(0,{})", 0, A ("-k"), 2, "k l!", F, F); |
| } |
| |
| /**************************************************************************/ |
| |
| int main () |
| { |
| // +--------- expected result string (formatted by callbacks) |
| // | +----- expected value returned from rw_runopts() |
| // | | +-- second argument to rw_runopts() (argv) |
| // | | | |
| // | | | +---------- expected rw_setopts() result |
| // | | | | +------- rw_setopts() first argument |
| // | | | | | +-- rw_setopts() callbacks... |
| // | | | | | | |
| // V V V V V V |
| T ("", 0, A (""), 0, "", 0); |
| T ("", 0, A ("a"), 0, "", 0); |
| T ("", 0, A ("a", "b"), 0, "", 0); |
| T ("", 0, A ("a", "b"), 0, "", 0); |
| |
| T ("", 0, A (""), 1, "f", F); |
| T ("", 0, A ("a"), 1, "f", F); |
| T ("", 0, A ("a", "b"), 1, "f", F); |
| T ("", 0, A ("a", "b"), 1, "f", F); |
| T ("", 0, A ("a", "f"), 1, "f", F); |
| T ("", 0, A ("f", "f"), 1, "f", F); |
| |
| // exercise short and/or long options |
| T ("foo(1,{\"-a\"})", 0, A ("-a"), 1, "a", F); |
| T ("foo(1,{\"--a\"})", 0, A ("--a"), 1, "|-a", F); |
| T ("foo(1,{\"-a\"})", 0, A ("-a"), 1, "a|-a", F); |
| T ("foo(1,{\"--a\"})", 0, A ("--a"), 1, "a|-a", F); |
| |
| // exercise the handling of unknown options |
| test_unknown_options (); |
| |
| // exercise the handling of options with a counter |
| // instead of a callback handler |
| test_counted_options (); |
| |
| // exercise the handling of options with an optional argument |
| test_optional_argument (); |
| |
| // exercise the handling of tristate options |
| test_tristate (); |
| |
| // exercise the handling of options with a required argument |
| test_required_argument (); |
| |
| // exercise the handling of repeated occurrences of the same option |
| test_repeated_options (); |
| |
| // exercise callback errors |
| retvals [0] = 1; |
| T ("foo(2,{\"-a\",\"-b\"})", |
| retvals [0], A ("-a", "-b"), 2, "a b", F, B); |
| |
| retvals [0] = 0; |
| retvals [1] = 2; |
| |
| T ("foo(3,{\"-a\",\"-b\",\"-c\"});" |
| "bar(2,{\"-b\",\"-c\"})", |
| retvals [1], A ("-a", "-b", "-c"), 3, "a b c", F, B, E); |
| |
| retvals [1] = 0; |
| |
| return exit_status; |
| } |
