clients/mrtest/tst.c

   1 /*
   2  *      $Source$
   3  *      $Author$
   4  *      $Header$
   5  *
   6  *      Copyright (C) 1991 by the Massachusetts Institute of Technology
   7  *      For copying and distribution information, please see the file
   8  *      <mit-copyright.h>.
   9  *
  10  */
  11
  12
  13 #include <stdio.h>
  14 #include <sys/types.h>
  15 #include <sys/file.h>
  16 #include <ctype.h>
  17 #include <moira.h>
  18 #include <ss.h>
  19 #include "mr_err_array.h"
  20
  21 extern ss_execute_line();
  22 extern print_reply();
  23 extern CompData();
  24 extern int ss;
  25 extern int errno;
  26 extern int count;
  27 extern int recursion;
  28
  29 char *DataBuf;
  30 char *ErrorBuf;
  31
  32 test_test (argc, argv)
  33 int argc;
  34 char *argv[];
  35 {
  36   FILE *inp, *outp;
  37   char *cp, *index();
  38   int LineNum;
  39   int status;
  40   int NumArgs;
  41   char *ValArgs[50];
  42   char lastcmd[BUFSIZ], input[BUFSIZ], cmd[BUFSIZ];
  43
  44   DataBuf =  (char *)malloc (2222);
  45   ErrorBuf = (char *)malloc (30);
  46
  47   if (recursion > 8) {
  48     ss_perror(ss, 0, "too many levels deep in script/test files\n");
  49     return;
  50   }
  51
  52   if (argc < 2) {
  53     ss_perror(ss, 0, "Usage: test input_file [ output_file ]");
  54     return;
  55   }
  56
  57   inp = fopen(argv[1], "r");
  58   if (inp == NULL) {
  59     sprintf(cmd, "Cannot open input file %s", argv[1]);
  60     ss_perror(ss, 0, cmd);
  61     return;
  62   }
  63
  64   if (argc == 3) {
  65     outp = fopen(argv[2], "a");
  66     if (!outp) {
  67       sprintf(cmd, "Unable to open output for %s\n", argv[2]);
  68       ss_perror(ss, errno, cmd);
  69       return;}}
  70   else outp = stdout;
  71
  72   *lastcmd = '\0';
  73
  74   recursion++;
  75
  76   for(LineNum = 0;;LineNum++) {
  77     *DataBuf = '\0';
  78     *ErrorBuf = '\0';
  79     if (fgets(input, BUFSIZ, inp) == NULL) {
  80       if (lastcmd[0] != '\0') {
  81         strcpy (input, lastcmd);
  82         lastcmd[0] = '\0';}
  83       else break;}
  84     if ((cp = index(input, '\n')) != (char *)NULL)
  85       *cp = 0;
  86     if (input[0] == 0) continue;
  87
  88     if (input[0] == '%') {
  89       for (cp = &input[1]; *cp && isspace(*cp); cp++);
  90       strcat(DataBuf, "Comment: ");
  91       strcat(DataBuf, cp);
  92       strcat(DataBuf, "\n");
  93       continue;
  94     }
  95
  96     if (input[0] == '>') {     /* Load in a Comparison String */
  97       if (lastcmd[0] == '\0') {
  98         fprintf(outp,
  99            "\nERROR IN LINE %d: Comparison String Without Comparable Command\n",
 100            LineNum);
 101         fprintf(outp, "%s\n", input);
 102         *DataBuf = '\0';
 103         continue;}
 104       else { /* Parse and Execute command with compare */
 105         sprintf (cmd, "COMPARE_%s", lastcmd);
 106         bzero((char *)ValArgs, sizeof(ValArgs));
 107         Partial_parse_string(0, cmd, &NumArgs, ValArgs);
 108         ValArgs[NumArgs] = (char *)malloc(sizeof(char) * (1+strlen(input)));
 109         strcpy(ValArgs[NumArgs], input);
 110         status = ss_execute_command(ss, ValArgs);
 111         lastcmd[0] = '\0';
 112
 113 /* Dump errors and data if necessary */
 114         if (!strcmp(ErrorBuf, "Malformed Comparison String0")) {
 115           fprintf(outp, "\nERROR IN LINE %d: %s\n", LineNum, ErrorBuf);
 116           fprintf(outp, "%s\n", input);
 117           continue;}
 118         else if (*ErrorBuf) { /* Data Error */
 119           fprintf(outp, "\nERROR IN LINE %d: %s\n", LineNum, ErrorBuf);
 120           fprintf(outp, "%s\n", DataBuf);
 121           continue;}
 122         else continue;  /* Command Checks */
 123       }}
 124
 125 /* It wasn't a Comparison line, so clear the stack */
 126     if (lastcmd[0] != '\0') {  /* Run an old command w/o a comparison string */
 127       ss_execute_line(ss, lastcmd, &status);
 128       if (status == SS_ET_COMMAND_NOT_FOUND)
 129         printf("Bad command: %s\n", input);
 130       *lastcmd = '\0';}
 131
 132 /* Push command on the stack if it's comparable (currently only queries are) */
 133     if (!(strncasecmp (input, "qy ", 3) && strncasecmp (input, "query ", 6))) {
 134       /* Delay this command in case there's a comparison line following it */
 135       strcpy (lastcmd, input);
 136       continue;}
 137
 138 /* Non-comparible command; execute immediately */
 139     ss_execute_line(ss, input, &status);
 140     if (status == SS_ET_COMMAND_NOT_FOUND) {
 141       printf("Bad command: %s\n", input);
 142     }
 143   }
 144
 145   recursion--;
 146
 147   fclose(inp);
 148   if (argc > 2)
 149     close(outp);
 150 }
 151
 152 /**********************************/
 153
 154 test_query_compare(argc, argv)
 155      int argc;
 156      char **argv;
 157 { /* argv = "COMPARE_qy" + args to query + compstring */
 158   int Qstatus = 0;      /* Status returned from the query */
 159   char *CompTo[5];
 160   int NumWordsComp=0, i;
 161
 162   if (argc < 2) {
 163     ss_perror(ss, 0, "Usage: query handle [ args ... ]");
 164     return;
 165   }
 166 /* Execute query with a comparison string */
 167   count = 0;
 168
 169   /* Parse comp string into '>', char, ErrMsg, NumEntries, and Data */
 170   bzero((char *)CompTo, sizeof(CompTo));
 171   Partial_parse_string (4, argv[argc-1], &NumWordsComp, CompTo);
 172   if (NumWordsComp < 3) { /* Too few args in comparison string */
 173         strcpy(ErrorBuf, "Malformed Comparison String1");}
 174   else {
 175
 176     for (i=0;i<argc;i++) {
 177       printf("argv[%d] = %s\n", i, argv[i]);}
 178     printf("CompTo[3] = %s\n\n", CompTo[3]);
 179
 180
 181     Qstatus = mr_query(argv[1], argc-3, argv+2, CompData,
 182                        (char *)(&CompTo[3]));
 183
 184 /* Check the number of tuples returned */
 185     if (*CompTo[2] == '<') {
 186       if (isdigit(*(CompTo[2] + 1))) {
 187         if (atoi(CompTo[2] + 1) <= count)
 188           strcat(ErrorBuf, "\nToo many tuples returned");}
 189       else if (*ErrorBuf == '\0')
 190         strcpy(ErrorBuf, "Malformed Comparison String2");}
 191     else if (*CompTo[2] == '>') {
 192       if (isdigit(*(CompTo[2] + 1))) {
 193         if (atoi(CompTo[2] + 1) >= count)
 194           strcat(ErrorBuf, "\nToo few tuples returned");}
 195       else if (*ErrorBuf == '\0')
 196         strcpy(ErrorBuf, "Malformed Comparison String3");}
 197     else if (isdigit(*(CompTo[2]))) {
 198       if (atoi(CompTo[2]) != count)
 199         strcat(ErrorBuf, "\nWrong number tuples returned");}
 200     else if (strcmp(CompTo[2], "*"))
 201       if (*ErrorBuf == '\0')
 202         strcpy(ErrorBuf, "Malformed Comparison String4");
 203
 204     /* Check return status */
 205     if (!Comp_mr_err_table(Qstatus, CompTo[1]))
 206       {
 207         strcat(ErrorBuf, "\nRet Status Error, returns: ");
 208         if (Qstatus)
 209           strcat(ErrorBuf, MR_ERR_ARRAY[Qstatus - ERROR_TABLE_BASE_sms]);
 210         else
 211           strcat(ErrorBuf, "SUCCESS");}
 212
 213   }}
 214
 215 /********************************************/
 216
 217 int Comp_mr_err_table (ErrNum, ErrName)
 218 int ErrNum;
 219 char *ErrName;
 220
 221 /* Returns 1 if ErrNum = the string in ErrName in MR_ERR_ARRAY, else 0 */
 222
 223 {
 224 if (!ErrNum && ((!strcasecmp(ErrName, "SUCCESS"))
 225                  || (!strcasecmp(ErrName, "S"))))
 226   return(1);
 227 else if (!ErrNum) return (0);
 228 else if (ErrNum >= ERROR_TABLE_BASE_sms)
 229   return (!strcmp (MR_ERR_ARRAY[ErrNum - ERROR_TABLE_BASE_sms], ErrName));
 230 else return (0);
 231 }
 232
 233 /********************************************/
 234
 235 int NumWords (Str)
 236 char *Str;
 237 {
 238 int Count;
 239 int CharIndex;
 240
 241 for (CharIndex = 0, Count = 0;*(Str + CharIndex);) {
 242   if (isspace(*(Str + CharIndex)))
 243     for (;isspace(*(Str + CharIndex));CharIndex++);
 244   else if (*(Str + CharIndex) && !isspace(*(Str + CharIndex)))
 245     for (Count++;(*(Str + CharIndex) && !isspace(*(Str + CharIndex)));
 246          CharIndex++);
 247 }
 248 return(Count);
 249 }
 250
 251 /**********************/
 252
 253 /*
 254  * Partial_parse_string(MaxWords, Str, argc_ptr, argv_ptr)
 255  *
 256  * Function:
 257  *      Parses line, dividing at whitespace, into tokens, returns
 258  *      the "argc" and "argv" values, up to MaxWords-1 tokens.  Remaining
 259  *      tokens after MaxWords-1 are all returned as one set in the final
 260  *      slot of "argv".  If MaxWords = 0, the number of tokens is not limited.
 261  * Arguments:
 262  *      MaxWords (int)
 263  *              Maximum number of tokens/strings to return
 264  *      Str (char *)
 265  *              Pointer to text string to be parsed.
 266  *      argc_ptr (int *)
 267  *              Where to put the "argc" (number of tokens) value.
 268  *      argv_ptr (char *[])
 269  *              Series of pointers to parsed tokens
 270  */
 271
 272 Partial_parse_string (MaxWords, Str, argc_ptr, argv_ptr)
 273 int MaxWords;
 274 char *Str;
 275 int *argc_ptr;
 276 char *argv_ptr[];
 277
 278 {
 279 char Buf[BUFSIZ];
 280 int NumTokens;
 281 int CharIndex;
 282 int i;
 283
 284 for (CharIndex = 0, NumTokens = 0;*(Str + CharIndex)
 285      && ((NumTokens < MaxWords-1) || !MaxWords);) {
 286   if (isspace(*(Str + CharIndex)))
 287     for (;isspace(*(Str + CharIndex));CharIndex++);
 288   else if (*(Str + CharIndex) && !isspace(*(Str + CharIndex)))
 289     for (NumTokens++, i=0;(*(Str + CharIndex) && !isspace(*(Str + CharIndex)));
 290          CharIndex++, i++) Buf[i] = *(Str + CharIndex);
 291   Buf[i] = '\0';
 292   argv_ptr[NumTokens-1] = (char *)malloc(sizeof(char) * (strlen(Buf) + 1));
 293   strcpy(argv_ptr[NumTokens-1], Buf);
 294 }
 295 *argc_ptr = NumTokens;
 296 if (NumTokens = MaxWords) {
 297   argv_ptr[NumTokens-1]=
 298     (char *) malloc(sizeof(char) * (1 + strlen(Str + CharIndex)));
 299   strcpy (argv_ptr[NumTokens-1], (Str + CharIndex));}
 300
 301 }
 302