t/unit-tests/test-lib.c

#include "test-lib.h"

enum result {
	RESULT_NONE,
	RESULT_FAILURE,
	RESULT_SKIP,
	RESULT_SUCCESS,
	RESULT_TODO
};

static struct {
	enum result result;
	int count;
	unsigned failed :1;
	unsigned lazy_plan :1;
	unsigned running :1;
	unsigned skip_all :1;
	unsigned todo :1;
} ctx = {
	.lazy_plan = 1,
	.result = RESULT_NONE,
};

/*
 * Visual C interpolates the absolute Windows path for `__FILE__`,
 * but we want to see relative paths, as verified by t0080.
 * There are other compilers that do the same, and are not for
 * Windows.
 */
#include "dir.h"

static const char *make_relative(const char *location)
{
	static char prefix[] = __FILE__, buf[PATH_MAX], *p;
	static size_t prefix_len;
	static int need_bs_to_fs = -1;

	/* one-time preparation */
	if (need_bs_to_fs < 0) {
		size_t len = strlen(prefix);
		char needle[] = "t\\unit-tests\\test-lib.c";
		size_t needle_len = strlen(needle);

		if (len < needle_len)
			die("unexpected prefix '%s'", prefix);

		/*
		 * The path could be relative (t/unit-tests/test-lib.c)
		 * or full (/home/user/git/t/unit-tests/test-lib.c).
		 * Check the slash between "t" and "unit-tests".
		 */
		prefix_len = len - needle_len;
		if (prefix[prefix_len + 1] == '/') {
			/* Oh, we're not Windows */
			for (size_t i = 0; i < needle_len; i++)
				if (needle[i] == '\\')
					needle[i] = '/';
			need_bs_to_fs = 0;
		} else {
			need_bs_to_fs = 1;
		}

		/*
		 * prefix_len == 0 if the compiler gives paths relative
		 * to the root of the working tree.  Otherwise, we want
		 * to see that we did find the needle[] at a directory
		 * boundary.  Again we rely on that needle[] begins with
		 * "t" followed by the directory separator.
		 */
		if (fspathcmp(needle, prefix + prefix_len) ||
		    (prefix_len && prefix[prefix_len - 1] != needle[1]))
			die("unexpected suffix of '%s'", prefix);
	}

	/*
	 * Does it not start with the expected prefix?
	 * Return it as-is without making it worse.
	 */
	if (prefix_len && fspathncmp(location, prefix, prefix_len))
		return location;

	/*
	 * If we do not need to munge directory separator, we can return
	 * the substring at the tail of the location.
	 */
	if (!need_bs_to_fs)
		return location + prefix_len;

	/* convert backslashes to forward slashes */
	strlcpy(buf, location + prefix_len, sizeof(buf));
	for (p = buf; *p; p++)
		if (*p == '\\')
			*p = '/';
	return buf;
}

static void msg_with_prefix(const char *prefix, const char *format, va_list ap)
{
	fflush(stderr);
	if (prefix)
		fprintf(stdout, "%s", prefix);
	vprintf(format, ap); /* TODO: handle newlines */
	putc('\n', stdout);
	fflush(stdout);
}

void test_msg(const char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	msg_with_prefix("# ", format, ap);
	va_end(ap);
}

void test_plan(int count)
{
	assert(!ctx.running);

	fflush(stderr);
	printf("1..%d\n", count);
	fflush(stdout);
	ctx.lazy_plan = 0;
}

int test_done(void)
{
	assert(!ctx.running);

	if (ctx.lazy_plan)
		test_plan(ctx.count);

	return ctx.failed;
}

void test_skip(const char *format, ...)
{
	va_list ap;

	assert(ctx.running);

	ctx.result = RESULT_SKIP;
	va_start(ap, format);
	if (format)
		msg_with_prefix("# skipping test - ", format, ap);
	va_end(ap);
}

void test_skip_all(const char *format, ...)
{
	va_list ap;
	const char *prefix;

	if (!ctx.count && ctx.lazy_plan) {
		/* We have not printed a test plan yet */
		prefix = "1..0 # SKIP ";
		ctx.lazy_plan = 0;
	} else {
		/* We have already printed a test plan */
		prefix = "Bail out! # ";
		ctx.failed = 1;
	}
	ctx.skip_all = 1;
	ctx.result = RESULT_SKIP;
	va_start(ap, format);
	msg_with_prefix(prefix, format, ap);
	va_end(ap);
}

int test__run_begin(void)
{
	assert(!ctx.running);

	ctx.count++;
	ctx.result = RESULT_NONE;
	ctx.running = 1;

	return ctx.skip_all;
}

static void print_description(const char *format, va_list ap)
{
	if (format) {
		fputs(" - ", stdout);
		vprintf(format, ap);
	}
}

