diff --git a/test/avb_atx_slot_verify_unittest.cc b/test/avb_atx_slot_verify_unittest.cc
index 79c1cfd..8992c72 100644
--- a/test/avb_atx_slot_verify_unittest.cc
+++ b/test/avb_atx_slot_verify_unittest.cc
@@ -49,7 +49,7 @@
 // relevant locations).
 class AvbAtxSlotVerifyExampleTest
     : public BaseAvbToolTest,
-      public FakeAvbOpsDelegate,
+      public FakeAvbOpsDelegateWithDefaults,
       public ::testing::WithParamInterface<uint64_t> {
  public:
   ~AvbAtxSlotVerifyExampleTest() override = default;
@@ -63,33 +63,7 @@
     ops_.set_stored_is_device_unlocked(false);
   }
 
-  // FakeAvbOpsDelegate methods. All forward to FakeAvbOps default except for
-  // validate_vbmeta_public_key().
-  AvbIOResult read_from_partition(const char* partition,
-                                  int64_t offset,
-                                  size_t num_bytes,
-                                  void* buffer,
-                                  size_t* out_num_read) override {
-    return ops_.read_from_partition(
-        partition, offset, num_bytes, buffer, out_num_read);
-  }
-
-  AvbIOResult get_preloaded_partition(
-      const char* partition,
-      size_t num_bytes,
-      uint8_t** out_pointer,
-      size_t* out_num_bytes_preloaded) override {
-    return ops_.get_preloaded_partition(
-        partition, num_bytes, out_pointer, out_num_bytes_preloaded);
-  }
-
-  AvbIOResult write_to_partition(const char* partition,
-                                 int64_t offset,
-                                 size_t num_bytes,
-                                 const void* buffer) override {
-    return ops_.write_to_partition(partition, offset, num_bytes, buffer);
-  }
-
+  // FakeAvbOpsDelegate overrides.
   AvbIOResult validate_vbmeta_public_key(AvbOps* ops,
                                          const uint8_t* public_key_data,
                                          size_t public_key_length,
@@ -106,13 +80,6 @@
                                               out_key_is_trusted);
   }
 
-  AvbIOResult read_rollback_index(AvbOps* ops,
-                                  size_t rollback_index_slot,
-                                  uint64_t* out_rollback_index) override {
-    return ops_.read_rollback_index(
-        ops, rollback_index_slot, out_rollback_index);
-  }
-
   AvbIOResult write_rollback_index(AvbOps* ops,
                                    size_t rollback_index_slot,
                                    uint64_t rollback_index) override {
@@ -120,35 +87,6 @@
     return ops_.write_rollback_index(ops, rollback_index_slot, rollback_index);
   }
 
-  AvbIOResult read_is_device_unlocked(AvbOps* ops,
-                                      bool* out_is_device_unlocked) override {
-    return ops_.read_is_device_unlocked(ops, out_is_device_unlocked);
-  }
-
-  AvbIOResult get_unique_guid_for_partition(AvbOps* ops,
-                                            const char* partition,
-                                            char* guid_buf,
-                                            size_t guid_buf_size) override {
-    return ops_.get_unique_guid_for_partition(
-        ops, partition, guid_buf, guid_buf_size);
-  }
-
-  AvbIOResult get_size_of_partition(AvbOps* ops,
-                                    const char* partition,
-                                    uint64_t* out_size) override {
-    return ops_.get_size_of_partition(ops, partition, out_size);
-  }
-
-  AvbIOResult read_permanent_attributes(
-      AvbAtxPermanentAttributes* attributes) override {
-    return ops_.read_permanent_attributes(attributes);
-  }
-
-  AvbIOResult read_permanent_attributes_hash(
-      uint8_t hash[AVB_SHA256_DIGEST_SIZE]) override {
-    return ops_.read_permanent_attributes_hash(hash);
-  }
-
   void set_key_version(size_t rollback_index_location,
                        uint64_t key_version) override {
     num_key_version_calls_++;
@@ -229,7 +167,6 @@
   }
 
  protected:
-  FakeAvbOps ops_;
   AvbAtxPermanentAttributes attributes_;
   int num_atx_calls_ = 0;
   int num_key_version_calls_ = 0;
diff --git a/test/avb_atx_validate_unittest.cc b/test/avb_atx_validate_unittest.cc
index 254048a..0299b51 100644
--- a/test/avb_atx_validate_unittest.cc
+++ b/test/avb_atx_validate_unittest.cc
@@ -82,7 +82,8 @@
 
 namespace avb {
 
-class AvbAtxValidateTest : public ::testing::Test, public FakeAvbOpsDelegate {
+class AvbAtxValidateTest : public ::testing::Test,
+                           public FakeAvbOpsDelegateWithDefaults {
  public:
   ~AvbAtxValidateTest() override {}
 
@@ -105,8 +106,11 @@
   }
 
   AvbIOResult get_preloaded_partition(
-      const char* partition, size_t num_bytes, uint8_t** out_pointer,
+      const char* partition,
+      size_t num_bytes,
+      uint8_t** out_pointer,
       size_t* out_num_bytes_preloaded) override {
+    // Expect method not used.
     return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
   }
 
@@ -185,11 +189,6 @@
     return ops_.read_permanent_attributes_hash(hash);
   }
 
-  void set_key_version(size_t rollback_index_location,
-                       uint64_t key_version) override {
-    ops_.set_key_version(rollback_index_location, key_version);
-  }
-
  protected:
   virtual AvbIOResult Validate(bool* is_trusted) {
     return avb_atx_validate_vbmeta_public_key(
@@ -222,7 +221,6 @@
                          metadata_.product_signing_key_certificate.signature));
   }
 
