auto-test: introduce a result() fn to check for pass/fail and show debug messages

Using individual pass/fail() functions, checking for conditions,
printing debug message after fail each time can be optimised by
using a result() function that can do all of that.

This also allows us to make the test output format look prettier
since it's all now handled in one function. So make the output
prettier as well while we're at it.

Signed-off-by: Amit Shah <amit.shah@redhat.com>

1 files changed, 274 insertions, 302 deletions

diff --git a/auto-virtserial.c b/auto-virtserial.c
index 1fa7208..1dc008e 100644
--- a/auto-virtserial.c
+++ b/auto-virtserial.c
@@ -43,9 +43,9 @@
 #define DEBUG 1
 
 #ifdef DEBUG
-#define debug(fmt, ...) 			\
-	do {					\
-		printf(fmt, __VA_ARGS__);	\
+#define debug(fmt, ...) 				\
+	do {						\
+		fprintf(stderr, fmt, __VA_ARGS__);	\
 	} while(0)
 #else
 #define debug(fmt, ...) do { } while (0)
@@ -242,16 +242,77 @@ static void show_stats(void)
 	fprintf(stderr, "-----\n");
 }
 
-static void pass(const char *msg, const char *subtype)
-{
-	fprintf(stderr, "%s(%s):\t\tPASS\n", msg, subtype);
-	nr_passed++;
-}
+enum result_ops {
+	OP_EQ = 0,
+	OP_NE,
+	OP_LT,
+	OP_GT,
+};
 
-static void fail(const char *msg, const char *subtype)
+/*
+ * Function that displays pass/fail results for each test, keeps a count
+ * of tests passing and failing.
+ * Arguments:
+ *  test: the name of the test
+ *  enabled: type of testing to be done: enabled / disabled
+ *  stage: in case of failures, this shows which stage failed
+ *  ret: return value of function
+ *  expected_en: expected value of 'ret'  for the test to pass in enabled case
+ *  expected_dis: expected value of 'ret' for the test to pass in disabled case
+ *  op: This is the operator to test the return and the expected return --
+ *      equal, greater than, less than, not equal.
+ *  final: is this the final subtest for this testcase? (helpful for
+ *         the test_passed case.)
+ *
+ * Returns 0 if test passed, -1 if it failed
+ */
+
+static int result(const char *test, const bool enabled, const char *stage,
+		  const int ret, const int expected_en, const int expected_dis,
+		  const int op, const bool final)
 {
-	fprintf(stderr, "%s(%s):\t\tFAIL\n", msg, subtype);
-	nr_failed++;
+	int r, expected;
+	char *ch_op;
+
+	expected = enabled ? expected_en : expected_dis;
+
+	switch (op) {
+	case OP_EQ:
+		r = (ret == expected) ? 0 : -1;
+		ch_op = "=";
+		break;
+	case OP_NE:
+		r = (ret != expected) ? 0 : -1;
+		ch_op = "!=";
+		break;
+	case OP_LT:
+		r = (ret < expected) ? 0 : -1;
+		ch_op = "<";
+		break;
+	case OP_GT:
+		r = (ret > expected) ? 0 : -1;
+		ch_op = ">";
+		break;
+	default:
+		r = -1;
+		ch_op = "?";
+	}
+	if (!final && !r)
+		return r;
+
+	fprintf(stderr, "%*s - %*s (%*s): ",
+		25, test, 8, enabled ? "enabled" : "disabled", 10, stage);
+	if (!r) {
+		fprintf(stderr, "PASS\n");
+		nr_passed++;
+	} else {
+		fprintf(stderr, "FAIL");
+		debug("  (Expected result: %s %d, received result: %d)",
+		      ch_op, expected, ret);
+		fprintf(stderr, "\n");
+		nr_failed++;
+	}
+	return r;
 }
 
 static int test_open(int nr)
@@ -259,36 +320,25 @@ static int test_open(int nr)
 	int ret;
 
 	ret = guest_open_port(nr);
