X-Git-Url: http://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=test%2Ftest_tparm.c;h=01fadfee714f4c5bc9943a5c13fff36792f8217e;hp=40ffc4fb1d07f0916a46110c39cd4efe98d0908a;hb=21b36e89c00f2188954d680bf9fea60328b4538c;hpb=3934889cc6b0f45cf218c88df7f35634d250c9e5;ds=sidebyside diff --git a/test/test_tparm.c b/test/test_tparm.c index 40ffc4fb..01fadfee 100644 --- a/test/test_tparm.c +++ b/test/test_tparm.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright 2020 Thomas E. Dickey * + * Copyright 2020,2021 Thomas E. Dickey * * * * Permission is hereby granted, free of charge, to any person obtaining a * * copy of this software and associated documentation files (the * @@ -29,7 +29,7 @@ /* * Author: Thomas E. Dickey * - * $Id: test_tparm.c,v 1.4 2020/05/31 00:51:32 tom Exp $ + * $Id: test_tparm.c,v 1.17 2021/03/06 23:39:14 tom Exp $ * * Exercise tparm, either for all possible capabilities with fixed parameters, * or one capability with all possible parameters. @@ -53,8 +53,35 @@ failed(const char *msg) #if HAVE_TIGETSTR static int a_opt; +static int p_opt; static int v_opt; +/* + * Total tests (and failures): + */ +static long total_tests; +static long total_fails; + +/* + * Total characters formatted for tputs: + */ +static long total_nulls; +static long total_ctrls; +static long total_print; + +static int +output_func(int ch) +{ + if (ch == 0) { + total_nulls++; + } else if (ch < 32 || (ch >= 127 && ch < 160)) { + total_ctrls++; + } else { + total_print++; + } + return ch; +} + static int isNumeric(char *source) { @@ -65,21 +92,30 @@ isNumeric(char *source) return result; } -static char * -validate(const char *name) +static int +relevant(const char *name, const char *value) { - char *value = tigetstr(name); - if (!VALID_STRING(value)) { - if (v_opt > 1) { + int code = 1; + if (VALID_STRING(value)) { + if (strstr(value, "%p") == 0 + && strstr(value, "%d") == 0 + && strstr(value, "%s") == 0 + && (!p_opt || strstr(value, "$<") == 0)) { + if (v_opt > 2) + printf("? %s noparams\n", name); + code = 0; + } + } else { + if (v_opt > 2) { printf("? %s %s\n", (value == ABSENT_STRING) ? "absent" : "cancel", name); } - value = 0; + code = 0; } - return value; + return code; } static int @@ -108,34 +144,37 @@ increment(int *all_parms, int *num_parms, int len_parms, int end_parms) } static void -test_tparm(const char *name, int *number) +test_tparm(const char *name, const char *format, int *number) { - char *format = tigetstr(name); - if ((format = validate(name)) != 0) { - char *result = tparm(format, - number[0], - number[1], - number[2], - number[3], - number[4], - number[5], - number[6], - number[7], - number[8]); - if (v_opt > 1) - printf(".. %2d = %2d %2d %2d %2d %2d %2d %2d %2d %2d %s\n", - result != 0 ? (int) strlen(result) : -1, - number[0], - number[1], - number[2], - number[3], - number[4], - number[5], - number[6], - number[7], - number[8], - name); + char *result = tparm(format, + number[0], + number[1], + number[2], + number[3], + number[4], + number[5], + number[6], + number[7], + number[8]); + total_tests++; + if (result != NULL) { + tputs(result, 1, output_func); + } else { + total_fails++; } + if (v_opt > 1) + printf(".. %2d = %2d %2d %2d %2d %2d %2d %2d %2d %2d %s\n", + result != 0 ? (int) strlen(result) : -1, + number[0], + number[1], + number[2], + number[3], + number[4], + number[5], + number[6], + number[7], + number[8], + name); } static void @@ -145,12 +184,14 @@ usage(void) { "Usage: test_tparm [options] [capability] [value1 [value2 [...]]]", "", - "Print all distinct combinations of given capability.", + "Use tparm/tputs for all distinct combinations of given capability.", "", "Options:", " -T TERM override $TERM; this may be a comma-separated list or \"-\"", " to read a list from standard-input", - " -a if capability is given, test all combinations of values", + " -a test all combinations of parameters", + " [value1...] forms a vector of maximum parameter-values.", + " -p test capabilities with no parameters but having padding", " -r NUM repeat tests NUM times", " -v show values and results", }; @@ -164,6 +205,8 @@ usage(void) #define PLURAL(n) n, (n != 1) ? "s" : "" #define COLONS(n) (n >= 1) ? ":" : "" +#define NUMFORM "%10ld" + int main(int argc, char *argv[]) { @@ -172,22 +215,31 @@ main(int argc, char *argv[]) char *old_term = getenv("TERM"); int r_opt = 1; char *t_opt = 0; - int len_names = 0; /* cur # of items in all_names[] */ - int use_names = 10; /* max # of items in all_names[] */ - char **all_names = typeCalloc(char *, use_names); + + int len_caps = 0; /* cur # of items in all_caps[] */ + int max_caps = 10; /* max # of items in all_caps[] */ + char **all_caps = typeCalloc(char *, max_caps); + int all_parms[10]; /* workspace for "-a" option */ + int len_terms = 0; /* cur # of items in all_terms[] */ - int use_terms = 10; /* max # of items in all_terms[] */ - char **all_terms = typeCalloc(char *, use_terms); + int max_terms = 10; /* max # of items in all_terms[] */ + char **all_terms = typeCalloc(char *, max_terms); + + int use_caps; + char **cap_name; + char **cap_data; + int len_parms = 0; /* cur # of items in num_parms[], str_parms[] */ - int use_parms = argc + 10; /* max # of items in num_parms[], str_parms[] */ - int *num_parms = typeCalloc(int, use_parms); - char **str_parms = typeCalloc(char *, use_parms); + int max_parms = argc + 10; /* max # of items in num_parms[], str_parms[] */ + int *num_parms = typeCalloc(int, max_parms); + char **str_parms = typeCalloc(char *, max_parms); + long use_parms = 1; - if (all_names == 0 || all_terms == 0 || num_parms == 0 || str_parms == 0) + if (all_caps == 0 || all_terms == 0 || num_parms == 0 || str_parms == 0) failed("no memory"); - while ((n = getopt(argc, argv, "T:ar:v")) != -1) { + while ((n = getopt(argc, argv, "T:apr:v")) != -1) { switch (n) { case 'T': t_opt = optarg; @@ -195,6 +247,9 @@ main(int argc, char *argv[]) case 'a': ++a_opt; break; + case 'p': + ++p_opt; + break; case 'r': r_opt = atoi(optarg); break; @@ -213,14 +268,14 @@ main(int argc, char *argv[]) */ if (optind < argc) { if (!isNumeric(argv[optind])) { - all_names[len_names++] = strdup(argv[optind++]); + all_caps[len_caps++] = strdup(argv[optind++]); } } /* * Any remaining arguments must be possible parameter values. If numeric, - * and "-a" is not set, use those as the maximum values within which the - * test parameters should vary. + * and "-a" is not set, use those as the actual values for which the + * capabilities are tested. */ while (optind < argc) { if (isNumeric(argv[optind])) { @@ -232,14 +287,16 @@ main(int argc, char *argv[]) ++optind; ++len_parms; } - for (n = len_parms; n < use_parms; ++n) { + for (n = len_parms; n < max_parms; ++n) { static char dummy[1]; str_parms[n] = dummy; } if (v_opt) { printf("%d parameter%s%s\n", PLURAL(len_parms), COLONS(len_parms)); - for (n = 0; n < len_parms; ++n) { - printf(" %d: %d (%s)\n", n + 1, num_parms[n], str_parms[n]); + if (v_opt > 3) { + for (n = 0; n < len_parms; ++n) { + printf(" %d: %d (%s)\n", n + 1, num_parms[n], str_parms[n]); + } } } @@ -260,9 +317,9 @@ main(int argc, char *argv[]) while (t != s && isspace(UChar(t[-1]))) *--t = '\0'; s = strdup(s); - if (len_terms + 2 >= use_terms) { - use_terms *= 2; - all_terms = typeRealloc(char *, use_terms, all_terms); + if (len_terms + 2 >= max_terms) { + max_terms *= 2; + all_terms = typeRealloc(char *, max_terms, all_terms); if (all_terms == 0) failed("no memory: all_terms"); } @@ -273,9 +330,9 @@ main(int argc, char *argv[]) char *t; while ((t = strtok(s, ",")) != 0) { s = 0; - if (len_terms + 2 >= use_terms) { - use_terms *= 2; - all_terms = typeRealloc(char *, use_terms, all_terms); + if (len_terms + 2 >= max_terms) { + max_terms *= 2; + all_terms = typeRealloc(char *, max_terms, all_terms); if (all_terms == 0) failed("no memory: all_terms"); } @@ -288,8 +345,10 @@ main(int argc, char *argv[]) all_terms[len_terms] = 0; if (v_opt) { printf("%d term%s:\n", PLURAL(len_terms)); - for (n = 0; n < len_terms; ++n) { - printf(" %d: %s\n", n + 1, all_terms[n]); + if (v_opt > 3) { + for (n = 0; n < len_terms; ++n) { + printf(" %d: %s\n", n + 1, all_terms[n]); + } } } @@ -300,34 +359,45 @@ main(int argc, char *argv[]) * TODO: To address the "other" systems which do not follow SVr4, * just use the output from infocmp on $TERM. */ - if (len_names == 0) { + if (len_caps == 0) { #if defined(HAVE_CURSES_DATA_BOOLNAMES) || defined(DECL_CURSES_DATA_BOOLNAMES) for (n = 0; strnames[n] != 0; ++n) { - if (len_names + 2 >= use_names) { - use_names *= 2; - all_names = typeRealloc(char *, use_names, all_names); - if (all_names == 0) { - failed("no memory: all_names"); + if (len_caps + 2 >= max_caps) { + max_caps *= 2; + all_caps = typeRealloc(char *, max_caps, all_caps); + if (all_caps == 0) { + failed("no memory: all_caps"); } } - all_names[len_names++] = strdup(strnames[n]); + all_caps[len_caps++] = strdup(strnames[n]); } #else - all_names[len_names++] = strdup("cup"); - all_names[len_names++] = strdup("sgr"); + all_caps[len_caps++] = strdup("cup"); + all_caps[len_caps++] = strdup("sgr"); #endif } - all_names[len_names] = 0; + all_caps[len_caps] = 0; if (v_opt) { - printf("%d name%s%s\n", PLURAL(len_names), COLONS(len_names)); - for (n = 0; n < len_names; ++n) { - printf(" %d: %s\n", n + 1, all_names[n]); + printf("%d name%s%s\n", PLURAL(len_caps), COLONS(len_caps)); + if (v_opt > 3) { + for (n = 0; n < len_caps; ++n) { + printf(" %d: %s\n", n + 1, all_caps[n]); + } } } + cap_name = typeMalloc(char *, len_caps); + cap_data = typeMalloc(char *, len_caps); + if (r_opt <= 0) r_opt = 1; + if (a_opt) { + for (n = 0; n < use_parms; ++n) + if (num_parms[n]) + use_parms *= (num_parms[n] + 1); + } + for (r_run = 0; r_run < r_opt; ++r_run) { for (t_run = 0; t_run < len_terms; ++t_run) { int errs; @@ -336,23 +406,42 @@ main(int argc, char *argv[]) printf("** skipping %s (errs:%d)\n", all_terms[t_run], errs); } - if (v_opt) - printf("** testing %s\n", all_terms[t_run]); - if (len_names == 1) { - if (a_opt) { - /* for each combination of values */ - memset(all_parms, 0, sizeof(all_parms)); - do { - test_tparm(all_names[0], all_parms); + /* + * Most of the capabilities have no parameters, e.g., they are + * function-keys or simple operations such as clear-display. + * Ignore those, since they do not really exercise tparm. + */ + use_caps = 0; + for (n = 0; n < len_caps; ++n) { + char *value = tigetstr(all_caps[n]); + if (relevant(all_caps[n], value)) { + cap_name[use_caps] = all_caps[n]; + cap_data[use_caps] = value; + use_caps++; + } + } + + if (v_opt) { + printf("[%d:%d] %d cap%s * %ld param%s \"%s\"\n", + r_run + 1, r_opt, + PLURAL(use_caps), + PLURAL(use_parms), + all_terms[t_run]); + } + + if (a_opt) { + /* for each combination of values */ + memset(all_parms, 0, sizeof(all_parms)); + do { + for (n_run = 0; n_run < use_caps; ++n_run) { + test_tparm(cap_name[n_run], cap_data[n_run], all_parms); } - while (increment(all_parms, num_parms, len_parms, 0)); - } else { - /* for the given values */ - test_tparm(all_names[0], num_parms); } + while (increment(all_parms, num_parms, len_parms, 0)); } else { - for (n_run = 0; n_run < len_names; ++n_run) { - test_tparm(all_names[n_run], num_parms); + /* for the given values */ + for (n_run = 0; n_run < use_caps; ++n_run) { + test_tparm(cap_name[n_run], cap_data[n_run], all_parms); } } if (cur_term != 0) { @@ -362,11 +451,21 @@ main(int argc, char *argv[]) } } } + + printf("Tests:\n"); + printf(NUMFORM " total\n", total_tests); + if (total_fails) + printf(NUMFORM " failed\n", total_fails); + printf("Characters:\n"); + printf(NUMFORM " nulls\n", total_nulls); + printf(NUMFORM " controls\n", total_ctrls); + printf(NUMFORM " printable\n", total_print); + printf(NUMFORM " total\n", total_nulls + total_ctrls + total_print); #if NO_LEAKS - for (n = 0; n < len_names; ++n) { - free(all_names[n]); + for (n = 0; n < len_caps; ++n) { + free(all_caps[n]); } - free(all_names); + free(all_caps); free(old_term); for (n = 0; n < len_terms; ++n) { free(all_terms[n]); @@ -374,6 +473,8 @@ main(int argc, char *argv[]) free(all_terms); free(num_parms); free(str_parms); + free(cap_name); + free(cap_data); #endif ExitProgram(EXIT_SUCCESS);