diff --git a/dbus/dbusconfiguration.cpp b/dbus/dbusconfiguration.cpp
index ef990c9..8871dfb 100644
--- a/dbus/dbusconfiguration.cpp
+++ b/dbus/dbusconfiguration.cpp
@@ -258,7 +258,7 @@
 }
 
 void populatePidInfo(
-    sdbusplus::bus_t& bus,
+    [[maybe_unused]] sdbusplus::bus_t& bus,
     const std::unordered_map<std::string, DbusVariantType>& base,
     conf::ControllerInfo& info, const std::string* thresholdProperty,
     const std::map<std::string, conf::SensorConfig>& sensorConfig)
diff --git a/dbus/dbuspassive.cpp b/dbus/dbuspassive.cpp
index 182a9a5..41047a1 100644
--- a/dbus/dbuspassive.cpp
+++ b/dbus/dbuspassive.cpp
@@ -331,7 +331,8 @@
     return 0;
 }
 
-int dbusHandleSignal(sd_bus_message* msg, void* usrData, sd_bus_error* err)
+int dbusHandleSignal(sd_bus_message* msg, void* usrData,
+                     [[maybe_unused]] sd_bus_error* err)
 {
     auto sdbpMsg = sdbusplus::message_t(msg);
     DbusPassive* obj = static_cast<DbusPassive*>(usrData);
diff --git a/dbus/dbusutil.hpp b/dbus/dbusutil.hpp
index 5012af0..49ec859 100644
--- a/dbus/dbusutil.hpp
+++ b/dbus/dbusutil.hpp
@@ -22,7 +22,7 @@
 
     template <typename T>
     std::enable_if_t<!std::is_arithmetic<T>::value, double>
-        operator()(const T& t) const
+        operator()([[maybe_unused]] const T& t) const
     {
         throw std::invalid_argument("Cannot translate type to double");
     }
diff --git a/experiments/drive.cpp b/experiments/drive.cpp
index 5fdbcf4..15ce05a 100644
--- a/experiments/drive.cpp
+++ b/experiments/drive.cpp
@@ -130,7 +130,8 @@
     return;
 }
 
