diff --git a/test/dbus_active_unittest.cpp b/test/dbus_active_unittest.cpp
index 562dd73..c9f663e 100644
--- a/test/dbus_active_unittest.cpp
+++ b/test/dbus_active_unittest.cpp
@@ -45,10 +45,10 @@
         .WillOnce(Invoke([&]([[maybe_unused]] const std::string& service,
                              [[maybe_unused]] const std::string& path,
                              SensorProperties* prop) {
-        prop->scale = -3;
-        prop->value = 10000;
-        prop->unit = "x";
-    }));
+            prop->scale = -3;
+            prop->value = 10000;
+            prop->unit = "x";
+        }));
 
     DbusActiveRead ar(bus_mock, path, service, std::move(helper));
 
diff --git a/test/dbus_passive_unittest.cpp b/test/dbus_passive_unittest.cpp
index 29c73dc..9120336 100644
--- a/test/dbus_passive_unittest.cpp
+++ b/test/dbus_passive_unittest.cpp
@@ -79,13 +79,13 @@
             .WillOnce(Invoke([&]([[maybe_unused]] const std::string& service,
                                  [[maybe_unused]] const std::string& path,
                                  SensorProperties* prop) {
-            prop->scale = _scale;
-            prop->value = _value;
-            prop->unit = "x";
-            prop->min = 0;
-            prop->max = 0;
-            prop->available = true;
-        }));
+                prop->scale = _scale;
+                prop->value = _value;
+                prop->unit = "x";
+                prop->min = 0;
+                prop->max = 0;
+                prop->available = true;
+            }));
         EXPECT_CALL(*helper, thresholdsAsserted(StrEq("asdf"), StrEq(path)))
             .WillOnce(Return(false));
 
@@ -168,18 +168,18 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        // Read the first parameter, the string.
-        *s = intf;
-        return 0;
-    }))
+            const char** s = static_cast<const char**>(p);
+            // Read the first parameter, the string.
+            *s = intf;
+            return 0;
+        }))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        *s = Value;
-        // Read the string in the pair (dictionary).
-        return 0;
-    }));
+            const char** s = static_cast<const char**>(p);
+            *s = Value;
+            // Read the string in the pair (dictionary).
+            return 0;
+        }));
 
     // std::map
     EXPECT_CALL(sdbus_mock,
@@ -206,10 +206,10 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'x', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        int64_t* s = static_cast<int64_t*>(p);
-        *s = xValue;
-        return 0;
-    }));
+            int64_t* s = static_cast<int64_t*>(p);
+            *s = xValue;
+            return 0;
+        }));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
         .WillOnce(Return(0))  /* variant. */
@@ -241,18 +241,18 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        // Read the first parameter, the string.
-        *s = intf;
-        return 0;
-    }))
+            const char** s = static_cast<const char**>(p);
+            // Read the first parameter, the string.
+            *s = intf;
+            return 0;
+        }))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        *s = Scale;
-        // Read the string in the pair (dictionary).
-        return 0;
-    }));
+            const char** s = static_cast<const char**>(p);
+            *s = Scale;
+            // Read the string in the pair (dictionary).
+            return 0;
+        }));
 
     // std::map
     EXPECT_CALL(sdbus_mock,
@@ -279,10 +279,10 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'x', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        int64_t* s = static_cast<int64_t*>(p);
-        *s = xScale;
-        return 0;
-    }));
+            int64_t* s = static_cast<int64_t*>(p);
+            *s = xScale;
+            return 0;
+        }));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
         .WillOnce(Return(0))  /* variant. */
@@ -312,18 +312,18 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        // Read the first parameter, the string.
-        *s = intf;
-        return 0;
-    }))
+            const char** s = static_cast<const char**>(p);
+            // Read the first parameter, the string.
+            *s = intf;
+            return 0;
+        }))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        *s = criticalAlarm;
-        // Read the string in the pair (dictionary).
-        return 0;
-    }));
+            const char** s = static_cast<const char**>(p);
+            *s = criticalAlarm;
+            // Read the string in the pair (dictionary).
+            return 0;
+        }));
 
     // std::map
     EXPECT_CALL(sdbus_mock,
@@ -356,10 +356,10 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        bool* s = static_cast<bool*>(p);
-        *s = alarm;
-        return 0;
-    }));
+            bool* s = static_cast<bool*>(p);
+            *s = alarm;
+            return 0;
+        }));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
         .WillOnce(Return(0))  /* variant. */
