xref: /titanic_51/usr/src/test/libc-tests/tests/common/test_common.c (revision dcdfe824b3dff2df12578b936adf1daf000aa129)

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2015 Garrett D'Amore <garrett@damore.org>
 */

/*
 * Common handling for test programs.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/param.h>
#include "test_common.h"

static int debug = 0;
static int force = 0;
static pthread_mutex_t lk;

static int passes;
static int tests;

struct test {
	char		*name;
	int		ntids;
	pthread_t	*tids;
	int		fails;
	void		*arg;
	void		(*func)(test_t t, void *);
};

void
test_set_debug(void)
{
	debug++;
}

void
test_set_force(void)
{
	force++;
}

test_t
test_start(const char *format, ...)
{
	va_list args;
	test_t t;
	char *s;

	t = calloc(1, sizeof (*t));
	va_start(args, format);
	(void) vasprintf(&s, format, args);
	va_end(args);

	(void) asprintf(&t->name, "%s (%s)", s, ARCH);
	free(s);

	(void) pthread_mutex_lock(&lk);
	(void) printf("TEST STARTING %s:\n", t->name);
	(void) fflush(stdout);
	(void) pthread_mutex_unlock(&lk);

#ifdef	LINT
	/* We inject references to make avoid name unused warnings */
	test_run(0, NULL, NULL, NULL);
	test_debugf(t, NULL);
	test_failed(t, NULL);
	test_passed(t);
	test_set_debug();
	test_set_force();
	test_summary();
	(void) test_load_config(t, NULL, NULL);
#endif

	tests++;
	return (t);
}

void
test_failed(test_t t, const char *format, ...)
{
	va_list args;

	(void) pthread_mutex_lock(&lk);
	if (t == NULL) {
		(void) printf("FAILURE: ");
		va_start(args, format);
		(void) vprintf(format, args);
		va_end(args);
		(void) printf("\n");
		(void) fflush(stdout);
		(void) pthread_mutex_unlock(&lk);
		return;
	}
	if (force || (t->ntids > 0)) {
		(void) printf("TEST FAILING %s: ", t->name);
	} else {
		(void) printf("TEST FAILED %s: ", t->name);
	}

	va_start(args, format);
	(void) vprintf(format, args);
	va_end(args);
	(void) printf("\n");
	(void) fflush(stdout);
	(void) pthread_mutex_unlock(&lk);

	t->fails++;
	if (!force) {
		if (t->ntids > 0) {
			pthread_exit(NULL);
		} else {
			(void) exit(EXIT_FAILURE);
		}
	}
}

void
test_passed(test_t t)
{
	if (t == NULL) {
		return;
	}
	if (t->ntids > 0) {
		if (debug) {
			(void) pthread_mutex_lock(&lk);
			(void) printf("TEST PASSING: %s\n", t->name);
			(void) pthread_mutex_unlock(&lk);
		}
		return;
	}
	(void) pthread_mutex_lock(&lk);
	if (t->fails == 0) {
		passes++;
		(void) printf("TEST PASS: %s\n", t->name);
	} else {
		(void) printf("TEST FAILED: %d failures\n", t->fails);
	}
	(void) fflush(stdout);
	(void) pthread_mutex_unlock(&lk);
	free(t->name);
	if (t->tids) {
		free(t->tids);
	}
	free(t);
}

void
test_summary(void)
{
	if (passes == tests) {
		(void) printf("TEST SUMMARY: %d / %d (ok)\n", passes, tests);
	} else {
		(void) printf("TEST SUMMARY: %d / %d (%d failing)\n",
		    passes, tests, tests - passes);
	}
}

void
test_debugf(test_t t, const char *format, ...)
{
	va_list args;

	if (!debug)
		return;

	(void) pthread_mutex_lock(&lk);
	if (t) {
		(void) printf("TEST DEBUG %s: ", t->name);
	} else {
		(void) printf("TEST DEBUG: ");
	}
	va_start(args, format);
	(void) vprintf(format, args);
	va_end(args);
	(void) printf("\n");
	(void) fflush(stdout);
	(void) pthread_mutex_unlock(&lk);
}

static void *
test_thr_one(void *arg)
{
	test_t t = arg;
	t->func(t, t->arg);
	return (NULL);
}