int test__run_end(int was_run UNUSED, const char *location, const char *format, ...)
{
	va_list ap;

	assert(ctx.running);
	assert(!ctx.todo);

	fflush(stderr);
	va_start(ap, format);
	if (!ctx.skip_all) {
		switch (ctx.result) {
		case RESULT_SUCCESS:
			printf("ok %d", ctx.count);
			print_description(format, ap);
			break;

		case RESULT_FAILURE:
			printf("not ok %d", ctx.count);
			print_description(format, ap);
			break;

		case RESULT_TODO:
			printf("not ok %d", ctx.count);
			print_description(format, ap);
			printf(" # TODO");
			break;

		case RESULT_SKIP:
			printf("ok %d", ctx.count);
			print_description(format, ap);
			printf(" # SKIP");
			break;

		case RESULT_NONE:
			test_msg("BUG: test has no checks at %s",
				 make_relative(location));
			printf("not ok %d", ctx.count);
			print_description(format, ap);
			ctx.result = RESULT_FAILURE;
			break;
		}
	}
	va_end(ap);
	ctx.running = 0;
	if (ctx.skip_all)
		return 1;
	putc('\n', stdout);
	fflush(stdout);
	ctx.failed |= ctx.result == RESULT_FAILURE;

	return ctx.result != RESULT_FAILURE;
}

static void test_fail(void)
{
	assert(ctx.result != RESULT_SKIP);

	ctx.result = RESULT_FAILURE;
}

static void test_pass(void)
{
	assert(ctx.result != RESULT_SKIP);

	if (ctx.result == RESULT_NONE)
		ctx.result = RESULT_SUCCESS;
}

static void test_todo(void)
{
	assert(ctx.result != RESULT_SKIP);

	if (ctx.result != RESULT_FAILURE)
		ctx.result = RESULT_TODO;
}

int test_assert(const char *location, const char *check, int ok)
{
	assert(ctx.running);

	if (ctx.result == RESULT_SKIP) {
		test_msg("skipping check '%s' at %s", check,
			 make_relative(location));
		return 1;
	}
	if (!ctx.todo) {
		if (ok) {
			test_pass();
		} else {
			test_msg("check \"%s\" failed at %s", check,
				 make_relative(location));
			test_fail();
		}
	}

	return !!ok;
}

void test__todo_begin(void)
{
	assert(ctx.running);
	assert(!ctx.todo);

	ctx.todo = 1;
}

int test__todo_end(const char *location, const char *check, int res)
{
	assert(ctx.running);
	assert(ctx.todo);

	ctx.todo = 0;
	if (ctx.result == RESULT_SKIP)
		return 1;
	if (res) {
		test_msg("todo check '%s' succeeded at %s", check,
			 make_relative(location));
		test_fail();
	} else {
		test_todo();
	}

	return !res;
}

int check_bool_loc(const char *loc, const char *check, int ok)
{
	return test_assert(loc, check, ok);
}

union test__tmp test__tmp[2];

int check_int_loc(const char *loc, const char *check, int ok,
		  intmax_t a, intmax_t b)
{
	int ret = test_assert(loc, check, ok);

	if (!ret) {
		test_msg("   left: %"PRIdMAX, a);
		test_msg("  right: %"PRIdMAX, b);
	}

	return ret;
}

int check_uint_loc(const char *loc, const char *check, int ok,
		   uintmax_t a, uintmax_t b)
{
	int ret = test_assert(loc, check, ok);

	if (!ret) {
		test_msg("   left: %"PRIuMAX, a);
		test_msg("  right: %"PRIuMAX, b);
	}

	return ret;
}

static void print_one_char(char ch, char quote)
{
	if ((unsigned char)ch < 0x20u || ch == 0x7f) {
		/* TODO: improve handling of \a, \b, \f ... */
		printf("\\%03o", (unsigned char)ch);
	} else {
		if (ch == '\\' || ch == quote)
			putc('\\', stdout);
		putc(ch, stdout);
	}
}

static void print_char(const char *prefix, char ch)
{
	printf("# %s: '", prefix);
	print_one_char(ch, '\'');
	fputs("'\n", stdout);
}

int check_char_loc(const char *loc, const char *check, int ok, char a, char b)
{
	int ret = test_assert(loc, check, ok);

	if (!ret) {
		fflush(stderr);
		print_char("   left", a);
		print_char("  right", b);
		fflush(stdout);
	}

	return ret;
}

static void print_str(const char *prefix, const char *str)
{
	printf("# %s: ", prefix);
	if (!str) {
		fputs("NULL\n", stdout);
	} else {
		putc('"', stdout);
		while (*str)
			print_one_char(*str++, '"');
		fputs("\"\n", stdout);
	}
}

int check_str_loc(const char *loc, const char *check,
		  const char *a, const char *b)
{
	int ok = (!a && !b) || (a && b && !strcmp(a, b));
	int ret = test_assert(loc, check, ok);

	if (!ret) {
		fflush(stderr);
		print_str("   left", a);
		print_str("  right", b);
		fflush(stdout);
	}

	return ret;
}