lib/External/isl/imath/imtest.c - llvm-project/polly - Git at Google

 /*
   Name:     imtest.c
   Purpose:  Test driver for imath library.
   Author:   M. J. Fromberger

   Copyright (C) 2002-2008 Michael J. Fromberger, All Rights Reserved.

   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, 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
   AUTHORS OR 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.

   Reads tests from input files or standard input, and runs them.  Tests have
   the form:

   code:inputs:outputs

   The 'code' is a string identifying the test to be performed.  The inputs and
   outputs are comma-separated sequences of values.  The format of each input
   is:

     1005    number in decimal notation (signs ok)
     #x-C0E  number in hexadecimal notation
     #b1011  number in binary notation
     #o37750 number in octal notation
     =k      use register k for this input

   For rational tests, the following syntax is also legal:
     @5.33   use decimal notation (for rationals only)
             may be combined with radix notation, e.g. #x@A0.5C

   Each output is a string representing the value to which the corresponding
   result is compared in order to pass the test.  By default, tests are expected
   to succeed (i.e., return MP_OK).  To specify an alternate return value, use
   the notation $RESULT, where RESULT is the name of an error (e.g., MP_MEMORY,
   MP_UNDEF, etc.) or a numeric result denoted $#number (e.g., $#-5).

   Results are written to standard output in the following formats:

   filename<tab>line<tab>number<tab>result<eoln>
   filename<tab>line<tab>number<tab>result<tab>message<eoln>

   The filename and line give the offset of the test in its input file, the
   number is the numbet of the test among all inputs, starting from 1.
   The result is a textual description of the result code returned by the
   operation being tested.

   The exit status is 0 if all tests passed, 1 if one or more tests failed or
   had errors.

   Note:  There is currently a fixed limit on the length of lines by this test
   ----   driver.  You can increase it if you wish, but the code doesn't check;
          lines over the length are truncated (split).
  */

 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>

 #include "imath.h"
 #include "imdrover.h"

 #ifdef LINE_MAX
 #undef LINE_MAX
 #endif

 #define LINE_MAX 4096

 typedef struct {
   char *code;
   int num_inputs;
   int num_outputs;
   test_f call;
 } test_t;

 test_t g_tests[] = {
     /* What it does...    */
     {"initu", 2, 1, test_init},        /* r0 = uv(r1)        */
     {"initv", 2, 1, test_init},        /* r0 = v(r1)         */
     {"setu", 2, 1, test_set},          /* r0 = uv(r1)        */
     {"setv", 2, 1, test_set},          /* r0 = v(r1)         */
     {"neg", 2, 1, test_neg},           /* r1 = -r0           */
     {"abs", 2, 1, test_abs},           /* r1 = |r0|          */
     {"add", 3, 1, test_add},           /* r3 = r1 + r2       */
     {"addv", 3, 1, test_add},          /* r3 = r1 + v(r2)    */
     {"sub", 3, 1, test_sub},           /* r3 = r1 - r2       */
     {"subv", 3, 1, test_sub},          /* r3 = r1 - v(r2)    */
     {"mul", 3, 1, test_mul},           /* r3 = r1 * r2       */
     {"mulp2", 3, 1, test_mulp2},       /* r3 = r1 * 2^v(r2)  */
     {"mulv", 3, 1, test_mulv},         /* r3 = r1 * v(r2)    */
     {"sqr", 2, 1, test_sqr},           /* r2 = r1 * r1       */
     {"div", 4, 2, test_div},           /* r2 = r1 / r2, r3 = r1 % r2         */
     {"divp2", 4, 2, test_divp2},       /* r2 = r1 / 2^v(r2),r3 = r1 % 2^v(r2)*/
     {"divv", 3, 2, test_divv},         /* r2 = r1 / v(r2), r3 = r1 % v(r2)   */
     {"expt", 3, 1, test_expt},         /* r3 = r1 ^ v(r2) */
     {"exptv", 3, 1, test_exptv},       /* r3 = v(r1) ^ v(r2) */
     {"exptf", 3, 1, test_exptf},       /* r3 = r1 ^ r2 */
     {"mod", 3, 1, test_mod},           /* r3 = r1 % r2       */
     {"gcd", 3, 1, test_gcd},           /* r3 = gcd(r1, r2)   */
     {"egcd", 5, 3, test_egcd},         /* r3 = gcd(r1, r2) = r1*r4 + r2*r5   */
     {"lcm", 3, 1, test_lcm},           /* r3 = lcm(r1, r2)   */
     {"sqrt", 2, 1, test_sqrt},         /* r2 = sqrt(r1)      */
     {"root", 3, 1, test_root},         /* r3 = r1^(1/v(r2))  */
     {"invmod", 3, 1, test_invmod},     /* r3 = r1^-1 mod r2  */
     {"emod", 4, 1, test_exptmod},      /* r4 = r1^r2 mod r3  */
     {"emodev", 4, 1, test_exptmod_ev}, /* r4 = r1^v(r2) mod r3  */
     {"emodbv", 4, 1, test_exptmod_bv}, /* r4 = v(r1)^r2 mod r3  */
     {"cmp", 2, 1, test_comp},          /* rtn = compare(r1, r2) */
     {"cmpu", 2, 1, test_ucomp},        /* rtn = compare(|r1|, |r2|) */
     {"cmpz", 1, 1, test_zcomp},        /* rtn = compare(r1, 0)      */
     {"cmpv", 2, 1, test_vcomp},        /* rtn = compare(r1, v(r2))  */
     {"cmpuv", 2, 1, test_uvcomp},      /* rtn = compare(r1, v(r2))  */
     {"tostr", 2, 1, test_tostr},       /* r1: value, r2: radix, o1: result */
     {"tobin", 1, 1, test_tobin},       /* r1: value, o1: result binary     */
     {"readbin", 1, 1, test_read_binary}, /* r1: 2's comp, o1: result value   */
     {"to-uns", 1, 1, test_to_uns},       /* r1: value, o1: result binary     */
     {"readuns", 1, 1, test_read_uns},    /* r1: unsigned, o1: result value   */
     {"to-int", 1, 1, test_to_int},       /* r1: value, o1: result */
     {"to-uint", 1, 1, test_to_uint},     /* r1: value, o1: result */
     {"meta", -1, -1, test_meta},
     {"qneg", 2, 1, test_qneg},        /* r2 = -r1        */
     {"qrecip", 2, 1, test_qrecip},    /* r2 = 1 / r1     */
     {"qabs", 2, 1, test_qabs},        /* r2 = |r1|       */
     {"qadd", 3, 1, test_qadd},        /* r3 = r1 + r2    */
     {"qsub", 3, 1, test_qsub},        /* r3 = r1 - r2    */
     {"qmul", 3, 1, test_qmul},        /* r3 = r1 * r2    */
     {"qdiv", 3, 1, test_qdiv},        /* r3 = r1 / r2    */
     {"qaddz", 3, 1, test_qaddz},      /* r3 = r1 + r2    */
     {"qsubz", 3, 1, test_qsubz},      /* r3 = r1 - r2    */
     {"qmulz", 3, 1, test_qmulz},      /* r3 = r1 * r2    */
     {"qdivz", 3, 1, test_qdivz},      /* r3 = r1 / r2    */
     {"qexpt", 3, 1, test_qexpt},      /* r3 = r1 ^ v(r2) */
     {"qtostr", 2, 1, test_qtostr},    /* r1: value, r2: radix; o1: result */
     {"qtodec", 4, 1, test_qtodec},    /* r1: val, r2: rdx, r3: prec,
                                          r4: rounding mode; o1: res */
     {"qrdec", 2, 1, test_qrdec},      /* r1: dec, r2: rdx; o1: result value  */
     {"isprime", 1, 1, test_is_prime}, /* rtn = prime(r1) ? MP_TRUE : MP_FALSE */
     {NULL, 0, 0, NULL}                /* end of list marker */
 };

 char g_line[LINE_MAX];

 extern mp_result imath_errno;
 extern char *imath_errmsg;

 const char *g_imath_strerr[] = {"MP_OK",    "MP_TRUE",  "MP_MEMORY", "MP_RANGE",
                                 "MP_UNDEF", "MP_TRUNC", "MP_BADARG"};

 bool process_file(char *file_name, FILE *ifp, FILE *ofp);
 int read_line(FILE *ifp, char *line, int limit);
 void trim_line(char *line);
 int is_blank(char *line);
 int parse_line(char *line, testspec_t *t);
 int count_fields(char *line, int delim);
 void parse_fields(char *line, int delim, char **start);
 int run_test(int test_num, testspec_t *t, FILE *ofp);
 void free_test(testspec_t *t);
 int find_test(char *code, test_t *info);
 char *error_string(mp_result res);

 int main(int argc, char *argv[]) {
   int exit_status = 0;

   init_testing();

   if (argc == 1) {
     fprintf(stderr, "[reading from stdin]\n");
     if (!process_file("-", stdin, stdout)) exit_status = 1;
   } else {
     FILE *ifp;
     int i;

     for (i = 1; i < argc; ++i) {
       if (strcmp(argv[i], "-") == 0) {
         ifp = stdin;
       } else if ((ifp = fopen(argv[i], "r")) == NULL) {
         fprintf(stderr, "Cannot open '%s': %s\n", argv[i], strerror(errno));
         return 1;
       }
       if (!process_file(argv[i], ifp, stdout)) exit_status = 1;

       fclose(ifp);
     }
   }
   return exit_status;
 }

 /** Reads and runs test cases from `ifp` and writes test results to `ofp`. The
     given `file_name` is used for cosmetic attribution. The return value is
     true if all tests passed, false if any tests failed or had errors. */
 bool process_file(char *file_name, FILE *ifp, FILE *ofp) {
   int res, line_num, test_num = 0, num_failed = 0, num_bogus = 0;
   clock_t start, finish;

   start = clock();
   while ((line_num = read_line(ifp, g_line, LINE_MAX)) != 0) {
     testspec_t t;
     t.line = line_num;
     t.file = file_name;
     if (parse_line(g_line, &t)) {
       if ((res = run_test(++test_num, &t, ofp)) < 0) {
         ++num_bogus;
       } else if (res == 0) {
         ++num_failed;
       }
       free_test(&t);
     } else {
       fprintf(stderr, "Line %d: Incorrect input syntax.\n", line_num);
       ++num_bogus;
     }
   }
   finish = clock();

   fprintf(ofp,
           "# %s %d tests: %d passed, %d failed, %d errors. (%.2f seconds)\n",
           file_name, test_num, (test_num - num_failed - num_bogus), num_failed,
           num_bogus, ((double)(finish - start) / CLOCKS_PER_SEC));

   return num_failed == 0 && num_bogus == 0;
 }

 int read_line(FILE *ifp, char *line, int limit) {
   static FILE *current_fp = NULL;
   static int current_line = 0;

   if (ifp != current_fp) {
     current_fp = ifp;
     current_line = 0;
   }

   do {
     if (fgets(line, limit, ifp) == NULL) return 0;

     ++current_line;
   } while (is_blank(line));

   trim_line(line);
   return current_line;
 }

 /** Removes leading and trailing whitespace from a zero-terminated `line`. */
 void trim_line(char *line) {
   int len;
   char *fnw = line;

   /* Remove leading whitespace */
   while (isspace((unsigned char)*fnw)) ++fnw;

   len = strlen(fnw);
   memmove(line, fnw, len);

   /* Remove trailing whitespace (including linefeeds) */
   fnw = line + len - 1;
   while (fnw >= line && isspace((unsigned char)*fnw)) *fnw-- = '\0';
 }

 /** Reports whether a zero-terminated `line` contains only whitespace after a
     line-trailing comment (`# ...`) is removed. */
 int is_blank(char *line) {
   while (*line && *line != '#' && isspace((unsigned char)*line)) ++line;

   return *line == '\0' || *line == '#';
 }

 int parse_line(char *line, testspec_t *t) {
   char *code_brk, *in_brk;
   int num_fields;

   if ((code_brk = strchr(line, ':')) == NULL) return 0;
   if ((in_brk = strchr(code_brk + 1, ':')) == NULL) return 0;

   *code_brk = '\0';
   t->code = line;
   *in_brk = '\0';

   num_fields = count_fields(code_brk + 1, ',');
   t->num_inputs = num_fields;
   t->input = NULL;

   num_fields = count_fields(in_brk + 1, ',');
   t->num_outputs = num_fields;
   t->output = NULL;

   if (t->num_inputs > 0) {
     t->input = calloc(t->num_inputs, sizeof(char *));
     parse_fields(code_brk + 1, ',', t->input);
   }
   if (t->num_outputs > 0) {
     t->output = calloc(t->num_outputs, sizeof(char *));
     parse_fields(in_brk + 1, ',', t->output);
   }
   return 1;
 }

 /** Returns the number of `delim` separated fields occur in `line`. */
 int count_fields(char *line, int delim) {
   int count = 1;

   if (*line == '\0') return 0;

   while (*line) {
     if (*line == (char)delim && *(line + 1) != '\0') ++count;
     ++line;
   }
   return count;
 }

 void parse_fields(char *line, int delim, char **start) {
   int pos = 0;

   start[pos++] = line;
   while ((line = strchr(line, delim)) != NULL) {
     *line++ = '\0';
     start[pos++] = line;
   }
 }

 /** Runs the test cases specified by `t`, and writes its results to `ofp`. The
     `test_num` is used in log output and should reflect the global ordering of
     tests, but is not otherwise interpreted by this function.

     This function returns 0 if the test succeeds, 1 if the test fails, and -1
     if the test is broken (e.g., its code is unknown). */
 int run_test(int test_num, testspec_t *t, FILE *ofp) {
   test_t info;

   /* Look up and reality check test parameters */
   if (find_test(t->code, &info) < 0) {
     fprintf(stderr, "Line %d: Test code '%s' is unknown.\n", t->line, t->code);
     return -1;
   } else {
     int errs = 0;

     if (info.num_inputs >= 0 && t->num_inputs != info.num_inputs) {
       fprintf(stderr,
               "Line %d: Wrong number of inputs to %s (want %d, have %d)\n",
               t->line, t->code, info.num_inputs, t->num_inputs);
       ++errs;
     }
     if (info.num_outputs >= 0 && t->num_outputs != info.num_outputs) {
       fprintf(stderr,
               "Line %d: Wrong number of outputs to %s (want %d, have %d)\n",
               t->line, t->code, info.num_outputs, t->num_outputs);
       ++errs;
     }
     if (errs) {
       fprintf(stderr, "Line %d: %d error(s), skipping this test.\n", t->line,
               errs);
       return -1;
     }
   }

   /* If return value is true, just print a generic OK message;
      otherwise, it is assumed that imath_errno has been set to
      a value indicating the problem. */
   if ((info.call)(t, ofp)) {
     fprintf(ofp, "%s\t%d\t%d\tOK\n", t->file, t->line, test_num);
     return 1;
   } else if (imath_errno >= MP_BADARG) {
     fprintf(ofp, "%s\t%d\t%d\t%s\n", t->file, t->line, test_num,
             error_string(imath_errno));
   } else {
     fprintf(ofp, "%s\t%d\t%d\tFAILED\t%s\n", t->file, t->line, test_num,
             imath_errmsg);
   }
   return 0;
 }

 /** Locates the run instructions for the specified test `code`, and if they are
     found populates `*info` with a copy. It returns -1 if `code` is unknown. */
 int find_test(char *code, test_t *info) {
   int i = 0;

   while (g_tests[i].code != NULL) {
     if (strcmp(g_tests[i].code, code) == 0) {
       *info = g_tests[i];
       return i;
     }
     ++i;
   }
   return -1;
 }

 /** Releases the memory occupied by a test case invocation. */
 void free_test(testspec_t *t) {
   assert(t != NULL);

   if (t->input != NULL) {
     free(t->input);
     t->input = NULL;
   }
   if (t->output != NULL) {
     free(t->output);
     t->output = NULL;
   }
 }

 /** Returns a static label string describing `res`. Note that this is not the
     same as the error string returned by `mp_error_string`, but corresponds to
     the spelling of the constant for its value. */
 char *error_string(mp_result res) {
   int v = abs(res);

   return (char *)g_imath_strerr[v];
 }

 /* Here there be dragons */
	/*
	Name: imtest.c
	Purpose: Test driver for imath library.
	Author: M. J. Fromberger

	Copyright (C) 2002-2008 Michael J. Fromberger, All Rights Reserved.

	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, 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
	AUTHORS OR 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.

	Reads tests from input files or standard input, and runs them. Tests have
	the form:

	code:inputs:outputs

	The 'code' is a string identifying the test to be performed. The inputs and
	outputs are comma-separated sequences of values. The format of each input
	is:

	1005 number in decimal notation (signs ok)
	#x-C0E number in hexadecimal notation
	#b1011 number in binary notation
	#o37750 number in octal notation
	=k use register k for this input

	For rational tests, the following syntax is also legal:
	@5.33 use decimal notation (for rationals only)
	may be combined with radix notation, e.g. #x@A0.5C

	Each output is a string representing the value to which the corresponding
	result is compared in order to pass the test. By default, tests are expected
	to succeed (i.e., return MP_OK). To specify an alternate return value, use
	the notation $RESULT, where RESULT is the name of an error (e.g., MP_MEMORY,
	MP_UNDEF, etc.) or a numeric result denoted $#number (e.g., $#-5).

	Results are written to standard output in the following formats:

	filename<tab>line<tab>number<tab>result<eoln>
	filename<tab>line<tab>number<tab>result<tab>message<eoln>

	The filename and line give the offset of the test in its input file, the
	number is the numbet of the test among all inputs, starting from 1.
	The result is a textual description of the result code returned by the
	operation being tested.

	The exit status is 0 if all tests passed, 1 if one or more tests failed or
	had errors.

	Note: There is currently a fixed limit on the length of lines by this test
	---- driver. You can increase it if you wish, but the code doesn't check;
	lines over the length are truncated (split).
	*/

	#include <assert.h>
	#include <ctype.h>
	#include <errno.h>
	#include <limits.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>

	#include "imath.h"
	#include "imdrover.h"

	#ifdef LINE_MAX
	#undef LINE_MAX
	#endif

	#define LINE_MAX 4096

	typedef struct {
	char *code;
	int num_inputs;
	int num_outputs;
	test_f call;
	} test_t;

	test_t g_tests[] = {
	/* What it does... */
	{"initu", 2, 1, test_init}, /* r0 = uv(r1) */
	{"initv", 2, 1, test_init}, /* r0 = v(r1) */
	{"setu", 2, 1, test_set}, /* r0 = uv(r1) */
	{"setv", 2, 1, test_set}, /* r0 = v(r1) */
	{"neg", 2, 1, test_neg}, /* r1 = -r0 */
	{"abs", 2, 1, test_abs}, /* r1 = \|r0\| */
	{"add", 3, 1, test_add}, /* r3 = r1 + r2 */
	{"addv", 3, 1, test_add}, /* r3 = r1 + v(r2) */
	{"sub", 3, 1, test_sub}, /* r3 = r1 - r2 */
	{"subv", 3, 1, test_sub}, /* r3 = r1 - v(r2) */
	{"mul", 3, 1, test_mul}, /* r3 = r1 * r2 */
	{"mulp2", 3, 1, test_mulp2}, /* r3 = r1 * 2^v(r2) */
	{"mulv", 3, 1, test_mulv}, /* r3 = r1 * v(r2) */
	{"sqr", 2, 1, test_sqr}, /* r2 = r1 * r1 */
	{"div", 4, 2, test_div}, /* r2 = r1 / r2, r3 = r1 % r2 */
	{"divp2", 4, 2, test_divp2}, /* r2 = r1 / 2^v(r2),r3 = r1 % 2^v(r2)*/
	{"divv", 3, 2, test_divv}, /* r2 = r1 / v(r2), r3 = r1 % v(r2) */
	{"expt", 3, 1, test_expt}, /* r3 = r1 ^ v(r2) */
	{"exptv", 3, 1, test_exptv}, /* r3 = v(r1) ^ v(r2) */
	{"exptf", 3, 1, test_exptf}, /* r3 = r1 ^ r2 */
	{"mod", 3, 1, test_mod}, /* r3 = r1 % r2 */
	{"gcd", 3, 1, test_gcd}, /* r3 = gcd(r1, r2) */
	{"egcd", 5, 3, test_egcd}, /* r3 = gcd(r1, r2) = r1r4 + r2r5 */
	{"lcm", 3, 1, test_lcm}, /* r3 = lcm(r1, r2) */
	{"sqrt", 2, 1, test_sqrt}, /* r2 = sqrt(r1) */
	{"root", 3, 1, test_root}, /* r3 = r1^(1/v(r2)) */
	{"invmod", 3, 1, test_invmod}, /* r3 = r1^-1 mod r2 */
	{"emod", 4, 1, test_exptmod}, /* r4 = r1^r2 mod r3 */
	{"emodev", 4, 1, test_exptmod_ev}, /* r4 = r1^v(r2) mod r3 */
	{"emodbv", 4, 1, test_exptmod_bv}, /* r4 = v(r1)^r2 mod r3 */
	{"cmp", 2, 1, test_comp}, /* rtn = compare(r1, r2) */
	{"cmpu", 2, 1, test_ucomp}, /* rtn = compare(\|r1\|, \|r2\|) */
	{"cmpz", 1, 1, test_zcomp}, /* rtn = compare(r1, 0) */
	{"cmpv", 2, 1, test_vcomp}, /* rtn = compare(r1, v(r2)) */
	{"cmpuv", 2, 1, test_uvcomp}, /* rtn = compare(r1, v(r2)) */
	{"tostr", 2, 1, test_tostr}, /* r1: value, r2: radix, o1: result */
	{"tobin", 1, 1, test_tobin}, /* r1: value, o1: result binary */
	{"readbin", 1, 1, test_read_binary}, /* r1: 2's comp, o1: result value */
	{"to-uns", 1, 1, test_to_uns}, /* r1: value, o1: result binary */
	{"readuns", 1, 1, test_read_uns}, /* r1: unsigned, o1: result value */
	{"to-int", 1, 1, test_to_int}, /* r1: value, o1: result */
	{"to-uint", 1, 1, test_to_uint}, /* r1: value, o1: result */
	{"meta", -1, -1, test_meta},
	{"qneg", 2, 1, test_qneg}, /* r2 = -r1 */
	{"qrecip", 2, 1, test_qrecip}, /* r2 = 1 / r1 */
	{"qabs", 2, 1, test_qabs}, /* r2 = \|r1\| */
	{"qadd", 3, 1, test_qadd}, /* r3 = r1 + r2 */
	{"qsub", 3, 1, test_qsub}, /* r3 = r1 - r2 */
	{"qmul", 3, 1, test_qmul}, /* r3 = r1 * r2 */
	{"qdiv", 3, 1, test_qdiv}, /* r3 = r1 / r2 */
	{"qaddz", 3, 1, test_qaddz}, /* r3 = r1 + r2 */
	{"qsubz", 3, 1, test_qsubz}, /* r3 = r1 - r2 */
	{"qmulz", 3, 1, test_qmulz}, /* r3 = r1 * r2 */
	{"qdivz", 3, 1, test_qdivz}, /* r3 = r1 / r2 */
	{"qexpt", 3, 1, test_qexpt}, /* r3 = r1 ^ v(r2) */
	{"qtostr", 2, 1, test_qtostr}, /* r1: value, r2: radix; o1: result */
	{"qtodec", 4, 1, test_qtodec}, /* r1: val, r2: rdx, r3: prec,
	r4: rounding mode; o1: res */
	{"qrdec", 2, 1, test_qrdec}, /* r1: dec, r2: rdx; o1: result value */
	{"isprime", 1, 1, test_is_prime}, /* rtn = prime(r1) ? MP_TRUE : MP_FALSE */
	{NULL, 0, 0, NULL} /* end of list marker */
	};

	char g_line[LINE_MAX];

	extern mp_result imath_errno;
	extern char *imath_errmsg;

	const char *g_imath_strerr[] = {"MP_OK", "MP_TRUE", "MP_MEMORY", "MP_RANGE",
	"MP_UNDEF", "MP_TRUNC", "MP_BADARG"};

	bool process_file(char file_name, FILE ifp, FILE *ofp);
	int read_line(FILE ifp, char line, int limit);
	void trim_line(char *line);
	int is_blank(char *line);
	int parse_line(char line, testspec_t t);
	int count_fields(char *line, int delim);
	void parse_fields(char line, int delim, char *start);
	int run_test(int test_num, testspec_t t, FILE ofp);
	void free_test(testspec_t *t);
	int find_test(char code, test_t info);
	char *error_string(mp_result res);

	int main(int argc, char *argv[]) {
	int exit_status = 0;

	init_testing();

	if (argc == 1) {
	fprintf(stderr, "[reading from stdin]\n");
	if (!process_file("-", stdin, stdout)) exit_status = 1;
	} else {
	FILE *ifp;
	int i;

	for (i = 1; i < argc; ++i) {
	if (strcmp(argv[i], "-") == 0) {
	ifp = stdin;
	} else if ((ifp = fopen(argv[i], "r")) == NULL) {
	fprintf(stderr, "Cannot open '%s': %s\n", argv[i], strerror(errno));
	return 1;
	}
	if (!process_file(argv[i], ifp, stdout)) exit_status = 1;

	fclose(ifp);
	}
	}
	return exit_status;
	}

	/** Reads and runs test cases from `ifp` and writes test results to `ofp`. The
	given `file_name` is used for cosmetic attribution. The return value is
	true if all tests passed, false if any tests failed or had errors. */
	bool process_file(char file_name, FILE ifp, FILE *ofp) {
	int res, line_num, test_num = 0, num_failed = 0, num_bogus = 0;
	clock_t start, finish;

	start = clock();
	while ((line_num = read_line(ifp, g_line, LINE_MAX)) != 0) {
	testspec_t t;
	t.line = line_num;
	t.file = file_name;
	if (parse_line(g_line, &t)) {
	if ((res = run_test(++test_num, &t, ofp)) < 0) {
	++num_bogus;
	} else if (res == 0) {
	++num_failed;
	}
	free_test(&t);
	} else {
	fprintf(stderr, "Line %d: Incorrect input syntax.\n", line_num);
	++num_bogus;
	}
	}
	finish = clock();

	fprintf(ofp,
	"# %s %d tests: %d passed, %d failed, %d errors. (%.2f seconds)\n",
	file_name, test_num, (test_num - num_failed - num_bogus), num_failed,
	num_bogus, ((double)(finish - start) / CLOCKS_PER_SEC));

	return num_failed == 0 && num_bogus == 0;
	}

	int read_line(FILE ifp, char line, int limit) {
	static FILE *current_fp = NULL;
	static int current_line = 0;

	if (ifp != current_fp) {
	current_fp = ifp;
	current_line = 0;
	}

	do {
	if (fgets(line, limit, ifp) == NULL) return 0;

	++current_line;
	} while (is_blank(line));

	trim_line(line);
	return current_line;
	}

	/** Removes leading and trailing whitespace from a zero-terminated `line`. */
	void trim_line(char *line) {
	int len;
	char *fnw = line;

	/* Remove leading whitespace */
	while (isspace((unsigned char)*fnw)) ++fnw;

	len = strlen(fnw);
	memmove(line, fnw, len);

	/* Remove trailing whitespace (including linefeeds) */
	fnw = line + len - 1;
	while (fnw >= line && isspace((unsigned char)fnw)) fnw-- = '\0';
	}

	/** Reports whether a zero-terminated `line` contains only whitespace after a
	line-trailing comment (`# ...`) is removed. */
	int is_blank(char *line) {
	while (line && line != '#' && isspace((unsigned char)*line)) ++line;

	return line == '\0' \|\| line == '#';
	}

	int parse_line(char line, testspec_t t) {
	char code_brk, in_brk;
	int num_fields;

	if ((code_brk = strchr(line, ':')) == NULL) return 0;
	if ((in_brk = strchr(code_brk + 1, ':')) == NULL) return 0;

	*code_brk = '\0';
	t->code = line;
	*in_brk = '\0';

	num_fields = count_fields(code_brk + 1, ',');
	t->num_inputs = num_fields;
	t->input = NULL;

	num_fields = count_fields(in_brk + 1, ',');
	t->num_outputs = num_fields;
	t->output = NULL;

	if (t->num_inputs > 0) {
	t->input = calloc(t->num_inputs, sizeof(char *));
	parse_fields(code_brk + 1, ',', t->input);
	}
	if (t->num_outputs > 0) {
	t->output = calloc(t->num_outputs, sizeof(char *));
	parse_fields(in_brk + 1, ',', t->output);
	}
	return 1;
	}

	/** Returns the number of `delim` separated fields occur in `line`. */
	int count_fields(char *line, int delim) {
	int count = 1;

	if (*line == '\0') return 0;

	while (*line) {
	if (line == (char)delim && (line + 1) != '\0') ++count;
	++line;
	}
	return count;
	}

	void parse_fields(char line, int delim, char *start) {
	int pos = 0;

	start[pos++] = line;
	while ((line = strchr(line, delim)) != NULL) {
	*line++ = '\0';
	start[pos++] = line;
	}
	}

	/** Runs the test cases specified by `t`, and writes its results to `ofp`. The
	`test_num` is used in log output and should reflect the global ordering of
	tests, but is not otherwise interpreted by this function.

	This function returns 0 if the test succeeds, 1 if the test fails, and -1
	if the test is broken (e.g., its code is unknown). */
	int run_test(int test_num, testspec_t t, FILE ofp) {
	test_t info;

	/* Look up and reality check test parameters */
	if (find_test(t->code, &info) < 0) {
	fprintf(stderr, "Line %d: Test code '%s' is unknown.\n", t->line, t->code);
	return -1;
	} else {
	int errs = 0;

	if (info.num_inputs >= 0 && t->num_inputs != info.num_inputs) {
	fprintf(stderr,
	"Line %d: Wrong number of inputs to %s (want %d, have %d)\n",
	t->line, t->code, info.num_inputs, t->num_inputs);
	++errs;
	}
	if (info.num_outputs >= 0 && t->num_outputs != info.num_outputs) {
	fprintf(stderr,
	"Line %d: Wrong number of outputs to %s (want %d, have %d)\n",
	t->line, t->code, info.num_outputs, t->num_outputs);
	++errs;
	}
	if (errs) {
	fprintf(stderr, "Line %d: %d error(s), skipping this test.\n", t->line,
	errs);
	return -1;
	}
	}

	/* If return value is true, just print a generic OK message;
	otherwise, it is assumed that imath_errno has been set to
	a value indicating the problem. */
	if ((info.call)(t, ofp)) {
	fprintf(ofp, "%s\t%d\t%d\tOK\n", t->file, t->line, test_num);
	return 1;
	} else if (imath_errno >= MP_BADARG) {
	fprintf(ofp, "%s\t%d\t%d\t%s\n", t->file, t->line, test_num,
	error_string(imath_errno));
	} else {
	fprintf(ofp, "%s\t%d\t%d\tFAILED\t%s\n", t->file, t->line, test_num,
	imath_errmsg);
	}
	return 0;
	}

	/** Locates the run instructions for the specified test `code`, and if they are
	found populates `info` with a copy. It returns -1 if `code` is unknown. /
	int find_test(char code, test_t info) {
	int i = 0;

	while (g_tests[i].code != NULL) {
	if (strcmp(g_tests[i].code, code) == 0) {
	*info = g_tests[i];
	return i;
	}
	++i;
	}
	return -1;
	}

	/** Releases the memory occupied by a test case invocation. */
	void free_test(testspec_t *t) {
	assert(t != NULL);

	if (t->input != NULL) {
	free(t->input);
	t->input = NULL;
	}
	if (t->output != NULL) {
	free(t->output);
	t->output = NULL;
	}
	}

	/** Returns a static label string describing `res`. Note that this is not the
	same as the error string returned by `mp_error_string`, but corresponds to
	the spelling of the constant for its value. */
	char *error_string(mp_result res) {
	int v = abs(res);

	return (char *)g_imath_strerr[v];
	}

	/* Here there be dragons */