-static void driveTime(int64_t& seriesCnt, int64_t setPwm, int64_t goal,
+static void driveTime([[maybe_unused]] int64_t& seriesCnt, int64_t setPwm,
+                      [[maybe_unused]] int64_t goal,
                       std::vector<std::tuple<tstamp, int64_t, int64_t>>& series,
                       std::vector<std::unique_ptr<Sensor>>& fanSensors)
 {
diff --git a/ipmi/manualcmds.cpp b/ipmi/manualcmds.cpp
index 0ff0c0a..1622e2e 100644
--- a/ipmi/manualcmds.cpp
+++ b/ipmi/manualcmds.cpp
@@ -104,9 +104,8 @@
  *   <arg name="value" direction="in" type="v"/>
  * </method>
  */
-ipmi_ret_t ZoneControlIpmiHandler::setManualModeState(const uint8_t* reqBuf,
-                                                      uint8_t* replyBuf,
-                                                      size_t* dataLen)
+ipmi_ret_t ZoneControlIpmiHandler::setManualModeState(
+    const uint8_t* reqBuf, [[maybe_unused]] uint8_t* replyBuf, size_t* dataLen)
 {
     if (*dataLen < sizeof(struct FanCtrlRequestSet))
     {
@@ -123,7 +122,8 @@
 }
 
 /* Three command packages: get, set true, set false */
-ipmi_ret_t manualModeControl(ZoneControlIpmiHandler* handler, ipmi_cmd_t cmd,
+ipmi_ret_t manualModeControl(ZoneControlIpmiHandler* handler,
+                             [[maybe_unused]] ipmi_cmd_t cmd,
                              const uint8_t* reqBuf, uint8_t* replyCmdBuf,
                              size_t* dataLen)
 {
diff --git a/notimpl/readonly.cpp b/notimpl/readonly.cpp
index 94d1702..30dca25 100644
--- a/notimpl/readonly.cpp
+++ b/notimpl/readonly.cpp
@@ -21,12 +21,12 @@
 namespace pid_control
 {
 
-void ReadOnly::write(double value)
+void ReadOnly::write([[maybe_unused]] double value)
 {
     throw std::runtime_error("Not supported.");
 }
 
-void ReadOnlyNoExcept::write(double value)
+void ReadOnlyNoExcept::write([[maybe_unused]] double value)
 {
     return;
 }
diff --git a/sensors/host.cpp b/sensors/host.cpp
index 9cc1eee..b0e08b1 100644
--- a/sensors/host.cpp
+++ b/sensors/host.cpp
@@ -91,7 +91,7 @@
     return r;
 }
 
-void HostSensor::write(double value)
+void HostSensor::write([[maybe_unused]] double value)
 {
     throw std::runtime_error("Not Implemented.");
 }
diff --git a/setsensor.cpp b/setsensor.cpp
index 53559f2..543700e 100644
--- a/setsensor.cpp
+++ b/setsensor.cpp
@@ -82,7 +82,7 @@
     }
 }
 
-int main(int argc, char* argv[])
+int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
 {
     int rc = 0;
 
diff --git a/test/dbus_active_unittest.cpp b/test/dbus_active_unittest.cpp
index 3f06c96..c9f663e 100644
--- a/test/dbus_active_unittest.cpp
+++ b/test/dbus_active_unittest.cpp
@@ -42,8 +42,9 @@
     std::string service = "asdfasdf.asdfasdf";
 
     EXPECT_CALL(*helper, getProperties(service, path, NotNull()))
-        .WillOnce(Invoke([&](const std::string& service,
-                             const std::string& path, SensorProperties* prop) {
+        .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";
diff --git a/test/dbus_passive_unittest.cpp b/test/dbus_passive_unittest.cpp
index 0f689e1..40e68c4 100644
--- a/test/dbus_passive_unittest.cpp
+++ b/test/dbus_passive_unittest.cpp
@@ -76,16 +76,16 @@
 
         EXPECT_CALL(*helper,
                     getProperties(StrEq("asdf"), StrEq(path), NotNull()))
-            .WillOnce(
-                Invoke([&](const std::string& service, const std::string& path,
-                           SensorProperties* prop) {
-                    prop->scale = _scale;
-                    prop->value = _value;
-                    prop->unit = "x";
-                    prop->min = 0;
-                    prop->max = 0;
-                    prop->available = true;
-                }));
+            .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;
+            }));
         EXPECT_CALL(*helper, thresholdsAsserted(StrEq("asdf"), StrEq(path)))
             .WillOnce(Return(false));
 
@@ -166,13 +166,15 @@
     // msg.read(msgSensor, msgData);
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
         }))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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).
@@ -202,7 +204,8 @@
         .WillOnce(Return(0));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'x', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
@@ -236,13 +239,15 @@
     // msg.read(msgSensor, msgData);
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
         }))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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).
@@ -272,7 +277,8 @@
         .WillOnce(Return(0));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'x', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
@@ -305,13 +311,15 @@
     passive->setFailed(false);
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
         }))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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).
@@ -347,7 +355,8 @@
         .WillOnce(Return(0));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
+                             [[maybe_unused]] char type, void* p) {
             bool* s = static_cast<bool*>(p);
             *s = alarm;
             return 0;
@@ -380,13 +389,15 @@
     passive->setFailed(true);
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
         }))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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).
@@ -422,7 +433,8 @@
         .WillOnce(Return(0));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
+                             [[maybe_unused]] char type, void* p) {
             bool* s = static_cast<bool*>(p);
             *s = alarm;
             return 0;
@@ -455,13 +467,15 @@
     passive->setAvailable(true);
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
         }))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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).
@@ -497,7 +511,8 @@
         .WillOnce(Return(0));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
+                             [[maybe_unused]] char type, void* p) {
             bool* s = static_cast<bool*>(p);
             *s = asserted;
             return 0;
@@ -532,13 +547,15 @@
     EXPECT_EQ(failed, true);
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
         }))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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).
@@ -574,7 +591,8 @@
         .WillOnce(Return(0));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
+                             [[maybe_unused]] char type, void* p) {
             bool* s = static_cast<bool*>(p);
             *s = asserted;
             return 0;
@@ -604,16 +622,16 @@
 
         EXPECT_CALL(*helper,
                     getProperties(StrEq("asdf"), StrEq(path), NotNull()))
-            .WillOnce(
-                Invoke([&](const std::string& service, const std::string& path,
-                           SensorProperties* prop) {
-                    prop->scale = _scale;
-                    prop->value = _value;
-                    prop->unit = "x";
-                    prop->min = 0;
-                    prop->max = 0;
-                    prop->available = true;
-                }));
+            .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;
+            }));
         EXPECT_CALL(*helper, thresholdsAsserted(StrEq("asdf"), StrEq(path)))
             .WillOnce(Return(false));
 