-	if (ret) {
-		fail(__func__, "open");
-		debug("%s: return: %d\n", __func__, ret);
-	} else {
-		pass(__func__, "open");
-	}
-	return ret;
+	return result(__func__, true, "open", ret, 0, 0, OP_EQ, true);
 }
 
 static int test_multiple_open(int nr)
 {
-	int ret;
+	int err, ret;
 
 	ret = guest_open_port(nr);
-	if (ret) {
-		fail(__func__, "open: single");
-		debug("%s: return: %d\n", __func__, ret);
-		return ret;
-	}
+	err = result(__func__, true, "single", ret, 0, 0, OP_EQ, false);
+	if (err)
+		return err;
+
 	ret = guest_open_port(nr);
-	if (ret == -EMFILE) {
-		pass(__func__, "open: multiple");
-	} else {
-		fail(__func__, "open: multiple");
-		debug("%s: return: %d\n", __func__, ret);
-	}
+	err = result(__func__, true, "multiple", ret, -EMFILE, 0, OP_EQ, true);
 	ret = guest_close_port(nr);
 	if (ret)
 		debug("%s: close return: %d\n", __func__, ret);
-	return ret;
+
+	return err;
 }
 
 static int test_close(int nr)
@@ -296,76 +346,57 @@ static int test_close(int nr)
 	int ret;
 
 	ret = guest_close_port(nr);
