diff --git a/tools/bt.hpp b/tools/bt.hpp
index 16605fd..fd0a8cc 100644
--- a/tools/bt.hpp
+++ b/tools/bt.hpp
@@ -14,8 +14,7 @@
   public:
     BtDataHandler(ipmiblob::BlobInterface* blob, ProgressInterface* progress,
                   const internal::Sys* sys = &internal::sys_impl) :
-        blob(blob),
-        progress(progress), sys(sys){};
+        blob(blob), progress(progress), sys(sys) {};
 
     bool sendContents(const std::string& input, std::uint16_t session) override;
     ipmi_flash::FirmwareFlags::UpdateFlags supportedType() const override
diff --git a/tools/handler.cpp b/tools/handler.cpp
index c3fa30c..55503b9 100644
--- a/tools/handler.cpp
+++ b/tools/handler.cpp
@@ -53,15 +53,15 @@
 {
     std::vector<std::string> blobs = blob->getBlobList();
 
-    auto blobInst = std::find_if(blobs.begin(), blobs.end(),
-                                 [&goalFirmware](const std::string& iter) {
-        /* Running into weird scenarios where the string comparison doesn't
-         * work.  TODO: revisit.
-         */
-        return (0 == std::memcmp(goalFirmware.c_str(), iter.c_str(),
-                                 goalFirmware.length()));
-        // return (goalFirmware.compare(iter));
-    });
+    auto blobInst = std::find_if(
+        blobs.begin(), blobs.end(), [&goalFirmware](const std::string& iter) {
+            /* Running into weird scenarios where the string comparison doesn't
+             * work.  TODO: revisit.
+             */
+            return (0 == std::memcmp(goalFirmware.c_str(), iter.c_str(),
+                                     goalFirmware.length()));
+            // return (goalFirmware.compare(iter));
+        });
     if (blobInst == blobs.end())
     {
         std::fprintf(stderr, "%s not found\n", goalFirmware.c_str());
@@ -84,8 +84,8 @@
         }
         catch (const ipmiblob::BlobException& b)
         {
-            throw ToolException("blob exception received: " +
-                                std::string(b.what()));
+            throw ToolException(
+                "blob exception received: " + std::string(b.what()));
         }
         catch (const ToolException& t)
         {
@@ -185,8 +185,9 @@
 
 std::vector<uint8_t> UpdateHandler::readVersion(const std::string& versionBlob)
 {
-    return retryIfFailed(
-        [this, versionBlob]() { return retryReadVersion(versionBlob); });
+    return retryIfFailed([this, versionBlob]() {
+        return retryReadVersion(versionBlob);
+    });
 }
 
 void UpdateHandler::cleanArtifacts()
diff --git a/tools/helper.cpp b/tools/helper.cpp
index f419410..34fab4f 100644
--- a/tools/helper.cpp
+++ b/tools/helper.cpp
@@ -80,8 +80,8 @@
     }
     catch (const ipmiblob::BlobException& b)
     {
-        throw ToolException("blob exception received: " +
-                            std::string(b.what()));
+        throw ToolException(
+            "blob exception received: " + std::string(b.what()));
     }
 }
 
@@ -92,24 +92,25 @@
 {
     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.
@@ -131,16 +132,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/io.cpp b/tools/io.cpp
index c84a8b3..9af8ace 100644
--- a/tools/io.cpp
+++ b/tools/io.cpp
@@ -38,8 +38,8 @@
         return false;
     }
 
-    void* alignedSource = static_cast<std::uint8_t*>(devMemMapped) +
-                          alignedDiff;
+    void* alignedSource =
+        static_cast<std::uint8_t*>(devMemMapped) + alignedDiff;
 
     /* Copy the bytes. */
     std::memcpy(destination, alignedSource, length);
@@ -78,8 +78,8 @@
         return false;
     }
 
-    void* alignedDestination = static_cast<std::uint8_t*>(devMemMapped) +
-                               alignedDiff;
+    void* alignedDestination =
+        static_cast<std::uint8_t*>(devMemMapped) + alignedDiff;
 
     /* Copy the bytes. */
     std::memcpy(alignedDestination, source, length);
