diff --git a/.clang-tidy b/.clang-tidy
index bc5bcaa..2eacd36 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,3 +1,4 @@
 Checks: 'readability-*,portability-*,performance-*,misc-*,bugprone-*,modernize-*'
 HeaderFilterRegex: '.*'
 FormatStyle: file
+WarningsAsErrors: '*'
diff --git a/build/image/image.ld b/build/image/image.ld
index 9973954..cb32f98 100644
--- a/build/image/image.ld
+++ b/build/image/image.ld
@@ -52,6 +52,21 @@
 		*(.rela.*)
 	}
 	rela_end = .;
+	/* The hftest framework adds test descriptors in the .hftest section
+	 * which is examined at runtime to discover the available tests. The
+	 * input sections are named after the test they include so sorting here
+	 * means they are stored sorted by the name of the test suite and then
+	 * by test case names. To ensure tests aren't accidentally included in
+	 * images that are not meant to have them, the assertion checks for a
+	 * marker to signal tests are allowed. */
+	. = ALIGN(8);
+	hftest_begin = .;
+	.hftest : {
+		KEEP(*(SORT(.hftest.*)))
+	}
+	hftest_end = .;
+	ASSERT((SIZEOF(.hftest) == (DEFINED(hftest_enable) ? SIZEOF(.hftest) : 0)),
+	       "Error: Image includes .hftest section but not HFTEST_ENABLE().")
 	rodata_end = .;
 
 	/*
diff --git a/kokoro/ubuntu/build.sh b/kokoro/ubuntu/build.sh
index 9a7f510..a0b2c90 100755
--- a/kokoro/ubuntu/build.sh
+++ b/kokoro/ubuntu/build.sh
@@ -43,6 +43,6 @@
 
 if [[ `git status --porcelain` ]]
 then
-	echo "Run `make format` and `make tidy` locally to fix this."
+	echo "Run \`make format\' and \`make tidy\` locally to fix this."
 	exit 1
 fi
diff --git a/kokoro/ubuntu/continuous.cfg b/kokoro/ubuntu/continuous.cfg
index c2554d0..0e0e286 100644
--- a/kokoro/ubuntu/continuous.cfg
+++ b/kokoro/ubuntu/continuous.cfg
@@ -2,3 +2,10 @@
 
 # Location of the continuous bash script in Git.
 build_file: "hafnium/kokoro/ubuntu/build.sh"
+
+action {
+  define_artifacts {
+    regex: "git/hafnium/out/**/test_log/**/*.log"
+    strip_prefix: "git/hafnium"
+  }
+}
diff --git a/kokoro/ubuntu/presubmit.cfg b/kokoro/ubuntu/presubmit.cfg
index 7d60242..aa7fd6b 100644
--- a/kokoro/ubuntu/presubmit.cfg
+++ b/kokoro/ubuntu/presubmit.cfg
@@ -2,3 +2,10 @@
 
 # Location of the presubmit bash script in Git.
 build_file: "hafnium/kokoro/ubuntu/build.sh"
+
+action {
+  define_artifacts {
+    regex: "git/hafnium/out/**/test_log/**/*.log"
+    strip_prefix: "git/hafnium"
+  }
+}
diff --git a/kokoro/ubuntu/test.sh b/kokoro/ubuntu/test.sh
index 623c4aa..6d146b6 100755
--- a/kokoro/ubuntu/test.sh
+++ b/kokoro/ubuntu/test.sh
@@ -9,10 +9,9 @@
 set -x
 
 TIMEOUT="timeout --foreground"
-QEMU="./prebuilts/linux-x64/qemu/qemu-system-aarch64 -M virt -cpu cortex-a57 -m 8M -machine virtualization=true -nographic -nodefaults -serial stdio"
-HAFNIUM="out/aarch64/qemu/clang_aarch64/hafnium.bin"
-INITRD="out/aarch64/qemu/clang_aarch64/initrd"
+OUT="out/aarch64/qemu/clang_aarch64"
+HFTEST="timeout --foreground 30s ./test/vm/hftest.py --out $OUT --initrd"
 
-# Run the QEMU tests with a timeout so they can't loop forever.
-$TIMEOUT 5s $QEMU -kernel $HAFNIUM -initrd $INITRD/primary_only_test.img
-$TIMEOUT 5s $QEMU -kernel $HAFNIUM -initrd $INITRD/primary_with_secondary_test.img
+# Run the tests with a timeout so they can't loop forever.
+$HFTEST primary_only_test
+$HFTEST primary_with_secondary_test
diff --git a/src/BUILD.gn b/src/BUILD.gn
index 3f54988..acac35f 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -5,17 +5,17 @@
     "api.c",
     "cpio.c",
     "cpu.c",
-    "fdt.c",
     "fdt_handler.c",
     "load.c",
     "main.c",
-    "memiter.c",
     "mm.c",
     "vm.c",
   ]
 
   deps = [
     ":common",
+    ":fdt",
+    ":memiter",
   ]
 
   if (is_debug) {
@@ -41,3 +41,15 @@
     "//src/arch/${arch}:putchar",
   ]
 }