-	if (ret) {
-		fail(__func__, "close");
-		debug("%s: return: %d\n", __func__, ret);
-	} else {
-		pass(__func__, "close");
-	}
-	return ret;
+	return result(__func__, true, "close", ret, 0, 0, OP_EQ, true);
 }
 
 static int test_sysfs_and_udev(int nr)
 {
 	struct guest_packet gpkt;
-	int ret;
+	int err, ret;
 
 	gpkt.key = KEY_CHECK_SYSFS;
 	gpkt.value = nr;
 	ret = guest_cmd(&gpkt);
-	if (ret < 0) {
-		fail(__func__, "sysfs");
-		if (ret == -ERANGE)
-			debug("%s: no name specified for port %u\n",
-			      __func__, nr);
-		else
-			debug("%s: ret = %d\n", __func__, ret);
-		return ret;
-	}
+	err = result(__func__, true, "sysfs", ret, 0, 0, OP_EQ, false);
+	if (err)
+		return err;
+
 	gpkt.key = KEY_CHECK_UDEV;
 	gpkt.value = nr;
 	ret = guest_cmd(&gpkt);
-	if (ret < 0) {
-		fail(__func__, "udev");
-		debug("%s: ret = %d\n", __func__, ret);
-	} else {
-		pass(__func__, "sysfs-udev");
-	}
-	return ret;
+	err = result(__func__, true, "udev", ret, 0, 0, OP_EQ, true);
+
+	return err;
 }
 
 /* Reads should return 0 when host chardev isn't connected */
 static int test_read_without_host(int nr)
 {
-	int ret;
+	int err, ret;
 
 	ret = guest_open_port(nr);
-	if (ret) {
-		fail(__func__, "open");
-		debug("%s: open: %d\n", __func__, ret);
-		return ret;
-	}
+	err = result(__func__, true, "open", ret, 0, 0, OP_EQ, false);
+	if (err)
+		return err;
+
 	ret = guest_read(nr, 0);
-	if (ret)
-		fail(__func__, "read");
-	else
-		pass(__func__, "read");
+	err = result(__func__, true, "read", ret, 0, 0, OP_EQ, true);
 	guest_close_port(nr);
-	return ret;
+
+	return err;
 }
 
 static int test_blocking_read(int nr)
 {
 	struct guest_packet gpkt;
 	struct pollfd pollfd[1];
-	int ret;
+	int err, ret;
 
 	ret = guest_open_port(nr);
-	if (ret) {
-		fail(__func__, "open");
-		debug("%s: open: %d\n", __func__, ret);
-		return ret;
-	}
+	err = result(__func__, true, "open", ret, 0, 0, OP_EQ, false);
+	if (err)
+		return err;
+
 	host_connect_chardev(nr);
 
 	guest_set_length(nr, sizeof(gpkt));
@@ -380,59 +411,48 @@ static int test_blocking_read(int nr)
 	ret = poll(pollfd, 1, 5000);
 	if (ret == -1)
 		error(errno, errno, "%s: poll", __func__);
-	if (ret) {
-		fail(__func__, "poll");
-		debug("%s: poll: %d\n", __func__, ret);
-		ret = -1;
+	err = result(__func__, true, "poll", ret, 0, 0, OP_EQ, false);
+	if (err)
 		goto out;
-	}
+
 	/* Write out anything -- doesn't matter what it is */
 	write(chardevs[nr].sock, &gpkt, sizeof(gpkt));
 	ret = poll(pollfd, 1, 5000);
-	if (ret != 1) {
-		fail(__func__, "poll");
-		debug("%s: no response from guest\n", __func__);
-		ret = -1;
+	err = result(__func__, true, "poll", ret, 1, 0, OP_EQ, false);
+	if (err)
 		goto out;
-	}
+
 	get_guest_response(&gpkt);
 	if (gpkt.key != KEY_RESULT)
 		error(EINVAL, EINVAL, "%s: guest response\n", __func__);
-	if (gpkt.value == sizeof(gpkt)) {
-		pass(__func__, "read");
-		ret = 0;
-	} else {
-		fail(__func__, "read");
-		debug("%s: expected return %zu, got %d\n",
-		      __func__, sizeof(gpkt), gpkt.value);
-		ret = -EINVAL;
-	}
+
+	err = result(__func__, true, "read",
+		     gpkt.value, sizeof(gpkt), 0, OP_EQ, true);
 out:
 	guest_close_port(nr);
 	host_close_chardev(nr);
-	return ret;
+
+	return err;
 }
 
 static int test_nonblocking_read(int nr)
 {
 	struct guest_packet gpkt;
 	struct pollfd pollfd[1];
-	int ret;
+	int err, ret;
 
 	ret = guest_open_port(nr);
-	if (ret) {
-		fail(__func__, "open");
-		debug("%s: open: %d\n", __func__, ret);
-		return ret;
-	}
+	err = result(__func__, true, "open", ret, 0, 0, OP_EQ, false);
+	if (err)
+		return err;
+
 	host_connect_chardev(nr);
 
 	ret = guest_set_port_nonblocking(nr, true);
-	if (ret) {
-		fail(__func__, "blocking");
-		debug("%s: blocking: %d\n", __func__, -ret);
+	err = result(__func__, true, "blocking", ret, 0, 0, OP_EQ, false);
+	if (err)
 		goto out;
-	}
+
 	guest_set_length(nr, sizeof(gpkt));
 	/* Reads should block now that the host is connected */
 	gpkt.key = KEY_READ;
@@ -445,92 +465,54 @@ static int test_nonblocking_read(int nr)
 	ret = poll(pollfd, 1, 5000);
 	if (ret == -1)
 		error(errno, errno, "%s: poll", __func__);
-	if (!ret) {
-		fail(__func__, "poll");
-		debug("%s: poll: %d\n", __func__, ret);
-		ret = -1;
+	err = result(__func__, true, "host poll", ret, 1, 0, OP_EQ, false);
+	if (err)
 		goto out;
-	}
+
 	get_guest_response(&gpkt);
-	if (gpkt.value != -EAGAIN) {
-		fail(__func__, "guest response");
-		debug("%s: Expected %d got %d\n",
-		      __func__, -EAGAIN, gpkt.value);
-	}
+	err = result(__func__, true, "guest poll",
+		     gpkt.value, -EAGAIN, 0, OP_EQ, false);
+	if (err)
+		goto out;
+
 	/* Write out anything -- doesn't matter what it is */
 	write(chardevs[nr].sock, &gpkt, sizeof(gpkt));
 
 	ret = guest_read(nr, sizeof(gpkt));
-	if (ret == sizeof(gpkt)) {
-		pass(__func__, "read");
-		ret = 0;
-	} else {
-		fail(__func__, "read");
-		debug("%s: expected return %zu, got %d\n",
-		      __func__, sizeof(gpkt), gpkt.value);
-		ret = -EINVAL;
-	}
+	err = result(__func__, true, "read", ret, sizeof(gpkt), 0, OP_EQ, true);
 out:
 	guest_close_port(nr);
 	host_close_chardev(nr);
-	return ret;
+
+	return err;
 }
 
 static int test_poll(int nr)
 {
-	int ret;
+	int err, ret;
 
 	guest_open_port(nr);
 	ret = guest_poll(nr, 0);
-	if (ret < 0) {
-		fail(__func__, "open");
-		debug("%s: poll error: %d\n", __func__, ret);
-		goto out;
-	}
-	if (ret != POLLHUP) {
-		fail(__func__, "POLLHUP");
-		debug("%s: poll ret: 0x%x, expected 0x%x\n",
-		      __func__, ret, POLLHUP);
+	err = result(__func__, true, "POLLHUP", ret, POLLHUP, 0, OP_EQ, true);
+	if (err)
 		goto out;
-	}
-	pass(__func__, "POLLHUP");
 
 	host_connect_chardev(nr);
 	ret = guest_poll(nr, 0);
-	if (ret < 0) {
-		fail(__func__, "poll");
-		debug("%s: poll error: %d\n", __func__, ret);
+	err = result(__func__, true, "POLLOUT", ret, POLLOUT, 0, OP_EQ, true);
+	if (err)
 		goto out_close;
-	} else if (ret == POLLOUT) {
-		pass(__func__, "POLLOUT");
-	} else {
-		fail(__func__, "POLLOUT");
-		debug("%s: poll ret: 0x%x, expected 0x%x\n",
-		      __func__, ret, POLLOUT);
-		goto out_close;
-	}
+
 	write(chardevs[nr].sock, &ret, sizeof(ret));
 	ret = guest_poll(nr, 0);
-	if (ret < 0) {
-		fail(__func__, "POLL");
-		debug("%s: poll error: %d\n", __func__, ret);
-		goto out_flush;
-	} else if (ret == (POLLIN|POLLOUT)) {
-		pass(__func__, "POLLIN");
-	} else {
-		fail(__func__, "POLLIN");
-		debug("%s: poll ret: 0x%d, expected 0x%d\n",
-		      __func__, ret, POLLIN|POLLOUT);
-		goto out_flush;
-	}
-	ret = 0;
-out_flush:
-	guest_read(nr, sizeof(ret));
+	err = result(__func__, true, "POLLIN",
+		     ret, POLLIN|POLLOUT, 0, OP_EQ, true);
+
 out_close:
 	host_close_chardev(nr);
 out:
 	guest_close_port(nr);
-	return ret;
+	return err;
 }
 
 /*
@@ -543,21 +525,21 @@ static int test_guest_throttle(int nr)
 	char *buf;
 	struct pollfd pollfd[1];
 	size_t size, copied;
-	int ret;
+	int err, ret;
 
 	/* Open guest */
 	ret = guest_open_port(nr);
