diff --git a/system/dev/bus/virtio/backends/fake.h b/system/dev/bus/virtio/backends/fake.h
new file mode 100644
index 0000000..01eec43
--- /dev/null
+++ b/system/dev/bus/virtio/backends/fake.h
@@ -0,0 +1,119 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <assert.h>
+#include <initializer_list>
+#include <map>
+#include <set>
+#include <utility>
+#include <unittest/unittest.h>
+#include "backend.h"
+
+namespace virtio {
+
+// FakeBackend allows writing tests of virtio device drivers.
+//
+// Tests may subclass FakeBackend and override certain functions to check device/driver
+// interactions. FakeBackend also provides a small amount of helper functionality itself - it
+// checks the device initialization state machine, tracks valid queues/sizes, and valid config
+// registers.
+class FakeBackend : public Backend {
+  public:
+    ~FakeBackend() override = default;
+
+    zx_status_t Bind() override { return ZX_OK; }
+    void Unbind() override {}
+    bool ReadFeature(uint32_t bit) override { return false; }
+    void SetFeature(uint32_t bit) override { EXPECT_NE(state_, State::DRIVER_OK); }
+    zx_status_t ConfirmFeatures() override { return ZX_OK; }
+    void DriverStatusOk() override {
+        EXPECT_EQ(state_, State::DEVICE_STATUS_ACK);
+        state_ = State::DRIVER_OK;
+    }
+    void DriverStatusAck() override {
+        EXPECT_EQ(state_, State::DEVICE_RESET);
+        state_ = State::DEVICE_STATUS_ACK;
+    }
+    void DeviceReset() override {
+        EXPECT_EQ(state_, State::DEVICE_VOID);
+        state_ = State::DEVICE_RESET;
+    }
+    void DeviceConfigRead(uint16_t offset, uint8_t* value) override {
+        EXPECT_GT(registers8_.count(offset), 0);
+        *value = registers8_[offset];
+    }
+    void DeviceConfigRead(uint16_t offset, uint16_t* value) override {
+        EXPECT_GT(registers16_.count(offset), 0);
+        *value = registers16_[offset];
+    }
+    void DeviceConfigRead(uint16_t offset, uint32_t* value) override {
+        EXPECT_GT(registers32_.count(offset), 0);
+        *value = registers32_[offset];
+    }
+    void DeviceConfigRead(uint16_t offset, uint64_t* value) override {
+        EXPECT_TRUE(0);  // Not Implemented.
+    }
+    void DeviceConfigWrite(uint16_t offset, uint8_t value) override {
+        registers8_[offset] = value;
+    }
+    void DeviceConfigWrite(uint16_t offset, uint16_t value) override {
+        registers16_[offset] = value;
+    }
+    void DeviceConfigWrite(uint16_t offset, uint32_t value) override {
+        registers32_[offset] = value;
+    }
+    void DeviceConfigWrite(uint16_t offset, uint64_t value) override {
+        EXPECT_TRUE(0);  // Not Implemented.
+    }
+    uint16_t GetRingSize(uint16_t index) override {
+        EXPECT_GT(queue_sizes_.count(index), 0);
+        return queue_sizes_[index];
+    }
+    void SetRing(uint16_t index, uint16_t count, zx_paddr_t pa_desc, zx_paddr_t pa_avail,
+                 zx_paddr_t pa_used) override {}
+    void RingKick(uint16_t ring_index) override {
+        EXPECT_EQ(state_, State::DRIVER_OK);
+        EXPECT_GT(queue_sizes_.count(ring_index), 0);
+        kicked_queues_.insert(ring_index);
+    }
+    uint32_t IsrStatus() override { return 0; }
+    zx_status_t InterruptValid() override { return ZX_OK; }
+    zx_status_t WaitForInterrupt() override { return ZX_OK; }
+
+  protected:
+    FakeBackend(std::initializer_list<std::pair<const uint16_t, uint8_t>> registers8,
+                std::initializer_list<std::pair<const uint16_t, uint16_t>> registers16,
+                std::initializer_list<std::pair<const uint16_t, uint32_t>> registers32,
+                std::initializer_list<std::pair<const uint16_t, uint16_t>> queue_sizes):
+        registers8_(registers8), registers16_(registers16), registers32_(registers32),
+        queue_sizes_(queue_sizes) {}
+
+   // Returns true if a queue has been kicked (notified) and clears the notified bit.
+   bool QueueKicked(uint16_t queue_index) {
+     bool is_queue_kicked = (kicked_queues_.count(queue_index));
+     if (is_queue_kicked) {
+       kicked_queues_.erase(queue_index);
+     }
+     return is_queue_kicked;
+   }
+
+  private:
+    enum class State {
+        DEVICE_VOID,
+        DEVICE_RESET,
+        DEVICE_STATUS_ACK,
+        DRIVER_OK,
+    };
+
+    State state_ = State::DEVICE_VOID;
+    std::map<uint16_t, uint8_t> registers8_;
+    std::map<uint16_t, uint16_t> registers16_;
+    std::map<uint16_t, uint32_t> registers32_;
+    std::map<uint16_t, uint16_t> queue_sizes_;
+    std::set<uint16_t> kicked_queues_;
+};
+
+} // namespace virtio