[moira.git] / clients / mrtest / tst.c

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1991 by the Massachusetts Institute of Technology
 *	For copying and distribution information, please see the file
 *	<mit-copyright.h>.
 *
 */


#include <stdio.h>
#include <sys/types.h>
#include <sys/file.h>
#include <ctype.h>
#include <moira.h>
#include <ss.h>
#include "mr_err_array.h"

extern ss_execute_line();
extern print_reply();
extern CompData();
extern int ss;
extern int errno;
extern int count;
extern int recursion;  

char *DataBuf;
char *ErrorBuf;

test_test (argc, argv)
int argc;
char *argv[];
{
  FILE *inp, *outp;
  char *cp, *index();
  int LineNum;
  int status;
  int NumArgs;
  char *ValArgs[50];
  char lastcmd[BUFSIZ], input[BUFSIZ], cmd[BUFSIZ];

  DataBuf =  (char *)malloc (2222);
  ErrorBuf = (char *)malloc (30);

  if (recursion > 8) {
    ss_perror(ss, 0, "too many levels deep in script/test files\n");
    return;
  }
  
  if (argc < 2) {
    ss_perror(ss, 0, "Usage: test input_file [ output_file ]");
    return;
  }
  
  inp = fopen(argv[1], "r");
  if (inp == NULL) {
    sprintf(cmd, "Cannot open input file %s", argv[1]);
    ss_perror(ss, 0, cmd);
    return;
  }
  
  if (argc == 3) {
    outp = fopen(argv[2], "a");
    if (!outp) {
      sprintf(cmd, "Unable to open output for %s\n", argv[2]);   
      ss_perror(ss, errno, cmd);
      return;}}
  else outp = stdout;

  *lastcmd = '\0';

  recursion++;
  
  for(LineNum = 0;;LineNum++) {
    *DataBuf = '\0';
    *ErrorBuf = '\0';
    if (fgets(input, BUFSIZ, inp) == NULL) {
      if (lastcmd[0] != '\0') {
	strcpy (input, lastcmd);
	lastcmd[0] = '\0';}
      else break;}
    if ((cp = index(input, '\n')) != (char *)NULL)
      *cp = 0;
    if (input[0] == 0) continue;

    if (input[0] == '%') {
      for (cp = &input[1]; *cp && isspace(*cp); cp++);
      strcat(DataBuf, "Comment: ");
      strcat(DataBuf, cp);
      strcat(DataBuf, "\n");
      continue;
    }

    if (input[0] == '>') {     /* Load in a Comparison String */
      if (lastcmd[0] == '\0') {
	fprintf(outp, 
	   "\nERROR IN LINE %d: Comparison String Without Comparable Command\n", 
	   LineNum);
	fprintf(outp, "%s\n", input);
	*DataBuf = '\0';
	continue;}
      else { /* Parse and Execute command with compare */
	sprintf (cmd, "COMPARE_%s", lastcmd);
	bzero((char *)ValArgs, sizeof(ValArgs));
	Partial_parse_string(0, cmd, &NumArgs, ValArgs); 
	ValArgs[NumArgs] = (char *)malloc(sizeof(char) * (1+strlen(input)));
	strcpy(ValArgs[NumArgs], input);
	status = ss_execute_command(ss, ValArgs); 
	lastcmd[0] = '\0';

/* Dump errors and data if necessary */
	if (!strcmp(ErrorBuf, "Malformed Comparison String0")) {
	  fprintf(outp, "\nERROR IN LINE %d: %s\n", LineNum, ErrorBuf);
	  fprintf(outp, "%s\n", input);
	  continue;}
	else if (*ErrorBuf) { /* Data Error */
	  fprintf(outp, "\nERROR IN LINE %d: %s\n", LineNum, ErrorBuf);
	  fprintf(outp, "%s\n", DataBuf);
	  continue;}
	else continue;  /* Command Checks */
      }}

/* It wasn't a Comparison line, so clear the stack */
    if (lastcmd[0] != '\0') {  /* Run an old command w/o a comparison string */
      ss_execute_line(ss, lastcmd, &status);
      if (status == SS_ET_COMMAND_NOT_FOUND) 
	printf("Bad command: %s\n", input);
      *lastcmd = '\0';}

/* Push command on the stack if it's comparable (currently only queries are) */
    if (!(strncasecmp (input, "qy ", 3) && strncasecmp (input, "query ", 6))) {
      /* Delay this command in case there's a comparison line following it */
      strcpy (lastcmd, input);
      continue;}

/* Non-comparible command; execute immediately */
    ss_execute_line(ss, input, &status);
    if (status == SS_ET_COMMAND_NOT_FOUND) {
      printf("Bad command: %s\n", input);
    }
  }
  
  recursion--;
  
  fclose(inp);
  if (argc > 2) 
    close(outp);
}

/**********************************/