-	if (ret) {
-		fail(__func__, "open");
-		debug("%s: open: %d\n", __func__, ret);
-		return ret;
-	}
-	host_connect_chardev(nr);
+	err = result(__func__, chardevs[nr].throttled, "open",
+		     ret, 0, 0, OP_EQ, false);
+	if (err)
+		return err;
 
 	buf = malloc(BUF_LENGTH);
 	if (!buf)
 		error(ENOMEM, ENOMEM, "%s\n", __func__);
 
+	host_connect_chardev(nr);
+
 	pollfd[0].fd = chardevs[nr].sock;
 	pollfd[0].events = POLLOUT;
 	ret = poll(pollfd, 1, 0);
@@ -578,26 +560,28 @@ static int test_guest_throttle(int nr)
 			error(errno, errno, "%s: poll\n", __func__);
 	} while ((pollfd[0].revents & POLLOUT) && (copied < 1048576));
 
-	if ((pollfd[0].revents & POLLOUT) && !chardevs[nr].throttled) {
-		pass(__func__, "disabled");
-	} else if (!(pollfd[0].revents & POLLOUT) && chardevs[nr].throttled) {
-		pass(__func__, "enabled");
-	} else {
-		fail(__func__, "throttle");
-		debug("%s: ret = %d, copied = %zu\n", __func__, ret, copied);
-	}
+	err = result(__func__, chardevs[nr].throttled, "throttle",
+		     pollfd[0].revents & POLLOUT, 0, POLLOUT, OP_EQ, true);
+	if (err)
+		debug("%s: copied = %zu\n", __func__, copied);
+
+	free(buf);
 	guest_close_port(nr);
 	host_close_chardev(nr);
