diff --git a/include/pattern.hpp b/include/pattern.hpp
index 691cb16..e8c61ee 100644
--- a/include/pattern.hpp
+++ b/include/pattern.hpp
@@ -6,12 +6,13 @@
 #include <stdplus/fd/create.hpp>
 #include <stdplus/fd/managed.hpp>
 
+#include <chrono>
 #include <span>
 #include <string>
 
 namespace estoraged
 {
-using stdplus::fd::ManagedFd;
+using stdplus::fd::Fd;
 
 class Pattern : public Erase
 {
@@ -23,29 +24,48 @@
     Pattern(std::string_view inDevPath) : Erase(inDevPath)
     {}
 
+    /** @brief writes an uncompressible random pattern to the drive, using
+     * default parameters. It also throws errors accordingly.
+     */
+    void writePattern()
+    {
+        stdplus::fd::Fd&& fd =
+            stdplus::fd::open(devPath, stdplus::fd::OpenAccess::WriteOnly);
+        writePattern(util::findSizeOfBlockDevice(devPath), fd);
+    }
+
     /** @brief writes an uncompressible random pattern to the drive
      * and throws errors accordingly.
      *
      *  @param[in] bytes - Size of the block device
+     *  @param[in] fd - the stdplus file descriptor
      */
-    void writePattern()
-    {
-        writePattern(util::findSizeOfBlockDevice(devPath));
-    }
+    void writePattern(uint64_t driveSize, Fd& fd);
 
-    void writePattern(uint64_t driveSize);
+    /** @brief verifies the uncompressible random pattern is on the drive, using
+     * default parameters. It also throws errors accordingly.
+     */
+    void verifyPattern()
+    {
+        stdplus::fd::Fd&& fd =
+            stdplus::fd::open(devPath, stdplus::fd::OpenAccess::ReadOnly);
+        verifyPattern(util::findSizeOfBlockDevice(devPath), fd);
+    }
 
     /** @brief verifies the uncompressible random pattern is on the drive
      * and throws errors accordingly.
      *
      *  @param[in] bytes - Size of the block device
+     *  @param[in] fd - the stdplus file descriptor
      */
+    void verifyPattern(uint64_t driveSize, Fd& fd);
 
-    void verifyPattern()
-    {
-        verifyPattern(util::findSizeOfBlockDevice(devPath));
-    }
-    void verifyPattern(uint64_t driveSize);
+  private:
+    static constexpr uint32_t seed = 0x6a656272;
+    static constexpr size_t blockSize = 4096;
+    static constexpr size_t blockSizeUsing32 = blockSize / sizeof(uint32_t);
+    static constexpr size_t maxRetry = 32;
+    static constexpr std::chrono::duration delay = std::chrono::milliseconds(1);
 };
 
 } // namespace estoraged
diff --git a/include/zero.hpp b/include/zero.hpp
index 562b8ce..bfa240d 100644
--- a/include/zero.hpp
+++ b/include/zero.hpp
@@ -6,10 +6,12 @@
 #include <stdplus/fd/create.hpp>
 #include <stdplus/fd/managed.hpp>
 
+#include <chrono>
+
 namespace estoraged
 {
 
-using stdplus::fd::ManagedFd;
+using stdplus::fd::Fd;
 
 class Zero : public Erase
 {
@@ -23,29 +25,35 @@
     /** @brief writes zero to the drive
      * and throws errors accordingly.
      *  @param[in] driveSize - the size of the block device in bytes
+     *  @param[in] fd - the stdplus file descriptor
      */
-    void writeZero(uint64_t driveSize);
+    void writeZero(uint64_t driveSize, Fd& fd);
 
-    /** @brief writes zero to the drive
+    /** @brief writes zero to the drive using default parameters,
      * and throws errors accordingly.
      */
     void writeZero()
     {
-        writeZero(util::findSizeOfBlockDevice(devPath));
+        stdplus::fd::Fd&& fd =
+            stdplus::fd::open(devPath, stdplus::fd::OpenAccess::WriteOnly);
+        writeZero(util::findSizeOfBlockDevice(devPath), fd);
     }
 
-    /** @brief verifies the  uncompressible random pattern is on the drive
+    /** @brief verifies the drive has only zeros on it,
      * and throws errors accordingly.
      *  @param[in] driveSize - the size of the block device in bytes
+     *  @param[in] fd - the stdplus file descriptor
      */
-    void verifyZero(uint64_t driveSize);
+    void verifyZero(uint64_t driveSize, Fd& fd);
 
-    /** @brief verifies the  uncompressible random pattern is on the drive
-     * and throws errors accordingly.
+    /** @brief verifies the drive has only zeros on it,
+     * using the default parameters. It also throws errors accordingly.
      */
     void verifyZero()
     {
-        verifyZero(util::findSizeOfBlockDevice(devPath));
+        stdplus::fd::Fd&& fd =
+            stdplus::fd::open(devPath, stdplus::fd::OpenAccess::ReadOnly);
+        verifyZero(util::findSizeOfBlockDevice(devPath), fd);
     }
 
   private:
@@ -53,6 +61,8 @@
      * 32768 was also tested. It had almost identical performance.
      */
     static constexpr size_t blockSize = 4096;
+    static constexpr size_t maxRetry = 32;
+    static constexpr std::chrono::duration delay = std::chrono::milliseconds(1);
 };
 
 } // namespace estoraged
