xref: /llvm-project/polly/lib/External/isl/imath/imtest.c (revision 658eb9e14264d48888ade0e3daf0b648f76c3f0e)

/*
  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 */