-  FakeAvbOps ops_;
   AvbAtxPermanentAttributes attributes_;
   AvbAtxPublicKeyMetadata metadata_;
   bool fail_read_permanent_attributes_{false};
@@ -551,7 +549,8 @@
 }
 
 // A fixture for testing avb_slot_verify() with ATX.
-class AvbAtxSlotVerifyTest : public BaseAvbToolTest, public FakeAvbOpsDelegate {
+class AvbAtxSlotVerifyTest : public BaseAvbToolTest,
+                             public FakeAvbOpsDelegateWithDefaults {
  public:
   ~AvbAtxSlotVerifyTest() override = default;
 
@@ -570,32 +569,7 @@
     ops_.set_stored_is_device_unlocked(false);
   }
 
-  // FakeAvbOpsDelegate methods. All forward to FakeAvbOps default except for
-  // validate_vbmeta_public_key().
-  AvbIOResult read_from_partition(const char* partition,
-                                  int64_t offset,
-                                  size_t num_bytes,
-                                  void* buffer,
-                                  size_t* out_num_read) override {
-    return ops_.read_from_partition(
-        partition, offset, num_bytes, buffer, out_num_read);
-  }
-
-  AvbIOResult get_preloaded_partition(
-      const char* partition, size_t num_bytes, uint8_t** out_pointer,
-      size_t* out_num_bytes_preloaded) override {
-    *out_num_bytes_preloaded = 0;
-    *out_pointer = NULL;
-    return AVB_IO_RESULT_OK;
-  }
-
-  AvbIOResult write_to_partition(const char* partition,
-                                 int64_t offset,
-                                 size_t num_bytes,
-                                 const void* buffer) override {
-    return ops_.write_to_partition(partition, offset, num_bytes, buffer);
-  }
-
+  // FakeAvbOpsDelegate override.
   AvbIOResult validate_vbmeta_public_key(AvbOps* ops,
                                          const uint8_t* public_key_data,
                                          size_t public_key_length,
@@ -612,55 +586,7 @@
                                               out_key_is_trusted);
   }
 
-  AvbIOResult read_rollback_index(AvbOps* ops,
-                                  size_t rollback_index_slot,
-                                  uint64_t* out_rollback_index) override {
-    return ops_.read_rollback_index(
-        ops, rollback_index_slot, out_rollback_index);
-  }
-
-  AvbIOResult write_rollback_index(AvbOps* ops,
-                                   size_t rollback_index_slot,
-                                   uint64_t rollback_index) override {
-    return ops_.write_rollback_index(ops, rollback_index_slot, rollback_index);
-  }
-
-  AvbIOResult read_is_device_unlocked(AvbOps* ops,
-                                      bool* out_is_device_unlocked) override {
-    return ops_.read_is_device_unlocked(ops, out_is_device_unlocked);
-  }
-
-  AvbIOResult get_unique_guid_for_partition(AvbOps* ops,
-                                            const char* partition,
-                                            char* guid_buf,
-                                            size_t guid_buf_size) override {
-    return ops_.get_unique_guid_for_partition(
-        ops, partition, guid_buf, guid_buf_size);
-  }
-
-  AvbIOResult get_size_of_partition(AvbOps* ops,
-                                    const char* partition,
-                                    uint64_t* out_size) override {
-    return ops_.get_size_of_partition(ops, partition, out_size);
-  }
-
-  AvbIOResult read_permanent_attributes(
-      AvbAtxPermanentAttributes* attributes) override {
-    return ops_.read_permanent_attributes(attributes);
-  }
-
-  AvbIOResult read_permanent_attributes_hash(
-      uint8_t hash[AVB_SHA256_DIGEST_SIZE]) override {
-    return ops_.read_permanent_attributes_hash(hash);
-  }
-
-  void set_key_version(size_t rollback_index_location,
-                       uint64_t key_version) override {
-    return ops_.set_key_version(rollback_index_location, key_version);
-  }
-
  protected:
-  FakeAvbOps ops_;
   AvbAtxPermanentAttributes attributes_;
   int num_atx_calls_ = 0;
 
