pan/tag_report.c

/*
 * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Further, this software is distributed without any warranty that it is
 * free of the rightful claim of any third person regarding infringement
 * or the like.  Any license provided herein, whether implied or
 * otherwise, applies only to this software file.  Patent licenses, if
 * any, provided herein do not apply to combinations of this program with
 * other software, or any other product whatsoever.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 * Mountain View, CA  94043, or:
 *
 * http://www.sgi.com
 *
 * For further information regarding this notice, see:
 *
 * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
 *
 */
/* $Id: tag_report.c,v 1.2 2006/12/13 22:55:22 vapier Exp $ */
#include "tag_report.h"
#include "debug.h"
#include "reporter.h"
#include "splitstr.h"

static char *worst_case(char *, char *);

/************************************************************************
 *			Report Generation				*
 ************************************************************************/

/*
 * printf format statement for standard reports
 * 5 fields with max/min widths
 */
#define FORMAT "%-20.20s %-15.15s %10.10s %-20.20s %s\n"

/*
 *  This is the central results reporting function.  All standard report
 *  format results are printed thru test_result.
 */
int test_result(char *tag, char *tcid, char *tc, char *result, SYM tags)
{
	char *expert, expkey[KEYSIZE];
	register char *c;
	char **cont;
	const char **cont_save;

	if (tcid == NULL)
		tcid = "-";
	if (tc == NULL)
		tc = "-";
	if (tag == NULL)
		tag = "test_result: no tag";
	if (result == NULL)
		result = "(RESULT IS NULL)";

	strcpy(expkey, "contacts");
	/* note: the sym_get here does _not_ change the "cursor" */
	if ((expert = (char *)sym_get(tags, expkey)) == NULL) {
		expert = "UNKNOWN";
	}

	/* ' tr " " "_" ' */
	for (c = result; *c; c++) {
		if (*c == ' ') {
			*c = '_';
		}
	}
	if (*result == '\0')
		result = "?";

	/* split contacts on "," and print out a line for each */
	cont_save = splitstr(expert, ",", NULL);
	for (cont = (char **)cont_save; *cont != NULL; cont++) {
		printf(FORMAT, tag, tcid, tc, result, *cont);
	}
	splitstr_free(cont_save);

	return 0;
}

/*
 * CUTS test reporting.
 *
 *  (1) make a list (2d char array) of all TCIDs (see above for why)
 *  (2) look thru the list:
 *	(a) keep track of the "worst case" in this *TAG*
 *	(b) report each testcase's results
 *	(c) if the testcase number is != 0, count it
 *  (3) report tag's results
 *  (4) check the number of expected results with the actual results,
 *	report an error if they don't match.
 */

int cuts_report(SYM tags, SYM keys, char *at, char *tag)
{
	DBT Key, Data;

	/* analysis type: count of CUTS test cases */
	const char **ant;
	char *dat;		/* strdup(at) */
	int tccount;		/* expected count of testcases */
	int tcnum;		/* seen count of testcases */

	/* a list of tcids */
	char **taglist, **tl;
	int ntags, tagcount;

	char key_get[255];

	char *result = "", *worst_case();	/* overall result */

	/* parse analysis type: cuts:tc-count */
	ant = splitstr((dat = strdup(at)), ":", NULL);
	if (ant[1] != NULL)
		tccount = atoi(ant[1]);
	else
		tccount = 0;
	free(dat);
	splitstr_free(ant);

	/* extract tcids */
	ntags = NTCID_START;
	taglist = (char **)malloc(sizeof(char *) * ntags);
	tagcount = 0;

	tl = taglist;
	sym_seq(tags, &Key, &Data, R_FIRST);
	do {
		if (tagcount == ntags) {
			/* exceeded tag array size -- realloc */
			ntags += NTCID_START;
			taglist =
			    (char **)realloc(taglist, sizeof(char *) * ntags);
			tl = taglist + tagcount;
		}

		if (strcmp((char *)Key.data, "_keys") == 0)
			continue;
		DEBUG(D_REPORT, 10)
		    printf("cuts_report: tcid %s\n", (char *)Key.data);
		*tl++ = Key.data;
		tagcount++;
	} while (sym_seq(tags, &Key, &Data, R_NEXT) == 0);

	if (tagcount == ntags) {
		/* exceeded tag array size -- realloc */
		ntags++;	/* need just one more */
		taglist = (char **)realloc(taglist, sizeof(char *) * ntags);
		tl = taglist + tagcount;
	}

	*tl++ = NULL;

	ntags = tagcount;

	/* dump all found records */
	tcnum = 0;
	for (tl = taglist; *tl != NULL; tl++) {

		strcpy(key_get, *tl);
		Key.data = (void *)key_get;

		/*sym_dump_s(sym_get(tags, key_get), 0); */

		sym_seq(tags, &Key, &Data, R_CURSOR);
		do {
			DEBUG(D_REPORT, 10)
			    printf("cuts_report: tc %s = %s\n",
				   (char *)Key.data, (char *)Data.data);
			result = worst_case(result, (char *)Data.data);
			test_result(tag, *tl, (char *)Key.data,
				    (char *)Data.data, keys);
			if (atoi((char *)Key.data))
				tcnum++;
		} while (sym_seq(tags, &Key, &Data, R_NEXT) == 0);
	}

	test_result(tag, "*", "*", result, keys);

	if (tccount != 0 && tccount != tcnum)
		test_result(tag, "-", "-", "TC count wrong", keys);

	free(taglist);

	return 0;
}