diff --git a/tools/io.hpp b/tools/io.hpp
index 8925418..7301e5f 100644
--- a/tools/io.hpp
+++ b/tools/io.hpp
@@ -42,8 +42,7 @@
   public:
     explicit PpcMemDevice(const std::string& ppcMemPath,
                           const internal::Sys* sys = &internal::sys_impl) :
-        ppcMemPath(ppcMemPath),
-        sys(sys)
+        ppcMemPath(ppcMemPath), sys(sys)
     {}
 
     ~PpcMemDevice() override;
diff --git a/tools/lpc.cpp b/tools/lpc.cpp
index e415331..c7f4013 100644
--- a/tools/lpc.cpp
+++ b/tools/lpc.cpp
@@ -125,8 +125,8 @@
 
         do
         {
-            bytesRead = sys->read(inputFd, readBuffer.get(),
-                                  host_lpc_buf.length);
+            bytesRead =
+                sys->read(inputFd, readBuffer.get(), host_lpc_buf.length);
             if (bytesRead > 0)
             {
                 if (!io->write(host_lpc_buf.address, bytesRead,
diff --git a/tools/lpc.hpp b/tools/lpc.hpp
index 1786c94..2fe7e08 100644
--- a/tools/lpc.hpp
+++ b/tools/lpc.hpp
@@ -27,9 +27,8 @@
                    std::uint32_t address, std::uint32_t length,
                    ProgressInterface* progress,
                    const internal::Sys* sys = &internal::sys_impl) :
-        blob(blob),
-        io(io), address(address), length(length), progress(progress),
-        sys(sys){};
+        blob(blob), io(io), address(address), length(length),
+        progress(progress), sys(sys) {};
 
     bool sendContents(const std::string& input, std::uint16_t session) override;
     ipmi_flash::FirmwareFlags::UpdateFlags supportedType() const override
diff --git a/tools/main.cpp b/tools/main.cpp
index 5bda3a0..c6ce451 100644
--- a/tools/main.cpp
+++ b/tools/main.cpp
@@ -80,8 +80,8 @@
 
 bool checkInterface(const std::string& interface)
 {
-    auto intf = std::find(interfaceList.begin(), interfaceList.end(),
-                          interface);
+    auto intf =
+        std::find(interfaceList.begin(), interfaceList.end(), interface);
     return (intf != interfaceList.end());
 }
 
@@ -226,8 +226,8 @@
         /* Input has already been validated in this case. */
         if (interface == IPMIBT)
         {
-            handler = std::make_unique<host_tool::BtDataHandler>(&blob,
-                                                                 &progress);
+            handler =
+                std::make_unique<host_tool::BtDataHandler>(&blob, &progress);
         }
         else if (interface == IPMINET)
         {
@@ -252,8 +252,8 @@
         else if (interface == IPMIPCI)
         {
             auto& pci = host_tool::PciAccessImpl::getInstance();
-            handler = std::make_unique<host_tool::P2aDataHandler>(&blob, &pci,
-                                                                  &progress);
+            handler = std::make_unique<host_tool::P2aDataHandler>(
+                &blob, &pci, &progress);
         }
         else if (interface == IPMIPCI_SKIP_BRIDGE_DISABLE)
         {
diff --git a/tools/net.hpp b/tools/net.hpp
index 7578c82..3a41ff5 100644
--- a/tools/net.hpp
+++ b/tools/net.hpp
@@ -21,8 +21,7 @@
     NetDataHandler(ipmiblob::BlobInterface* blob, ProgressInterface* progress,
                    const std::string& host, const std::string& port,
                    const internal::Sys* sys = &internal::sys_impl) :
-        blob(blob),
-        progress(progress), host(host), port(port), sys(sys){};
+        blob(blob), progress(progress), host(host), port(port), sys(sys) {};
 
     bool sendContents(const std::string& input, std::uint16_t session) override;
     ipmi_flash::FirmwareFlags::UpdateFlags supportedType() const override
diff --git a/tools/p2a.hpp b/tools/p2a.hpp
index 259ca23..8882ac4 100644
--- a/tools/p2a.hpp
+++ b/tools/p2a.hpp
@@ -19,9 +19,8 @@
     explicit P2aDataHandler(ipmiblob::BlobInterface* blob, const PciAccess* pci,
                             ProgressInterface* progress, bool skipBridgeDisable,
                             const internal::Sys* sys = &internal::sys_impl) :
-        blob(blob),
-        pci(pci), progress(progress), skipBridgeDisable(skipBridgeDisable),
-        sys(sys)
+        blob(blob), pci(pci), progress(progress),
+        skipBridgeDisable(skipBridgeDisable), sys(sys)
     {}
 
     P2aDataHandler(ipmiblob::BlobInterface* blob, const PciAccess* pci,
diff --git a/tools/pci.cpp b/tools/pci.cpp
index a6bc74d..516bbad 100644
--- a/tools/pci.cpp
+++ b/tools/pci.cpp
@@ -52,8 +52,7 @@
 PciAccessBridge::PciAccessBridge(const struct pci_id_match* match, int bar,
                                  std::size_t dataOffset, std::size_t dataLength,
                                  const PciAccess* pci) :
-    dataOffset(dataOffset),
-    dataLength(dataLength), pci(pci)
+    dataOffset(dataOffset), dataLength(dataLength), pci(pci)
 {
     It it(pci->pci_id_match_iterator_create(match), pci);
 
diff --git a/tools/pci.hpp b/tools/pci.hpp
index c13a4e1..9f72e78 100644
--- a/tools/pci.hpp
+++ b/tools/pci.hpp
@@ -51,7 +51,7 @@
     virtual ~PciAccessBridge();
 
     virtual void write(const std::span<const std::uint8_t> data) override;
-    virtual void configure(const ipmi_flash::PciConfigResponse&) override{};
+    virtual void configure(const ipmi_flash::PciConfigResponse&) override {};
 
     std::size_t getDataLength() override
     {
diff --git a/tools/pciaccess.cpp b/tools/pciaccess.cpp
index e5b9a2f..f3c9e6e 100644
--- a/tools/pciaccess.cpp
+++ b/tools/pciaccess.cpp
@@ -50,16 +50,14 @@
     return ::pci_device_probe(dev);
 }
 
-int PciAccessImpl::pci_device_cfg_read_u8(struct pci_device* dev,
-                                          std::uint8_t* data,
-                                          pciaddr_t offset) const
+int PciAccessImpl::pci_device_cfg_read_u8(
+    struct pci_device* dev, std::uint8_t* data, pciaddr_t offset) const
 {
     return ::pci_device_cfg_read_u8(dev, data, offset);
 }
 
-int PciAccessImpl::pci_device_cfg_write_u8(struct pci_device* dev,
-                                           std::uint8_t data,
-                                           pciaddr_t offset) const
+int PciAccessImpl::pci_device_cfg_write_u8(
+    struct pci_device* dev, std::uint8_t data, pciaddr_t offset) const
 {
     return ::pci_device_cfg_write_u8(dev, data, offset);
 }
diff --git a/tools/pciaccess.hpp b/tools/pciaccess.hpp
index 23fc4ab..99ba265 100644
--- a/tools/pciaccess.hpp
+++ b/tools/pciaccess.hpp
@@ -41,12 +41,10 @@
     virtual struct pci_device*
         pci_device_next(struct pci_device_iterator* iter) const = 0;
     virtual int pci_device_probe(struct pci_device* dev) const = 0;
-    virtual int pci_device_cfg_read_u8(struct pci_device* dev,
-                                       std::uint8_t* data,
-                                       pciaddr_t offset) const = 0;
-    virtual int pci_device_cfg_write_u8(struct pci_device* dev,
-                                        std::uint8_t data,
-                                        pciaddr_t offset) const = 0;
+    virtual int pci_device_cfg_read_u8(
+        struct pci_device* dev, std::uint8_t* data, pciaddr_t offset) const = 0;
+    virtual int pci_device_cfg_write_u8(
+        struct pci_device* dev, std::uint8_t data, pciaddr_t offset) const = 0;
     virtual int pci_device_map_range(struct pci_device* dev, pciaddr_t base,
                                      pciaddr_t size, unsigned map_flags,
                                      void** addr) const = 0;
diff --git a/tools/test/tools_bt_unittest.cpp b/tools/test/tools_bt_unittest.cpp
index e1a091b..3d2c181 100644
--- a/tools/test/tools_bt_unittest.cpp
+++ b/tools/test/tools_bt_unittest.cpp
@@ -58,10 +58,11 @@
 
     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()));
 
@@ -99,10 +100,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_helper_unittest.cpp b/tools/test/tools_helper_unittest.cpp
index 572e136..cfe5208 100644
--- a/tools/test/tools_helper_unittest.cpp
+++ b/tools/test/tools_helper_unittest.cpp
@@ -51,8 +51,8 @@
 {
     ipmiblob::StatResponse blobResponse = {};
     /* the other details of the response are ignored, and should be. */
-    blobResponse.blob_state = blobs::StateFlags::open_read |
-                              blobs::StateFlags::committed;
+    blobResponse.blob_state =
+        blobs::StateFlags::open_read | blobs::StateFlags::committed;
 
     EXPECT_CALL(blobMock, getStat(TypedEq<std::uint16_t>(session)))
         .WillOnce(Return(blobResponse));
diff --git a/tools/test/tools_lpc_unittest.cpp b/tools/test/tools_lpc_unittest.cpp
index 2ecbaf0..b180df5 100644
--- a/tools/test/tools_lpc_unittest.cpp
+++ b/tools/test/tools_lpc_unittest.cpp
@@ -56,16 +56,17 @@
         .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 cb8776f..8c88ba9 100644
--- a/tools/test/tools_net_unittest.cpp
+++ b/tools/test/tools_net_unittest.cpp
@@ -134,9 +134,9 @@
     EXPECT_CALL(sysMock, socket(AF_INET6, SOCK_STREAM, 0))
         .WillOnce(Return(connFd));
     EXPECT_CALL(sysMock, close(connFd)).WillOnce(Return(0));
-    EXPECT_CALL(
-        sysMock,
-        connect(connFd, reinterpret_cast<struct sockaddr*>(&sa), sizeof(sa)))
+    EXPECT_CALL(sysMock,
+                connect(connFd, reinterpret_cast<struct sockaddr*>(&sa),
+                        sizeof(sa)))
         .WillOnce(SetErrnoAndReturn(ECONNREFUSED, -1));
 
     EXPECT_FALSE(handler.sendContents(filePath, session));
@@ -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));
diff --git a/tools/test/tools_pci_unittest.cpp b/tools/test/tools_pci_unittest.cpp
index 96a204a..c3ce610 100644
--- a/tools/test/tools_pci_unittest.cpp
+++ b/tools/test/tools_pci_unittest.cpp
@@ -338,8 +338,8 @@
 INSTANTIATE_TEST_SUITE_P(Default, PciSetupTest,
                          ::testing::Values(&nuvotonDevice, &aspeedDevice),
                          [](const testing::TestParamInfo<Device*>& info) {
-    return info.param->getName();
-});
+                             return info.param->getName();
+                         });
 
 TEST(NuvotonWriteTest, TooLarge)
 {
@@ -660,8 +660,8 @@
 
     {
         std::vector<std::uint8_t> enabledRegion(mockRegionSize);
-        enabledRegion[AspeedDevice::config] = defaultVal |
-                                              AspeedDevice::bridgeEnabled;
+        enabledRegion[AspeedDevice::config] =
+            defaultVal | AspeedDevice::bridgeEnabled;
         EXPECT_THAT(region, ContainerEq(enabledRegion));
     }
 
@@ -689,13 +689,13 @@
     expectSetup(pciMock, dev, &aspeedDevice, region.data());
 
     /* Setting skipBridgeDisable to true */
-    std::unique_ptr<PciBridgeIntf> bridge = aspeedDevice.getBridge(&pciMock,
-                                                                   true);
+    std::unique_ptr<PciBridgeIntf> bridge =
+        aspeedDevice.getBridge(&pciMock, true);
 
     {
         std::vector<std::uint8_t> enabledRegion(mockRegionSize);
-        enabledRegion[AspeedDevice::config] = defaultVal |
-                                              AspeedDevice::bridgeEnabled;
+        enabledRegion[AspeedDevice::config] =
+            defaultVal | AspeedDevice::bridgeEnabled;
         EXPECT_THAT(region, ContainerEq(enabledRegion));
     }
 
@@ -703,8 +703,8 @@
 
     {
         std::vector<std::uint8_t> disabledRegion(mockRegionSize);
-        disabledRegion[AspeedDevice::config] = defaultVal |
-                                               AspeedDevice::bridgeEnabled;
+        disabledRegion[AspeedDevice::config] =
+            defaultVal | AspeedDevice::bridgeEnabled;
         EXPECT_THAT(region, ContainerEq(disabledRegion));
     }
 }
@@ -726,8 +726,8 @@
 
     {
         std::vector<std::uint8_t> enabledRegion(mockRegionSize);
-        enabledRegion[AspeedDevice::config] = defaultVal |
-                                              AspeedDevice::bridgeEnabled;
+        enabledRegion[AspeedDevice::config] =
+            defaultVal | AspeedDevice::bridgeEnabled;
         EXPECT_THAT(region, ContainerEq(enabledRegion));
     }
 
diff --git a/tools/test/tools_updater_unittest.cpp b/tools/test/tools_updater_unittest.cpp
index acaaee7..fd795ee 100644
--- a/tools/test/tools_updater_unittest.cpp
+++ b/tools/test/tools_updater_unittest.cpp
@@ -235,8 +235,8 @@
     EXPECT_CALL(blobMock, openBlob(ipmi_flash::biosVersionBlobId, _))
         .WillOnce(Return(session));
     ipmiblob::StatResponse readVersionResponse = {};
-    readVersionResponse.blob_state = blobs::StateFlags::open_read |
-                                     blobs::StateFlags::committed;
+    readVersionResponse.blob_state =
+        blobs::StateFlags::open_read | blobs::StateFlags::committed;
     readVersionResponse.size = 10;
     EXPECT_CALL(blobMock, getStat(TypedEq<std::uint16_t>(session)))
         .WillOnce(Return(readVersionResponse));
@@ -253,8 +253,8 @@
     EXPECT_CALL(blobMock, openBlob(ipmi_flash::biosVersionBlobId, _))
         .WillOnce(Return(session));
     ipmiblob::StatResponse readVersionResponse = {};
-    readVersionResponse.blob_state = blobs::StateFlags::open_read |
-                                     blobs::StateFlags::committed;
+    readVersionResponse.blob_state =
+        blobs::StateFlags::open_read | blobs::StateFlags::committed;
     readVersionResponse.size = 10;
     EXPECT_CALL(blobMock, getStat(TypedEq<std::uint16_t>(session)))
         .WillOnce(Return(readVersionResponse));
@@ -288,8 +288,8 @@
         .Times(3)
         .WillRepeatedly(Return(session));
     ipmiblob::StatResponse readVersionResponse = {};
-    readVersionResponse.blob_state = blobs::StateFlags::open_read |
-                                     blobs::StateFlags::committed;
+    readVersionResponse.blob_state =
+        blobs::StateFlags::open_read | blobs::StateFlags::committed;
     readVersionResponse.size = 10;
     EXPECT_CALL(blobMock, getStat(TypedEq<std::uint16_t>(session)))
         .Times(3)
diff --git a/tools/tool_errors.hpp b/tools/tool_errors.hpp
index 96dfa10..3b614f9 100644
--- a/tools/tool_errors.hpp
+++ b/tools/tool_errors.hpp
@@ -9,7 +9,7 @@
 class ToolException : public std::exception
 {
   public:
-    explicit ToolException(const std::string& message) : message(message){};
+    explicit ToolException(const std::string& message) : message(message) {};
 
     virtual const char* what() const noexcept override
     {
@@ -24,7 +24,7 @@
 {
   public:
     explicit NotFoundException(const std::string& device) :
-        ToolException(std::string("Couldn't find " + device)){};
+        ToolException(std::string("Couldn't find " + device)) {};
 };
 
 } // namespace host_tool