@@ -654,13 +672,15 @@
     passive->setAvailable(true);
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
         }))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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).
@@ -696,7 +716,8 @@
         .WillOnce(Return(0));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
+                             [[maybe_unused]] char type, void* p) {
             bool* s = static_cast<bool*>(p);
             *s = asserted;
             return 0;
@@ -733,13 +754,15 @@
     EXPECT_EQ(failed, false);
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 's', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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;
         }))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .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).
@@ -775,7 +798,8 @@
         .WillOnce(Return(0));
 
     EXPECT_CALL(sdbus_mock, sd_bus_message_read_basic(IsNull(), 'b', NotNull()))
-        .WillOnce(Invoke([&](sd_bus_message* m, char type, void* p) {
+        .WillOnce(Invoke([&]([[maybe_unused]] sd_bus_message* m,
+                             [[maybe_unused]] char type, void* p) {
             bool* s = static_cast<bool*>(p);
             *s = asserted;
             return 0;
@@ -792,7 +816,8 @@
     EXPECT_EQ(failed, false);
 }
 
-void GetPropertiesMax3k(const std::string& service, const std::string& path,
+void GetPropertiesMax3k([[maybe_unused]] const std::string& service,
+                        [[maybe_unused]] const std::string& path,
                         SensorProperties* prop)
 {
     prop->scale = -3;
diff --git a/test/dbus_util_unittest.cpp b/test/dbus_util_unittest.cpp
index 2f20fd6..4896e03 100644
--- a/test/dbus_util_unittest.cpp
+++ b/test/dbus_util_unittest.cpp
@@ -32,7 +32,7 @@
                 StrEq(std::get<2>(params)));
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
     GetSensorPathTests, GetSensorPathTest,
     ::testing::Values(
         std::make_tuple("fan", "0", "/xyz/openbmc_project/sensors/fan_tach/0"),
diff --git a/test/helpers.hpp b/test/helpers.hpp
index 1f41523..8f81bc6 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -61,12 +61,13 @@
                     sd_bus_emit_properties_changed_strv(IsNull(), StrEq(path),
                                                         StrEq(intf), NotNull()))
             .Times(properties.size())
-            .WillRepeatedly(
-                Invoke([=](sd_bus* bus, const char* path, const char* interface,
-                           const char** names) {
-                    EXPECT_STREQ(properties[(*index)++].c_str(), names[0]);
-                    return 0;
-                }));
+            .WillRepeatedly(Invoke([=]([[maybe_unused]] sd_bus* bus,
+                                       [[maybe_unused]] const char* path,
+                                       [[maybe_unused]] const char* interface,
+                                       const char** names) {
+                EXPECT_STREQ(properties[(*index)++].c_str(), names[0]);
+                return 0;
+            }));
     }
 
     return;
diff --git a/test/pid_json_unittest.cpp b/test/pid_json_unittest.cpp
index 827d207..f243212 100644
--- a/test/pid_json_unittest.cpp
+++ b/test/pid_json_unittest.cpp
@@ -65,8 +65,8 @@
     )"_json;
 
     std::tie(pidConfig, zoneConfig) = buildPIDsFromJson(j2);
-    EXPECT_EQ(pidConfig.size(), 1);
-    EXPECT_EQ(zoneConfig.size(), 1);
+    EXPECT_EQ(pidConfig.size(), static_cast<u_int64_t>(1));
+    EXPECT_EQ(zoneConfig.size(), static_cast<u_int64_t>(1));
 
     EXPECT_EQ(pidConfig[1]["fan1-5"].type, "fan");
     EXPECT_DOUBLE_EQ(zoneConfig[1].minThermalOutput, 3000.0);
@@ -112,8 +112,8 @@
     )"_json;
 
     std::tie(pidConfig, zoneConfig) = buildPIDsFromJson(j2);
-    EXPECT_EQ(pidConfig.size(), 1);
-    EXPECT_EQ(zoneConfig.size(), 1);
+    EXPECT_EQ(pidConfig.size(), static_cast<u_int64_t>(1));
+    EXPECT_EQ(zoneConfig.size(), static_cast<u_int64_t>(1));
 
     EXPECT_EQ(pidConfig[1]["fan1-5"].type, "fan");
     EXPECT_DOUBLE_EQ(pidConfig[1]["fan1-5"].pidInfo.positiveHysteresis, 1000.0);
@@ -196,8 +196,8 @@
     )"_json;
 
     std::tie(pidConfig, zoneConfig) = buildPIDsFromJson(j2);
-    EXPECT_EQ(pidConfig.size(), 1);
-    EXPECT_EQ(zoneConfig.size(), 1);
+    EXPECT_EQ(pidConfig.size(), static_cast<u_int64_t>(1));
+    EXPECT_EQ(zoneConfig.size(), static_cast<u_int64_t>(1));
 
     EXPECT_EQ(pidConfig[1]["temp1"].type, "stepwise");
     EXPECT_DOUBLE_EQ(pidConfig[1]["temp1"].stepwiseInfo.positiveHysteresis,
diff --git a/test/pid_zone_unittest.cpp b/test/pid_zone_unittest.cpp
index 172c818..275dfe6 100644
--- a/test/pid_zone_unittest.cpp
+++ b/test/pid_zone_unittest.cpp
@@ -558,11 +558,12 @@
     EXPECT_CALL(sdbus_mock_mode,
                 sd_bus_emit_properties_changed_strv(
                     IsNull(), StrEq(objPath), StrEq(modeInterface), NotNull()))
-        .WillOnce(Invoke([&](sd_bus* bus, const char* path,
-                             const char* interface, const char** names) {
-            EXPECT_STREQ("Manual", names[0]);
-            return 0;
-        }));
+        .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;
+            }));
 
     // 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 eeccdc1..e9800cf 100644
