evolution/camel/tests/lib/camel-test.c

#include "camel-test.h"

#include <stdio.h>
#include <signal.h>

struct _stack {
	struct _stack *next;
	char *what;
};

static int setup;
static struct _stack *state;
static struct _stack *nonfatal;
static int ok;

int camel_test_verbose;

static void die(int sig)
{
	static int indie = 0;
	struct _stack *node;

	if (!indie) {
		indie = 1;
		printf("\n\nReceived fatal signal %d\n", sig);
		node = state;
		if (node) {
			printf("Current action:\n");
			while (node) {
				printf("\t%s\n", node->what);
				node = node->next;
			}
		}
	}

	_exit(1);
}

void camel_test_init(int argc, char **argv)
{
	void camel_init(void);
	int i;

	setup = 1;

	camel_init();

	/* yeah, we do need ot thread init, even though camel isn't compiled with enable threads */
	g_thread_init(NULL);

	signal(SIGSEGV, die);
	signal(SIGABRT, die);

	/* default, just say what, how well we did, unless fail, then abort */
	camel_test_verbose = 1;

	for (i=0;i<argc;i++) {
		if (argv[i][0] == '-') {
			switch (argv[i][1]) {
			case 'v':
				camel_test_verbose = strlen(argv[i]);
				break;
			case 'q':
				camel_test_verbose = 0;
				break;
			}
		}
	}
}

void camel_test_start(const char *what)
{
	if (!setup)
		camel_test_init(0, 0);

	ok = 1;

	if (camel_test_verbose > 0) {
		printf("Test: %s ... ", what);
		fflush(stdout);
	}
}

void camel_test_push(const char *what, ...)
{
	struct _stack *node;
	va_list ap;
	char *text;

	va_start(ap, what);
	text = g_strdup_vprintf(what, ap);
	va_end(ap);

	if (camel_test_verbose > 3)
		printf("Start step: %s\n", text);

	node = g_malloc(sizeof(*node));
	node->what = text;
	node->next = state;
	state = node;
}

void camel_test_pull(void)
{
	struct _stack *node;

	g_assert(state);

	if (camel_test_verbose > 3)
		printf("Finish step: %s\n", state->what);

	node = state;
	state = node->next;
	g_free(node->what);
	g_free(node);
}

/* where to set breakpoints */
void camel_test_break(void)
{
}

void camel_test_fail(const char *why, ...)
{
	va_list ap;

	va_start(ap, why);
	camel_test_failv(why, ap);
	va_end(ap);
}

void camel_test_failv(const char *why, va_list ap)
{
	struct _stack *node;
	char *text;

	text = g_strdup_vprintf(why, ap);

	if ((nonfatal == NULL && camel_test_verbose > 0)
	    || (nonfatal && camel_test_verbose > 1)) {
		printf("Failed.\n%s\n", text);
		camel_test_break();
	}

	g_free(text);

	if ((nonfatal == NULL && camel_test_verbose > 0)
	    || (nonfatal && camel_test_verbose > 2)) {
		node = state;
		if (node) {
			printf("Current action:\n");
			while (node) {
				printf("\t%s\n", node->what);
				node = node->next;
			}
		}
	}

	if (nonfatal == NULL) {
		exit(1);
	} else {
		ok=0;
		if (camel_test_verbose > 1) {
			printf("Known problem (ignored): %s\n", nonfatal->what);
		}
	}
}

void camel_test_nonfatal(const char *why, ...)
{
	struct _stack *node;
	va_list ap;
	char *text;

	va_start(ap, why);
	text = g_strdup_vprintf(why, ap);
	va_end(ap);

	if (camel_test_verbose>3)
		printf("Start nonfatal: %s\n", text);

	node = g_malloc(sizeof(*node));
	node->what = text;
	node->next = nonfatal;
	nonfatal = node;
}

void camel_test_fatal(void)
{
	struct _stack *node;

	g_assert(nonfatal);

	if (camel_test_verbose>3)
		printf("Finish nonfatal: %s\n", nonfatal->what);

	node = nonfatal;
	nonfatal = node->next;
	g_free(node->what);
	g_free(node);
}

void camel_test_end(void)
{
	if (camel_test_verbose > 0) {
		if (ok)
			printf("Ok\n");
		else
			printf("Partial success\n");
	}

	fflush(stdout);
}




/* compare strings, ignore whitespace though */
int string_equal(const char *a, const char *b)
{
	const char *ap, *bp;

	ap = a;
	bp = b;

	while (*ap && *bp) {
		while (*ap == ' ' || *ap == '\n' || *ap == '\t')
			ap++;
		while (*bp == ' ' || *bp == '\n' || *bp == '\t')
			bp++;

		a = ap;
		b = bp;

		while (*ap && *ap != ' ' && *ap != '\n' && *ap != '\t')
			ap++;
		while (*bp && *bp != ' ' && *bp != '\n' && *bp != '\t')
			bp++;

		if (ap - a != bp - a
		    && ap - 1 > 0
		    && memcmp(a, b, ap-a) != 0) {
			return 0;
		}
	}

	return 1;
}