test/pair_content.c

   1 /****************************************************************************
   2  * Copyright 2018-2019,2020 Thomas E. Dickey                                *
   3  *                                                                          *
   4  * Permission is hereby granted, free of charge, to any person obtaining a  *
   5  * copy of this software and associated documentation files (the            *
   6  * "Software"), to deal in the Software without restriction, including      *
   7  * without limitation the rights to use, copy, modify, merge, publish,      *
   8  * distribute, distribute with modifications, sublicense, and/or sell       *
   9  * copies of the Software, and to permit persons to whom the Software is    *
  10  * furnished to do so, subject to the following conditions:                 *
  11  *                                                                          *
  12  * The above copyright notice and this permission notice shall be included  *
  13  * in all copies or substantial portions of the Software.                   *
  14  *                                                                          *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22  *                                                                          *
  23  * Except as contained in this notice, the name(s) of the above copyright   *
  24  * holders shall not be used in advertising or otherwise to promote the     *
  25  * sale, use or other dealings in this Software without prior written       *
  26  * authorization.                                                           *
  27  ****************************************************************************/
  28 /*
  29  * $Id: pair_content.c,v 1.14 2020/02/02 23:34:34 tom Exp $
  30  */
  31
  32 #define NEED_TIME_H
  33 #include <test.priv.h>
  34
  35 #if USE_EXTENDED_COLOR
  36 typedef int my_color_t;
  37 #else
  38 typedef NCURSES_COLOR_T my_color_t;
  39 #endif
  40
  41 typedef struct {
  42     my_color_t fg;
  43     my_color_t bg;
  44 } MYPAIR;
  45
  46 static int f_opt;
  47 static int i_opt;
  48 static int l_opt;
  49 static int n_opt;
  50 static int p_opt;
  51 static int r_opt;
  52 static int s_opt;
  53
  54 #if USE_EXTENDED_COLOR
  55 static int x_opt;
  56 #endif
  57
  58 static MYPAIR *expected;
  59
  60 #if HAVE_GETTIMEOFDAY
  61 static struct timeval initial_time;
  62 static struct timeval finish_time;
  63 #endif
  64
  65 static void
  66 failed(const char *msg)
  67 {
  68     printw("%s", msg);
  69     getch();
  70     endwin();
  71     ExitProgram(EXIT_FAILURE);
  72 }
  73
  74 #if USE_EXTENDED_COLOR
  75 static int
  76 InitPair(int pair, int fg, int bg)
  77 {
  78     int rc;
  79     if (x_opt) {
  80         rc = init_extended_pair(pair, fg, bg);
  81     } else {
  82         rc = init_pair((NCURSES_PAIRS_T) pair,
  83                        (NCURSES_COLOR_T) fg,
  84                        (NCURSES_COLOR_T) bg);
  85     }
  86     return rc;
  87 }
  88
  89 static int
  90 PairContent(int pair, int *fgp, int *bgp)
  91 {
  92     int rc;
  93     if (x_opt) {
  94         rc = extended_pair_content(pair, fgp, bgp);
  95     } else {
  96         short fg, bg;
  97         if ((rc = pair_content((short) pair, &fg, &bg)) == OK) {
  98             *fgp = fg;
  99             *bgp = bg;
 100         }
 101     }
 102     return rc;
 103 }
 104 #else
 105 #define InitPair(pair,fg,bg)      init_pair((NCURSES_COLOR_T)pair,(NCURSES_COLOR_T)fg,(NCURSES_COLOR_T)bg)
 106 #define PairContent(pair,fgp,bgp) pair_content((NCURSES_PAIRS_T)pair,fgp,bgp)
 107 #endif
 108
 109 static my_color_t
 110 random_color(void)
 111 {
 112     return (my_color_t) (rand() % COLORS);
 113 }
 114
 115 static void
 116 setup_test(void)
 117 {
 118     initscr();
 119     cbreak();
 120     noecho();
 121     scrollok(stdscr, TRUE);
 122     if (has_colors()) {
 123         start_color();
 124
 125         if (!f_opt)
 126             f_opt = 1;
 127         if (!l_opt)
 128             l_opt = COLOR_PAIRS;
 129         if (l_opt <= 1)
 130             failed("color-pair limit must be greater than one");
 131
 132         if (!n_opt) {
 133             int pair;
 134             size_t need = (size_t) ((l_opt > COLOR_PAIRS)
 135                                     ? l_opt
 136                                     : COLOR_PAIRS) + 1;
 137
 138             expected = typeCalloc(MYPAIR, need);
 139             if (s_opt) {
 140                 my_color_t fg;
 141                 my_color_t bg;
 142                 pair = f_opt;
 143                 for (fg = 0; fg < COLORS; ++fg) {
 144                     for (bg = 0; bg < COLORS; ++bg) {
 145                         if (pair < l_opt) {
 146                             InitPair(pair, fg, bg);
 147                             expected[pair].fg = (my_color_t) fg;
 148                             expected[pair].bg = (my_color_t) bg;
 149                             ++pair;
 150                         } else {
 151                             break;
 152                         }
 153                     }
 154                 }
 155             } else {
 156                 for (pair = f_opt; pair < l_opt; ++pair) {
 157                     expected[pair].fg = random_color();
 158                     expected[pair].bg = random_color();
 159                     InitPair(pair, expected[pair].fg, expected[pair].bg);
 160                 }
 161             }
 162         }
 163     } else {
 164         failed("This demo requires a color terminal");
 165     }
 166 #if HAVE_GETTIMEOFDAY
 167     gettimeofday(&initial_time, 0);
 168 #endif
 169 }
 170
 171 static void
 172 run_test(void)
 173 {
 174     int pair;
 175     bool success = TRUE;
 176     for (pair = 1; pair < l_opt; ++pair) {
 177         my_color_t fg;
 178         my_color_t bg;
 179         if (PairContent(pair, &fg, &bg) == OK) {
 180             if (expected != 0) {
 181                 if (fg != expected[pair].fg)
 182                     success = FALSE;
 183                 if (bg != expected[pair].bg)
 184                     success = FALSE;
 185             }
 186         }
 187     }
 188     if (i_opt) {
 189         addch(success ? '.' : '?');
 190         refresh();
 191     }
 192 }
 193
 194 static void
 195 finish_test(void)
 196 {
 197     getch();
 198     endwin();
 199 }
 200
 201 #if HAVE_GETTIMEOFDAY
 202 static double
 203 seconds(struct timeval *mark)
 204 {
 205     double result = (double) mark->tv_sec;
 206     result += ((double) mark->tv_usec / 1e6);
 207     return result;
 208 }
 209 #endif
 210
 211 static void
 212 usage(void)
 213 {
 214     static const char *msg[] =
 215     {
 216         "Usage: pair_content [options]"
 217         ,""
 218         ,"Options:"
 219         ," -f PAIR  first color pair to test (default: 1)"
 220         ," -i       interactive, showing test-progress"
 221         ," -l PAIR  last color pair to test (default: max_pairs-1)"
 222         ," -n       do not initialize color pairs"
 223         ," -p       print data for color pairs instead of testing"
 224         ," -r COUNT repeat for given count"
 225         ," -s       initialize pairs sequentially rather than random"
 226 #if USE_EXTENDED_COLOR
 227         ," -x       use extended color pairs/values"
 228 #endif
 229     };
 230     size_t n;
 231     for (n = 0; n < SIZEOF(msg); n++)
 232         fprintf(stderr, "%s\n", msg[n]);
 233     ExitProgram(EXIT_FAILURE);
 234 }
 235
 236 int
 237 main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
 238 {
 239     int i;
 240
 241     while ((i = getopt(argc, argv, "f:il:npr:sx")) != -1) {
 242         switch (i) {
 243         case 'f':
 244             if ((f_opt = atoi(optarg)) <= 0)
 245                 usage();
 246             break;
 247         case 'i':
 248             i_opt = 1;
 249             break;
 250         case 'l':
 251             if ((l_opt = atoi(optarg)) <= 0)
 252                 usage();
 253             break;
 254         case 'n':
 255             n_opt = 1;
 256             break;
 257         case 'p':
 258             p_opt = 1;
 259             break;
 260         case 'r':
 261             if ((r_opt = atoi(optarg)) <= 0)
 262                 usage();
 263             break;
 264         case 's':
 265             s_opt = 1;
 266             break;
 267 #if USE_EXTENDED_COLOR
 268         case 'x':
 269             x_opt = 1;
 270             break;
 271 #endif
 272         default:
 273             usage();
 274         }
 275     }
 276     if (optind < argc)
 277         usage();
 278     if (r_opt <= 0)
 279         r_opt = 1;
 280
 281     setup_test();
 282     if (p_opt) {
 283         endwin();
 284         for (i = f_opt; i < l_opt; ++i) {
 285             my_color_t fg, bg;
 286             if (PairContent(i, &fg, &bg) == OK) {
 287                 printf("%d: %d %d\n", i, fg, bg);
 288             } else {
 289                 printf("%d: ? ?\n", i);
 290             }
 291         }
 292     } else {
 293         int repeat;
 294
 295         for (repeat = 0; repeat < r_opt; ++repeat) {
 296             run_test();
 297             if (i_opt) {
 298                 addch('.');
 299                 refresh();
 300             }
 301         }
 302
 303         if (i_opt) {
 304             addch('\n');
 305         }
 306         printw("DONE: ");
 307 #if HAVE_GETTIMEOFDAY
 308         gettimeofday(&finish_time, 0);
 309         printw("%.03f seconds",
 310                seconds(&finish_time)
 311                - seconds(&initial_time));
 312 #endif
 313         finish_test();
 314     }
 315
 316     ExitProgram(EXIT_SUCCESS);
 317 }