@@ -389,18 +389,18 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        // Read the first parameter, the string.
-        *s = intf;
-        return 0;
-    }))
+            const char** s = static_cast<const char**>(p);
+            // Read the first parameter, the string.
+            *s = intf;
+            return 0;
+        }))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        *s = criticalAlarm;
-        // Read the string in the pair (dictionary).
-        return 0;
-    }));
+            const char** s = static_cast<const char**>(p);
+            *s = criticalAlarm;
+            // Read the string in the pair (dictionary).
+            return 0;
+        }));
 
     // std::map
     EXPECT_CALL(sdbus_mock,
@@ -433,10 +433,10 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        bool* s = static_cast<bool*>(p);
-        *s = alarm;
-        return 0;
-    }));
+            bool* s = static_cast<bool*>(p);
+            *s = alarm;
+            return 0;
+        }));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
         .WillOnce(Return(0))  /* variant. */
@@ -466,18 +466,18 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        // Read the first parameter, the string.
-        *s = intf;
-        return 0;
-    }))
+            const char** s = static_cast<const char**>(p);
+            // Read the first parameter, the string.
+            *s = intf;
+            return 0;
+        }))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        *s = property;
-        // Read the string in the pair (dictionary).
-        return 0;
-    }));
+            const char** s = static_cast<const char**>(p);
+            *s = property;
+            // Read the string in the pair (dictionary).
+            return 0;
+        }));
 
     // std::map
     EXPECT_CALL(sdbus_mock,
@@ -510,10 +510,10 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        bool* s = static_cast<bool*>(p);
-        *s = asserted;
-        return 0;
-    }));
+            bool* s = static_cast<bool*>(p);
+            *s = asserted;
+            return 0;
+        }));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
         .WillOnce(Return(0))  /* variant. */
@@ -545,18 +545,18 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        // Read the first parameter, the string.
-        *s = intf;
-        return 0;
-    }))
+            const char** s = static_cast<const char**>(p);
+            // Read the first parameter, the string.
+            *s = intf;
+            return 0;
+        }))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        *s = property;
-        // Read the string in the pair (dictionary).
-        return 0;
-    }));
+            const char** s = static_cast<const char**>(p);
+            *s = property;
+            // Read the string in the pair (dictionary).
+            return 0;
+        }));
 
     // std::map
     EXPECT_CALL(sdbus_mock,
@@ -589,10 +589,10 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        bool* s = static_cast<bool*>(p);
-        *s = asserted;
-        return 0;
-    }));
+            bool* s = static_cast<bool*>(p);
+            *s = asserted;
+            return 0;
+        }));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
         .WillOnce(Return(0))  /* variant. */
@@ -621,13 +621,13 @@
             .WillOnce(Invoke([&]([[maybe_unused]] const std::string& service,
                                  [[maybe_unused]] const std::string& path,
                                  SensorProperties* prop) {
-            prop->scale = _scale;
-            prop->value = _value;
-            prop->unit = "x";
-            prop->min = 0;
-            prop->max = 0;
-            prop->available = true;
-        }));
+                prop->scale = _scale;
+                prop->value = _value;
+                prop->unit = "x";
+                prop->min = 0;
+                prop->max = 0;
+                prop->available = true;
+            }));
         EXPECT_CALL(*helper, thresholdsAsserted(StrEq("asdf"), StrEq(path)))
             .WillOnce(Return(false));
 
@@ -669,18 +669,18 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        // Read the first parameter, the string.
-        *s = intf;
-        return 0;
-    }))
+            const char** s = static_cast<const char**>(p);
+            // Read the first parameter, the string.
+            *s = intf;
+            return 0;
+        }))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        *s = property;
-        // Read the string in the pair (dictionary).
-        return 0;
-    }));
+            const char** s = static_cast<const char**>(p);
+            *s = property;
+            // Read the string in the pair (dictionary).
+            return 0;
+        }));
 
     // std::map
     EXPECT_CALL(sdbus_mock,
@@ -713,10 +713,10 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        bool* s = static_cast<bool*>(p);
-        *s = asserted;
-        return 0;
-    }));
+            bool* s = static_cast<bool*>(p);
+            *s = asserted;
+            return 0;
+        }));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
         .WillOnce(Return(0))  /* variant. */