/*
 * Do the report generation.
 *
 * A problem: I really need multiple cursors.  I'd rather not look into
 * the depths of the current symbol table implimentation (there are the
 * cursors there that I could use) so that a different (faster!) symbol
 * table can be used in the future.
 *
 * I could get a key (tag), get it's sub-keys (TCIDs), then get the key
 * again to reset to the top level, _then_ get the next key.  That would
 * be very inefficient.
 *
 * The solution I chose is to extract all tags into a list (char array),
 * then go thru that list with the cursor free for other levels to use.
 *
 *  (1) make a list (2d char array) of all Tags
 *  (2) search for the first tag that has a "stime" record, and use that as
 *      the date (MMDDYY) that the tests were run.
 *  (3) print the report header
 *  (4) go thru all tags and report each as described at the beginning of
 *      this file
 */
int tag_report(SYM alltags, SYM ctag, SYM keys)
{

	extern int extended;

	char key_get[KEYSIZE];
	char *info;

	/* retrieved _keys values: initation status, start time, duration,
	 * termination type, termination id, start line, end line.          */
	char *tag, *contact, *is, *mystime, *duration, *tt, *ti, *sl, *el;

	/* Check all driver-level status first */
	strcpy(key_get, "tag");
	if ((tag = (char *)sym_get(keys, key_get)) == NULL) {
		return -1;
	}

	/* Check all driver-level status first */
	strcpy(key_get, "initiation_status");
	if ((is = (char *)sym_get(keys, key_get)) == NULL) {
		test_result(tag, NULL, NULL, "no init status", keys);
		return -1;
	}

	if (strcmp(is, "ok")) {
		test_result(tag, NULL, NULL, is, keys);
	} else {

		strcpy(key_get, "corefile");
		if ((info = (char *)sym_get(keys, key_get)) != NULL)
			if (strcmp(info, "no") != 0) {
				test_result(tag, NULL, NULL, "coredump", keys);
			}

		strcpy(key_get, "termination_type");
		if ((tt = (char *)sym_get(keys, key_get)) == NULL) {
			test_result(tag, NULL, NULL, "no Term Type", keys);
			return -1;
		}

		if (strcmp(tt, "exited")) {
			test_result(tag, NULL, NULL, tt, keys);
		}

		strcpy(key_get, "analysis");
		if ((info = (char *)sym_get(keys, key_get)) == NULL) {
			test_result(tag, NULL, NULL, "no Analysis Type", keys);
			return -1;
		}

		/* Getting here indicates that there were no fatal driver-level
		 * errors.  Do the kind of reporting requested by the test.
		 */

		if (strncmp(info, "none", 4) == 0) {
			/*
			 * If analysis is 'none', alway report the test as
			 * a pass regardless of output or exit status.
			 */
			test_result(tag, NULL, NULL, "pass", keys);

		} else if (strncmp(info, "cuts", 4)) {

			/*
			 * If analysis is not cuts, assume it is 'exit', thus
			 * the termination_id is used to determine pass/fail result.
			 */
			if (strcmp(tt, "timeout")) {
				strcpy(key_get, "termination_id");
				if ((info =
				     (char *)sym_get(keys, key_get)) == NULL) {
					test_result(tag, NULL, NULL,
						    "no_Term_Id", keys);
				} else {
					if (strcmp(info, "0")) {
						test_result(tag, NULL, NULL,
							    "fail", keys);
					} else {
						test_result(tag, NULL, NULL,
							    "pass", keys);
					}
				}
			}
		} else {
			cuts_report(ctag, keys, info, tag);
		}
	}

	/*
	 * Extended Format:
	 *  - tcid+tc = "!"
	 *  - tab separated fields
	 *  - no field widths
	 *  - fields 6 - ~ are:
	 *  start-time (time_t)
	 *  duration
	 *  termination_id
	 *  termination_type
	 *  Start Line (of test results in output file)
	 *  End Line
	 */

	if (extended) {

		strcpy(key_get, "termination_id");
		if ((ti = (char *)sym_get(keys, key_get)) == NULL) {
			ti = "No_Termination_ID";
		}

		strcpy(key_get, "termination_type");
		if ((tt = (char *)sym_get(keys, key_get)) == NULL) {
			tt = "No_Termination_Type";
		}

		strcpy(key_get, "duration");
		if ((duration = (char *)sym_get(keys, key_get)) == NULL) {
			duration = "No_Duration";
		}

		strcpy(key_get, "_Start_line");
		if ((sl = (char *)sym_get(keys, key_get)) == NULL) {
			sl = "No_Start_line";
		}

		strcpy(key_get, "_End_line");
		if ((el = (char *)sym_get(keys, key_get)) == NULL) {
			el = "No_End_line";
		}

		strcpy(key_get, "contacts");
		if ((contact = (char *)sym_get(keys, key_get)) == NULL) {
			contact = "No_Contacts";
		}

		strcpy(key_get, "stime");
		if ((mystime = (char *)sym_get(keys, key_get)) == NULL) {
			mystime = "No_stime";
		}

		printf("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t\n",
		       tag, "!", "!", is, contact, mystime, duration,
		       ti, tt, sl, el);
	}

	return 0;
}