-	free(buf);
-	return 0;
+
+	return err;
 }
 
 static int test_host_throttle(int nr)
 {
 	size_t copied;
-	int ret;
+	int err, ret;
 
 	ret = guest_open_port(nr);
+	err = result(__func__, chardevs[nr].throttled, "open",
+		     ret, 0, 0, OP_EQ, false);
+	if (err)
+		return err;
 
 	copied = 0;
 	do {
@@ -606,30 +590,26 @@ static int test_host_throttle(int nr)
 			copied += ret;
 	} while ((copied < 1048576) && (ret > 0));
 
-	if (ret && !chardevs[nr].throttled) {
-		pass(__func__, "disabled");
-	} else if (!(ret == -ENOSPC) && chardevs[nr].throttled) {
-		pass(__func__, "enabled");
-	} else {
-		fail(__func__, "throttle");
-		debug("%s: ret = %d, copied = %zu\n", __func__, ret, copied);
-	}
+	err = result(__func__, chardevs[nr].throttled, "throttle",
+		     ret, 0, -ENOSPC, OP_NE, true);
+
 	guest_close_port(nr);
 	host_close_chardev(nr);
-	return ret;
+
+	return err;
 }
 
 static int test_guest_caching(int nr)
 {
 	char *buf;
-	int ret;
+	int err, ret;
 
 	ret = guest_open_port(nr);
-	if (ret) {
-		fail(__func__, "open");
-		debug("%s: open: %d\n", __func__, ret);
-		return ret;
-	}
+	err = result(__func__, chardevs[nr].caching, "open",
+		     ret, 0, 0, OP_EQ, false);
+	if (err)
+		return err;
+
 	host_connect_chardev(nr);
 
 	buf = malloc(BUF_LENGTH);
@@ -646,88 +626,81 @@ static int test_guest_caching(int nr)
 
 	ret = guest_open_port(nr);
 	ret = guest_read(nr, BUF_LENGTH);
-	if ((ret == BUF_LENGTH) && chardevs[nr].caching) {
-		pass(__func__, "disabled");
-	} else if (!ret && !chardevs[nr].caching) {
-		pass(__func__, "enabled");
-	} else {
-		fail(__func__, "caching");
-		debug("%s: ret = %d\n", __func__, ret);
-	}
+	err = result(__func__, chardevs[nr].caching, "caching",
+		     ret, BUF_LENGTH, 0, OP_EQ, true);
 	guest_close_port(nr);
-	return 0;
+
+	return err;
 }
 
 static int test_host_caching(int nr)
 {
-	int ret;
 	char *buf;
 	struct pollfd pollfds[1];
+	int err, ret;
 
 	guest_open_port(nr);
 	ret = guest_write(nr, BUF_LENGTH);
-	if (ret != BUF_LENGTH) {
-		fail(__func__, "write");
-		debug("%s: guest_write return: %d\n", __func__, ret);
+	err = result(__func__, chardevs[nr].caching, "guest_write",
+		     ret, BUF_LENGTH, BUF_LENGTH, OP_EQ, false);
+	if (err)
 		goto out;
-	}
+
 	host_connect_chardev(nr);
 
 	pollfds[0].fd = chardevs[nr].sock;
 	pollfds[0].events = POLLIN;
 	ret = poll(pollfds, 1, 2000);
-	if (ret < 0) {
-		fail(__func__, "poll");
-		debug("%s: poll returned %d, revents %d\n",
-		      __func__, ret, pollfds[0].revents);
-		goto out;
-	}
-	if (ret > 0 && !chardevs[nr].caching) {
-		fail(__func__, "disabled");
-		debug("%s: ret = %d, revents = %d\n",
-		      __func__, ret, pollfds[0].revents);
-		goto out;
-	}
-	if (ret != 1 && chardevs[nr].caching) {
-		fail(__func__, "enabled");
-		debug("%s: ret = %d, revents = %d\n",
-		      __func__, ret, pollfds[0].revents);
+
+	/*
+	 * Ensure:
+	 *  ret >= 0
+	 *      == 1 if caching enabled
+	 *      == 0 if caching disabled
+	 */
+	err = result(__func__, chardevs[nr].caching, "poll",
+		     ret, 1, 0, OP_EQ, false);
+	if (err)
 		goto out;
-	}
+
+	/* Handle the noncaching case first */
 	if (!chardevs[nr].caching) {
-		pass(__func__, "enabled");
+		/*
+		 *  We know the test has passed above. Take that into
+		 *  account now (pass 'true' as the last arg)
+		 */
+		result(__func__, chardevs[nr].caching, "caching",
+		       0, 0, 0, OP_EQ, true);
 		goto out;
 	}
+	/* Caching case */
+	/*
+	 * poll worked fine -- but do we also read the length that we wrote?
+	 */
 	buf = malloc(BUF_LENGTH);
 	ret = read(chardevs[nr].sock, buf, BUF_LENGTH);
 	free(buf);
-	if (ret == BUF_LENGTH) {
-		pass(__func__, "enabled");
-	} else {
-		fail(__func__, "caching");
-		if (ret == -1)
-			ret = -errno;
-		debug("%s: read %d\n", __func__, ret);
-	}
+
+	err = result(__func__, chardevs[nr].caching, "caching",
+		     ret, BUF_LENGTH, 0, OP_EQ, true);
 out:
 	host_close_chardev(nr);
 	guest_close_port(nr);
-	return ret;
+	return err;
 }
 
 static int test_console(int nr)
 {
 	char buf[1024], *str;
 	struct pollfd pollfds[1];
-	int ret;
+	int err, ret;
 
 	if (guest_ok) {
 		ret = guest_open_port(nr);
-		if (ret != -ENXIO) {
-			fail(__func__, "open");
-			debug("%s: guest_open ret: %d\n", __func__, ret);
-			return ret;
-		}
+		err = result(__func__, true, "open",
+			     ret, -ENXIO, 0, OP_EQ, false);
+		if (err)
+			return err;
 	}
 	host_connect_chardev(nr);
 
@@ -753,8 +726,7 @@ static int test_console(int nr)
 
 	str = strstr(buf, "login: ");
 	if (!str) {
-		fail(__func__, "console");
-		debug("%s: no login prompt received\n", __func__);
+		err = result(__func__, true, "login", 0, 1, 0, OP_EQ, false);
 		goto out;
 	}
 	str = "amit\n";
@@ -766,8 +738,7 @@ static int test_console(int nr)
 
 	str = strstr(buf, "Password: ");
 	if (!str) {
-		fail(__func__, "console");
-		debug("%s: no password prompt received\n", __func__);
+		err = result(__func__, true, "password", 0, 1, 0, OP_EQ, false);
 		goto out;
 	}
 	str = "123456\n";
@@ -780,8 +751,7 @@ static int test_console(int nr)
 	/* Check if we have a prompt */
 	str = strstr(buf, "~]$");
 	if (!str) {
-		fail(__func__, "console");
-		debug("%s: didn't get a shell prompt\n", __func__);
+		err = result(__func__, true, "console", 0, 1, 0, OP_EQ, false);
 		goto out;
 	}
 	/* 'ls' in the current dir */
@@ -810,15 +780,15 @@ static int test_console(int nr)
 		 * didn't finish the 'ls' and 'find /' tests. That's
 		 * failure.
 		 */
-		fail(__func__, "console");
+		err = result(__func__, true, "console", 0, 1, 0, OP_EQ, true);
 		debug("%s: didn't drop to bash prompt\n", __func__);
 		debug("%s: last buf (%d) was %s\n", __func__, ret, buf);
 	} else {
-		pass(__func__, "console");
+		err = result(__func__, true, "console", 0, 0, 0, OP_EQ, true);
 	}
 out:
 	host_close_chardev(nr);