diff --git a/src/erase/pattern.cpp b/src/erase/pattern.cpp
index 5563661..7d7990b 100644
--- a/src/erase/pattern.cpp
+++ b/src/erase/pattern.cpp
@@ -10,22 +10,20 @@
 #include <xyz/openbmc_project/Common/error.hpp>
 
 #include <array>
+#include <chrono>
 #include <iostream>
 #include <random>
 #include <span>
 #include <string>
+#include <thread>
 
 namespace estoraged
 {
 
-constexpr uint32_t seed = 0x6a656272;
-constexpr size_t blockSize = 4096;
-constexpr size_t blockSizeUsing32 = blockSize / sizeof(uint32_t);
-
 using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
-using stdplus::fd::ManagedFd;
+using stdplus::fd::Fd;
 
-void Pattern::writePattern(const uint64_t driveSize)
+void Pattern::writePattern(const uint64_t driveSize, Fd& fd)
 {
     // static seed defines a fixed prng sequnce so it can be verified later,
     // and validated for entropy
@@ -36,9 +34,6 @@
     std::minstd_rand0 generator(seed);
     std::array<std::byte, blockSize> randArr{};
 
-    ManagedFd fd =
-        stdplus::fd::open(devPath, stdplus::fd::OpenAccess::WriteOnly);
-
     while (currentIndex < driveSize)
     {
         // generate a 4k block of prng
@@ -52,19 +47,34 @@
         size_t writeSize = currentIndex + blockSize < driveSize
                                ? blockSize
                                : driveSize - currentIndex;
-        if (fd.write({randArr.data(), writeSize}).size() != writeSize)
+        size_t written = 0;
+        size_t retry = 0;
+        while (written < writeSize)
         {
-            lg2::error("Estoraged erase pattern unable to write sizeof(long)",
-                       "REDFISH_MESSAGE_ID",
-                       std::string("eStorageD.1.0.EraseFailure"),
-                       "REDFISH_MESSAGE_ARGS", std::to_string(fd.get()));
-            throw InternalFailure();
+            written += fd.write({randArr.data() + written, writeSize - written})
+                           .size();
+            if (written == writeSize)
+            {
+                break;
+            }
+            if (written > writeSize)
+            {
+                throw InternalFailure();
+            }
+            retry++;
+            if (retry > maxRetry)
+            {
+                lg2::error("Unable to do full write", "REDFISH_MESSAGE_ID",
+                           std::string("eStorageD.1.0.EraseFailure"));
+                throw InternalFailure();
+            }
+            std::this_thread::sleep_for(delay);
         }
         currentIndex = currentIndex + writeSize;
     }
 }
 
-void Pattern::verifyPattern(const uint64_t driveSize)
+void Pattern::verifyPattern(const uint64_t driveSize, Fd& fd)
 {
 
     uint64_t currentIndex = 0;
@@ -74,9 +84,6 @@
     std::array<std::byte, blockSize> randArr{};
     std::array<std::byte, blockSize> readArr{};
 
-    ManagedFd fd =
-        stdplus::fd::open(devPath, stdplus::fd::OpenAccess::ReadOnly);
-
     while (currentIndex < driveSize)
     {
         size_t readSize = currentIndex + blockSize < driveSize
@@ -91,14 +98,35 @@
             {
                 (*randArrFill)[i] = generator();
             }
-            fd.read({readArr.data(), readSize});
+            size_t read = 0;
+            size_t retry = 0;
+            while (read < readSize)
+            {
+                read +=
+                    fd.read({readArr.data() + read, readSize - read}).size();
+                if (read == readSize)
+                {
+                    break;
+                }
+                if (read > readSize)
+                {
+                    throw InternalFailure();
+                }
+                retry++;
+                if (retry > maxRetry)
+                {
+                    lg2::error("Unable to do full read", "REDFISH_MESSAGE_ID",
+                               std::string("eStorageD.1.0.EraseFailure"));
+                    throw InternalFailure();
+                }
+                std::this_thread::sleep_for(delay);
+            }
         }
         catch (...)
         {
             lg2::error("Estoraged erase pattern unable to read",
                        "REDFISH_MESSAGE_ID",
-                       std::string("eStorageD.1.0.EraseFailure"),
-                       "REDFISH_MESSAGE_ARGS", std::to_string(fd.get()));
+                       std::string("eStorageD.1.0.EraseFailure"));
             throw InternalFailure();
         }
 
diff --git a/src/erase/zero.cpp b/src/erase/zero.cpp
index 2c5a6f5..d26e1b9 100644
--- a/src/erase/zero.cpp
+++ b/src/erase/zero.cpp
@@ -2,26 +2,26 @@
 
 #include "erase.hpp"
 
+#include <unistd.h>
+
 #include <phosphor-logging/lg2.hpp>
 #include <stdplus/fd/create.hpp>
 #include <stdplus/fd/managed.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 
 #include <array>
+#include <chrono>
 #include <span>
+#include <thread>
 
 namespace estoraged
 {
 
 using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
-using stdplus::fd::ManagedFd;
+using stdplus::fd::Fd;
 
-void Zero::writeZero(const uint64_t driveSize)
+void Zero::writeZero(const uint64_t driveSize, Fd& fd)
 {
-
-    ManagedFd fd =
-        stdplus::fd::open(devPath, stdplus::fd::OpenAccess::WriteOnly);
-
     uint64_t currentIndex = 0;
     const std::array<const std::byte, blockSize> blockOfZeros{};
 
@@ -32,7 +32,31 @@
                                  : driveSize - currentIndex;
         try
         {
-            fd.write({blockOfZeros.data(), writeSize});
+            size_t written = 0;
+            size_t retry = 0;
+            while (written < writeSize)
+            {
+                written += fd.write({blockOfZeros.data() + written,
+                                     writeSize - written})
+                               .size();
+                if (written == writeSize)
+                {
+                    break;
+                }
+                if (written > writeSize)
+                {
+                    throw InternalFailure();
+                }
+                retry++;
+                if (retry > maxRetry)
+                {
+                    lg2::error("Unable to make full write",
+                               "REDFISH_MESSAGE_ID",
+                               std::string("eStorageD.1.0.EraseFailure"));
+                    throw InternalFailure();
+                }
+                std::this_thread::sleep_for(delay);
+            }
         }
         catch (...)
         {
@@ -45,11 +69,8 @@
     }
 }
 
-void Zero::verifyZero(uint64_t driveSize)
+void Zero::verifyZero(uint64_t driveSize, Fd& fd)
 {
-    ManagedFd fd =
-        stdplus::fd::open(devPath, stdplus::fd::OpenAccess::ReadOnly);
-
     uint64_t currentIndex = 0;
     std::array<std::byte, blockSize> readArr{};
     const std::array<const std::byte, blockSize> blockOfZeros{};
@@ -61,7 +82,29 @@
                                 : driveSize - currentIndex;
         try
         {
-            fd.read({readArr.data(), readSize});
+            size_t read = 0;
+            size_t retry = 0;
+            while (read < readSize)
+            {
+                read +=
+                    fd.read({readArr.data() + read, readSize - read}).size();
+                if (read == readSize)
+                {
+                    break;
+                }
+                if (read > readSize)
+                {
+                    throw InternalFailure();
+                }
+                retry++;
+                if (retry > maxRetry)
+                {
+                    lg2::error("Unable to make full read", "REDFISH_MESSAGE_ID",
+                               std::string("eStorageD.1.0.EraseFailure"));
+                    throw InternalFailure();
+                }
+                std::this_thread::sleep_for(delay);
+            }
         }
         catch (...)
         {
diff --git a/src/test/erase/pattern_test.cpp b/src/test/erase/pattern_test.cpp
index e0192a0..2e2ac81 100644
--- a/src/test/erase/pattern_test.cpp
+++ b/src/test/erase/pattern_test.cpp
@@ -5,6 +5,7 @@
 #include <unistd.h>
 
 #include <stdplus/fd/create.hpp>
+#include <stdplus/fd/gmock.hpp>
 #include <stdplus/fd/managed.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 
@@ -20,6 +21,9 @@
 
 using estoraged::Pattern;
 using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
+using testing::_;
+using testing::Invoke;
+using testing::Return;
 
 TEST(pattern, patternPass)
 {
@@ -30,14 +34,22 @@
                   std::ios::out | std::ios::binary | std::ios::trunc);
     testFile.close();
 
+    stdplus::fd::Fd&& writeFd =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::WriteOnly);
+
     Pattern pass(testFileName);
-    EXPECT_NO_THROW(pass.writePattern(size));
-    EXPECT_NO_THROW(pass.verifyPattern(size));
+    EXPECT_NO_THROW(pass.writePattern(size, writeFd));
+
+    stdplus::fd::Fd&& readFd =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadOnly);
+
+    EXPECT_NO_THROW(pass.verifyPattern(size, readFd));
 }
 
 /* This test that pattern writes the correct number of bytes even if
  * size of the drive is not divisable by the block size
  */
+
 TEST(pattern, patternNotDivisible)
 {
     std::string testFileName = "notDivisible";
@@ -48,9 +60,14 @@
                   std::ios::out | std::ios::binary | std::ios::trunc);
     testFile.close();
 
+    stdplus::fd::Fd&& writeFd =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::WriteOnly);
     Pattern pass(testFileName);