--- a/test/sensor_host_unittest.cpp
+++ b/test/sensor_host_unittest.cpp
@@ -90,11 +90,12 @@
     EXPECT_CALL(sdbus_mock,
                 sd_bus_emit_properties_changed_strv(
                     IsNull(), StrEq(objPath), StrEq(interface), NotNull()))
-        .WillOnce(Invoke([=](sd_bus* bus, const char* path,
-                             const char* interface, const char** names) {
-            EXPECT_STREQ("Value", names[0]);
-            return 0;
-        }));
+        .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;
+            }));
 
     std::chrono::high_resolution_clock::time_point t1 =
         std::chrono::high_resolution_clock::now();
diff --git a/test/sensors_json_unittest.cpp b/test/sensors_json_unittest.cpp
index 1064d23..257b6d7 100644
--- a/test/sensors_json_unittest.cpp
+++ b/test/sensors_json_unittest.cpp
@@ -41,7 +41,7 @@
     )"_json;
 
     auto output = buildSensorsFromJson(j2);
-    EXPECT_EQ(1, output.size());
+    EXPECT_EQ(static_cast<u_int64_t>(1), output.size());
     EXPECT_EQ(output["fan1"].type, "fan");
     EXPECT_EQ(output["fan1"].readPath,
               "/xyz/openbmc_project/sensors/fan_tach/fan1");
@@ -69,7 +69,7 @@
     )"_json;
 
     auto output = buildSensorsFromJson(j2);
-    EXPECT_EQ(1, output.size());
+    EXPECT_EQ(static_cast<u_int64_t>(1), output.size());
     EXPECT_EQ(output["fan1"].type, "fan");
     EXPECT_EQ(output["fan1"].readPath,
               "/xyz/openbmc_project/sensors/fan_tach/fan1");
@@ -95,7 +95,7 @@
     )"_json;
 
     auto output = buildSensorsFromJson(j2);
-    EXPECT_EQ(1, output.size());
+    EXPECT_EQ(static_cast<u_int64_t>(1), output.size());
     EXPECT_EQ(output["CPU_DTS"].type, "temp");
     EXPECT_EQ(output["CPU_DTS"].readPath,
               "/xyz/openbmc_project/sensors/temperature/CPU_DTS");
@@ -123,7 +123,7 @@
     )"_json;
 
     auto output = buildSensorsFromJson(j2);
-    EXPECT_EQ(1, output.size());
+    EXPECT_EQ(static_cast<u_int64_t>(1), output.size());
     EXPECT_EQ(output["fan1"].type, "fan");
     EXPECT_EQ(output["fan1"].readPath,
               "/xyz/openbmc_project/sensors/fan_tach/fan1");
@@ -157,7 +157,7 @@
     )"_json;
 
     auto output = buildSensorsFromJson(j2);
-    EXPECT_EQ(2, output.size());
+    EXPECT_EQ(static_cast<u_int64_t>(2), output.size());
 }
 
 } // namespace