@@ -750,18 +750,18 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        // Read the first parameter, the string.
-        *s = intf;
-        return 0;
-    }))
+            const char** s = static_cast<const char**>(p);
+            // Read the first parameter, the string.
+            *s = intf;
+            return 0;
+        }))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        const char** s = static_cast<const char**>(p);
-        *s = property;
-        // Read the string in the pair (dictionary).
-        return 0;
-    }));
+            const char** s = static_cast<const char**>(p);
+            *s = property;
+            // Read the string in the pair (dictionary).
+            return 0;
+        }));
 
     // std::map
     EXPECT_CALL(sdbus_mock,
@@ -794,10 +794,10 @@
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
         .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
                              [[maybe_unused]] char type, void* p) {
-        bool* s = static_cast<bool*>(p);
-        *s = asserted;
-        return 0;
-    }));
+            bool* s = static_cast<bool*>(p);
+            *s = asserted;
+            return 0;
+        }));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_exit_container(IsNull()))
         .WillOnce(Return(0))  /* variant. */
diff --git a/test/helpers.hpp b/test/helpers.hpp
index 378a4ae..4d3faea 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -66,9 +66,9 @@
                                        [[maybe_unused]] const char* path,
                                        [[maybe_unused]] const char* interface,
                                        const char** names) {
-            EXPECT_STREQ(properties[(*index)++].c_str(), names[0]);
-            return 0;
-        }));
+                EXPECT_STREQ(properties[(*index)++].c_str(), names[0]);
+                return 0;
+            }));
     }
 
     return;
diff --git a/test/pid_thermalcontroller_unittest.cpp b/test/pid_thermalcontroller_unittest.cpp
index 8abedf5..b4b1e5d 100644
--- a/test/pid_thermalcontroller_unittest.cpp
+++ b/test/pid_thermalcontroller_unittest.cpp
@@ -118,8 +118,8 @@
 
     ZoneMock z;
 
-    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"},
-                                                          {"fleeting1"}};
+    std::vector<pid_control::conf::SensorInput> inputs = {
+        {"fleeting0"}, {"fleeting1"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
@@ -140,8 +140,8 @@
 
     ZoneMock z;
 
-    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"},
-                                                          {"fleeting1"}};
+    std::vector<pid_control::conf::SensorInput> inputs = {
+        {"fleeting0"}, {"fleeting1"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
@@ -162,8 +162,8 @@
 
     ZoneMock z;
 
-    std::vector<pid_control::conf::SensorInput> inputs = {{"fleeting0"},
-                                                          {"fleeting1"}};
+    std::vector<pid_control::conf::SensorInput> inputs = {
+        {"fleeting0"}, {"fleeting1"}};
     double setpoint = 10.0;
     ec::pidinfo initial;
 
diff --git a/test/pid_zone_unittest.cpp b/test/pid_zone_unittest.cpp
index 1f6e672..3e8077c 100644
--- a/test/pid_zone_unittest.cpp
+++ b/test/pid_zone_unittest.cpp
@@ -68,8 +68,8 @@
                     properties, &d);
 
     std::string sensorname = "temp1";
-    std::string pidsensorpath = "/xyz/openbmc_project/settings/fanctrl/zone1/" +
-                                sensorname;
+    std::string pidsensorpath =
+        "/xyz/openbmc_project/settings/fanctrl/zone1/" + sensorname;
 
     double de;
     std::vector<std::string> propertiesenable;
@@ -154,8 +154,8 @@
 
     std::string sensorname = "temp1";
     std::string sensorType = "temp";
-    std::string pidsensorpath = "/xyz/openbmc_project/settings/fanctrl/zone1/" +
-                                sensorname;
+    std::string pidsensorpath =
+        "/xyz/openbmc_project/settings/fanctrl/zone1/" + sensorname;
 
     std::unique_ptr<DbusPidZone> zone;
 };
@@ -190,9 +190,9 @@
         .WillOnce(Invoke(
             [&]([[maybe_unused]] sd_bus* bus, [[maybe_unused]] const char* path,
                 [[maybe_unused]] const char* interface, const char** names) {
-        EXPECT_STREQ("Enable", names[0]);
-        return 0;
-    }));
+                EXPECT_STREQ("Enable", names[0]);
+                return 0;
+            }));
 
     zone->addPidControlProcess(sensorname, sensorType, setpoint,
                                bus_mock_enable, pidsensorpath.c_str(), defer);