-	return ret;
+	return err;
 }
 
 static int test_file_send(int nr)
@@ -826,28 +796,25 @@ static int test_file_send(int nr)
 	char buf[BUF_LENGTH];
 	char csum[BUF_LENGTH];
 	struct guest_packet gpkt;
-	int ret, fd, csum_fd;
+	int err, ret, fd, csum_fd;
 
 	/*
 	 * Open guest, open host, send file, compute checksum on
 	 * guest, compute checksum here, compare
 	 */
 	fd = open(BIG_FILE, O_RDONLY);
-	if (fd < 0) {
-		fail(__func__, "open");
-		debug("%s: open: ret = %d\n", __func__, -errno);
-		ret = -errno;
-		goto out;
-	}
+	err = result(__func__, true, "open", fd, -1, 0, OP_GT, false);
+	if (err)
+		return err;
+
 	guest_open_port(nr);
 	host_connect_chardev(nr);
 
 	ret = guest_open_bigfile(1);
-	if (ret < 0) {
-		fail(__func__, "open bigfile");
-		debug("%s: open_bigfile: ret = %d\n", __func__, ret);
+	err = result(__func__, true, "guest open", ret, -1, 0, OP_GT, false);
+	if (err)
 		goto out_close;
-	}
+
 	guest_set_length(nr, BUF_LENGTH);
 
 	gpkt.key = KEY_BYTESTREAM;
@@ -861,67 +828,70 @@ static int test_file_send(int nr)
 	/* guest will stop reading only if read() returns 0 */
 	host_close_chardev(nr);
 
-	if (ret < 0) {
-		fail(__func__, "read/write");
-		debug("%s: read/write: ret = %d\n", __func__, -errno);
-		fd = -errno;
+	err = result(__func__, true, "read/write", ret, -1, 0, OP_GT, false);
+	if (err)
 		goto out_close;
-	}
+
 	get_guest_response(&gpkt);
