diff --git a/tools/helper.cpp b/tools/helper.cpp
index 15c363f..f419410 100644
--- a/tools/helper.cpp
+++ b/tools/helper.cpp
@@ -92,25 +92,24 @@
 {
     pollStat(session, blob,
              [](const ipmiblob::StatResponse& resp) -> std::optional<bool> {
-                 if (resp.metadata.size() != 1)
-                 {
-                     throw ToolException("Invalid stat metadata");
-                 }
-                 auto result =
-                     static_cast<ipmi_flash::ActionStatus>(resp.metadata[0]);
-                 switch (result)
-                 {
-                     case ipmi_flash::ActionStatus::failed:
-                         throw ToolException("BMC reported failure");
-                     case ipmi_flash::ActionStatus::unknown:
-                     case ipmi_flash::ActionStatus::running:
-                         return std::nullopt;
-                     case ipmi_flash::ActionStatus::success:
-                         return true;
-                     default:
-                         throw ToolException("Unrecognized action status");
-                 }
-             });
+        if (resp.metadata.size() != 1)
+        {
+            throw ToolException("Invalid stat metadata");
+        }
+        auto result = static_cast<ipmi_flash::ActionStatus>(resp.metadata[0]);
+        switch (result)
+        {
+            case ipmi_flash::ActionStatus::failed:
+                throw ToolException("BMC reported failure");
+            case ipmi_flash::ActionStatus::unknown:
+            case ipmi_flash::ActionStatus::running:
+                return std::nullopt;
+            case ipmi_flash::ActionStatus::success:
+                return true;
+            default:
+                throw ToolException("Unrecognized action status");
+        }
+    });
 }
 
 /* Poll an open blob session for reading.
@@ -132,16 +131,16 @@
     return pollStat(
         session, blob,
         [](const ipmiblob::StatResponse& resp) -> std::optional<uint32_t> {
-            if (resp.blob_state & ipmiblob::StateFlags::open_read)
-            {
-                return resp.size;
-            }
-            if (resp.blob_state & ipmiblob::StateFlags::committing)
-            {
-                return std::nullopt;
-            }
-            throw ToolException("BMC blob failed to become ready");
-        });
+        if (resp.blob_state & ipmiblob::StateFlags::open_read)
+        {
+            return resp.size;
+        }
+        if (resp.blob_state & ipmiblob::StateFlags::committing)
+        {
+            return std::nullopt;
+        }
+        throw ToolException("BMC blob failed to become ready");
+    });
 }
 
 void* memcpyAligned(void* destination, const void* source, std::size_t size)
diff --git a/tools/test/tools_bt_unittest.cpp b/tools/test/tools_bt_unittest.cpp
index 3d2c181..e1a091b 100644
--- a/tools/test/tools_bt_unittest.cpp
+++ b/tools/test/tools_bt_unittest.cpp
@@ -58,11 +58,10 @@
 
     EXPECT_CALL(sysMock, read(fd, NotNull(), _))
         .WillOnce(Invoke([&](int, void* buf, std::size_t count) {
-            EXPECT_TRUE(count > bytes.size());
-            std::memcpy(buf, bytes.data(), bytes.size());
-            return bytes.size();
-        }))
-        .WillOnce(Return(0));
+        EXPECT_TRUE(count > bytes.size());
+        std::memcpy(buf, bytes.data(), bytes.size());
+        return bytes.size();
+    })).WillOnce(Return(0));
 
     EXPECT_CALL(progMock, updateProgress(bytes.size()));
 
@@ -100,10 +99,10 @@
 
     EXPECT_CALL(sysMock, read(fd, NotNull(), _))
         .WillOnce(Invoke([&](int, void* buf, std::size_t count) {
-            EXPECT_TRUE(count > bytes.size());
-            std::memcpy(buf, bytes.data(), bytes.size());
-            return bytes.size();
-        }));
+        EXPECT_TRUE(count > bytes.size());
+        std::memcpy(buf, bytes.data(), bytes.size());
+        return bytes.size();
+    }));
 
     EXPECT_CALL(blobMock, writeBytes(session, 0, ContainerEq(bytes)))
         .WillOnce(Throw(ipmiblob::BlobException("failure")));
diff --git a/tools/test/tools_lpc_unittest.cpp b/tools/test/tools_lpc_unittest.cpp
index b180df5..2ecbaf0 100644
--- a/tools/test/tools_lpc_unittest.cpp
+++ b/tools/test/tools_lpc_unittest.cpp
@@ -56,17 +56,16 @@
         .WillOnce(Return(fakeFileSize));
     EXPECT_CALL(sysMock, read(_, NotNull(), Gt(data.size())))
         .WillOnce(Invoke([&data](int, void* buf, std::size_t) {
-            std::memcpy(buf, data.data(), data.size());
-            return data.size();
-        }))
-        .WillOnce(Return(0));
+        std::memcpy(buf, data.data(), data.size());
+        return data.size();
+    })).WillOnce(Return(0));
 
     EXPECT_CALL(ioMock, write(_, data.size(), _))
         .WillOnce(Invoke([&data](const std::size_t, const std::size_t,
                                  const void* const source) {
-            EXPECT_THAT(std::memcmp(source, data.data(), data.size()), 0);
-            return true;
-        }));
+        EXPECT_THAT(std::memcmp(source, data.data(), data.size()), 0);
+        return true;
+    }));
 
     EXPECT_CALL(blobMock, writeBytes(session, 0, _));
 
diff --git a/tools/test/tools_net_unittest.cpp b/tools/test/tools_net_unittest.cpp
index b291e1c..cb8776f 100644
--- a/tools/test/tools_net_unittest.cpp
+++ b/tools/test/tools_net_unittest.cpp
@@ -232,9 +232,9 @@
         InSequence seq;
         EXPECT_CALL(sysMock, sendfile(connFd, inFd, _, _))
             .WillOnce([](int, int, off_t*, size_t) {
-                errno = EINVAL;
-                return -1;
-            });
+            errno = EINVAL;
+            return -1;
+        });
 
         std::vector<uint8_t> chunk(chunkSize);
         for (std::uint32_t offset = 0; offset < fakeFileSize;
@@ -246,16 +246,16 @@
             }
             EXPECT_CALL(sysMock, read(inFd, _, Ge(chunkSize)))
                 .WillOnce([chunk](int, void* buf, size_t) {
-                    memcpy(buf, chunk.data(), chunkSize);
-                    return chunkSize;
-                });
+                memcpy(buf, chunk.data(), chunkSize);
+                return chunkSize;
+            });
             EXPECT_CALL(sysMock, send(connFd, _, chunkSize, 0))
                 .WillOnce([chunk](int, const void* data, size_t len, int) {
-                    std::vector<uint8_t> dcopy(len);
-                    memcpy(dcopy.data(), data, len);
-                    EXPECT_THAT(dcopy, ContainerEq(chunk));
-                    return chunkSize;
-                });
+                std::vector<uint8_t> dcopy(len);
+                memcpy(dcopy.data(), data, len);
+                EXPECT_THAT(dcopy, ContainerEq(chunk));
+                return chunkSize;
+            });
             EXPECT_CALL(blobMock,
                         writeBytes(session, offset, ContainerEq(chunkBytes)));
             EXPECT_CALL(progMock, updateProgress(chunkSize));