@@ -248,9 +248,9 @@
         .WillOnce(Invoke(
             [&]([[maybe_unused]] sd_bus* bus, [[maybe_unused]] const char* path,
                 [[maybe_unused]] const char* interface, const char** names) {
-        EXPECT_STREQ("Enable", names[0]);
-        return 0;
-    }));
+                EXPECT_STREQ("Enable", names[0]);
+                return 0;
+            }));
 
     zone->addPidControlProcess(sensorname, sensorType, setpoint,
                                bus_mock_enable, pidsensorpath.c_str(), defer);
@@ -292,9 +292,9 @@
         .WillOnce(Invoke(
             [&]([[maybe_unused]] sd_bus* bus, [[maybe_unused]] const char* path,
                 [[maybe_unused]] const char* interface, const char** names) {
-        EXPECT_STREQ("Enable", names[0]);
-        return 0;
-    }));
+                EXPECT_STREQ("Enable", names[0]);
+                return 0;
+            }));
 
     zone->addPidControlProcess(sensorname, sensorType, setpoint,
                                bus_mock_enable, pidsensorpath.c_str(), defer);
@@ -362,13 +362,13 @@
     std::string name1 = "temp1";
     int64_t timeout = 1;
 
-    std::unique_ptr<Sensor> sensor1 = std::make_unique<SensorMock>(name1,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor1 =
+        std::make_unique<SensorMock>(name1, timeout);
     SensorMock* sensor_ptr1 = reinterpret_cast<SensorMock*>(sensor1.get());
 
     std::string name2 = "temp2";
-    std::unique_ptr<Sensor> sensor2 = std::make_unique<SensorMock>(name2,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor2 =
+        std::make_unique<SensorMock>(name2, timeout);
     SensorMock* sensor_ptr2 = reinterpret_cast<SensorMock*>(sensor2.get());
 
     std::string type = "unchecked";
@@ -414,13 +414,13 @@
     std::string name1 = "fan1";
     int64_t timeout = 2;
 
-    std::unique_ptr<Sensor> sensor1 = std::make_unique<SensorMock>(name1,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor1 =
+        std::make_unique<SensorMock>(name1, timeout);
     SensorMock* sensor_ptr1 = reinterpret_cast<SensorMock*>(sensor1.get());
 
     std::string name2 = "fan2";
-    std::unique_ptr<Sensor> sensor2 = std::make_unique<SensorMock>(name2,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor2 =
+        std::make_unique<SensorMock>(name2, timeout);
     SensorMock* sensor_ptr2 = reinterpret_cast<SensorMock*>(sensor2.get());
 
     std::string type = "unchecked";
@@ -462,13 +462,13 @@
     int64_t timeout = 1;
 
     std::string name1 = "temp1";
-    std::unique_ptr<Sensor> sensor1 = std::make_unique<SensorMock>(name1,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor1 =
+        std::make_unique<SensorMock>(name1, timeout);
     SensorMock* sensor_ptr1 = reinterpret_cast<SensorMock*>(sensor1.get());
 
     std::string name2 = "temp2";
-    std::unique_ptr<Sensor> sensor2 = std::make_unique<SensorMock>(name2,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor2 =
+        std::make_unique<SensorMock>(name2, timeout);
     SensorMock* sensor_ptr2 = reinterpret_cast<SensorMock*>(sensor2.get());
 
     std::string type = "unchecked";
@@ -524,13 +524,13 @@
     int64_t timeout = 1;
 
     std::string name1 = "temp1";
-    std::unique_ptr<Sensor> sensor1 = std::make_unique<SensorMock>(name1,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor1 =
+        std::make_unique<SensorMock>(name1, timeout);
     SensorMock* sensor_ptr1 = reinterpret_cast<SensorMock*>(sensor1.get());
 
     std::string name2 = "temp2";
-    std::unique_ptr<Sensor> sensor2 = std::make_unique<SensorMock>(name2,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor2 =
+        std::make_unique<SensorMock>(name2, timeout);
     SensorMock* sensor_ptr2 = reinterpret_cast<SensorMock*>(sensor2.get());
 
     std::string type = "unchecked";
@@ -620,13 +620,13 @@
     std::string name1 = "fan1";
     int64_t timeout = 2;
 
-    std::unique_ptr<Sensor> sensor1 = std::make_unique<SensorMock>(name1,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor1 =
+        std::make_unique<SensorMock>(name1, timeout);
     SensorMock* sensor_ptr1 = reinterpret_cast<SensorMock*>(sensor1.get());
 
     std::string name2 = "fan2";
-    std::unique_ptr<Sensor> sensor2 = std::make_unique<SensorMock>(name2,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor2 =
+        std::make_unique<SensorMock>(name2, timeout);
     SensorMock* sensor_ptr2 = reinterpret_cast<SensorMock*>(sensor2.get());
 
     std::string type = "unchecked";
@@ -673,13 +673,13 @@
     std::string name1 = "fan1";
     int64_t timeout = 2;
 
-    std::unique_ptr<Sensor> sensor1 = std::make_unique<SensorMock>(name1,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor1 =
+        std::make_unique<SensorMock>(name1, timeout);
     SensorMock* sensor_ptr1 = reinterpret_cast<SensorMock*>(sensor1.get());
 
     std::string name2 = "fan2";
-    std::unique_ptr<Sensor> sensor2 = std::make_unique<SensorMock>(name2,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor2 =
+        std::make_unique<SensorMock>(name2, timeout);
     SensorMock* sensor_ptr2 = reinterpret_cast<SensorMock*>(sensor2.get());
 
     std::string type = "unchecked";
@@ -732,8 +732,8 @@
     int64_t timeout = 1;
 
     std::string name1 = "temp1";
-    std::unique_ptr<Sensor> sensor1 = std::make_unique<SensorMock>(name1,
-                                                                   timeout);
+    std::unique_ptr<Sensor> sensor1 =
+        std::make_unique<SensorMock>(name1, timeout);
     SensorMock* sensor_ptr1 = reinterpret_cast<SensorMock*>(sensor1.get());
 
     std::string type = "unchecked";
@@ -807,9 +807,9 @@
         .WillOnce(Invoke(
             [&]([[maybe_unused]] sd_bus* bus, [[maybe_unused]] const char* path,
                 [[maybe_unused]] const char* interface, const char** names) {
-        EXPECT_STREQ("Manual", names[0]);
-        return 0;
-    }));
+                EXPECT_STREQ("Manual", names[0]);
+                return 0;
+            }));
 
     // Method under test will set the manual mode to true and broadcast this
     // change on dbus.
diff --git a/test/sensor_host_unittest.cpp b/test/sensor_host_unittest.cpp
index cb5ede4..e9800cf 100644
--- a/test/sensor_host_unittest.cpp
+++ b/test/sensor_host_unittest.cpp
@@ -51,8 +51,8 @@
                 sd_bus_emit_object_removed(IsNull(), StrEq(objPath)))
         .WillOnce(Return(0));
 
-    std::unique_ptr<Sensor> s = HostSensor::createTemp(name, timeout, bus_mock,
-                                                       objPath, defer);
+    std::unique_ptr<Sensor> s =
+        HostSensor::createTemp(name, timeout, bus_mock, objPath, defer);
 }
 
 TEST(HostSensorTest, VerifyWriteThenReadMatches)
@@ -77,8 +77,8 @@
                 sd_bus_emit_object_removed(IsNull(), StrEq(objPath)))
         .WillOnce(Return(0));
 
-    std::unique_ptr<Sensor> s = HostSensor::createTemp(name, timeout, bus_mock,
-                                                       objPath, defer);
+    std::unique_ptr<Sensor> s =
+        HostSensor::createTemp(name, timeout, bus_mock, objPath, defer);
 
     // Value is updated from dbus calls only (normally).
     HostSensor* hs = static_cast<HostSensor*>(s.get());
@@ -93,9 +93,9 @@
         .WillOnce(Invoke(
             [=]([[maybe_unused]] sd_bus* bus, [[maybe_unused]] const char* path,
                 [[maybe_unused]] const char* interface, const char** names) {
-        EXPECT_STREQ("Value", names[0]);
-        return 0;
-    }));
+                EXPECT_STREQ("Value", names[0]);
+                return 0;
+            }));
 
     std::chrono::high_resolution_clock::time_point t1 =
         std::chrono::high_resolution_clock::now();
diff --git a/test/sensor_manager_unittest.cpp b/test/sensor_manager_unittest.cpp
index b5b67c7..85865a8 100644
--- a/test/sensor_manager_unittest.cpp
+++ b/test/sensor_manager_unittest.cpp
@@ -53,8 +53,8 @@
     std::string name = "name";
     std::string type = "invalid";
     int64_t timeout = 1;
-    std::unique_ptr<Sensor> sensor = std::make_unique<SensorMock>(name,
-                                                                  timeout);
+    std::unique_ptr<Sensor> sensor =
+        std::make_unique<SensorMock>(name, timeout);
     Sensor* sensor_ptr = sensor.get();
 
     s.addSensor(type, name, std::move(sensor));