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