test_query_compare(argc, argv)
     int argc;
     char **argv;
{ /* argv = "COMPARE_qy" + args to query + compstring */
  int Qstatus = 0;      /* Status returned from the query */
  char *CompTo[5];
  int NumWordsComp=0, i;

  if (argc < 2) { 
    ss_perror(ss, 0, "Usage: query handle [ args ... ]");
    return;
  }
/* Execute query with a comparison string */
  count = 0;

  /* Parse comp string into '>', char, ErrMsg, NumEntries, and Data */
  bzero((char *)CompTo, sizeof(CompTo));
  Partial_parse_string (4, argv[argc-1], &NumWordsComp, CompTo);
  if (NumWordsComp < 3) { /* Too few args in comparison string */
        strcpy(ErrorBuf, "Malformed Comparison String1");}
  else {

    for (i=0;i<argc;i++) {
      printf("argv[%d] = %s\n", i, argv[i]);}
    printf("CompTo[3] = %s\n\n", CompTo[3]);


    Qstatus = mr_query(argv[1], argc-3, argv+2, CompData,
		       (char *)(&CompTo[3]));

/* Check the number of tuples returned */
    if (*CompTo[2] == '<') {
      if (isdigit(*(CompTo[2] + 1))) {
	if (atoi(CompTo[2] + 1) <= count) 
	  strcat(ErrorBuf, "\nToo many tuples returned");}
      else if (*ErrorBuf == '\0') 
	strcpy(ErrorBuf, "Malformed Comparison String2");}
    else if (*CompTo[2] == '>') {
      if (isdigit(*(CompTo[2] + 1))) {
	if (atoi(CompTo[2] + 1) >= count)
	  strcat(ErrorBuf, "\nToo few tuples returned");}
      else if (*ErrorBuf == '\0') 
	strcpy(ErrorBuf, "Malformed Comparison String3");}
    else if (isdigit(*(CompTo[2]))) {
      if (atoi(CompTo[2]) != count)
	strcat(ErrorBuf, "\nWrong number tuples returned");}
    else if (strcmp(CompTo[2], "*")) 
      if (*ErrorBuf == '\0')
	strcpy(ErrorBuf, "Malformed Comparison String4");
    
    /* Check return status */
    if (!Comp_mr_err_table(Qstatus, CompTo[1]))
      {
	strcat(ErrorBuf, "\nRet Status Error, returns: ");
	if (Qstatus)
	  strcat(ErrorBuf, MR_ERR_ARRAY[Qstatus - ERROR_TABLE_BASE_sms]);
	else 
	  strcat(ErrorBuf, "SUCCESS");}
    
  }}

/********************************************/

int Comp_mr_err_table (ErrNum, ErrName)
int ErrNum;
char *ErrName;

/* Returns 1 if ErrNum = the string in ErrName in MR_ERR_ARRAY, else 0 */

{
if (!ErrNum && ((!strcasecmp(ErrName, "SUCCESS"))  
		 || (!strcasecmp(ErrName, "S")))) 
  return(1);
else if (!ErrNum) return (0);
else if (ErrNum >= ERROR_TABLE_BASE_sms) 
  return (!strcmp (MR_ERR_ARRAY[ErrNum - ERROR_TABLE_BASE_sms], ErrName));
else return (0);
}

/********************************************/

int NumWords (Str)
char *Str;
{
int Count;
int CharIndex;

for (CharIndex = 0, Count = 0;*(Str + CharIndex);) {
  if (isspace(*(Str + CharIndex)))
    for (;isspace(*(Str + CharIndex));CharIndex++);
  else if (*(Str + CharIndex) && !isspace(*(Str + CharIndex)))
    for (Count++;(*(Str + CharIndex) && !isspace(*(Str + CharIndex)));
         CharIndex++);
}
return(Count);
}

/**********************/

/*
 * Partial_parse_string(MaxWords, Str, argc_ptr, argv_ptr)
 *
 * Function:
 *      Parses line, dividing at whitespace, into tokens, returns
 *      the "argc" and "argv" values, up to MaxWords-1 tokens.  Remaining
 *      tokens after MaxWords-1 are all returned as one set in the final
 *      slot of "argv".  If MaxWords = 0, the number of tokens is not limited.
 * Arguments:
 *      MaxWords (int)
 *              Maximum number of tokens/strings to return
 *      Str (char *)
 *              Pointer to text string to be parsed.
 *      argc_ptr (int *)
 *              Where to put the "argc" (number of tokens) value.
 *      argv_ptr (char *[])
 *              Series of pointers to parsed tokens
 */

Partial_parse_string (MaxWords, Str, argc_ptr, argv_ptr)
int MaxWords;
char *Str;
int *argc_ptr;
char *argv_ptr[];

{
char Buf[BUFSIZ];
int NumTokens;
int CharIndex;
int i;

for (CharIndex = 0, NumTokens = 0;*(Str + CharIndex) 
     && ((NumTokens < MaxWords-1) || !MaxWords);) {
  if (isspace(*(Str + CharIndex)))
    for (;isspace(*(Str + CharIndex));CharIndex++);
  else if (*(Str + CharIndex) && !isspace(*(Str + CharIndex)))
    for (NumTokens++, i=0;(*(Str + CharIndex) && !isspace(*(Str + CharIndex)));
         CharIndex++, i++) Buf[i] = *(Str + CharIndex);
  Buf[i] = '\0';
  argv_ptr[NumTokens-1] = (char *)malloc(sizeof(char) * (strlen(Buf) + 1));
  strcpy(argv_ptr[NumTokens-1], Buf);
}
*argc_ptr = NumTokens;
if (NumTokens = MaxWords) {
  argv_ptr[NumTokens-1]=
    (char *) malloc(sizeof(char) * (1 + strlen(Str + CharIndex)));
  strcpy (argv_ptr[NumTokens-1], (Str + CharIndex));}

}
Commit	Line	Data
92e88c2c	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>
4ca813bd	18	#include <ss.h>
92e88c2c	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) {
bddd8492	59	sprintf(cmd, "Cannot open input file %s", argv[1]);
bddd8492	60	ss_perror(ss, 0, cmd);
92e88c2c	61	return;
	62	}
	63
	64	if (argc == 3) {
	65	outp = fopen(argv[2], "a");
	66	if (!outp) {
bddd8492	67	sprintf(cmd, "Unable to open output for %s\n", argv[2]);
bddd8492	68	ss_perror(ss, errno, cmd);
92e88c2c	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