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