| /**************************************************************************** |
| * Copyright 2020-2021,2022 Thomas E. Dickey * |
| * * |
| * Permission is hereby granted, free of charge, to any person obtaining a * |
| * copy of this software and associated documentation files (the * |
| * "Software"), to deal in the Software without restriction, including * |
| * without limitation the rights to use, copy, modify, merge, publish, * |
| * distribute, distribute with modifications, sublicense, and/or sell * |
| * copies of the Software, and to permit persons to whom the Software is * |
| * furnished to do so, subject to the following conditions: * |
| * * |
| * The above copyright notice and this permission notice shall be included * |
| * in all copies or substantial portions of the Software. * |
| * * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * |
| * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * |
| * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * |
| * * |
| * Except as contained in this notice, the name(s) of the above copyright * |
| * holders shall not be used in advertising or otherwise to promote the * |
| * sale, use or other dealings in this Software without prior written * |
| * authorization. * |
| ****************************************************************************/ |
| |
| /* |
| * Author: Thomas E. Dickey |
| * |
| * $Id: test_tparm.c,v 1.24 2022/12/10 23:23:27 tom Exp $ |
| * |
| * Exercise tparm, either for all possible capabilities with fixed parameters, |
| * or one capability with all possible parameters. |
| * |
| * TODO: incorporate tic.h and _nc_tparm_analyze |
| * TODO: optionally test tiparm |
| * TODO: add checks/logic to handle "%s" in tparm |
| */ |
| #define USE_TINFO |
| #include <test.priv.h> |
| |
| static GCC_NORETURN void failed(const char *); |
| |
| static void |
| failed(const char *msg) |
| { |
| fprintf(stderr, "%s\n", msg); |
| ExitProgram(EXIT_FAILURE); |
| } |
| |
| #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) |
| { |
| char *next = 0; |
| long value = strtol(source, &next, 0); |
| int result = (next == 0 || next == source || *next != '\0') ? 0 : 1; |
| (void) value; |
| return result; |
| } |
| |
| static int |
| relevant(const char *name, const char *value) |
| { |
| 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); |
| } |
| code = 0; |
| } |
| return code; |
| } |
| |
| static int |
| increment(int *all_parms, int *num_parms, int len_parms, int end_parms) |
| { |
| int rc = 0; |
| int n; |
| |
| if (len_parms > 9) |
| len_parms = 9; |
| |
| if (end_parms < len_parms) { |
| if (all_parms[end_parms]++ >= num_parms[end_parms]) { |
| all_parms[end_parms] = 0; |
| increment(all_parms, num_parms, len_parms, end_parms + 1); |
| } |
| } |
| for (n = 0; n < len_parms; ++n) { |
| if (all_parms[n] != 0) { |
| rc = 1; |
| break; |
| } |
| } |
| /* return 1 until the vector resets to all 0's */ |
| return rc; |
| } |
| |
| static void |
| test_tparm(const char *name, const char *format, int *number) |
| { |
| 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 |
| usage(int ok) |
| { |
| static const char *msg[] = |
| { |
| "Usage: test_tparm [options] [capability] [value1 [value2 [...]]]" |
| ,"" |
| ,"Use tparm/tputs for all distinct combinations of given capability." |
| ,"" |
| ,USAGE_COMMON |
| ,"Options:" |
| ," -T TERM override $TERM; this may be a comma-separated list or \"-\"" |
| ," to read a list from standard-input" |
| ," -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" |
| }; |
| unsigned n; |
| for (n = 0; n < SIZEOF(msg); ++n) { |
| fprintf(stderr, "%s\n", msg[n]); |
| } |
| ExitProgram(ok ? EXIT_SUCCESS : EXIT_FAILURE); |
| } |
| |
| #define PLURAL(n) n, (n != 1) ? "s" : "" |
| #define COLONS(n) (n >= 1) ? ":" : "" |
| |
| #define NUMFORM "%10ld" |
| /* *INDENT-OFF* */ |
| VERSION_COMMON() |
| /* *INDENT-ON* */ |
| |
| int |
| main(int argc, char *argv[]) |
| { |
| int ch; |
| int n; |
| int r_run, t_run, n_run; |
| char *old_term = getenv("TERM"); |
| int r_opt = 1; |
| char *t_opt = 0; |
| |
| 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 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 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_caps == 0 || all_terms == 0 || num_parms == 0 || str_parms == 0) |
| failed("no memory"); |
| |
| while ((ch = getopt(argc, argv, OPTS_COMMON "T:apr:v")) != -1) { |
| switch (ch) { |
| case 'T': |
| t_opt = optarg; |
| break; |
| case 'a': |
| ++a_opt; |
| break; |
| case 'p': |
| ++p_opt; |
| break; |
| case 'r': |
| r_opt = atoi(optarg); |
| break; |
| case 'v': |
| ++v_opt; |
| break; |
| case OPTS_VERSION: |
| show_version(argv); |
| ExitProgram(EXIT_SUCCESS); |
| default: |
| usage(ch == OPTS_USAGE); |
| /* NOTREACHED */ |
| } |
| } |
| |
| /* |
| * If there is a nonnumeric parameter after the options, use that as the |
| * capability name. |
| */ |
| if (optind < argc) { |
| if (!isNumeric(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 actual values for which the |
| * capabilities are tested. |
| */ |
| while (optind < argc) { |
| if (isNumeric(argv[optind])) { |
| char *dummy = 0; |
| long value = strtol(argv[optind], &dummy, 0); |
| num_parms[len_parms] = (int) value; |
| } |
| str_parms[len_parms] = argv[optind]; |
| ++optind; |
| ++len_parms; |
| } |
| 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)); |
| if (v_opt > 3) { |
| for (n = 0; n < len_parms; ++n) { |
| printf(" %d: %d (%s)\n", n + 1, num_parms[n], str_parms[n]); |
| } |
| } |
| } |
| |
| /* |
| * Make a list of values for $TERM. Accept "-" for standard input to |
| * simplify scripting a check of the whole database. |
| */ |
| old_term = strdup((old_term == 0) ? "unknown" : old_term); |
| if (t_opt != 0) { |
| if (!strcmp(t_opt, "-")) { |
| char buffer[BUFSIZ]; |
| while (fgets(buffer, sizeof(buffer) - 1, stdin) != 0) { |
| char *s = buffer; |
| char *t; |
| while (isspace(UChar(s[0]))) |
| ++s; |
| t = s + strlen(s); |
| while (t != s && isspace(UChar(t[-1]))) |
| *--t = '\0'; |
| s = strdup(s); |
| 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"); |
| } |
| all_terms[len_terms++] = s; |
| } |
| } else { |
| char *s = t_opt; |
| char *t; |
| while ((t = strtok(s, ",")) != 0) { |
| s = 0; |
| 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"); |
| } |
| all_terms[len_terms++] = strdup(t); |
| } |
| } |
| } else { |
| all_terms[len_terms++] = strdup(old_term); |
| } |
| all_terms[len_terms] = 0; |
| if (v_opt) { |
| printf("%d term%s:\n", PLURAL(len_terms)); |
| if (v_opt > 3) { |
| for (n = 0; n < len_terms; ++n) { |
| printf(" %d: %s\n", n + 1, all_terms[n]); |
| } |
| } |
| } |
| |
| /* |
| * If no capability name was selected, use the predefined list of string |
| * capabilities. |
| * |
| * TODO: To address the "other" systems which do not follow SVr4, |
| * just use the output from infocmp on $TERM. |
| */ |
| if (len_caps == 0) { |
| #if defined(HAVE_CURSES_DATA_BOOLNAMES) || defined(DECL_CURSES_DATA_BOOLNAMES) |
| for (n = 0; strnames[n] != 0; ++n) { |
| 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_caps[len_caps++] = strdup(strnames[n]); |
| } |
| #else |
| all_caps[len_caps++] = strdup("cup"); |
| all_caps[len_caps++] = strdup("sgr"); |
| #endif |
| } |
| all_caps[len_caps] = 0; |
| if (v_opt) { |
| 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 < max_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; |
| |
| if (setupterm(all_terms[t_run], fileno(stdout), &errs) != OK) { |
| printf("** skipping %s (errs:%d)\n", all_terms[t_run], errs); |
| } |
| |
| /* |
| * 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]); |
| } |
| |
| memset(all_parms, 0, sizeof(all_parms)); |
| if (a_opt) { |
| /* for each combination of values */ |
| 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 */ |
| 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) { |
| del_curterm(cur_term); |
| } else { |
| printf("? no cur_term\n"); |
| } |
| } |
| } |
| |
| 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_caps; ++n) { |
| free(all_caps[n]); |
| } |
| free(all_caps); |
| free(old_term); |
| for (n = 0; n < len_terms; ++n) { |
| free(all_terms[n]); |
| } |
| free(all_terms); |
| free(num_parms); |
| free(str_parms); |
| free(cap_name); |
| free(cap_data); |
| #endif |
| |
| ExitProgram(EXIT_SUCCESS); |
| } |
| |
| #else /* !HAVE_TIGETSTR */ |
| int |
| main(void) |
| { |
| failed("This program requires the terminfo functions such as tigetstr"); |
| } |
| #endif /* HAVE_TIGETSTR */ |