path: root/usr/src/lib/fm/libdiagcode/common/diagcode_test.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * diagcode library unit test
 *
 * usually run from "make test" target.  takes a single argument
 * which is the directory where the test dictionaries are found.
 * this test driver scans the dictionaries for comments of the form:
 *	#TEST:<routine>:<errno>:<input>:<output>
 * and executes that test.
 *
 * exit 0 and an "All tests passed" message means no failures.  otherwise
 * error messages are spewed as appropriate and exit value is non-zero.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <alloca.h>
#include <errno.h>
#include <sys/types.h>
#include <dirent.h>
#include <stdarg.h>

#include <fm/diagcode.h>

#define	MAXLINE	10240
#define	MAXARG 10
#define	MAXKEY 100
#define	MAXCODE 100

static char *Myname;
static char *Dict;
static int Line;
static int Errcount;
static fm_dc_handle_t *Dhp;

/*PRINTFLIKE1*/
static void
err(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	(void) fprintf(stderr, "%s: %s:%d ", Myname, Dict, Line);
	(void) vfprintf(stderr, fmt, ap);
	(void) fprintf(stderr, "\n");
	Errcount++;
}

/* parse an expected errno value from test line (numeric or some symbolic) */
static int
geterrno(const char *s)
{
	if (*s == '\0' || isspace(*s))
		return (0);
	else if (isdigit(*s))
		return (atoi(s));
	else if (strcmp(s, "EPERM") == 0)
		return (EPERM);
	else if (strcmp(s, "ENOENT") == 0)
		return (ENOENT);
	else if (strcmp(s, "ESRCH") == 0)
		return (ESRCH);
	else if (strcmp(s, "ENOMEM") == 0)
		return (ENOMEM);
	else if (strcmp(s, "EACCES") == 0)
		return (EACCES);
	else if (strcmp(s, "EINVAL") == 0)
		return (EINVAL);
	else if (strcmp(s, "ERANGE") == 0)
		return (ERANGE);
	else if (strcmp(s, "ENOMSG") == 0)
		return (ENOMSG);
	else if (strcmp(s, "ENOTSUP") == 0)
		return (ENOTSUP);
	else {
		err("geterrno: don't know errno \"%s\"", s);
		Errcount++;
		return (0);
	}
}

/* call fm_dc_opendict() as part of a test */
static void
do_open(const char *dirpath, const char *dictname, char *argv[], int argc)
{
	int reterrno;
	int experrno;

	if (argc != 2) {
		err("argc != 2");
		return;
	}
	experrno = geterrno(argv[1]);

	if ((Dhp = fm_dc_opendict(FM_DC_VERSION, dirpath, dictname)) == NULL)
		reterrno = errno;
	else
		reterrno = 0;

	if (reterrno != experrno)
		err("opendict errno %d, expected %d", reterrno, experrno);
}

/* call fm_dc_closedict() as part of a test */
static void
do_close(const char *dirpath, const char *dictname, char *argv[], int argc)
{
	if (Dhp) {
		fm_dc_closedict(Dhp);
		Dhp = NULL;
	}
}

/* call fm_dc_codelen() as part of a test */
static void
do_codelen(const char *dirpath, const char *dictname, char *argv[], int argc)
{
	int retcodelen;
	int expcodelen;

	if (argc != 3) {
		err("argc != 3");
		return;
	}
	expcodelen = geterrno(argv[2]);

	if (Dhp == NULL) {
		err("codelen NULL handle");
		return;
	}

	retcodelen = fm_dc_codelen(Dhp);

	if (retcodelen != expcodelen)
		err("codelen %d, expected %d", retcodelen, expcodelen);
}

/* call fm_dc_maxkey() as part of a test */
static void
do_maxkey(const char *dirpath, const char *dictname, char *argv[], int argc)
{
	int retmaxkey;
	int expmaxkey;

	if (argc != 3) {
		err("argc != 3");
		return;
	}
	expmaxkey = geterrno(argv[2]);

	if (Dhp == NULL) {
		err("maxkey NULL handle");
		return;
	}

	retmaxkey = fm_dc_maxkey(Dhp);

	if (retmaxkey != expmaxkey)
		err("maxkey %d, expected %d", retmaxkey, expmaxkey);
}

/* call fm_dc_key2code() as part of a test */
static void
do_key2code(const char *dirpath, const char *dictname, char *argv[], int argc)
{
	int reterrno;
	int experrno;
	const char *key[MAXKEY];
	char code[MAXCODE];
	int nel;
	char *beginp;
	char *endp;

	if (argc < 3) {
		err("argc < 3");
		return;
	}
	if (argc > 4) {
		err("argc > 4");
		return;
	}
	experrno = geterrno(argv[1]);

	/* convert key into array */
	nel = 0;
	beginp = argv[2];
	while (nel < MAXKEY - 1) {
		key[nel++] = beginp;
		if ((endp = strchr(beginp, ' ')) != NULL) {
			*endp++ = '\0';
			beginp = endp;
		} else
			break;
	}
	key[nel] = NULL;

	if (Dhp == NULL) {
		err("key2code NULL handle");
		return;
	}

	if (fm_dc_key2code(Dhp, key, code, MAXCODE) < 0)
		reterrno = errno;
	else
		reterrno = 0;

	if (reterrno != experrno) {
		err("key2code errno %d, expected %d", reterrno, experrno);
		return;
	}

	if (reterrno == 0 && argc > 3 && strcmp(code, argv[3]))
		err("code \"%s\", expected \"%s\"", code, argv[3]);
}