diff --git a/test/fake_avb_ops.h b/test/fake_avb_ops.h
index a2bb473..93c7ee9 100644
--- a/test/fake_avb_ops.h
+++ b/test/fake_avb_ops.h
@@ -36,7 +36,8 @@
 namespace avb {
 
 // A delegate interface for ops callbacks. This allows tests to override default
-// fake implementations.
+// fake implementations. For convenience, test fixtures can inherit
+// FakeAvbOpsDelegateWithDefaults and only override as needed.
 class FakeAvbOpsDelegate {
  public:
   virtual ~FakeAvbOpsDelegate() {}
@@ -47,7 +48,9 @@
                                           size_t* out_num_read) = 0;
 
   virtual AvbIOResult get_preloaded_partition(
-      const char* partition, size_t num_bytes, uint8_t** out_pointer,
+      const char* partition,
+      size_t num_bytes,
+      uint8_t** out_pointer,
       size_t* out_num_bytes_preloaded) = 0;
 
   virtual AvbIOResult write_to_partition(const char* partition,
@@ -182,9 +185,10 @@
                                   void* buffer,
                                   size_t* out_num_read) override;
 
-  AvbIOResult get_preloaded_partition(
-      const char* partition, size_t num_bytes, uint8_t** out_pointer,
-      size_t* out_num_bytes_preloaded) override;
+  AvbIOResult get_preloaded_partition(const char* partition,
+                                      size_t num_bytes,
+                                      uint8_t** out_pointer,
+                                      size_t* out_num_bytes_preloaded) override;
 
   AvbIOResult write_to_partition(const char* partition,
                                  int64_t offset,
@@ -251,6 +255,99 @@
   std::map<std::string, uint8_t*> preloaded_partitions_;
 };
 
+// A delegate implementation that calls FakeAvbOps by default.
+class FakeAvbOpsDelegateWithDefaults : public FakeAvbOpsDelegate {
+ public:
+  AvbIOResult read_from_partition(const char* partition,
+                                  int64_t offset,
+                                  size_t num_bytes,
+                                  void* buffer,
+                                  size_t* out_num_read) override {
+    return ops_.read_from_partition(
+        partition, offset, num_bytes, buffer, out_num_read);
+  }
+
+  AvbIOResult get_preloaded_partition(
+      const char* partition,
+      size_t num_bytes,
+      uint8_t** out_pointer,
+      size_t* out_num_bytes_preloaded) override {
+    return ops_.get_preloaded_partition(
+        partition, num_bytes, out_pointer, out_num_bytes_preloaded);
+  }
+
+  AvbIOResult write_to_partition(const char* partition,
+                                 int64_t offset,
+                                 size_t num_bytes,
+                                 const void* buffer) override {
+    return ops_.write_to_partition(partition, offset, num_bytes, buffer);
+  }
+
+  AvbIOResult validate_vbmeta_public_key(AvbOps* ops,
+                                         const uint8_t* public_key_data,
+                                         size_t public_key_length,
+                                         const uint8_t* public_key_metadata,
+                                         size_t public_key_metadata_length,
+                                         bool* out_key_is_trusted) override {
+    return ops_.validate_vbmeta_public_key(ops,
+                                           public_key_data,
+                                           public_key_length,
+                                           public_key_metadata,
+                                           public_key_metadata_length,
+                                           out_key_is_trusted);
+  }
+
+  AvbIOResult read_rollback_index(AvbOps* ops,
+                                  size_t rollback_index_slot,
+                                  uint64_t* out_rollback_index) override {
+    return ops_.read_rollback_index(
+        ops, rollback_index_slot, out_rollback_index);
+  }
+
+  AvbIOResult write_rollback_index(AvbOps* ops,
+                                   size_t rollback_index_slot,
+                                   uint64_t rollback_index) override {
+    return ops_.write_rollback_index(ops, rollback_index_slot, rollback_index);
+  }
+
+  AvbIOResult read_is_device_unlocked(AvbOps* ops,
+                                      bool* out_is_device_unlocked) override {
+    return ops_.read_is_device_unlocked(ops, out_is_device_unlocked);
+  }
+
+  AvbIOResult get_unique_guid_for_partition(AvbOps* ops,
+                                            const char* partition,
+                                            char* guid_buf,
+                                            size_t guid_buf_size) override {
+    return ops_.get_unique_guid_for_partition(
+        ops, partition, guid_buf, guid_buf_size);
+  }
+
+  AvbIOResult get_size_of_partition(AvbOps* ops,
+                                    const char* partition,
+                                    uint64_t* out_size) override {
+    return ops_.get_size_of_partition(ops, partition, out_size);
+  }
+
+  AvbIOResult read_permanent_attributes(
+      AvbAtxPermanentAttributes* attributes) override {
+    return ops_.read_permanent_attributes(attributes);
+  }
+
+  AvbIOResult read_permanent_attributes_hash(
+      uint8_t hash[AVB_SHA256_DIGEST_SIZE]) override {
+    return ops_.read_permanent_attributes_hash(hash);
+  }
+
+  void set_key_version(size_t rollback_index_location,
+                       uint64_t key_version) override {
+    ops_.set_key_version(rollback_index_location, key_version);
+  }
+
+ protected:
+  FakeAvbOps ops_;
+};
+
 }  // namespace avb
 
 #endif /* FAKE_AVB_OPS_H_ */