/****************************************************************************
- * 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 *
/*
* 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.19 2021/03/13 17:18:28 tom Exp $
*
* Exercise tparm, either for all possible capabilities with fixed parameters,
* or one capability with all possible parameters.
#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)
{
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
}
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
{
"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",
};
#define PLURAL(n) n, (n != 1) ? "s" : ""
#define COLONS(n) (n >= 1) ? ":" : ""
+#define NUMFORM "%10ld"
+
int
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;
case 'a':
++a_opt;
break;
+ case 'p':
+ ++p_opt;
+ break;
case 'r':
r_opt = atoi(optarg);
break;
*/
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])) {
++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]);
+ }
}
}
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");
}
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");
}
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]);
+ }
}
}
* 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 < 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;
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]);
+ }
+
+ 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 */
- 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) {
}
}
}
+
+ 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]);
free(all_terms);
free(num_parms);
free(str_parms);
+ free(cap_name);
+ free(cap_data);
#endif
ExitProgram(EXIT_SUCCESS);