-    EXPECT_NO_THROW(pass.writePattern(size));
-    EXPECT_NO_THROW(pass.verifyPattern(size));
+    EXPECT_NO_THROW(pass.writePattern(size, writeFd));
+
+    stdplus::fd::Fd&& readFd =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadOnly);
+    EXPECT_NO_THROW(pass.verifyPattern(size, readFd));
 }
 
 TEST(pattern, patternsDontMatch)
@@ -67,8 +84,140 @@
                    sizeof(dummyValue));
     testFile.close();
 
-    EXPECT_NO_THROW(pass.writePattern(size - sizeof(dummyValue)));
-    EXPECT_THROW(pass.verifyPattern(size), InternalFailure);
+    stdplus::fd::Fd&& writeFd =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::WriteOnly);
+
+    EXPECT_NO_THROW(pass.writePattern(size - sizeof(dummyValue), writeFd));
+
+    stdplus::fd::Fd&& readFd =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadOnly);
+
+    EXPECT_THROW(pass.verifyPattern(size, readFd), InternalFailure);
+}
+
+uint64_t size = 4096;
+size_t shortSize = 128;
+static auto shortData1 = std::vector<std::byte>(shortSize);
+static auto shortData2 = std::vector<std::byte>(shortSize);
+static auto restOfData = std::vector<std::byte>(size - shortSize * 2);
+
+TEST(pattern, shortReadWritePass)
+{
+    std::string testFileName = "testfile_shortRead";
+
+    uint64_t size = 4096;
+    Pattern pass(testFileName);
+    stdplus::fd::FdMock mock;
+
+    testing::Sequence s;
+
+    // test write pattern with short blocks
+    EXPECT_CALL(mock, write(_))
+        .WillOnce(Invoke([](std::span<const std::byte> x) {
+            std::copy_n(x.begin(), shortData1.size(), shortData1.begin());
+            return shortData1;
+        }))
+        .RetiresOnSaturation();
+    EXPECT_CALL(mock, write(_))
+        .WillOnce(Invoke([](std::span<const std::byte> x) {
+            std::copy_n(x.begin(), restOfData.size(), restOfData.begin());
+            return restOfData;
+        }))
+        .RetiresOnSaturation();
+    EXPECT_CALL(mock, write(_))
+        .WillOnce(Invoke([](std::span<const std::byte> x) {
+            std::copy_n(x.begin(), shortData2.size(), shortData2.begin());
+            return shortData2;
+        }))
+        .RetiresOnSaturation();
+
+    // test read pattern
+    EXPECT_CALL(mock, read(_))
+        .WillOnce(Invoke([](nonstd::span<std::byte> x) {
+            std::copy_n(shortData1.begin(), shortData1.size(), x.data());
+            nonstd::span ret(shortData1);
+            return ret;
+        }))
+        .RetiresOnSaturation();
+
+    EXPECT_CALL(mock, read(_))
+        .WillOnce(Invoke([](nonstd::span<std::byte> x) {
+            std::copy_n(restOfData.begin(), restOfData.size(), x.data());
+            nonstd::span ret(restOfData);
+            return ret;
+        }))
+        .RetiresOnSaturation();
+
+    EXPECT_CALL(mock, read(_))
+        .WillOnce(Invoke([](nonstd::span<std::byte> x) {
+            std::copy_n(shortData2.begin(), shortData2.size(), x.data());
+            nonstd::span ret(shortData2);
+            return ret;
+        }))
+        .RetiresOnSaturation();
+
+    EXPECT_NO_THROW(pass.writePattern(size, mock));
+    EXPECT_NO_THROW(pass.verifyPattern(size, mock));
+}
+
+TEST(Zeros, shortReadWriteFail)
+{
+    std::string testFileName = "testfile_shortRead";
+
+    uint64_t size = 4096;
+    size_t shortSize = 128;
+    Pattern tryPattern(testFileName);
+    auto shortData = std::vector<std::byte>(shortSize, std::byte{0});
+    auto restOfData =
+        std::vector<std::byte>(size - shortSize * 3, std::byte{0});
+    // open the file and write none to it
+
+    stdplus::fd::FdMock mock;
+
+    // test writes
+    EXPECT_CALL(mock, write(_))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(restOfData))
+        .WillOnce(Return(restOfData)); // return too much data!
+
+    EXPECT_THROW(tryPattern.writePattern(size, mock), InternalFailure);
+
+    // test reads
+    EXPECT_CALL(mock, read(_))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(restOfData))
+        .WillOnce(Return(restOfData)); // return too much data!
+
+    EXPECT_THROW(tryPattern.verifyPattern(size, mock), InternalFailure);
+}
+
+TEST(pattern, driveIsSmaller)
+{
+    std::string testFileName = "testfile_driveIsSmaller";
+
+    uint64_t size = 4096;
+    Pattern tryPattern(testFileName);
+
+    stdplus::fd::FdMock mocks;
+    testing::InSequence s;
+
+    // test writes
+    EXPECT_CALL(mocks, write(_))
+        .Times(33)
+        .WillRepeatedly(Return(std::vector<std::byte>{}))
+        .RetiresOnSaturation();
+
+    EXPECT_THROW(tryPattern.writePattern(size, mocks), InternalFailure);
+
+    // test reads
+    EXPECT_CALL(mocks, read(_))
+        .Times(33)
+        .WillRepeatedly(Return(std::vector<std::byte>{}))
+        .RetiresOnSaturation();
+
+    EXPECT_THROW(tryPattern.verifyPattern(size, mocks), InternalFailure);
 }
 
 } // namespace estoraged_test