void
test_run(int nthr, void (*func)(test_t, void *), void *arg,
    const char *tname, ...)
{
	test_t		t;
	char		*s;
	va_list		args;

	t = calloc(1, sizeof (*t));
	t->ntids = nthr;
	t->tids = calloc(nthr, sizeof (pthread_t));
	t->func = func;
	t->arg = arg;

	va_start(args, tname);
	(void) vasprintf(&s, tname, args);
	va_end(args);

	(void) asprintf(&t->name, "%s (%s)", s, ARCH);
	free(s);

	(void) pthread_mutex_lock(&lk);
	(void) printf("TEST STARTING %s:\n", t->name);
	(void) fflush(stdout);
	(void) pthread_mutex_unlock(&lk);

	test_debugf(t, "running %d threads", nthr);

	for (int i = 0; i < nthr; i++) {
		test_debugf(t, "started thread %d", i);
		(void) pthread_create(&t->tids[i], NULL, test_thr_one, t);
	}

	for (int i = 0; i < nthr; i++) {
		(void) pthread_join(t->tids[i], NULL);
		test_debugf(t, "thread %d joined", i);
		t->ntids--;
	}
	test_passed(t);
}

void
test_trim(char **ptr)
{
	char *p = *ptr;
	while (isspace(*p)) {
		p++;
	}
	*ptr = p;
	p += strlen(p);
	while ((--p >= *ptr) && (isspace(*p))) {
		*p = '\0';
	}
}

#define	MAXCB		20
#define	MAXFIELD	20

int
test_load_config(test_t t, const char *fname, ...)
{
	va_list		va;
	const char	*keyws[MAXCB];
	test_cfg_func_t	callbs[MAXCB];
	char		*fields[MAXFIELD];
	int		nfields;

	FILE    	*cfg;
	char    	line[1024];
	char    	buf[1024];
	int		done;
	char		*ptr;
	char		*tok;
	char		*err;
	int		lineno;
	int		rv;
	int		found;
	char		path[MAXPATHLEN];
	int		i;

	va_start(va, fname);
	for (i = 0; i < MAXCB; i++) {
		keyws[i] = (const char *)va_arg(va, const char *);
		if (keyws[i] == NULL)
			break;
		callbs[i] = (test_cfg_func_t)va_arg(va, test_cfg_func_t);
	}
	va_end(va);
	if (i == MAXCB) {
		test_debugf(t, "too many arguments to function >= %d", MAXCB);
	}

	found = 0;

	if (access(fname, F_OK) == 0) {
		found++;
	}
	if (!found && fname[0] != '/') {
		char *stf = getenv("STF_SUITE");
		if (stf == NULL) {
			stf = "../..";
		}
		(void) snprintf(path, sizeof (path), "%s/cfg/%s", stf, fname);
		if (access(path, F_OK) == 0) {
			fname = path;
			found++;
		} else {
			(void) snprintf(path, sizeof (path), "cfg/%s", fname);
			if (access(path, F_OK) == 0) {
				fname = path;
				found++;
			}
		}
	}

	if ((cfg = fopen(fname, "r")) ==  NULL) {
		test_failed(t, "open(%s): %s", fname, strerror(errno));
		return (-1);
	}

	line[0] = 0;
	done = 0;
	lineno = 0;

	while (!done) {

		lineno++;

		if (fgets(buf, sizeof (buf), cfg) == NULL) {
			done++;
		} else {
			(void) strtok(buf, "\n");
			if ((*buf != 0) && (buf[strlen(buf)-1] == '\\')) {
				/*
				 * Continuation.  This isn't quite right,
				 * as it doesn't allow for a "\" at the
				 * end of line (no escaping).
				 */
				buf[strlen(buf)-1] = 0;
				(void) strlcat(line, buf, sizeof (line));
				continue;
			}
			(void) strlcat(line, buf, sizeof (line));
		}

		/* got a line */
		ptr = line;
		test_trim(&ptr);

		/* skip comments and empty lines */
		if (ptr[0] == 0 || ptr[0] == '#') {
			line[0] = 0;
			continue;
		}

		tok = strsep(&ptr, "|");
		if (tok == NULL) {
			break;
		}
		test_trim(&tok);

		for (nfields = 0; nfields < MAXFIELD; nfields++) {
			fields[nfields] = strsep(&ptr, "|");
			if (fields[nfields] == NULL) {
				break;
			}
			test_trim(&fields[nfields]);
		}

		found = 0;
		rv = 0;

		for (int i = 0; keyws[i] != NULL; i++) {
			if (strcmp(tok, keyws[i]) == 0) {
				found++;
				err = NULL;
				rv = callbs[i](fields, nfields, &err);
			}
		}
		if (!found) {
			rv = -1;
			err = NULL;
			(void) asprintf(&err, "unknown keyword %s", tok);
		}
		if (rv != 0) {
			if (err) {
				test_failed(t, "%s:%d: %s", fname,
				    lineno, err);
				free(err);
			} else {
				test_failed(t, "%s:%d: unknown error",
				    fname, lineno);
			}
			(void) fclose(cfg);
			return (rv);
		}

		line[0] = 0;
	}
	(void) fclose(cfg);
	return (0);
}