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;
}