-	if (gpkt.key != KEY_RESULT || gpkt.value != 0) {
-		fail(__func__, "guest response");
-		debug("%s: guest responded with %d(%d)\n",
-		      __func__, gpkt.key, gpkt.value);
+	err = result(__func__, true, "bytestream response",
+		     gpkt.key, KEY_RESULT, 0, OP_EQ, false);
+	if (err)
 		goto out_close;
-	}
+
+	err = result(__func__, true, "bytestream response",
+		     gpkt.value, 0, 0, OP_EQ, false);
+	if (err)
+		goto out_close;
+
 	host_connect_chardev(nr);
 	gpkt.key = KEY_CSUM;
 	gpkt.value = nr;
 	guest_cmd_only(&gpkt);
 	/* Compute checksum here while the guest does the same */
 	ret = system("sha1sum /tmp/amit/big-file > /tmp/amit/csumfile");
-	if (ret == -1) {
-		fail(__func__, "csum");
-		ret = -errno;
+	err = result(__func__, true, "csum1",
+		     ret, -1, 0, OP_GT, false);
+	if (err)
 		goto out_close;
-	}
-	if (WIFEXITED(ret) != true) {
-		fail(__func__, "csum2");
-		ret = -1;
+
+	err = result(__func__, true, "csum2",
+		     WIFEXITED(ret), true, 0, OP_EQ, false);
+	if (err)
 		goto out_close;
-	}
-	if (WEXITSTATUS(ret) != 0) {
-		fail(__func__, "csum3");
-		ret = -WEXITSTATUS(ret);
+
+	err = result(__func__, true, "csum3",
+		     WEXITSTATUS(ret), 0, 0, OP_EQ, false);
+	if (err)
 		goto out_close;
-	}
+
 	csum_fd = open("/tmp/amit/csumfile", O_RDONLY);
-	if (!csum_fd) {
-		return -errno;
-	}
-	ret = read(csum_fd, csum, BUF_LENGTH);
+	err = result(__func__, true, "open csumfd",
+		     csum_fd, -1, 0, OP_GT, false);
+	if (err)
+		goto out_close;
+
+	read(csum_fd, csum, BUF_LENGTH);
 	close(csum_fd);
 
 	get_guest_response(&gpkt);
-	if (gpkt.key != KEY_RESULT || gpkt.value < 0) {
-		fail(__func__, "guest csum");
-		debug("%s: guest responded with %d(%d)\n",
-		      __func__, gpkt.key, gpkt.value);
+	err = result(__func__, true, "csum response",
+		     gpkt.key, KEY_RESULT, 0, OP_EQ, false);
+	if (err)
 		goto out_close;
-	}
+
+	err = result(__func__, true, "guest csum",
+		     gpkt.value, 0, 0, OP_GT, false);
+	if (err)
+		goto out_close;
+
 	/* Guest sent its computed checksum on the same port */
 	read(chardevs[nr].sock, buf, gpkt.value);
-	if (!strncmp(csum, buf, gpkt.value)) {
-		pass(__func__, "csum");
-	} else {
-		fail(__func__, "csum");
-		debug("%s: guest csum: %s, host csum: %s\n",
-		      __func__, buf, csum);
-	}
+	ret = strncmp(csum, buf, gpkt.value);
+	err = result(__func__, true, "csum", ret, 0, 0, OP_EQ, true);
+
 out_close:
 	guest_close_port(nr);
-out:
-	return ret;
+	return err;
 }
 
 static void post_test_cleanup(int nr)
@@ -1040,6 +1010,7 @@ int main(int argc, const char *argv[])
 	ret = host_connect_chardev(1);
 	if (ret < 0) {
 		/* old qemu case -- Give the guest time to finish its bootup */
+		debug("%s: Old qemu, new kernel?\n", __func__);
 		sleep(20);
 		goto next;
 	}
@@ -1065,7 +1036,8 @@ int main(int argc, const char *argv[])
 		 * This perhaps is an old kernel or an old qemu -
 		 * guest won't contact us.
 		 */
-		debug("%s: No contact from Guest\n", __func__);
+		debug("%s: No contact from Guest - Old kernel, New qemu?\n",
+		      __func__);
 		goto next;
 	}
 	if (pollfd[0].revents & POLLIN) {