+
+source_set("fdt") {
+  sources = [
+    "fdt.c",
+  ]
+}
+
+source_set("memiter") {
+  sources = [
+    "memiter.c",
+  ]
+}
diff --git a/src/arch/aarch64/vm/vm_entry.S b/src/arch/aarch64/vm/vm_entry.S
index 6db2526..0e6a29e 100644
--- a/src/arch/aarch64/vm/vm_entry.S
+++ b/src/arch/aarch64/vm/vm_entry.S
@@ -2,8 +2,8 @@
 .global image_entry
 image_entry:
 	/* Prepare the stack. */
-	adr x0, kstack + 4096
-	mov sp, x0
+	adr x30, kstack + 4096
+	mov sp, x30
 
 	/* Call into C code. */
 	bl kmain
diff --git a/test/vm/BUILD.gn b/test/vm/BUILD.gn
index dd1825e..2103fbd 100644
--- a/test/vm/BUILD.gn
+++ b/test/vm/BUILD.gn
@@ -1,13 +1,28 @@
 import("//build/image/image.gni")
 
-source_set("hf_test_vm") {
+source_set("hftest_vm") {
   sources = [
-    "hf_test.h",
+    "hftest.c",
+    "hftest.h",
   ]
 
   deps = [
     "//src:common",
     "//src:common_debug",
+    "//src:fdt",
+    "//src:memiter",
+    "//src/arch/${arch}:entry",
+    "//src/arch/${arch}/vm:hf_call",
+    "//src/arch/${arch}/vm:shutdown",
+    "//src/arch/${arch}/vm:vm_entry",
+  ]
+}
+
+# TODO: work out what to run in the secondary VMs
+source_set("other_vm") {
+  deps = [
+    "//src:common",
+    "//src:common_debug",
     "//src/arch/${arch}:entry",
     "//src/arch/${arch}/vm:hf_call",
     "//src/arch/${arch}/vm:shutdown",
diff --git a/test/vm/hf_test.h b/test/vm/hf_test.h
deleted file mode 100644
index 146d6aa1..0000000
--- a/test/vm/hf_test.h
+++ /dev/null
@@ -1,141 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "hf/dlog.h"
-
-/*
- * Prefixed to log lines from tests for easy filtering in the console.
- */
-#define HF_TEST_LOG_PREFIX "[hf_test] "
-
-/*
- * Context for tests.
- */
-struct hf_test_context {
-	uint32_t failures;
-};
-
-/*
- * This union can store any of the primitive types supported by the assertion
- * macros.
- */
-union hf_test_any {
-	bool b;
-	char c;
-	signed char sc;
-	unsigned char uc;
-	signed short ss;
-	unsigned short us;
-	signed int si;
-	unsigned int ui;
-	signed long int sli;
-	unsigned long int uli;
-	signed long long int slli;
-	unsigned long long int ulli;
-	void *p;
-};
-
-/* _Generic formatting doesn't seem to be supported so doing this manually. */
-/* clang-format off */
-
-/* Select the union member to match the type of the expression. */
-#define hf_test_any_get(any, x)                     \
-	_Generic((x),                               \
-		bool:                   (any).b,    \
-		char:                   (any).c,    \
-		signed char:            (any).sc,   \
-		unsigned char:          (any).uc,   \
-		signed short:           (any).ss,   \
-		unsigned short:         (any).us,   \
-		signed int:             (any).si,   \
-		unsigned int:           (any).ui,   \
-		signed long int:        (any).sli,  \
-		unsigned long int:      (any).uli,  \
-		signed long long int:   (any).slli, \
-		unsigned long long int: (any).ulli, \
-		void *:                 (any).p)
-
-/*
- * dlog format specifier for types. Note, these aren't the standard specifiers
- * for the types.
- */
-#define hf_test_dlog_format(x)                \
-	_Generic((x),                         \
-		bool:                   "%u", \
-		char:                   "%c", \
-		signed char:            "%d", \
-		unsigned char:          "%u", \
-		signed short:           "%d", \
-		unsigned short:         "%u", \
-		signed int:             "%d", \
-		unsigned int:           "%u", \
-		signed long int:        "%d", \
-		unsigned long int:      "%u", \
-		signed long long int:   "%d", \
-		unsigned long long int: "%u", \
-		void *:                 "%p")
-
-/* clang-format on */
-
-#define ASSERT_OP(lhs, rhs, op, fatal)                                     \
-	do {                                                               \
-		union hf_test_any lhs_value;                               \
-		union hf_test_any rhs_value;                               \
-		hf_test_any_get(lhs_value, lhs) = (lhs);                   \
-		hf_test_any_get(rhs_value, rhs) = (rhs);                   \
-		if (!(hf_test_any_get(lhs_value, lhs)                      \
-			      op hf_test_any_get(rhs_value, rhs))) {       \
-			++hf_test_ctx->failures;                           \
-			dlog(HF_TEST_LOG_PREFIX "  %s:%u: Failure\n",      \
-			     __FILE__, __LINE__);                          \
-			dlog(HF_TEST_LOG_PREFIX "    %s %s %s (%s=", #lhs, \
-			     #op, #rhs, #lhs);                             \
-			dlog(hf_test_dlog_format(lhs),                     \
-			     hf_test_any_get(lhs_value, lhs));             \
-			dlog(", %s=", #rhs);                               \
-			dlog(hf_test_dlog_format(rhs),                     \
-			     hf_test_any_get(rhs_value, rhs));             \
-			dlog(")\n");                                       \
-			if (fatal) {                                       \
-				return;                                    \
-			}                                                  \
-		}                                                          \
-	} while (0)
-
-#define ASSERT_EQ(x, y) ASSERT_OP(x, y, ==, true)
-#define ASSERT_NE(x, y) ASSERT_OP(x, y, !=, true)
-#define ASSERT_LE(x, y) ASSERT_OP(x, y, <=, true)
-#define ASSERT_LT(x, y) ASSERT_OP(x, y, <, true)
-#define ASSERT_GE(x, y) ASSERT_OP(x, y, >=, true)
-#define ASSERT_GT(x, y) ASSERT_OP(x, y, >, true)
-
-#define EXPECT_EQ(x, y) ASSERT_OP(x, y, ==, false)
-#define EXPECT_NE(x, y) ASSERT_OP(x, y, !=, false)
-#define EXPECT_LE(x, y) ASSERT_OP(x, y, <=, false)
-#define EXPECT_LT(x, y) ASSERT_OP(x, y, <, false)
-#define EXPECT_GE(x, y) ASSERT_OP(x, y, >=, false)
-#define EXPECT_GT(x, y) ASSERT_OP(x, y, >, false)
-
-/*
- * Declare a test case.
- */
-#define TEST(name) static void name(struct hf_test_context *hf_test_ctx)
-
-/*
- * Run a test case.
- */
-#define RUN_TEST(test)                                       \
-	do {                                                 \
-		struct hf_test_context ctx = {               \
-			.failures = 0,                       \
-		};                                           \
-		dlog(HF_TEST_LOG_PREFIX "RUN %s\n", #test);  \
-		test(&ctx);                                  \
-		if (ctx.failures) {                          \
-			dlog(HF_TEST_LOG_PREFIX "FAILED\n"); \
-		} else {                                     \
-			dlog(HF_TEST_LOG_PREFIX "OK\n");     \
-		}                                            \
-	} while (0)
diff --git a/test/vm/hftest.c b/test/vm/hftest.c
new file mode 100644
index 0000000..90b5cf0
--- /dev/null
+++ b/test/vm/hftest.c
@@ -0,0 +1,232 @@
+#include "hftest.h"
+
+#include <stdalign.h>
+#include <stdint.h>
+
+#include "hf/fdt.h"
+#include "hf/memiter.h"
+
+alignas(4096) uint8_t kstack[4096];
+
+HFTEST_ENABLE();
+
+extern struct hftest_test hftest_begin[];
+extern struct hftest_test hftest_end[];
+
+static void json(void)
+{
+	struct hftest_test *test;
+	const char *suite = NULL;
+	size_t suites_in_image = 0;
+	size_t tests_in_suite = 0;
+
+	HFTEST_LOG("{");
+	HFTEST_LOG("  \"suites\": [");
+	for (test = hftest_begin; test < hftest_end; ++test) {
+		if (test->suite != suite) {
+			/* Close out previously open suite. */
+			if (tests_in_suite) {
+				HFTEST_LOG("      ]");
+				HFTEST_LOG("    },");
+			}
+			/* Move onto new suite. */
+			++suites_in_image;
+			suite = test->suite;
+			tests_in_suite = 0;
+			HFTEST_LOG("    {");
+			HFTEST_LOG("      \"name\": \"%s\",", test->suite);
+		}
+		if (test->kind == HFTEST_KIND_SET_UP) {
+			HFTEST_LOG("      \"setup\": true,");
+		}
+		if (test->kind == HFTEST_KIND_TEAR_DOWN) {
+			HFTEST_LOG("      \"teardown\": true,");
+		}
+		if (test->kind == HFTEST_KIND_TEST) {
+			if (!tests_in_suite) {
+				HFTEST_LOG("      \"tests\": [");
+			}
+			/* It's easier to put the comma at the start of the line
+			 * than the end even
+			 * though the JSON looks a bit funky. */
+			HFTEST_LOG("       %c\"%s\"",
+				   tests_in_suite ? ',' : ' ', test->name);
+			++tests_in_suite;
+		}
+	}
+	if (tests_in_suite) {
+		HFTEST_LOG("      ]");
+		HFTEST_LOG("    }");
+	}
+	HFTEST_LOG("  ]");
+	HFTEST_LOG("}");
+}
+
+static void run_test(hftest_test_fn set_up, hftest_test_fn test,
+		     hftest_test_fn tear_down)
+{
+	struct hftest_context ctx = {
+		.failures = 0,
+	};
+
+	if (set_up) {
+		set_up(&ctx);
+		if (ctx.failures) {
+			goto fail;
+		}
+	}
+
+	test(&ctx);
+	if (ctx.failures) {
+		goto fail;
+	}
+
+	if (tear_down) {
+		tear_down(&ctx);
+		if (ctx.failures) {
+			goto fail;
+		}
+	}
+
+	HFTEST_LOG("PASS");
+	return;
+
+fail:
+	HFTEST_LOG("FAIL");
+}
+
+static void run(struct memiter *args)
+{
+	struct memiter suite_name;
+	struct memiter test_name;
+	struct hftest_test *test;
+	bool found_suite = false;
+	const char *suite = NULL;
+	hftest_test_fn suite_set_up = NULL;
+	hftest_test_fn suite_tear_down = NULL;
+
+	if (!memiter_parse_str(args, &suite_name)) {
+		HFTEST_LOG("Unable to parse test suite.");
+		return;
+	}
+
+	if (!memiter_parse_str(args, &test_name)) {
+		HFTEST_LOG("Unable to parse test.");
+		return;
+	}
+
+	for (test = hftest_begin; test < hftest_end; ++test) {
+		/* Find the test suite. */
+		if (found_suite) {
+			if (test->suite != suite) {
+				/* Test wasn't in the suite. */
+				break;
+			}
+		} else {
+			if (test->suite == suite) {
+				/* This isn't the right suite so keep going. */
+				continue;
+			}
+			/* Examine a new suite. */
+			suite = test->suite;
+			if (memiter_iseq(&suite_name, test->suite)) {
+				found_suite = true;
+			}
+		}
+
+		switch (test->kind) {
+		/* The first entries in the suite are the set up and tear down
+		 * functions. */
+		case HFTEST_KIND_SET_UP:
+			suite_set_up = test->fn;
+			break;
+		case HFTEST_KIND_TEAR_DOWN:
+			suite_tear_down = test->fn;
+			break;
+		/* Find the test. */
+		case HFTEST_KIND_TEST:
+			if (memiter_iseq(&test_name, test->name)) {
+				run_test(suite_set_up, test->fn,
+					 suite_tear_down);
+				return;
+			}
+			break;
+		}
+	}
+
+	HFTEST_LOG("Unable to find requested tests.");
+}
+
+void help(void)
+{
+	HFTEST_LOG("usage:");
+	HFTEST_LOG("");
+	HFTEST_LOG("  help");
+	HFTEST_LOG("");
+	HFTEST_LOG("    Show this help.");
+	HFTEST_LOG("");
+	HFTEST_LOG("  json");
+	HFTEST_LOG("");
+	HFTEST_LOG(
+		"    Print a directory of test suites and tests in "
+		"JSON "
+		"format.");
+	HFTEST_LOG("");
+	HFTEST_LOG("  run <suite> <test>");
+	HFTEST_LOG("");
+	HFTEST_LOG("    Run the named test from the named test suite.");
+}
+
+void main(const struct fdt_header *fdt)
+{
+	struct fdt_node n;
+	const char *bootargs;
+	uint32_t bootargs_size;
+	struct memiter bootargs_iter;
+	struct memiter command;
+
+	if (!fdt_root_node(&n, fdt)) {
+		HFTEST_LOG("FDT failed validation.");
+		return;
+	}
+
+	if (!fdt_find_child(&n, "")) {
+		HFTEST_LOG("Unable to find root node in FDT.");
+		return;
+	}
+
+	if (!fdt_find_child(&n, "chosen")) {
+		HFTEST_LOG("Unable to find 'chosen' node in FDT.");
+		return;
+	}
+
+	if (!fdt_read_property(&n, "bootargs", &bootargs, &bootargs_size)) {
+		HFTEST_LOG("Unable to read bootargs.");
+		return;
+	}
+
+	/* Remove null terminator. */
+	memiter_init(&bootargs_iter, bootargs, bootargs_size - 1);
+
+	if (!memiter_parse_str(&bootargs_iter, &command)) {
+		HFTEST_LOG("Unable to parse command.");
+		return;
+	}
+
+	if (memiter_iseq(&command, "json")) {
+		json();
+		return;
+	}
+
+	if (memiter_iseq(&command, "run")) {
+		run(&bootargs_iter);
+		return;
+	}
+
+	help();
+}
+
+void kmain(const struct fdt_header *fdt)
+{
+	main(fdt);
+}
diff --git a/test/vm/hftest.h b/test/vm/hftest.h
new file mode 100644
index 0000000..6e22a3e
--- /dev/null
+++ b/test/vm/hftest.h
@@ -0,0 +1,231 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "hf/dlog.h"
+
+/*
+ * Define a set up function to be run before every test in a test suite.
+ */
+#define SET_UP(suite) HFTEST_SET_UP(suite)
+
+/*
+ * Define a tear down function to be run after every test in a test suite.
+ */
+#define TEAR_DOWN(suite) HFTEST_TEAR_DOWN(suite)
+
+/*
+ * Define a test as part of a test suite.
+ */
+#define TEST(suite, test) HFTEST_TEST(suite, test)
+
+/* Assertions. */
+#define ASSERT_EQ(x, y) ASSERT_OP(x, y, ==, true)
+#define ASSERT_NE(x, y) ASSERT_OP(x, y, !=, true)
+#define ASSERT_LE(x, y) ASSERT_OP(x, y, <=, true)
+#define ASSERT_LT(x, y) ASSERT_OP(x, y, <, true)
+#define ASSERT_GE(x, y) ASSERT_OP(x, y, >=, true)
+#define ASSERT_GT(x, y) ASSERT_OP(x, y, >, true)
+
+#define EXPECT_EQ(x, y) ASSERT_OP(x, y, ==, false)
+#define EXPECT_NE(x, y) ASSERT_OP(x, y, !=, false)
+#define EXPECT_LE(x, y) ASSERT_OP(x, y, <=, false)
+#define EXPECT_LT(x, y) ASSERT_OP(x, y, <, false)
+#define EXPECT_GE(x, y) ASSERT_OP(x, y, >=, false)
+#define EXPECT_GT(x, y) ASSERT_OP(x, y, >, false)
+
+/*
+ * This must be used exactly once in a test image to signal to the linker that
+ * the .hftest section is allowed to be included in the generated image.
+ */
+#define HFTEST_ENABLE() int hftest_enable
+
+/*
+ * Prefixed to log lines from tests for easy filtering in the console.
+ */
+#define HFTEST_LOG_PREFIX "[hftest] "
+
+/* Above this point is the public API. Below are the implementation details. */
+
+/* Log with the HFTEST_LOG_PREFIX and a new line. The zero is added so there is
+ * always at least one variadic argument. */
+#define HFTEST_LOG(...) HFTEST_LOG_IMPL(__VA_ARGS__, 0)
+#define HFTEST_LOG_IMPL(format, ...) \
+	dlog("%s" format "\n", HFTEST_LOG_PREFIX, __VA_ARGS__)
+
+/* Helper to wrap the argument in quotes. */
+#define HFTEST_STR(str) #str
+
+/* Sections are names such that when the linker sorts them, all entries for the
+ * same test suite are contiguous and the set up and tear down entries come
+ * before the tests. This order simplifies test discovery in the running image.
+ */
+#define HFTEST_SET_UP_SECTION(suite_name) \
+	HFTEST_STR(.hftest.suite_name .1set_up)
+#define HFTEST_TEAR_DOWN_SECTION(suite_name) \
+	HFTEST_STR(.hftest.suite_name .1tear_down)
+#define HFTEST_TEST_SECTION(suite_name, test_name) \
+	HFTEST_STR(.hftest.suite_name .2test.test_name)
+
+/* Helpers to construct unique identifiers. */
+#define HFTEST_SET_UP_STRUCT(suite_name) hftest_set_up_##suite_name
+#define HFTEST_TEAR_DOWN_STRUCT(suite_name) hftest_tear_down_##suite_name
+#define HFTEST_TEST_STRUCT(suite_name, test_name) \
+	hftest_test_##suite_name##_##test_name
+
+#define HFTEST_SET_UP_FN(suite_name) hftest_set_up_fn_##suite_name
+#define HFTEST_TEAR_DOWN_FN(suite_name) hftest_tear_down_fn_##suite_name
+#define HFTEST_TEST_FN(suite_name, test_name) \
+	hftest_test_fn_##suite_name##_##test_name
+
+/* Register test functions. */
+#define HFTEST_SET_UP(suite_name)                                           \
+	static void HFTEST_SET_UP_FN(suite_name)(struct hftest_context *    \
+						 hftest_ctx);               \
+	const struct hftest_test __attribute__((used))                      \
+		__attribute__((section(HFTEST_SET_UP_SECTION(suite_name)))) \
+			HFTEST_SET_UP_STRUCT(suite_name) = {                \
+				.suite = #suite_name,                       \
+				.kind = HFTEST_KIND_SET_UP,                 \
+				.fn = HFTEST_SET_UP_FN(suite_name),         \
+	};                                                                  \
+	static void HFTEST_SET_UP_FN(suite_name)(                           \
+		__attribute__((unused)) struct hftest_context * hftest_ctx)
+
+#define HFTEST_TEAR_DOWN(suite_name)                                           \
+	static void HFTEST_TEAR_DOWN_FN(suite_name)(struct hftest_context *    \
+						    hftest_ctx);               \
+	const struct hftest_test __attribute__((used))                         \
+		__attribute__((section(HFTEST_TEAR_DOWN_SECTION(suite_name)))) \
+			HFTEST_TEAR_DOWN_STRUCT(suite_name) = {                \
+				.suite = #suite_name,                          \
+				.kind = HFTEST_KIND_TEAR_DOWN,                 \
+				.fn = HFTEST_TEAR_DOWN_FN(suite_name),         \
+	};                                                                     \
+	static void HFTEST_TEAR_DOWN_FN(suite_name)(                           \
+		__attribute__((unused)) struct hftest_context * hftest_ctx)
+
+#define HFTEST_TEST(suite_name, test_name)                                  \
+	static void HFTEST_TEST_FN(                                         \
+		suite_name, test_name)(struct hftest_context * hftest_ctx); \
+	const struct hftest_test __attribute__((used)) __attribute__(       \
+		(section(HFTEST_TEST_SECTION(suite_name, test_name))))      \
+		HFTEST_TEST_STRUCT(suite_name, test_name) = {               \
+			.suite = #suite_name,                               \
+			.kind = HFTEST_KIND_TEST,                           \
+			.name = #test_name,                                 \
+			.fn = HFTEST_TEST_FN(suite_name, test_name),        \
+	};                                                                  \
+	static void HFTEST_TEST_FN(suite_name, test_name)(                  \
+		__attribute__((unused)) struct hftest_context * hftest_ctx)
+
+/* Context for tests. */
+struct hftest_context {
+	uint32_t failures;
+};
+
+/* A test case. */
+typedef void (*hftest_test_fn)(struct hftest_context *);
+
+enum hftest_kind {
+	HFTEST_KIND_SET_UP = 0,
+	HFTEST_KIND_TEST = 1,
+	HFTEST_KIND_TEAR_DOWN = 2,
+};
+
+struct hftest_test {
+	const char *suite;
+	enum hftest_kind kind;
+	const char *name;
+	hftest_test_fn fn;
+};
+
+/*
+ * This union can store any of the primitive types supported by the assertion
+ * macros.
+ *
+ * It does not include pointers as comparison of pointers is not often needed
+ * and could be a mistake for string comparison. If pointer comparison is needed
+ * and explicit assertion such as ASSERT_PTR_EQ() would be more appropriate.
+ */
+union hftest_any {
+	bool b;
+	char c;
+	signed char sc;
+	unsigned char uc;
+	signed short ss;
+	unsigned short us;
+	signed int si;
+	unsigned int ui;
+	signed long int sli;
+	unsigned long int uli;
+	signed long long int slli;
+	unsigned long long int ulli;
+};
+
+/* _Generic formatting doesn't seem to be supported so doing this manually. */
+/* clang-format off */
+
+/* Select the union member to match the type of the expression. */
+#define hftest_any_get(any, x)                      \
+	_Generic((x),                               \
+		bool:                   (any).b,    \
+		char:                   (any).c,    \
+		signed char:            (any).sc,   \
+		unsigned char:          (any).uc,   \
+		signed short:           (any).ss,   \
+		unsigned short:         (any).us,   \
+		signed int:             (any).si,   \
+		unsigned int:           (any).ui,   \
+		signed long int:        (any).sli,  \
+		unsigned long int:      (any).uli,  \
+		signed long long int:   (any).slli, \
+		unsigned long long int: (any).ulli)
+
+/*
+ * dlog format specifier for types. Note, these aren't the standard specifiers
+ * for the types.
+ */
+#define hftest_dlog_format(x)                 \
+	_Generic((x),                         \
+		bool:                   "%u", \
+		char:                   "%c", \
+		signed char:            "%d", \
+		unsigned char:          "%u", \
+		signed short:           "%d", \
+		unsigned short:         "%u", \
+		signed int:             "%d", \
+		unsigned int:           "%u", \
+		signed long int:        "%d", \
+		unsigned long int:      "%u", \
+		signed long long int:   "%d", \
+		unsigned long long int: "%u")
+
+/* clang-format on */
+
+#define ASSERT_OP(lhs, rhs, op, fatal)                                         \
+	do {                                                                   \
+		union hftest_any lhs_value;                                    \
+		union hftest_any rhs_value;                                    \
+		hftest_any_get(lhs_value, lhs) = (lhs);                        \
+		hftest_any_get(rhs_value, rhs) = (rhs);                        \
+		if (!(hftest_any_get(lhs_value, lhs)                           \
+			      op hftest_any_get(rhs_value, rhs))) {            \
+			++hftest_ctx->failures;                                \
+			dlog(HFTEST_LOG_PREFIX "  %s:%u: Failure\n", __FILE__, \
+			     __LINE__);                                        \
+			dlog(HFTEST_LOG_PREFIX "    %s %s %s (%s=", #lhs, #op, \
+			     #rhs, #lhs);                                      \
+			dlog(hftest_dlog_format(lhs),                          \
+			     hftest_any_get(lhs_value, lhs));                  \
+			dlog(", %s=", #rhs);                                   \
+			dlog(hftest_dlog_format(rhs),                          \
+			     hftest_any_get(rhs_value, rhs));                  \
+			dlog(")\n");                                           \
+			if (fatal) {                                           \
+				return;                                        \
+			}                                                      \
+		}                                                              \
+	} while (0)
diff --git a/test/vm/hftest.py b/test/vm/hftest.py
new file mode 100755
index 0000000..6cf8e97
--- /dev/null
+++ b/test/vm/hftest.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+"""Run tests.
+
+Runs tests on QEMU.
+"""
+
+from __future__ import print_function
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+
+
+def qemu(hafnium, initrd, args, log):
+    qemu_args = [
+        "timeout", "--foreground", "5s",
+        "./prebuilts/linux-x64/qemu/qemu-system-aarch64", "-M", "virt", "-cpu",
+        "cortex-a57", "-m", "8M", "-machine", "virtualization=true",
+        "-nographic", "-nodefaults", "-serial", "stdio", "-kernel", hafnium,
+        "-initrd", initrd
+    ]
+    if args:
+        qemu_args += ["-append", args]
+    # Save the log to a file.
+    with open(log, "w") as f:
+        f.write("$ {}\r\n".format(" ".join(qemu_args)))
+        f.flush()
+        subprocess.check_call(qemu_args, stdout=f, stderr=f)
+    # Return that log for processing.
+    with open(log, "r") as f:
+        return f.read()
+
+
+def ensure_dir(path):
+    try:
+        os.makedirs(path)
+    except OSError:
+        if not os.path.isdir(path):
+            raise
+
+
+def hftest_lines(raw):
+    prefix = "[hftest] "
+    return [
+        line[len(prefix):]
+        for line in raw.splitlines()
+        if line.startswith(prefix)
+    ]
+
+
+def Main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--out", required=True)
+    parser.add_argument("--initrd", required=True)
+    parser.add_argument("--suite")
+    parser.add_argument("--test")
+    args = parser.parse_args()
+    # Resolve some paths.
+    hafnium = os.path.join(args.out, "hafnium.bin")
+    initrd = os.path.join(args.out, "initrd", args.initrd + ".img")
+    log = os.path.join(args.out, "test_log", args.initrd)
+    ensure_dir(log)
+    print("Logs saved under", log)
+    # Query the tests in the image.
+    out = qemu(hafnium, initrd, "json", os.path.join(log, "json.log"))
+    hftest_json = "\n".join(hftest_lines(out))
+    tests = json.loads(hftest_json)
+    # Run the selected tests.
+    tests_run = 0
+    failures = 0
+    suite_re = re.compile(args.suite or ".*")
+    test_re = re.compile(args.test or ".*")
+    for suite in tests['suites']:
+        if not suite_re.match(suite['name']):
+            continue
+        tests_run_from_suite = 0
+        for test in suite['tests']:
+            if not test_re.match(test):
+                continue
+            tests_run_from_suite += 1
+            if tests_run_from_suite == 1:
+                print("    SUITE", suite['name'])
+            print("      RUN", test)
+            test_log = os.path.join(log, suite['name'] + "." + test + ".log")
+            out = qemu(hafnium, initrd, "run {} {}".format(suite['name'], test), test_log)
+            hftest_out = hftest_lines(out)
+            if hftest_out[-1] == "PASS":
+                print("        PASS")
+            else:
+                failures += 1
+                print("[x]     FAIL --", test_log)
+        tests_run += tests_run_from_suite
+    # If none were run, this is probably a mistake.
+    if tests_run == 0:
+        print("Error: no tests match")
+        return 10
+    # Exit with 0 on success and 1 if any test failed.
+    if failures:
+        print("[x] FAIL:", failures, "of", tests_run, "tests failed")
+        return 1
+    else:
+        print("    PASS: all", tests_run, "tests passed")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(Main())
diff --git a/test/vm/primary_only/BUILD.gn b/test/vm/primary_only/BUILD.gn
index b4e1212..821ef0e 100644
--- a/test/vm/primary_only/BUILD.gn
+++ b/test/vm/primary_only/BUILD.gn
@@ -8,7 +8,7 @@
   ]
 
   deps = [
-    "//test/vm:hf_test_vm",
+    "//test/vm:hftest_vm",
   ]
 }
 
diff --git a/test/vm/primary_only/primary.c b/test/vm/primary_only/primary.c
index 03dc95c..18c4709 100644
--- a/test/vm/primary_only/primary.c
+++ b/test/vm/primary_only/primary.c
@@ -1,29 +1,18 @@
-#include <stdint.h>
-
 #include "vmapi/hf/call.h"
 
-#include "../hf_test.h"
+#include "../hftest.h"
 
-uint8_t kstack[4096] __attribute__((aligned(4096)));
-
-TEST(vm_get_count)
+TEST(hf_vm_get_count, no_secondary_vms)
 {
 	EXPECT_EQ(hf_vm_get_count(), 0);
 }
 
-TEST(vcpu_get_count_when_no_secondary_vm)
+TEST(hf_vcpu_get_count, no_secondary_vms)
 {
 	EXPECT_EQ(hf_vcpu_get_count(0), -1);
 }
 
-TEST(vcpu_get_count_for_large_invalid_vm_index)
+TEST(hf_vcpu_get_count, large_invalid_vm_index)
 {
 	EXPECT_EQ(hf_vcpu_get_count(0xffffffff), -1);
 }
-
-void kmain(void)
-{
-	RUN_TEST(vm_get_count);
-	RUN_TEST(vcpu_get_count_when_no_secondary_vm);
-	RUN_TEST(vcpu_get_count_for_large_invalid_vm_index);
-}
diff --git a/test/vm/primary_with_secondary/BUILD.gn b/test/vm/primary_with_secondary/BUILD.gn
index 512ccfd..8b4c489 100644
--- a/test/vm/primary_with_secondary/BUILD.gn
+++ b/test/vm/primary_with_secondary/BUILD.gn
@@ -8,7 +8,7 @@
   ]
 
   deps = [
-    "//test/vm:hf_test_vm",
+    "//test/vm:hftest_vm",
   ]
 }
 
@@ -20,7 +20,7 @@
   ]
 
   deps = [
-    "//test/vm:hf_test_vm",
+    "//test/vm:other_vm",
   ]
 }
 
diff --git a/test/vm/primary_with_secondary/primary.c b/test/vm/primary_with_secondary/primary.c
index 5502904..58d8ba4 100644
--- a/test/vm/primary_with_secondary/primary.c
+++ b/test/vm/primary_with_secondary/primary.c
@@ -6,35 +6,49 @@
 
 #include "vmapi/hf/call.h"
 
-#include "../hf_test.h"
+#include "../hftest.h"
 
-alignas(4096) uint8_t kstack[4096];
-
-alignas(PAGE_SIZE) uint8_t send_page[PAGE_SIZE];
-alignas(PAGE_SIZE) uint8_t recv_page[PAGE_SIZE];
+static alignas(PAGE_SIZE) uint8_t send_page[PAGE_SIZE];
+static alignas(PAGE_SIZE) uint8_t recv_page[PAGE_SIZE];
 static_assert(sizeof(send_page) == PAGE_SIZE, "Send page is not a page.");
 static_assert(sizeof(recv_page) == PAGE_SIZE, "Recv page is not a page.");
 
-TEST(vm_get_count)
+static hf_ipaddr_t send_page_addr = (hf_ipaddr_t)send_page;
+static hf_ipaddr_t recv_page_addr = (hf_ipaddr_t)recv_page;
+
+/**
+ * Confirm there is 1 secondary VM.
+ */
+TEST(hf_vm_get_count, one_secondary_vm)
 {
 	EXPECT_EQ(hf_vm_get_count(), 1);
 }
 
-TEST(vcpu_get_count_when_no_secondary_vm)
+/**
+ * Confirm there that secondary VM has 1 VCPU.
+ */
+TEST(hf_vcpu_get_count, secondary_has_one_vcpu)
 {
 	EXPECT_EQ(hf_vcpu_get_count(0), 1);
 }
 
-TEST(vcpu_get_count_for_large_invalid_vm_index)
+/**
+ * Confirm it is an error to query how many VCPUs are assigned to a nonexistent
+ * secondary VM.
+ */
+TEST(hf_vcpu_get_count, large_invalid_vm_index)
 {
 	EXPECT_EQ(hf_vcpu_get_count(0xffffffff), -1);
 }
 
-TEST(vm_configure_fails_with_unaligned_pointer)
+/**
+ * The configured send/receive addresses can't be unaligned.
+ */
+TEST(hf_vm_configure, fails_with_unaligned_pointer)
 {
 	uint8_t maybe_aligned[2];
 	hf_ipaddr_t unaligned_addr = (hf_ipaddr_t)&maybe_aligned[1];
-	hf_ipaddr_t aligned_addr = (hf_ipaddr_t)&send_page;
+	hf_ipaddr_t aligned_addr = (hf_ipaddr_t)send_page;
 
 	/* Check the the address is unaligned. */
 	ASSERT_EQ(unaligned_addr & 1, 1);
@@ -44,40 +58,29 @@
 	EXPECT_EQ(hf_vm_configure(unaligned_addr, unaligned_addr), -1);
 }
 
-TEST(vm_configure_fails_with_same_page)
+/**
+ * The configured send/receive addresses can't be the same page.
+ */
+TEST(hf_vm_configure, fails_with_same_page)
 {
-	EXPECT_EQ(
-		hf_vm_configure((hf_ipaddr_t)send_page, (hf_ipaddr_t)send_page),
-		-1);
-	EXPECT_EQ(
-		hf_vm_configure((hf_ipaddr_t)recv_page, (hf_ipaddr_t)recv_page),
-		-1);
+	EXPECT_EQ(hf_vm_configure(send_page_addr, send_page_addr), -1);
+	EXPECT_EQ(hf_vm_configure(recv_page_addr, recv_page_addr), -1);
 }
 
-TEST(vm_configure)
+/**
+ * The configuration of the send/receive addresses can only happen once.
+ */
+TEST(hf_vm_configure, fails_if_already_succeeded)
 {
-	EXPECT_EQ(
-		hf_vm_configure((hf_ipaddr_t)send_page, (hf_ipaddr_t)recv_page),
-		0);
+	EXPECT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), 0);
+	EXPECT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), -1);
 }
 
