diff --git a/build/image/image.gni b/build/image/image.gni
index 2f9da5b..02489f0 100644
--- a/build/image/image.gni
+++ b/build/image/image.gni
@@ -33,6 +33,8 @@
                              "cflags_c",
                              "defines",
                              "deps",
+                             "include_dirs",
+                             "public_configs",
                              "public_deps",
                              "sources",
                              "testonly",
@@ -99,6 +101,8 @@
                              "cflags_c",
                              "defines",
                              "deps",
+                             "include_dirs",
+                             "public_configs",
                              "public_deps",
                              "sources",
                              "testonly",
diff --git a/test/vmapi/BUILD.gn b/test/vmapi/BUILD.gn
index 7ad3834..da28503 100644
--- a/test/vmapi/BUILD.gn
+++ b/test/vmapi/BUILD.gn
@@ -15,6 +15,10 @@
 import("//build/image/image.gni")
 import("//build/toolchain/platform.gni")
 
+config("config") {
+  include_dirs = [ "inc" ]
+}
+
 group("vmapi") {
   testonly = true
 
@@ -27,6 +31,7 @@
 # Tests with no secondary VMs.
 vm_kernel("primary_only_test_vm") {
   testonly = true
+  public_configs = [ "//test/vmapi:config" ]
 
   sources = [
     "primary_only.c",
@@ -46,6 +51,7 @@
 # Tests specific to GICv3.
 vm_kernel("gicv3_test_vm") {
   testonly = true
+  public_configs = [ "//test/vmapi:config" ]
 
   sources = [
     "gicv3.c",
@@ -66,6 +72,7 @@
 # Tests with secondary VMs.
 vm_kernel("primary_with_secondaries_test_vm") {
   testonly = true
+  public_configs = [ "//test/vmapi:config" ]
 
   sources = [
     "primary_with_secondaries.c",
diff --git a/test/vmapi/inc/constants.h b/test/vmapi/inc/constants.h
new file mode 100644
index 0000000..1be98cd
--- /dev/null
+++ b/test/vmapi/inc/constants.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define SELF_INTERRUPT_ID 5
+#define EXTERNAL_INTERRUPT_ID 7
+#define EXTERNAL_INTERRUPT_ID_B 8
diff --git a/test/vmapi/primary_with_secondaries.c b/test/vmapi/primary_with_secondaries.c
index c70f38e..b13ac6e 100644
--- a/test/vmapi/primary_with_secondaries.c
+++ b/test/vmapi/primary_with_secondaries.c
@@ -23,6 +23,7 @@
 
 #include "vmapi/hf/call.h"
 
+#include "constants.h"
 #include "hftest.h"
 
 static alignas(PAGE_SIZE) uint8_t send_page[PAGE_SIZE];
@@ -307,3 +308,115 @@
 		0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
+
+/**
+ * Inject an interrupt to the interrupt VM, which will send a message back.
+ * Repeat this twice to make sure it doesn't get into a bad state after the
+ * first one.
+ */
+TEST(interrupts, inject_interrupt_twice)
+{
+	const char expected_response[] = "Got IRQ 07.";
+	struct hf_vcpu_run_return run_res;
+
+	/* Configure mailbox pages. */
+	EXPECT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), 0);
+	run_res = hf_vcpu_run(INTERRUPTIBLE_VM_ID, 0);
+	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
+
+	/* Inject the interrupt and wait for a message. */
+	hf_inject_interrupt(INTERRUPTIBLE_VM_ID, 0, EXTERNAL_INTERRUPT_ID);
+	run_res = hf_vcpu_run(INTERRUPTIBLE_VM_ID, 0);
+	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
+	EXPECT_EQ(
+		memcmp(recv_page, expected_response, sizeof(expected_response)),
+		0);
+	EXPECT_EQ(hf_mailbox_clear(), 0);
+
+	/* Inject the interrupt again, and wait for the same message. */
+	hf_inject_interrupt(INTERRUPTIBLE_VM_ID, 0, EXTERNAL_INTERRUPT_ID);
+	run_res = hf_vcpu_run(INTERRUPTIBLE_VM_ID, 0);
+	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
+	EXPECT_EQ(
+		memcmp(recv_page, expected_response, sizeof(expected_response)),
+		0);
+	EXPECT_EQ(hf_mailbox_clear(), 0);
+}
+
+/**
+ * Inject two different interrupts to the interrupt VM, which will send a
+ * message back each time.
+ */
+TEST(interrupts, inject_two_interrupts)
+{
+	const char expected_response[] = "Got IRQ 07.";
+	const char expected_response_2[] = "Got IRQ 08.";
+	struct hf_vcpu_run_return run_res;
+
+	/* Configure mailbox pages. */
+	EXPECT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), 0);
+	run_res = hf_vcpu_run(INTERRUPTIBLE_VM_ID, 0);
+	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
+
+	/* Inject the interrupt and wait for a message. */
+	hf_inject_interrupt(INTERRUPTIBLE_VM_ID, 0, EXTERNAL_INTERRUPT_ID);
+	run_res = hf_vcpu_run(INTERRUPTIBLE_VM_ID, 0);
+	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
+	EXPECT_EQ(
+		memcmp(recv_page, expected_response, sizeof(expected_response)),
+		0);
+	EXPECT_EQ(hf_mailbox_clear(), 0);
+
+	/* Inject a different interrupt and wait for a different message. */
+	hf_inject_interrupt(INTERRUPTIBLE_VM_ID, 0, EXTERNAL_INTERRUPT_ID_B);
+	run_res = hf_vcpu_run(INTERRUPTIBLE_VM_ID, 0);
+	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	EXPECT_EQ(run_res.message.size, sizeof(expected_response_2));
+	EXPECT_EQ(memcmp(recv_page, expected_response_2,
+			 sizeof(expected_response_2)),
+		  0);
+	EXPECT_EQ(hf_mailbox_clear(), 0);
+}
+
+/**
+ * Inject an interrupt then send a message to the interrupt VM, which will send
+ * a message back each time. This is to test that interrupt injection doesn't
+ * interfere with message reception.
+ */
+TEST(interrupts, inject_interrupt_message)
+{
+	const char expected_response[] = "Got IRQ 07.";
+	const char message[] = "Ping";
+	const char expected_response_2[] = "Got IRQ 05.";
+	struct hf_vcpu_run_return run_res;
+
+	/* Configure mailbox pages. */
+	EXPECT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), 0);
+	run_res = hf_vcpu_run(INTERRUPTIBLE_VM_ID, 0);
+	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
+
+	/* Inject the interrupt and wait for a message. */
+	hf_inject_interrupt(INTERRUPTIBLE_VM_ID, 0, EXTERNAL_INTERRUPT_ID);
+	run_res = hf_vcpu_run(INTERRUPTIBLE_VM_ID, 0);
+	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
+	EXPECT_EQ(
+		memcmp(recv_page, expected_response, sizeof(expected_response)),
+		0);
+	EXPECT_EQ(hf_mailbox_clear(), 0);
+
+	/* Now send a message to the secondary. */
+	memcpy(send_page, message, sizeof(message));
+	EXPECT_EQ(hf_mailbox_send(INTERRUPTIBLE_VM_ID, sizeof(message)),
+		  HF_INVALID_VCPU);
+	run_res = hf_vcpu_run(INTERRUPTIBLE_VM_ID, 0);
+	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	EXPECT_EQ(run_res.message.size, sizeof(expected_response_2));
+	EXPECT_EQ(memcmp(recv_page, expected_response_2,
+			 sizeof(expected_response_2)),
+		  0);
+	EXPECT_EQ(hf_mailbox_clear(), 0);
+}
diff --git a/test/vmapi/secondaries/BUILD.gn b/test/vmapi/secondaries/BUILD.gn
index af4bfd6..52dfd57 100644
--- a/test/vmapi/secondaries/BUILD.gn
+++ b/test/vmapi/secondaries/BUILD.gn
@@ -16,6 +16,7 @@
 
 vm_kernel("echo") {
   testonly = true
+  public_configs = [ "//test/vmapi:config" ]
 
   sources = [
     "echo.c",
@@ -28,6 +29,7 @@
 
 vm_kernel("relay_a") {
   testonly = true
+  public_configs = [ "//test/vmapi:config" ]
 
   sources = [
     "relay_a.c",
@@ -40,6 +42,7 @@
 
 vm_kernel("relay_b") {
   testonly = true
+  public_configs = [ "//test/vmapi:config" ]
 
   sources = [
     "relay_b.c",
@@ -52,6 +55,7 @@
 
 vm_kernel("interruptible") {
   testonly = true
+  public_configs = [ "//test/vmapi:config" ]
 
   sources = [
     "interruptible.c",
diff --git a/test/vmapi/secondaries/interruptible.c b/test/vmapi/secondaries/interruptible.c
index 09ebd51..73c6da0 100644
--- a/test/vmapi/secondaries/interruptible.c
+++ b/test/vmapi/secondaries/interruptible.c
@@ -26,15 +26,13 @@
 #include "vmapi/hf/call.h"
 
 #include "../msr.h"
+#include "constants.h"
 
 /*
  * Secondary VM that sends messages in response to interrupts, and interrupts
  * itself when it receives a message.
  */
 
-#define DESTINATION_VM_ID 0
-#define SELF_INTERRUPT_ID 5
-
 alignas(4096) uint8_t kstack[4096];
 
 static alignas(PAGE_SIZE) uint8_t send_page[PAGE_SIZE];
@@ -54,7 +52,23 @@
 	buffer[8] = '0' + interrupt_id / 10;
 	buffer[9] = '0' + interrupt_id % 10;
 	memcpy(send_page, buffer, size);
-	hf_mailbox_send(DESTINATION_VM_ID, size);
+	hf_mailbox_send(HF_PRIMARY_VM_ID, size);
+}
+
+/**
+ * Try to receive a message from the mailbox, blocking if necessary, and
+ * retrying if interrupted.
+ */
+struct hf_mailbox_receive_return mailbox_receive_retry()
+{
+	struct hf_mailbox_receive_return received = {
+		.vm_id = HF_INVALID_VM_ID,
+		.size = 0,
+	};
+	while (received.vm_id == HF_INVALID_VM_ID && received.size == 0) {
+		received = hf_mailbox_receive(true);
+	}
+	return received;
 }
 
 void kmain(void)
@@ -63,13 +77,23 @@
 
 	exception_setup();
 	hf_enable_interrupt(SELF_INTERRUPT_ID, true);
+	hf_enable_interrupt(EXTERNAL_INTERRUPT_ID, true);
+	hf_enable_interrupt(EXTERNAL_INTERRUPT_ID_B, true);
 	arch_irq_enable();
 
 	/* Loop, echo messages back to the sender. */
 	for (;;) {
-		received_message = hf_mailbox_receive(true);
+		const char ping_message[] = "Ping";
+		received_message = mailbox_receive_retry();
+		if (received_message.vm_id == 0 && received_message.size == 5 &&
+		    memcmp(recv_page, ping_message, sizeof(ping_message)) ==
+			    0) {
+			/* Interrupt ourselves */
+			hf_inject_interrupt(4, 0, SELF_INTERRUPT_ID);
+		} else {
+			dlog("Got unexpected message from VM %d, size %d.\n",
+			     received_message.vm_id, received_message.size);
+		}
 		hf_mailbox_clear();
-		/* Interrupt ourselves */
-		hf_inject_interrupt(4, 0, SELF_INTERRUPT_ID);
 	}
 }