diff --git a/src/test/erase/zero_test.cpp b/src/test/erase/zero_test.cpp
index 846059d..b14d546 100644
--- a/src/test/erase/zero_test.cpp
+++ b/src/test/erase/zero_test.cpp
@@ -5,6 +5,7 @@
 #include <unistd.h>
 
 #include <stdplus/fd/create.hpp>
+#include <stdplus/fd/gmock.hpp>
 #include <stdplus/fd/managed.hpp>
 #include <xyz/openbmc_project/Common/error.hpp>
 
@@ -15,12 +16,14 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-using estoraged::Zero;
-using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
-
 namespace estoraged_test
 {
 
+using estoraged::Zero;
+using sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
+using testing::_;
+using testing::Return;
+
 TEST(Zeros, zeroPass)
 {
     std::string testFileName = "testfile_pass";
@@ -31,8 +34,12 @@
     testFile.close();
     uint64_t size = 4096;
     Zero pass(testFileName);
-    EXPECT_NO_THROW(pass.writeZero(size));
-    EXPECT_NO_THROW(pass.verifyZero(size));
+    stdplus::fd::Fd&& write =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadWrite);
+    EXPECT_NO_THROW(pass.writeZero(size, write));
+    stdplus::fd::Fd&& read =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadWrite);
+    EXPECT_NO_THROW(pass.verifyZero(size, read));
 }
 
 /* This test that pattern writes the correct number of bytes even if
@@ -49,9 +56,14 @@
 
     uint64_t size = 4097;
     // 4097 is not divisible by the block size, and we expect no errors
+
+    stdplus::fd::Fd&& write =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadWrite);
     Zero pass(testFileName);
-    EXPECT_NO_THROW(pass.writeZero(size));
-    EXPECT_NO_THROW(pass.verifyZero(size));
+    EXPECT_NO_THROW(pass.writeZero(size, write));
+    stdplus::fd::Fd&& read =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadWrite);
+    EXPECT_NO_THROW(pass.verifyZero(size, read));
 }
 
 TEST(Zeros, notZeroStart)
@@ -66,15 +78,18 @@
                    sizeof(dummyValue));
     testFile.close();
     uint64_t size = 4096;
+    stdplus::fd::Fd&& readWrite =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadWrite);
+
     Zero pass(testFileName);
-    EXPECT_NO_THROW(pass.writeZero(size - sizeof(dummyValue)));
+    EXPECT_NO_THROW(pass.writeZero(size - sizeof(dummyValue), readWrite));
 
     // force flush, needed for unit testing
     std::ofstream file;
     file.open(testFileName);
     file.close();
 
-    EXPECT_THROW(pass.verifyZero(size), InternalFailure);
+    EXPECT_THROW(pass.verifyZero(size, readWrite), InternalFailure);
 }
 
 TEST(Zeros, notZeroEnd)
@@ -89,14 +104,106 @@
     uint64_t size = 4096;
     Zero pass(testFileName);
     uint32_t dummyValue = 88;
-    EXPECT_NO_THROW(pass.writeZero(size - sizeof(dummyValue)));
+    stdplus::fd::Fd&& write =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadWrite);
+    EXPECT_NO_THROW(pass.writeZero(size - sizeof(dummyValue), write));
 
     // open the file and write none zero to it
     testFile.open(testFileName, std::ios::out);
     testFile << dummyValue;
     testFile.close();
 
-    EXPECT_THROW(pass.verifyZero(size), InternalFailure);
+    stdplus::fd::Fd&& read =
+        stdplus::fd::open(testFileName, stdplus::fd::OpenAccess::ReadWrite);
+    EXPECT_THROW(pass.verifyZero(size, read), InternalFailure);
+}
+
+TEST(Zeros, shortReadWritePass)
+{
+    std::string testFileName = "testfile_shortRead";
+
+    uint64_t size = 4096;
+    size_t shortSize = 128;
+    Zero pass(testFileName);
+    auto shortData = std::vector<std::byte>(shortSize, std::byte{0});
+    auto restOfData =
+        std::vector<std::byte>(size - shortSize * 3, std::byte{0});
+    stdplus::fd::FdMock mock;
+
+    // test write zeros with short blocks
+    EXPECT_CALL(mock, write(_))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(restOfData))
+        .WillOnce(Return(shortData));
+
+    EXPECT_NO_THROW(pass.writeZero(size, mock));
+
+    // test read zeros with short blocks
+    EXPECT_CALL(mock, read(_))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(restOfData))
+        .WillOnce(Return(shortData));
+
+    EXPECT_NO_THROW(pass.verifyZero(size, mock));
+}
+
+TEST(Zeros, shortReadWriteFail)
+{
+    std::string testFileName = "testfile_shortRead";
+
+    uint64_t size = 4096;
+    size_t shortSize = 128;
+    Zero tryZero(testFileName);
+    auto shortData = std::vector<std::byte>(shortSize, std::byte{0});
+    auto restOfData =
+        std::vector<std::byte>(size - shortSize * 3, std::byte{0});
+    // open the file and write none zero to it
+
+    stdplus::fd::FdMock mock;
+
+    // test writes
+    EXPECT_CALL(mock, write(_))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(restOfData))
+        .WillOnce(Return(restOfData)); // return too much data!
+
+    EXPECT_THROW(tryZero.writeZero(size, mock), InternalFailure);
+
+    // test reads
+    EXPECT_CALL(mock, read(_))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(shortData))
+        .WillOnce(Return(restOfData))
+        .WillOnce(Return(restOfData)); // return too much data!
+
+    EXPECT_THROW(tryZero.verifyZero(size, mock), InternalFailure);
+}
+
+TEST(Zeros, driveIsSmaller)
+{
+    std::string testFileName = "testfile_driveIsSmaller";
+
+    uint64_t size = 4096;
+    Zero tryZero(testFileName);
+
+    stdplus::fd::FdMock mocks;
+    testing::InSequence s;
+
+    // test writes
+    EXPECT_CALL(mocks, write(_))
+        .Times(33)
+        .WillRepeatedly(Return(std::vector<std::byte>{}))
+        .RetiresOnSaturation();
+    EXPECT_THROW(tryZero.writeZero(size, mocks), InternalFailure);
+    // test reads
+    EXPECT_CALL(mocks, read(_))
+        .Times(33)
+        .WillRepeatedly(Return(std::vector<std::byte>{}))
+        .RetiresOnSaturation();
+    EXPECT_THROW(tryZero.verifyZero(size, mocks), InternalFailure);
 }
 
 } // namespace estoraged_test