-TEST(vm_configure_fails_if_already_succeeded)
+/**
+ * The configuration of the send/receive address is successful with valid
+ * arguments.
+ */
+TEST(hf_vm_configure, succeeds)
 {
-	EXPECT_EQ(
-		hf_vm_configure((hf_ipaddr_t)send_page, (hf_ipaddr_t)recv_page),
-		-1);
-}
-
-void kmain(void)
-{
-	RUN_TEST(vm_get_count);
-	RUN_TEST(vcpu_get_count_when_no_secondary_vm);
-	RUN_TEST(vcpu_get_count_for_large_invalid_vm_index);
-
-	/* TODO: the order matters as the configuration can only be set once.
-	 * We'll need to work out how to deal with this better in the tests. */
-	RUN_TEST(vm_configure_fails_with_unaligned_pointer);
-	RUN_TEST(vm_configure_fails_with_same_page);
-	RUN_TEST(vm_configure);
-	RUN_TEST(vm_configure_fails_if_already_succeeded);
+	EXPECT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), 0);
 }
diff --git a/test/vm/primary_with_secondary/secondary.c b/test/vm/primary_with_secondary/secondary.c
index 19f6901..788e310 100644
--- a/test/vm/primary_with_secondary/secondary.c
+++ b/test/vm/primary_with_secondary/secondary.c
@@ -1,10 +1,11 @@
+#include <stdalign.h>
 #include <stdint.h>
 
 #include "vmapi/hf/call.h"
 
-#include "../hf_test.h"
+#include "../hftest.h"
 
-uint8_t kstack[4096] __attribute__((aligned(4096)));
+alignas(4096) uint8_t kstack[4096];
 
 void kmain(void)
 {