/*
 *  Print a header made up of the RTS keywords
 *  In "extended" mode, print the header to stderr.
 */
int print_header(SYM tags)
{
	DBT Key, Data;
	char key_get[255];

	FILE *out;

	extern int extended;

	if (extended)
		out = stderr;
	else
		out = stdout;

	fprintf(out, "System Configuration:\n");
	/* build header out of RTS keywords */
	sprintf(key_get, "_RTS");
	Key.data = (void *)key_get;
	if (sym_seq(tags, &Key, &Data, R_CURSOR) == 0) {
		do {
			if (strcmp((char *)Key.data, "PATH") == 0)
				continue;
			fprintf(out, "%-20.20s %s\n", (char *)Key.data,
				(char *)Data.data);
		} while (sym_seq(tags, &Key, &Data, R_NEXT) == 0);
	}

	fprintf(out, "\n");
	fprintf(out, FORMAT, "tag", "tcid", "testcase", "status", "contact");
	fprintf(out,
		"-------------------------------------------------------------------------------\n");

	return 0;
}

/*
 * CUTS testcase record
 *
 * This is passed s SYM for the current tag and the initiation keys.
 * The text seen by lex is in yytext (global).
 */
int cuts_testcase(SYM tag, SYM keys)
{
	char *cuts_info[6];
	char key[KEYSIZE];
	char *oldresult, *newresult, *worst_case();
	int tok_num = 0;
	extern char yytext[];

	cuts_info[tok_num] = strtok(yytext, "\t ");
	while (tok_num < 5 &&
	       (cuts_info[++tok_num] = strtok(NULL, "\t ")) != NULL) ;

	strcpy(key, cuts_info[0]);
	strcat(key, ",");
	strcat(key, cuts_info[1]);

#ifdef DEBUGGING
	DEBUG(D_SCAN_CUTS, 1) {
		printf("cuts_testcase: TCID=%s TC=%s Result=%s\n", cuts_info[0],
		       cuts_info[1], cuts_info[2]);
		printf("cuts_testcase: %d %s\n", tok_num, key);
	}
#endif

	if ((oldresult = (char *)sym_get(tag, key)) != NULL) {
		/* Duplicate -- assume mulitple runs */
		/* keep "worst case" */
		newresult = worst_case(oldresult, cuts_info[2]);
		sym_put(tag, key, strdup(newresult), PUT_REPLACE);
		free(oldresult);	/* remove the "data" portion of the key */
	} else {
		sym_put(tag, key, strdup(cuts_info[2]), 0);
	}
	return 0;
}

/*
 * Determine a "worst case" status from two given statuses.
 */
static char *worst_case(char *t1, char *t2)
{
	/* NULL-terminated table, ordered from worst-case to best-case */
	static char *worst[] = {
		"FAIL", "BROK", "PASS", "CONF",
		"WARN", "INFO", NULL,
	};

	char **w1, **w2;

	/* Search the table for each status, then use the index to determine
	   which has a lower precedence */
	for (w1 = worst; *w1 != NULL && strcmp(t1, *w1); w1++) ;

	for (w2 = worst; *w2 != NULL && strcmp(t2, *w2); w2++) ;

	if (w1 < w2)
		return (t1);
	else
		return (t2);

}