/* call fm_dc_code2key() as part of a test */
static void
do_code2key(const char *dirpath, const char *dictname, char *argv[], int argc)
{
	int reterrno;
	int experrno;
	char keystr[MAXLINE];
	char *key[MAXKEY];
	int nel;

	if (argc < 3) {
		err("argc < 3");
		return;
	}
	if (argc > 4) {
		err("argc > 4");
		return;
	}
	experrno = geterrno(argv[1]);

	if (Dhp == NULL) {
		err("code2key NULL handle");
		return;
	}

	if (fm_dc_code2key(Dhp, argv[2], key, fm_dc_maxkey(Dhp)) < 0)
		reterrno = errno;
	else
		reterrno = 0;

	if (reterrno != experrno) {
		err("errno %d, expected %d", reterrno, experrno);
		return;
	}

	if (reterrno)
		return;

	if (argc > 3) {
		/* convert key into string */
		keystr[0] = '\0';
		for (nel = 0; key[nel]; nel++) {
			if (nel)
				(void) strcat(keystr, " ");
			(void) strcat(keystr, key[nel]);
		}

		if (strcmp(keystr, argv[3]))
			err("key \"%s\", expected \"%s\"", keystr, argv[3]);
	}
	for (nel = 0; key[nel]; nel++)
		free(key[nel]);
}

/* call fm_dc_getprop() as part of a test */
static void
do_getprop(const char *dirpath, const char *dictname, char *argv[], int argc)
{
	int reterrno;
	int experrno;
	const char *val;

	if (argc != 4) {
		err("argc != 4");
		return;
	}
	experrno = geterrno(argv[1]);

	if (Dhp == NULL) {
		err("getprop NULL handle");
		return;
	}

	if ((val = fm_dc_getprop(Dhp, argv[2])) == NULL)
		reterrno = errno;
	else
		reterrno = 0;

	if (reterrno != experrno) {
		err("getprop errno %d, expected %d", reterrno, experrno);
		return;
	}

	if (reterrno == 0 && strcmp(val, argv[3]))
		err("val \"%s\", expected \"%s\"", val, argv[3]);
}

/* scan a dictionary, looking for test directives embedded in the comments */
static void
testdict(const char *dirpath, const char *dictname)
{
	char linebuf[MAXLINE];
	char fname[MAXLINE];
	FILE *fp;

	(void) snprintf(fname, MAXLINE, "%s/%s.dict", dirpath, dictname);

	if ((fp = fopen(fname, "r")) == NULL) {
		perror(fname);
		Errcount++;
		return;
	}

	Line = 0;
	Dict = fname;

	while (fgets(linebuf, MAXLINE, fp) != NULL) {
		char *argv[MAXARG];
		int argc;
		char *beginp;
		char *endp;

		Line++;
		if (strncmp(linebuf, "#TEST:", 6))
			continue;

		if ((endp = strchr(linebuf, '\n')) != NULL)
			*endp = '\0';
		argc = 0;
		beginp = &linebuf[6];
		while (argc < MAXARG - 1) {
			argv[argc++] = beginp;
			if ((endp = strchr(beginp, ':')) != NULL) {
				*endp++ = '\0';
				beginp = endp;
			} else
				break;
		}
		argv[argc] = NULL;

		if (strcmp(argv[0], "open") == 0)
			do_open(dirpath, dictname, argv, argc);
		else if (strcmp(argv[0], "close") == 0)
			do_close(dirpath, dictname, argv, argc);
		else if (strcmp(argv[0], "codelen") == 0)
			do_codelen(dirpath, dictname, argv, argc);
		else if (strcmp(argv[0], "maxkey") == 0)
			do_maxkey(dirpath, dictname, argv, argc);
		else if (strcmp(argv[0], "key2code") == 0)
			do_key2code(dirpath, dictname, argv, argc);
		else if (strcmp(argv[0], "code2key") == 0)
			do_code2key(dirpath, dictname, argv, argc);
		else if (strcmp(argv[0], "getprop") == 0)
			do_getprop(dirpath, dictname, argv, argc);
		else {
			err("unknown TEST command: \"%s\"", argv[0]);
			Errcount++;
		}
	}

	(void) fclose(fp);

	if (Dhp) {
		fm_dc_closedict(Dhp);
		Dhp = NULL;
	}
}

/* scan a directory, looking for dictionaries to test against */
int
main(int argc, char *argv[])
{
	DIR *dirp;
	struct dirent *dp;

	if ((Myname = strrchr(argv[0], '/')) == NULL)
		Myname = argv[0];
	else
		Myname++;

	if (argc != 2) {
		(void) fprintf(stderr, "usage: %s test-directory\n", argv[0]);
		exit(1);
	}

	if ((dirp = opendir(argv[1])) == NULL) {
		perror(argv[1]);
		exit(1);
	}

	while ((dp = readdir(dirp)) != NULL) {
		char *ptr;

		if (dp->d_name[0] == '.')
			continue;

		if ((ptr = strrchr(dp->d_name, '.')) == NULL ||
		    strcmp(ptr, ".dict"))
			continue;

		*ptr = '\0';	/* remove the extension */
		testdict(argv[1], dp->d_name);
	}
	(void) closedir(dirp);

	if (Errcount == 0)
		(void) printf("%s: All tests passed.\n", Myname);

	return (Errcount);
}