src/regress/lib/libutil/fmt_scaled/fmt_test.c

   1 /* $OpenBSD: fmt_test.c,v 1.9 2009/06/20 14:23:38 ian Exp $ */
   2
   3 /*
   4  * Combined tests for fmt_scaled and scan_scaled.
   5  * Ian Darwin, January 2001. Public domain.
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <sys/types.h>
  12 #include <errno.h>
  13
  14 #include <util.h>
  15
  16 static int fmt_test(void);
  17 static int scan_test(void);
  18
  19 static void print_errno(int e);
  20 static int assert_int(int testnum, int checknum, int expect, int result);
  21 static int assert_errno(int testnum, int checknum, int expect, int result);
  22 static int assert_quad_t(int testnum, int checknum, quad_t expect, quad_t result);
  23 static int assert_str(int testnum, int checknum, char * expect, char * result);
  24
  25 extern char *__progname;
  26 static int verbose = 0;
  27
  28 __dead static void usage(int stat)
  29 {
  30         fprintf(stderr, "usage: %s [-v]\n", __progname);
  31         exit(stat);
  32 }
  33
  34 int
  35 main(int argc, char **argv)
  36 {
  37         extern char *optarg;
  38         extern int optind;
  39         int i, ch;
  40
  41         while ((ch = getopt(argc, argv, "hv")) != -1) {
  42                         switch (ch) {
  43                         case 'v':
  44                                         verbose = 1;
  45                                         break;
  46                         case 'h':
  47                                         usage(0);
  48                         case '?':
  49                         default:
  50                                         usage(1);
  51                         }
  52         }
  53         argc -= optind;
  54         argv += optind;
  55
  56         if (verbose)
  57                 printf("Starting fmt_test\n");
  58         i = fmt_test();
  59         if (verbose)
  60                 printf("Starting scan_test\n");
  61         i += scan_test();
  62         if (i) {
  63                 printf("*** %d errors in libutil/fmt_scaled tests ***\n", i);
  64         } else {
  65                 if (verbose)
  66                         printf("Tests done; no unexpected errors\n");
  67         }
  68         return i;
  69 }
  70
  71 /************** tests for fmt_scaled *******************/
  72
  73 static struct {                 /* the test cases */
  74         quad_t input;
  75         char *expect;
  76         int err;
  77 } ddata[] = {
  78         { 0, "0B", 0 },
  79         { 1, "1B", 0 },
  80         { -1, "-1B", 0 },
  81         { 100, "100B", 0},
  82         { -100, "-100B", 0},
  83         { 999, "999B", 0 },
  84         { 1000, "1000B", 0 },
  85         { 1023, "1023B", 0 },
  86         { -1023, "-1023B", 0 },
  87         { 1024, "1.0K", 0 },
  88         { 1025, "1.0K", 0 },
  89         { 1234, "1.2K", 0 },
  90         { -1234, "-1.2K", 0 },
  91         { 1484, "1.4K", 0 },            /* rounding boundary, down */
  92         { 1485, "1.5K", 0 },            /* rounding boundary, up   */
  93         { -1484, "-1.4K", 0 },          /* rounding boundary, down */
  94         { -1485, "-1.5K", 0 },          /* rounding boundary, up   */
  95         { 1536, "1.5K", 0 },
  96         { 1786, "1.7K", 0 },
  97         { 1800, "1.8K", 0 },
  98         { 2000, "2.0K", 0 },
  99         { 123456, "121K", 0 },
 100         { 578318, "565K", 0 },
 101         { 902948, "882K", 0 },
 102         { 1048576, "1.0M", 0},
 103         { 1048628, "1.0M", 0},
 104         { 1049447, "1.0M", 0},
 105         { -102400, "-100K", 0},
 106         { -103423, "-101K", 0 },
 107         { 7299072, "7.0M", 0 },
 108         { 409478144L, "391M", 0 },
 109         { -409478144L, "-391M", 0 },
 110         { 999999999L, "954M", 0 },
 111         { 1499999999L, "1.4G", 0 },
 112         { 12475423744LL, "11.6G", 0},
 113         { 1LL<<61, "2.0E", 0 },
 114         { 1LL<<62, "4.0E", 0 },
 115         { 1LL<<63, "", ERANGE },
 116         { 1099512676352LL, "1.0T", 0}
 117 };
 118 #       define DDATA_LENGTH (sizeof ddata/sizeof *ddata)
 119
 120 static int
 121 fmt_test(void)
 122 {
 123         unsigned int i, e, errs = 0;
 124         int ret;
 125         char buf[FMT_SCALED_STRSIZE];
 126
 127         for (i = 0; i < DDATA_LENGTH; i++) {
 128                 strlcpy(buf, "UNSET", FMT_SCALED_STRSIZE);
 129                 ret = fmt_scaled(ddata[i].input, buf);
 130                 e = errno;
 131                 if (verbose) {
 132                         printf("%lld --> %s (%d)", ddata[i].input, buf, ret);
 133                         if (ret == -1)
 134                                 print_errno(e);
 135                         printf("\n");
 136                 }
 137                 if (ret == -1)
 138                         errs += assert_int(i, 1, ret, ddata[i].err == 0 ? 0 : -1);
 139                 if (ddata[i].err)
 140                         errs += assert_errno(i, 2, ddata[i].err, errno);
 141                 else
 142                         errs += assert_str(i, 3, ddata[i].expect, buf);
 143         }
 144
 145         return errs;
 146 }
 147
 148 /************** tests for scan_scaled *******************/
 149
 150
 151 #define IMPROBABLE      (-42)
 152
 153 extern int errno;
 154
 155 struct {                                        /* the test cases */
 156         char *input;
 157         quad_t result;
 158         int err;
 159 } sdata[] = {
 160         { "0",          0, 0 },
 161         { "123",        123, 0 },
 162         { "1k",         1024, 0 },              /* lower case */
 163         { "100.944", 100, 0 },  /* should --> 100 (truncates fraction) */
 164         { "10099",      10099LL, 0 },
 165         { "1M",         1048576LL, 0 },
 166         { "1.1M",       1153433LL, 0 },         /* fractions */
 167         { "1.111111111111111111M",      1165084LL, 0 },         /* fractions */
 168         { "1.55M",      1625292LL, 0 }, /* fractions */
 169         { "1.9M",       1992294LL, 0 },         /* fractions */
 170         { "-2K",        -2048LL, 0 },           /* negatives */
 171         { "-2.2K",      -2252LL, 0 },   /* neg with fract */
 172         { "4.5k", 4608, 0 },
 173         { "4.5555555555555555K", 4664, 0 },
 174         { "4.5555555555555555555K", 4664, 0 },  /* handle enough digits? */
 175         { "4.555555555555555555555555555555K", 4664, 0 }, /* ignores extra digits? */
 176         { "1G",         1073741824LL, 0 },
 177         { "G",          0, 0 },                 /* should == 0G? */
 178         { "1234567890", 1234567890LL, 0 },      /* should work */
 179         { "1.5E",       1729382256910270464LL, 0 },             /* big */
 180         { "32948093840918378473209480483092", 0, ERANGE },  /* too big */
 181         { "329480938409.8378473209480483092", 0, ERANGE },  /* fraction too big */
 182         { "1.5Q",       0, ERANGE },            /* invalid multiplier (XXX ERANGE??) */
 183         { "1ab",        0, ERANGE },            /* ditto */
 184         { "5.0e3",      0, EINVAL },    /* digits after */
 185         { "5.0E3",      0, EINVAL },    /* ditto */
 186         { "1..0",       0, EINVAL },            /* bad format */
 187         { "",           0, 0 },                 /* boundary */
 188         { "--1", -1, EINVAL },
 189         { "++42", -1, EINVAL },
 190         /* { "9223372036854775808", -9223372036854775808LL, 0 }, */     /* XXX  */
 191 };
 192 #       define SDATA_LENGTH (sizeof sdata/sizeof *sdata)
 193
 194 static void
 195 print_errno(int e)
 196 {
 197         switch(e) {
 198                 case EINVAL: printf("EINVAL"); break;
 199                 case EDOM:   printf("EDOM"); break;
 200                 case ERANGE: printf("ERANGE"); break;
 201                 default: printf("errno %d", errno);
 202         }
 203 }
 204
 205 /** Print one result */
 206 static void
 207 print(char *input, quad_t result, int ret)
 208 {
 209         int e = errno;
 210         printf("\"%10s\" --> %lld (%d)", input, result, ret);
 211         if (ret == -1) {
 212                 printf(" -- ");
 213                 print_errno(e);
 214         }
 215         printf("\n");
 216 }
 217
 218 static int
 219 scan_test(void)
 220 {
 221         unsigned int i, errs = 0, e;
 222         int ret;
 223         quad_t result;
 224
 225         for (i = 0; i < SDATA_LENGTH; i++) {
 226                 result = IMPROBABLE;
 227                 /* printf("Calling scan_scaled(%s, ...)\n", sdata[i].input); */
 228                 ret = scan_scaled(sdata[i].input, &result);
 229                 e = errno;      /* protect across printfs &c. */
 230                 if (verbose)
 231                         print(sdata[i].input, result, ret);
 232                 errno = e;
 233                 if (ret == -1)
 234                         errs += assert_int(i, 1, ret, sdata[i].err == 0 ? 0 : -1);
 235                 errno = e;
 236                 if (sdata[i].err)
 237                         errs += assert_errno(i, 2, sdata[i].err, errno);
 238                 else
 239                         errs += assert_quad_t(i, 3, sdata[i].result, result);
 240         }
 241         return errs;
 242 }
 243
 244 /************** common testing stuff *******************/
 245
 246 static int
 247 assert_int(int testnum, int check, int expect, int result)
 248 {
 249         if (expect == result)
 250                 return 0;
 251         printf("** FAILURE: test %d check %d, expect %d, result %d **\n",
 252                 testnum, check, expect, result);
 253         return 1;
 254 }
 255
 256 static int
 257 assert_errno(int testnum, int check, int expect, int result)
 258 {
 259         if (expect == result)
 260                 return 0;
 261         printf("** FAILURE: test %d check %d, expect ",
 262                 testnum, check);
 263         print_errno(expect);
 264         printf(", got ");
 265         print_errno(result);
 266         printf(" **\n");
 267         return 1;
 268 }
 269
 270 static int
 271 assert_quad_t(int testnum, int check, quad_t expect, quad_t result)
 272 {
 273         if (expect == result)
 274                 return 0;
 275         printf("** FAILURE: test %d check %d, expect %lld, result %lld **\n",
 276                 testnum, check, expect, result);
 277         return 1;
 278 }
 279
 280 static int
 281 assert_str(int testnum, int check, char * expect, char * result)
 282 {
 283         if (strcmp(expect, result) == 0)
 284                 return 0;
 285         printf("** FAILURE: test %d check %d, expect %s, result %s **\n",
 286                 testnum, check, expect, result);
 287         return 1;
 288 }