system/stack/Android.bp: Enforce -Wunused-parameter

Bug: 299772495
Test: m com.android.btservices
Flag: EXEMPT, mechanical refactor
Change-Id: I104fb6a6b0695cd9ccd71a60e4ef60902af64b20

24 files changed, 178 insertions, 162 deletions

diff --git a/system/stack/Android.bp b/system/stack/Android.bp
index 20f12e4c23..f106a3c455 100644
--- a/system/stack/Android.bp
+++ b/system/stack/Android.bp
@@ -364,9 +364,6 @@ cc_defaults {
         "bluetooth_cflags",
         "bluetooth_flatbuffer_bundler_defaults",
     ],
-    cflags: [
-        "-Wno-unused-parameter",
-    ],
     include_dirs: [
         "packages/modules/Bluetooth/system",
         "packages/modules/Bluetooth/system/gd",
@@ -957,7 +954,6 @@ cc_test {
         cfi: false,
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 // Bluetooth stack smp unit tests for target
@@ -1041,8 +1037,6 @@ cc_test {
             ],
         },
     },
-    //    header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 // Bluetooth stack advertise data parsing unit tests for target
@@ -1115,7 +1109,6 @@ cc_test {
         cfi: false,
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 cc_test {
@@ -1183,7 +1176,6 @@ cc_test {
         misc_undefined: ["bounds"],
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 cc_test {
@@ -1254,7 +1246,6 @@ cc_test {
         misc_undefined: ["bounds"],
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 cc_test {
@@ -1265,7 +1256,6 @@ cc_test {
     ],
     cflags: [
         "-DUNIT_TESTS",
-        "-Wno-unused-parameter",
     ],
     test_suites: ["general-tests"],
     host_supported: true,
@@ -1407,7 +1397,6 @@ cc_test {
         misc_undefined: ["bounds"],
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 // gatt sr hash test
@@ -1474,7 +1463,6 @@ cc_test {
         },
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 // Iso manager unit tests
@@ -1614,7 +1602,6 @@ cc_test {
         cfi: false,
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 cc_test {
@@ -1870,7 +1857,6 @@ cc_test {
         },
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 cc_test {
@@ -1943,7 +1929,6 @@ cc_test {
         },
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 cc_test {
@@ -2044,7 +2029,6 @@ cc_test {
         },
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 cc_test {
@@ -2139,7 +2123,6 @@ cc_test {
         },
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 cc_test {
@@ -2229,7 +2212,6 @@ cc_test {
         },
     },
     header_libs: ["libbluetooth_headers"],
-    cflags: ["-Wno-unused-parameter"],
 }
 
 cc_test {
diff --git a/system/stack/fuzzers/avrc_fuzzer.cc b/system/stack/fuzzers/avrc_fuzzer.cc
index 03267249fd..1592b707fd 100644
--- a/system/stack/fuzzers/avrc_fuzzer.cc
+++ b/system/stack/fuzzers/avrc_fuzzer.cc
@@ -36,6 +36,7 @@
 
 // TODO(b/369381361) Enfore -Wmissing-prototypes
 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 
 using bluetooth::Uuid;
 using namespace bluetooth;
diff --git a/system/stack/fuzzers/bnep_fuzzer.cc b/system/stack/fuzzers/bnep_fuzzer.cc
index 4ad6bffb0b..79a70556e4 100644
--- a/system/stack/fuzzers/bnep_fuzzer.cc
+++ b/system/stack/fuzzers/bnep_fuzzer.cc
@@ -33,6 +33,7 @@
 
 // TODO(b/369381361) Enfore -Wmissing-prototypes
 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 
 using bluetooth::Uuid;
 
diff --git a/system/stack/fuzzers/gatt_fuzzer.cc b/system/stack/fuzzers/gatt_fuzzer.cc
index 3aa0f8ce01..3a9fb81276 100644
--- a/system/stack/fuzzers/gatt_fuzzer.cc
+++ b/system/stack/fuzzers/gatt_fuzzer.cc
@@ -35,6 +35,7 @@
 
 // TODO(b/369381361) Enfore -Wmissing-prototypes
 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 
 using bluetooth::Uuid;
 bt_status_t do_in_main_thread(base::OnceCallback<void()>) {
diff --git a/system/stack/fuzzers/l2cap_fuzzer.cc b/system/stack/fuzzers/l2cap_fuzzer.cc
index f9fff7ff80..74b3590a45 100644
--- a/system/stack/fuzzers/l2cap_fuzzer.cc
+++ b/system/stack/fuzzers/l2cap_fuzzer.cc
@@ -73,8 +73,8 @@ bluetooth::common::PostableContext* get_main() { return nullptr; }
 
 namespace bluetooth {
 namespace os {
-uint32_t GetSystemPropertyUint32Base(const std::string& property, uint32_t default_value,
-                                     int base) {
+uint32_t GetSystemPropertyUint32Base(const std::string& /*property*/, uint32_t default_value,
+                                     int /*base*/) {
   return default_value;
 }
 }  // namespace os
@@ -100,15 +100,15 @@ namespace {
 class FakeBtStack {
 public:
   FakeBtStack() {
-    test::mock::stack_acl::acl_create_le_connection.body = [](const RawAddress& bd_addr) {
+    test::mock::stack_acl::acl_create_le_connection.body = [](const RawAddress& /*bd_addr*/) {
       return true;
     };
-    test::mock::stack_acl::acl_send_data_packet_br_edr.body = [](const RawAddress& bd_addr,
+    test::mock::stack_acl::acl_send_data_packet_br_edr.body = [](const RawAddress& /*bd_addr*/,
                                                                  BT_HDR* hdr) {
       ConsumeData((const uint8_t*)hdr, hdr->offset + hdr->len);
       osi_free(hdr);
     };
-    test::mock::stack_acl::acl_send_data_packet_ble.body = [](const RawAddress& bd_addr,
+    test::mock::stack_acl::acl_send_data_packet_ble.body = [](const RawAddress& /*bd_addr*/,
                                                               BT_HDR* hdr) {
       ConsumeData((const uint8_t*)hdr, hdr->offset + hdr->len);
       osi_free(hdr);
diff --git a/system/stack/fuzzers/rfcomm_fuzzer.cc b/system/stack/fuzzers/rfcomm_fuzzer.cc
index 238354d642..3f3afbfe40 100644
--- a/system/stack/fuzzers/rfcomm_fuzzer.cc
+++ b/system/stack/fuzzers/rfcomm_fuzzer.cc
@@ -40,6 +40,7 @@
 
 // TODO(b/369381361) Enfore -Wmissing-prototypes
 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 
 namespace bluetooth {
 namespace hal {
diff --git a/system/stack/fuzzers/sdp_fuzzer.cc b/system/stack/fuzzers/sdp_fuzzer.cc
index 8fbcb8f7d8..bd5b6f77c2 100644
--- a/system/stack/fuzzers/sdp_fuzzer.cc
+++ b/system/stack/fuzzers/sdp_fuzzer.cc
@@ -33,6 +33,7 @@
 
 // TODO(b/369381361) Enfore -Wmissing-prototypes
 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 
 namespace {
 
diff --git a/system/stack/fuzzers/smp_fuzzer.cc b/system/stack/fuzzers/smp_fuzzer.cc
index e8f3ba8d91..a99010254a 100644
--- a/system/stack/fuzzers/smp_fuzzer.cc
+++ b/system/stack/fuzzers/smp_fuzzer.cc
@@ -35,6 +35,7 @@
 
 // TODO(b/369381361) Enfore -Wmissing-prototypes
 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 
 bluetooth::common::MessageLoopThread* main_thread_ptr = nullptr;
 
diff --git a/system/stack/test/a2dp/a2dp_aac_unittest.cc b/system/stack/test/a2dp/a2dp_aac_unittest.cc
index 4ad50da241..7c35eaeb37 100644
--- a/system/stack/test/a2dp/a2dp_aac_unittest.cc
+++ b/system/stack/test/a2dp/a2dp_aac_unittest.cc
@@ -142,9 +142,9 @@ protected:
 TEST_F(A2dpAacTest, a2dp_source_read_underflow) {
   static int enqueue_cb_invoked = 0;
 
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t { return 0; };
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) -> uint32_t { return 0; };
 
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     enqueue_cb_invoked += 1;
     osi_free(p_buf);
     return false;
@@ -161,9 +161,9 @@ TEST_F(A2dpAacTest, a2dp_source_read_underflow) {
 TEST_F(A2dpAacTest, a2dp_enqueue_cb_is_invoked) {
   static int enqueue_cb_invoked = 0;
 
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t { return len; };
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t len) -> uint32_t { return len; };
 
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     enqueue_cb_invoked += 1;
     osi_free(p_buf);
     return false;
@@ -178,7 +178,7 @@ TEST_F(A2dpAacTest, a2dp_enqueue_cb_is_invoked) {
 }
 
 TEST_F(A2dpAacTest, decoded_data_cb_not_invoked_when_empty_packet) {
-  auto data_cb = +[](uint8_t* p_buf, uint32_t len) { FAIL(); };
+  auto data_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) { FAIL(); };
   InitializeDecoder(data_cb);
   std::vector<uint8_t> data;
   BT_HDR* packet = AllocateL2capPacket(data);
@@ -190,7 +190,7 @@ TEST_F(A2dpAacTest, decoded_data_cb_invoked) {
   static int data_cb_invoked = 0;
   static int enqueue_cb_invoked = 0;
 
-  auto data_cb = +[](uint8_t* p_buf, uint32_t len) { data_cb_invoked += 1; };
+  auto data_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) { data_cb_invoked += 1; };
 
   InitializeDecoder(data_cb);
 
@@ -201,7 +201,7 @@ TEST_F(A2dpAacTest, decoded_data_cb_invoked) {
     return len;
   };
 
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     enqueue_cb_invoked += 1;
     packet = p_buf;
     return false;
@@ -234,11 +234,11 @@ TEST_F(A2dpAacTest, sink_supports_aac) {
 }
 
 TEST_F(A2dpAacTest, effective_mtu_when_peer_supports_3mbps) {
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t len) -> uint32_t {
     log::assert_that(kAacReadSize == len, "assert failed: kAacReadSize == len");
     return len;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     osi_free(p_buf);
     return false;
   };
@@ -247,11 +247,11 @@ TEST_F(A2dpAacTest, effective_mtu_when_peer_supports_3mbps) {
 }
 
 TEST_F(A2dpAacTest, effective_mtu_when_peer_does_not_support_3mbps) {
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t len) -> uint32_t {
     log::assert_that(kAacReadSize == len, "assert failed: kAacReadSize == len");
     return len;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     osi_free(p_buf);
     return false;
   };
diff --git a/system/stack/test/a2dp/a2dp_opus_unittest.cc b/system/stack/test/a2dp/a2dp_opus_unittest.cc
index b0d79f3ecc..eb517fd9a8 100644
--- a/system/stack/test/a2dp/a2dp_opus_unittest.cc
+++ b/system/stack/test/a2dp/a2dp_opus_unittest.cc
@@ -133,11 +133,11 @@ protected:
 
 TEST_F(A2dpOpusTest, a2dp_source_read_underflow) {
   promise = {};
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) -> uint32_t {
     // underflow
     return 0;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     promise.set_value();
     osi_free(p_buf);
     return false;
@@ -154,11 +154,11 @@ TEST_F(A2dpOpusTest, a2dp_source_read_underflow) {
 
 TEST_F(A2dpOpusTest, a2dp_enqueue_cb_is_invoked) {
   promise = {};
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t len) -> uint32_t {
     log::assert_that(GetReadSize() == len, "assert failed: GetReadSize() == len");
     return len;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     static bool first_invocation = true;
     if (first_invocation) {
       promise.set_value();
@@ -177,7 +177,7 @@ TEST_F(A2dpOpusTest, a2dp_enqueue_cb_is_invoked) {
 }
 
 TEST_F(A2dpOpusTest, decoded_data_cb_not_invoked_when_empty_packet) {
-  auto data_cb = +[](uint8_t* p_buf, uint32_t len) { FAIL(); };
+  auto data_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) { FAIL(); };
   InitializeDecoder(data_cb);
   std::vector<uint8_t> data;
   BT_HDR* packet = AllocateL2capPacket(data);
@@ -187,7 +187,7 @@ TEST_F(A2dpOpusTest, decoded_data_cb_not_invoked_when_empty_packet) {
 
 TEST_F(A2dpOpusTest, decoded_data_cb_invoked) {
   promise = {};
-  auto data_cb = +[](uint8_t* p_buf, uint32_t len) {};
+  auto data_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) {};
   InitializeDecoder(data_cb);
 
   auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
@@ -196,7 +196,7 @@ TEST_F(A2dpOpusTest, decoded_data_cb_invoked) {
     counter += len;
     return len;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t /*len*/) -> bool {
     static bool first_invocation = true;
     if (first_invocation) {
       packet = reinterpret_cast<BT_HDR*>(osi_malloc(sizeof(*p_buf) + p_buf->len + 1));
diff --git a/system/stack/test/a2dp/a2dp_sbc_unittest.cc b/system/stack/test/a2dp/a2dp_sbc_unittest.cc
index 89e76bd7a3..950a6100dd 100644
--- a/system/stack/test/a2dp/a2dp_sbc_unittest.cc
+++ b/system/stack/test/a2dp/a2dp_sbc_unittest.cc
@@ -141,11 +141,11 @@ protected:
 
 TEST_F(A2dpSbcTest, a2dp_source_read_underflow) {
   promise = {};
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) -> uint32_t {
     // underflow
     return 0;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     promise.set_value();
     osi_free(p_buf);
     return false;
@@ -162,11 +162,11 @@ TEST_F(A2dpSbcTest, a2dp_source_read_underflow) {
 
 TEST_F(A2dpSbcTest, a2dp_enqueue_cb_is_invoked) {
   promise = {};
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t len) -> uint32_t {
     log::assert_that(kSbcReadSize == len, "assert failed: kSbcReadSize == len");
     return len;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     static bool first_invocation = true;
     if (first_invocation) {
       promise.set_value();
@@ -185,7 +185,7 @@ TEST_F(A2dpSbcTest, a2dp_enqueue_cb_is_invoked) {
 }
 
 TEST_F(A2dpSbcTest, decoded_data_cb_not_invoked_when_empty_packet) {
-  auto data_cb = +[](uint8_t* p_buf, uint32_t len) { FAIL(); };
+  auto data_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) { FAIL(); };
   InitializeDecoder(data_cb);
   std::vector<uint8_t> data;
   BT_HDR* packet = AllocateL2capPacket(data);
@@ -195,7 +195,7 @@ TEST_F(A2dpSbcTest, decoded_data_cb_not_invoked_when_empty_packet) {
 
 TEST_F(A2dpSbcTest, decoded_data_cb_invoked) {
   promise = {};
-  auto data_cb = +[](uint8_t* p_buf, uint32_t len) {};
+  auto data_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) {};
   InitializeDecoder(data_cb);
 
   auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
@@ -204,7 +204,7 @@ TEST_F(A2dpSbcTest, decoded_data_cb_invoked) {
     counter += len;
     return len;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t /*len*/) -> bool {
     static bool first_invocation = true;
     if (first_invocation) {
       packet = reinterpret_cast<BT_HDR*>(osi_malloc(sizeof(*p_buf) + p_buf->len + 1));
@@ -244,11 +244,11 @@ TEST_F(A2dpSbcTest, sink_supports_sbc) {
 }
 
 TEST_F(A2dpSbcTest, effective_mtu_when_peer_supports_3mbps) {
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t len) -> uint32_t {
     log::assert_that(kSbcReadSize == len, "assert failed: kSbcReadSize == len");
     return len;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     osi_free(p_buf);
     return false;
   };
@@ -257,11 +257,11 @@ TEST_F(A2dpSbcTest, effective_mtu_when_peer_supports_3mbps) {
 }
 
 TEST_F(A2dpSbcTest, effective_mtu_when_peer_does_not_support_3mbps) {
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t len) -> uint32_t {
     log::assert_that(kSbcReadSize == len, "assert failed: kSbcReadSize == len");
     return len;
   };
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* p_buf, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     osi_free(p_buf);
     return false;
   };
diff --git a/system/stack/test/a2dp/a2dp_vendor_ldac_unittest.cc b/system/stack/test/a2dp/a2dp_vendor_ldac_unittest.cc
index 90b00507f1..d446d808ac 100644
--- a/system/stack/test/a2dp/a2dp_vendor_ldac_unittest.cc
+++ b/system/stack/test/a2dp/a2dp_vendor_ldac_unittest.cc
@@ -124,9 +124,9 @@ protected:
 TEST_F(A2dpLdacTest, a2dp_source_read_underflow) {
   static int enqueue_cb_invoked = 0;
 
-  auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t { return 0; };
+  auto read_cb = +[](uint8_t* /*p_buf*/, uint32_t /*len*/) -> uint32_t { return 0; };
 
-  auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
+  auto enqueue_cb = +[](BT_HDR* /*p_buf*/, size_t /*frames_n*/, uint32_t /*len*/) -> bool {
     enqueue_cb_invoked += 1;
     return false;
   };
diff --git a/system/stack/test/a2dp/misc_fake.cc b/system/stack/test/a2dp/misc_fake.cc
index 4c583807f0..ee82394629 100644
--- a/system/stack/test/a2dp/misc_fake.cc
+++ b/system/stack/test/a2dp/misc_fake.cc
@@ -16,6 +16,6 @@
 
 #include "stack/include/a2dp_vendor_ldac.h"
 
-int A2DP_VendorGetTrackSampleRateLdac(const uint8_t* p_codec_info) { return 0; }
-int A2DP_VendorGetTrackBitsPerSampleLdac(const uint8_t* p_codec_info) { return 0; }
-int A2DP_VendorGetChannelModeCodeLdac(const uint8_t* p_codec_info) { return 0; }
+int A2DP_VendorGetTrackSampleRateLdac(const uint8_t* /*p_codec_info*/) { return 0; }
+int A2DP_VendorGetTrackBitsPerSampleLdac(const uint8_t* /*p_codec_info*/) { return 0; }
+int A2DP_VendorGetChannelModeCodeLdac(const uint8_t* /*p_codec_info*/) { return 0; }
diff --git a/system/stack/test/common/mock_btm_layer.cc b/system/stack/test/common/mock_btm_layer.cc
index acfb6357a6..129b58ce18 100644
--- a/system/stack/test/common/mock_btm_layer.cc
+++ b/system/stack/test/common/mock_btm_layer.cc
@@ -33,9 +33,11 @@ void bluetooth::manager::SetMockSecurityInternalInterface(
   btm_security_internal_interface = mock_btm_security_internal_interface;
 }
 
-uint16_t BTM_GetMaxPacketSize(const RawAddress& addr) { return RFCOMM_DEFAULT_MTU; }
+uint16_t BTM_GetMaxPacketSize(const RawAddress& /*addr*/) { return RFCOMM_DEFAULT_MTU; }
 
-bool BTM_IsAclConnectionUp(const RawAddress& remote_bda, tBT_TRANSPORT transport) { return true; }
+bool BTM_IsAclConnectionUp(const RawAddress& /*remote_bda*/, tBT_TRANSPORT /*transport*/) {
+  return true;
+}
 
 struct btm_client_interface_t btm_client_interface = {
         .peer =
diff --git a/system/stack/test/common/mock_l2cap_layer.cc b/system/stack/test/common/mock_l2cap_layer.cc
index c2c6ab18a0..b61b80c567 100644
--- a/system/stack/test/common/mock_l2cap_layer.cc
+++ b/system/stack/test/common/mock_l2cap_layer.cc
@@ -32,11 +32,11 @@ void bluetooth::l2cap::SetMockInterface(MockL2capInterface* mock_l2cap_interface
   l2cap_interface = mock_l2cap_interface;
 }
 
-tL2C_CCB* l2cu_find_ccb_by_cid(tL2C_LCB* p_lcb, uint16_t local_cid) { return nullptr; }
+tL2C_CCB* l2cu_find_ccb_by_cid(tL2C_LCB* /*p_lcb*/, uint16_t /*local_cid*/) { return nullptr; }
 
 uint16_t L2CA_Register(uint16_t psm, const tL2CAP_APPL_INFO& p_cb_info, bool enable_snoop,
-                       tL2CAP_ERTM_INFO* p_ertm_info, uint16_t my_mtu, uint16_t required_remote_mtu,
-                       uint16_t sec_level) {
+                       tL2CAP_ERTM_INFO* p_ertm_info, uint16_t /*my_mtu*/,
+                       uint16_t /*required_remote_mtu*/, uint16_t /*sec_level*/) {
   bluetooth::log::verbose("psm={}, enable_snoop={}", psm, enable_snoop);
   return l2cap_interface->Register(psm, p_cb_info, enable_snoop, p_ertm_info);
 }
@@ -62,7 +62,7 @@ tL2CAP_DW_RESULT L2CA_DataWrite(uint16_t cid, BT_HDR* p_data) {
 }
 
 uint16_t L2CA_RegisterLECoc(uint16_t psm, const tL2CAP_APPL_INFO& cb_info, uint16_t sec_level,
-                            tL2CAP_LE_CFG_INFO cfg) {
+                            tL2CAP_LE_CFG_INFO /*cfg*/) {
   return l2cap_interface->RegisterLECoc(psm, cb_info, sec_level);
 }
 
diff --git a/system/stack/test/common/mock_stack_avdt_msg.cc b/system/stack/test/common/mock_stack_avdt_msg.cc
index 76ff6ac8c4..22a5afce90 100644
--- a/system/stack/test/common/mock_stack_avdt_msg.cc
+++ b/system/stack/test/common/mock_stack_avdt_msg.cc
@@ -30,7 +30,7 @@
 
 static std::vector<uint8_t> _rsp_sig_ids{};
 
-void avdt_msg_send_rsp(AvdtpCcb* p_ccb, uint8_t sig_id, tAVDT_MSG* p_params) {
+void avdt_msg_send_rsp(AvdtpCcb* /*p_ccb*/, uint8_t sig_id, tAVDT_MSG* /*p_params*/) {
   inc_func_call_count(__func__);
   _rsp_sig_ids.push_back(sig_id);
 }
@@ -41,15 +41,16 @@ void mock_avdt_msg_send_rsp_clear_history(void) { _rsp_sig_ids.clear(); }
 
 uint8_t mock_avdt_msg_send_rsp_get_sig_id_at(size_t nth) { return _rsp_sig_ids[nth]; }
 
-void avdt_msg_ind(AvdtpCcb* p_ccb, BT_HDR* p_buf) { inc_func_call_count(__func__); }
+void avdt_msg_ind(AvdtpCcb* /*p_ccb*/, BT_HDR* /*p_buf*/) { inc_func_call_count(__func__); }
 
-void avdt_msg_send_rej(AvdtpCcb* p_ccb, uint8_t sig_id, tAVDT_MSG* p_params) {
+void avdt_msg_send_rej(AvdtpCcb* /*p_ccb*/, uint8_t /*sig_id*/, tAVDT_MSG* /*p_params*/) {
   inc_func_call_count(__func__);
 }
 
 static std::vector<uint8_t> _cmd_sig_ids{};
 
-void avdt_msg_send_cmd(AvdtpCcb* p_ccb, void* p_scb, uint8_t sig_id, tAVDT_MSG* p_params) {
+void avdt_msg_send_cmd(AvdtpCcb* /*p_ccb*/, void* /*p_scb*/, uint8_t sig_id,
+                       tAVDT_MSG* /*p_params*/) {
   inc_func_call_count(__func__);
   _cmd_sig_ids.push_back(sig_id);
 }
@@ -60,7 +61,7 @@ void mock_avdt_msg_send_cmd_clear_history(void) { _cmd_sig_ids.clear(); }
 
 uint8_t mock_avdt_msg_send_cmd_get_sig_id_at(size_t nth) { return _cmd_sig_ids[nth]; }
 
-bool avdt_msg_send(AvdtpCcb* p_ccb, BT_HDR* p_msg) {
+bool avdt_msg_send(AvdtpCcb* /*p_ccb*/, BT_HDR* /*p_msg*/) {
   inc_func_call_count(__func__);
   return true;
 }
diff --git a/system/stack/test/eatt/eatt_test.cc b/system/stack/test/eatt/eatt_test.cc
index 0965fc5987..437a2f13ef 100644
--- a/system/stack/test/eatt/eatt_test.cc
+++ b/system/stack/test/eatt/eatt_test.cc
@@ -59,10 +59,10 @@ extern struct fake_osi_alarm_set_on_mloop fake_osi_alarm_set_on_mloop_;
 
 /* Needed for testing context */
 static tGATT_TCB test_tcb;
-void btif_storage_add_eatt_supported(const RawAddress& addr) { return; }
-void gatt_consolidate(const RawAddress& identity_addr, const RawAddress& rpa) {}
-void gatt_data_process(tGATT_TCB& tcb, uint16_t cid, BT_HDR* p_buf) { return; }
-tGATT_TCB* gatt_find_tcb_by_addr(const RawAddress& bda, tBT_TRANSPORT transport) {
+void btif_storage_add_eatt_supported(const RawAddress& /*addr*/) { return; }
+void gatt_consolidate(const RawAddress& /*identity_addr*/, const RawAddress& /*rpa*/) {}
+void gatt_data_process(tGATT_TCB& /*tcb*/, uint16_t /*cid*/, BT_HDR* /*p_buf*/) { return; }
+tGATT_TCB* gatt_find_tcb_by_addr(const RawAddress& /*bda*/, tBT_TRANSPORT /*transport*/) {
   log::info("");
   return &test_tcb;
 }
@@ -80,7 +80,7 @@ protected:
               std::move(cb).Run(addr, BLE_GATT_SVR_SUP_FEAT_EATT_BITMASK);
               return true;
             });
-    EXPECT_CALL(gatt_interface_, GetEattSupport).WillRepeatedly([](const RawAddress& addr) {
+    EXPECT_CALL(gatt_interface_, GetEattSupport).WillRepeatedly([](const RawAddress& /*addr*/) {
       return true;
     });
 
@@ -137,14 +137,14 @@ protected:
 
     ON_CALL(gatt_interface_, ClientReadSupportedFeatures)
             .WillByDefault(
-                    [&eatt_supp_feat_cb](const RawAddress& addr,
+                    [&eatt_supp_feat_cb](const RawAddress& /*addr*/,
                                          base::OnceCallback<void(const RawAddress&, uint8_t)> cb) {
                       eatt_supp_feat_cb = std::move(cb);
                       return true;
                     });
 
     // Return false to trigger supported features request
-    ON_CALL(gatt_interface_, GetEattSupport).WillByDefault([](const RawAddress& addr) {
+    ON_CALL(gatt_interface_, GetEattSupport).WillByDefault([](const RawAddress& /*addr*/) {
       return false;
     });
 
@@ -297,7 +297,8 @@ TEST_F(EattTest, IncomingEattConnectionByUnknownDevice) {
   std::vector<uint16_t> incoming_cids{71, 72, 73, 74, 75};
 
   ON_CALL(btm_api_interface_, IsEncrypted)
-          .WillByDefault([](const RawAddress& addr, tBT_TRANSPORT transport) { return true; });
+          .WillByDefault(
+                  [](const RawAddress& /*addr*/, tBT_TRANSPORT /*transport*/) { return true; });
   EXPECT_CALL(mock_stack_l2cap_interface_,
               L2CA_ConnectCreditBasedRsp(test_address, 1, incoming_cids,
                                          tL2CAP_LE_RESULT_CODE::L2CAP_LE_RESULT_CONN_OK, _))
@@ -312,14 +313,15 @@ TEST_F(EattTest, IncomingEattConnectionByUnknownDevice) {
 TEST_F(EattTest, IncomingEattConnectionByKnownDevice) {
   hci_role_ = HCI_ROLE_PERIPHERAL;
   ON_CALL(btm_api_interface_, IsEncrypted)
-          .WillByDefault([](const RawAddress& addr, tBT_TRANSPORT transport) { return true; });
+          .WillByDefault(
+                  [](const RawAddress& /*addr*/, tBT_TRANSPORT /*transport*/) { return true; });
   ON_CALL(gatt_interface_, ClientReadSupportedFeatures)
           .WillByDefault([](const RawAddress& addr,
                             base::OnceCallback<void(const RawAddress&, uint8_t)> cb) {
             std::move(cb).Run(addr, BLE_GATT_SVR_SUP_FEAT_EATT_BITMASK);
             return true;
           });
-  ON_CALL(gatt_interface_, GetEattSupport).WillByDefault([](const RawAddress& addr) {
+  ON_CALL(gatt_interface_, GetEattSupport).WillByDefault([](const RawAddress& /*addr*/) {
     return true;
   });
 
@@ -342,16 +344,18 @@ TEST_F(EattTest, IncomingEattConnectionByKnownDevice) {
 TEST_F(EattTest, IncomingEattConnectionByKnownDeviceEncryptionOff) {
   hci_role_ = HCI_ROLE_PERIPHERAL;
   ON_CALL(btm_api_interface_, IsEncrypted)
-          .WillByDefault([](const RawAddress& addr, tBT_TRANSPORT transport) { return false; });
+          .WillByDefault(
+                  [](const RawAddress& /*addr*/, tBT_TRANSPORT /*transport*/) { return false; });
   ON_CALL(btm_api_interface_, IsLinkKeyKnown)
-          .WillByDefault([](const RawAddress& addr, tBT_TRANSPORT transport) { return true; });
+          .WillByDefault(
+                  [](const RawAddress& /*addr*/, tBT_TRANSPORT /*transport*/) { return true; });
   ON_CALL(gatt_interface_, ClientReadSupportedFeatures)
           .WillByDefault([](const RawAddress& addr,
                             base::OnceCallback<void(const RawAddress&, uint8_t)> cb) {
             std::move(cb).Run(addr, BLE_GATT_SVR_SUP_FEAT_EATT_BITMASK);
             return true;
           });
-  ON_CALL(gatt_interface_, GetEattSupport).WillByDefault([](const RawAddress& addr) {
+  ON_CALL(gatt_interface_, GetEattSupport).WillByDefault([](const RawAddress& /*addr*/) {
     return true;
   });
 
@@ -374,9 +378,11 @@ TEST_F(EattTest, IncomingEattConnectionByUnknownDeviceEncryptionOff) {
   std::vector<uint16_t> incoming_cids{71, 72, 73, 74, 75};
 
   ON_CALL(btm_api_interface_, IsEncrypted)
-          .WillByDefault([](const RawAddress& addr, tBT_TRANSPORT transport) { return false; });
+          .WillByDefault(
+                  [](const RawAddress& /*addr*/, tBT_TRANSPORT /*transport*/) { return false; });
   ON_CALL(btm_api_interface_, IsLinkKeyKnown)
-          .WillByDefault([](const RawAddress& addr, tBT_TRANSPORT transport) { return false; });
+          .WillByDefault(
+                  [](const RawAddress& /*addr*/, tBT_TRANSPORT /*transport*/) { return false; });
   EXPECT_CALL(mock_stack_l2cap_interface_,
               L2CA_ConnectCreditBasedRsp(
                       test_address, 1, _,
@@ -393,7 +399,8 @@ TEST_F(EattTest, ReconnectInitiatedByRemoteSucceed) {
   std::vector<uint16_t> incoming_cids{71, 72, 73, 74, 75};
 
   ON_CALL(btm_api_interface_, IsEncrypted)
-          .WillByDefault([](const RawAddress& addr, tBT_TRANSPORT transport) { return true; });
+          .WillByDefault(
+                  [](const RawAddress& /*addr*/, tBT_TRANSPORT /*transport*/) { return true; });
 
   EXPECT_CALL(mock_stack_l2cap_interface_,
               L2CA_ConnectCreditBasedRsp(test_address, 1, incoming_cids,
@@ -408,7 +415,8 @@ TEST_F(EattTest, ReconnectInitiatedByRemoteSucceed) {
 
 TEST_F(EattTest, ConnectInitiatedWhenRemoteConnects) {
   ON_CALL(btm_api_interface_, IsEncrypted)
-          .WillByDefault([](const RawAddress& addr, tBT_TRANSPORT transport) { return true; });
+          .WillByDefault(
+                  [](const RawAddress& /*addr*/, tBT_TRANSPORT /*transport*/) { return true; });
 
   std::vector<uint16_t> incoming_cids{71, 72, 73, 74};
   ConnectDeviceBothSides(1, incoming_cids);
@@ -432,7 +440,7 @@ TEST_F(EattTest, ConnectFailedEattNotSupported) {
             std::move(cb).Run(addr, 0);
             return true;
           });
-  ON_CALL(gatt_interface_, GetEattSupport).WillByDefault([](const RawAddress& addr) {
+  ON_CALL(gatt_interface_, GetEattSupport).WillByDefault([](const RawAddress& /*addr*/) {
     return false;
   });
 
diff --git a/system/stack/test/gatt/gatt_sr_test.cc b/system/stack/test/gatt/gatt_sr_test.cc
index 72707e1900..7992f876ea 100644
--- a/system/stack/test/gatt/gatt_sr_test.cc
+++ b/system/stack/test/gatt/gatt_sr_test.cc
@@ -53,67 +53,77 @@ TestMutables test_state_;
 }  // namespace
 
 namespace connection_manager {
-bool background_connect_remove(uint8_t app_id, const RawAddress& address) { return false; }
-bool direct_connect_remove(uint8_t app_id, const RawAddress& address, bool connection_timeout) {
+bool background_connect_remove(uint8_t /*app_id*/, const RawAddress& /*address*/) { return false; }
+bool direct_connect_remove(uint8_t /*app_id*/, const RawAddress& /*address*/,
+                           bool /*connection_timeout*/) {
   return false;
 }
-bool is_background_connection(const RawAddress& address) { return false; }
+bool is_background_connection(const RawAddress& /*address*/) { return false; }
 
 }  // namespace connection_manager
 
-BT_HDR* attp_build_sr_msg(tGATT_TCB& tcb, uint8_t op_code, tGATT_SR_MSG* p_msg,
-                          uint16_t payload_size) {
+BT_HDR* attp_build_sr_msg(tGATT_TCB& /*tcb*/, uint8_t op_code, tGATT_SR_MSG* /*p_msg*/,
+                          uint16_t /*payload_size*/) {
   test_state_.attp_build_sr_msg.op_code_ = op_code;
   return nullptr;
 }
-tGATT_STATUS attp_send_cl_confirmation_msg(tGATT_TCB& tcb, uint16_t cid) { return GATT_SUCCESS; }
-tGATT_STATUS attp_send_cl_msg(tGATT_TCB& tcb, tGATT_CLCB* p_clcb, uint8_t op_code,
-                              tGATT_CL_MSG* p_msg) {
+tGATT_STATUS attp_send_cl_confirmation_msg(tGATT_TCB& /*tcb*/, uint16_t /*cid*/) {
   return GATT_SUCCESS;
 }
-tGATT_STATUS attp_send_sr_msg(tGATT_TCB& tcb, uint16_t cid, BT_HDR* p_msg) { return GATT_SUCCESS; }
-
-void gatt_act_discovery(tGATT_CLCB* p_clcb) {}
-bool gatt_disconnect(tGATT_TCB* p_tcb) { return false; }
-void gatt_cancel_connect(const RawAddress& bd_addr, tBT_TRANSPORT transport) {}
-tGATT_CH_STATE gatt_get_ch_state(tGATT_TCB* p_tcb) { return GATT_CH_CLOSE; }
-tGATT_STATUS gatts_db_read_attr_value_by_type(tGATT_TCB& tcb, uint16_t cid, tGATT_SVC_DB* p_db,
-                                              uint8_t op_code, BT_HDR* p_rsp, uint16_t s_handle,
-                                              uint16_t e_handle, const Uuid& type, uint16_t* p_len,
-                                              tGATT_SEC_FLAG sec_flag, uint8_t key_size,
-                                              uint32_t trans_id, uint16_t* p_cur_handle) {
+tGATT_STATUS attp_send_cl_msg(tGATT_TCB& /*tcb*/, tGATT_CLCB* /*p_clcb*/, uint8_t /*op_code*/,
+                              tGATT_CL_MSG* /*p_msg*/) {
   return GATT_SUCCESS;
 }
-void gatt_set_ch_state(tGATT_TCB* p_tcb, tGATT_CH_STATE ch_state) {}
-Uuid* gatts_get_service_uuid(tGATT_SVC_DB* p_db) { return nullptr; }
-tGATT_STATUS GATTS_HandleValueIndication(uint16_t conn_id, uint16_t attr_handle, uint16_t val_len,
-                                         uint8_t* p_val) {
+tGATT_STATUS attp_send_sr_msg(tGATT_TCB& /*tcb*/, uint16_t /*cid*/, BT_HDR* /*p_msg*/) {
   return GATT_SUCCESS;
 }
-tGATT_STATUS gatts_read_attr_perm_check(tGATT_SVC_DB* p_db, bool is_long, uint16_t handle,
-                                        tGATT_SEC_FLAG sec_flag, uint8_t key_size) {
+
+void gatt_act_discovery(tGATT_CLCB* /*p_clcb*/) {}
+bool gatt_disconnect(tGATT_TCB* /*p_tcb*/) { return false; }
+void gatt_cancel_connect(const RawAddress& /*bd_addr*/, tBT_TRANSPORT /*transport*/) {}
+tGATT_CH_STATE gatt_get_ch_state(tGATT_TCB* /*p_tcb*/) { return GATT_CH_CLOSE; }
+tGATT_STATUS gatts_db_read_attr_value_by_type(tGATT_TCB& /*tcb*/, uint16_t /*cid*/,
+                                              tGATT_SVC_DB* /*p_db*/, uint8_t /*op_code*/,
+                                              BT_HDR* /*p_rsp*/, uint16_t /*s_handle*/,
+                                              uint16_t /*e_handle*/, const Uuid& /*type*/,
+                                              uint16_t* /*p_len*/, tGATT_SEC_FLAG /*sec_flag*/,
+                                              uint8_t /*key_size*/, uint32_t /*trans_id*/,
+                                              uint16_t* /*p_cur_handle*/) {
+  return GATT_SUCCESS;
+}
+void gatt_set_ch_state(tGATT_TCB* /*p_tcb*/, tGATT_CH_STATE /*ch_state*/) {}
+Uuid* gatts_get_service_uuid(tGATT_SVC_DB* /*p_db*/) { return nullptr; }
+tGATT_STATUS GATTS_HandleValueIndication(uint16_t /*conn_id*/, uint16_t /*attr_handle*/,
+                                         uint16_t /*val_len*/, uint8_t* /*p_val*/) {
+  return GATT_SUCCESS;
+}
+tGATT_STATUS gatts_read_attr_perm_check(tGATT_SVC_DB* /*p_db*/, bool /*is_long*/,
+                                        uint16_t /*handle*/, tGATT_SEC_FLAG /*sec_flag*/,
+                                        uint8_t /*key_size*/) {
   return GATT_SUCCESS;
 }
-tGATT_STATUS gatts_read_attr_value_by_handle(tGATT_TCB& tcb, uint16_t cid, tGATT_SVC_DB* p_db,
-                                             uint8_t op_code, uint16_t handle, uint16_t offset,
-                                             uint8_t* p_value, uint16_t* p_len, uint16_t mtu,
-                                             tGATT_SEC_FLAG sec_flag, uint8_t key_size,
-                                             uint32_t trans_id) {
+tGATT_STATUS gatts_read_attr_value_by_handle(tGATT_TCB& /*tcb*/, uint16_t /*cid*/,
+                                             tGATT_SVC_DB* /*p_db*/, uint8_t /*op_code*/,
+                                             uint16_t /*handle*/, uint16_t /*offset*/,
+                                             uint8_t* /*p_value*/, uint16_t* /*p_len*/,
+                                             uint16_t /*mtu*/, tGATT_SEC_FLAG /*sec_flag*/,
+                                             uint8_t /*key_size*/, uint32_t /*trans_id*/) {
   return GATT_SUCCESS;
 }
-tGATT_STATUS gatts_write_attr_perm_check(tGATT_SVC_DB* p_db, uint8_t op_code, uint16_t handle,
-                                         uint16_t offset, uint8_t* p_data, uint16_t len,
-                                         tGATT_SEC_FLAG sec_flag, uint8_t key_size) {
+tGATT_STATUS gatts_write_attr_perm_check(tGATT_SVC_DB* /*p_db*/, uint8_t /*op_code*/,
+                                         uint16_t /*handle*/, uint16_t /*offset*/,
+                                         uint8_t* /*p_data*/, uint16_t /*len*/,
+                                         tGATT_SEC_FLAG /*sec_flag*/, uint8_t /*key_size*/) {
   test_state_.gatts_write_attr_perm_check.access_count_++;
   return test_state_.gatts_write_attr_perm_check.return_status_;
 }
-void gatt_update_app_use_link_flag(tGATT_IF gatt_if, tGATT_TCB* p_tcb, bool is_add,
-                                   bool check_acl_link) {}
+void gatt_update_app_use_link_flag(tGATT_IF /*gatt_if*/, tGATT_TCB* /*p_tcb*/, bool /*is_add*/,
+                                   bool /*check_acl_link*/) {}
 bluetooth::common::MessageLoopThread* get_main_thread() { return nullptr; }
-void l2cble_set_fixed_channel_tx_data_length(const RawAddress& remote_bda, uint16_t fix_cid,
-                                             uint16_t tx_mtu) {}
-void L2CA_SetLeFixedChannelTxDataLength(const RawAddress& remote_bda, uint16_t fix_cid,
-                                        uint16_t tx_mtu) {}
+void l2cble_set_fixed_channel_tx_data_length(const RawAddress& /*remote_bda*/, uint16_t /*fix_cid*/,
+                                             uint16_t /*tx_mtu*/) {}
+void L2CA_SetLeFixedChannelTxDataLength(const RawAddress& /*remote_bda*/, uint16_t /*fix_cid*/,
+                                        uint16_t /*tx_mtu*/) {}
 void ApplicationRequestCallback(uint16_t conn_id, uint32_t trans_id, tGATTS_REQ_TYPE type,
                                 tGATTS_DATA* p_data) {
   test_state_.application_request_callback.conn_id_ = conn_id;
@@ -122,8 +132,8 @@ void ApplicationRequestCallback(uint16_t conn_id, uint32_t trans_id, tGATTS_REQ_
   test_state_.application_request_callback.data_ = *p_data;
 }
 
-bool gatt_sr_is_cl_change_aware(tGATT_TCB& tcb) { return false; }
-void gatt_sr_init_cl_status(tGATT_TCB& p_tcb) {}
+bool gatt_sr_is_cl_change_aware(tGATT_TCB& /*tcb*/) { return false; }
+void gatt_sr_init_cl_status(tGATT_TCB& /*p_tcb*/) {}
 void gatt_sr_update_cl_status(tGATT_TCB& p_tcb, bool chg_aware) {
   p_tcb.is_robust_cache_change_aware = chg_aware;
 }
diff --git a/system/stack/test/gatt/mock_gatt_utils_ref.cc b/system/stack/test/gatt/mock_gatt_utils_ref.cc
index 564a2e555a..f79db0ac3d 100644
--- a/system/stack/test/gatt/mock_gatt_utils_ref.cc
+++ b/system/stack/test/gatt/mock_gatt_utils_ref.cc
@@ -20,6 +20,7 @@
 
 // TODO(b/369381361) Enfore -Wmissing-prototypes
 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 
 /** stack/gatt/connection_manager.cc */
 namespace connection_manager {
diff --git a/system/stack/test/gatt/stack_gatt_test.cc b/system/stack/test/gatt/stack_gatt_test.cc
index 2a6b243d43..0a5c40d920 100644
--- a/system/stack/test/gatt/stack_gatt_test.cc
+++ b/system/stack/test/gatt/stack_gatt_test.cc
@@ -68,20 +68,23 @@ size_t actual_sizeof_tGATT_REG() {
          sizeof(uint8_t) + sizeof(bool);
 }
 
-void tGATT_DISC_RES_CB(uint16_t conn_id, tGATT_DISC_TYPE disc_type, tGATT_DISC_RES* p_data) {}
-void tGATT_DISC_CMPL_CB(uint16_t conn_id, tGATT_DISC_TYPE disc_type, tGATT_STATUS status) {}
-void tGATT_CMPL_CBACK(uint16_t conn_id, tGATTC_OPTYPE op, tGATT_STATUS status,
-                      tGATT_CL_COMPLETE* p_data) {}
-void tGATT_CONN_CBACK(tGATT_IF gatt_if, const RawAddress& bda, uint16_t conn_id, bool connected,
-                      tGATT_DISCONN_REASON reason, tBT_TRANSPORT transport) {}
-void tGATT_REQ_CBACK(uint16_t conn_id, uint32_t trans_id, tGATTS_REQ_TYPE type,
-                     tGATTS_DATA* p_data) {}
-void tGATT_CONGESTION_CBACK(uint16_t conn_id, bool congested) {}
-void tGATT_ENC_CMPL_CB(tGATT_IF gatt_if, const RawAddress& bda) {}
-void tGATT_PHY_UPDATE_CB(tGATT_IF gatt_if, uint16_t conn_id, uint8_t tx_phy, uint8_t rx_phy,
-                         tGATT_STATUS status) {}
-void tGATT_CONN_UPDATE_CB(tGATT_IF gatt_if, uint16_t conn_id, uint16_t interval, uint16_t latency,
-                          uint16_t timeout, tGATT_STATUS status) {}
+void tGATT_DISC_RES_CB(uint16_t /*conn_id*/, tGATT_DISC_TYPE /*disc_type*/,
+                       tGATT_DISC_RES* /*p_data*/) {}
+void tGATT_DISC_CMPL_CB(uint16_t /*conn_id*/, tGATT_DISC_TYPE /*disc_type*/,
+                        tGATT_STATUS /*status*/) {}
+void tGATT_CMPL_CBACK(uint16_t /*conn_id*/, tGATTC_OPTYPE /*op*/, tGATT_STATUS /*status*/,
+                      tGATT_CL_COMPLETE* /*p_data*/) {}
+void tGATT_CONN_CBACK(tGATT_IF /*gatt_if*/, const RawAddress& /*bda*/, uint16_t /*conn_id*/,
+                      bool /*connected*/, tGATT_DISCONN_REASON /*reason*/,
+                      tBT_TRANSPORT /*transport*/) {}
+void tGATT_REQ_CBACK(uint16_t /*conn_id*/, uint32_t /*trans_id*/, tGATTS_REQ_TYPE /*type*/,
+                     tGATTS_DATA* /*p_data*/) {}
+void tGATT_CONGESTION_CBACK(uint16_t /*conn_id*/, bool /*congested*/) {}
+void tGATT_ENC_CMPL_CB(tGATT_IF /*gatt_if*/, const RawAddress& /*bda*/) {}
+void tGATT_PHY_UPDATE_CB(tGATT_IF /*gatt_if*/, uint16_t /*conn_id*/, uint8_t /*tx_phy*/,
+                         uint8_t /*rx_phy*/, tGATT_STATUS /*status*/) {}
+void tGATT_CONN_UPDATE_CB(tGATT_IF /*gatt_if*/, uint16_t /*conn_id*/, uint16_t /*interval*/,
+                          uint16_t /*latency*/, uint16_t /*timeout*/, tGATT_STATUS /*status*/) {}
 
 tGATT_CBACK gatt_callbacks = {
         .p_conn_cb = tGATT_CONN_CBACK,
diff --git a/system/stack/test/gatt_connection_manager_test.cc b/system/stack/test/gatt_connection_manager_test.cc
index e791210608..e5a8596710 100644
--- a/system/stack/test/gatt_connection_manager_test.cc
+++ b/system/stack/test/gatt_connection_manager_test.cc
@@ -69,15 +69,16 @@ void BTM_BleTargetAnnouncementObserve(bool enable, tBTM_INQ_RESULTS_CB* p_result
   localAcceptlistMock->EnableTargetedAnnouncements(enable, p_results_cb);
 }
 
-void BTM_LogHistory(const std::string& tag, const RawAddress& bd_addr, const std::string& msg) {}
+void BTM_LogHistory(const std::string& /*tag*/, const RawAddress& /*bd_addr*/,
+                    const std::string& /*msg*/) {}
 
 namespace bluetooth {
 namespace shim {
-void set_target_announcements_filter(bool enable) {}
+void set_target_announcements_filter(bool /*enable*/) {}
 }  // namespace shim
 }  // namespace bluetooth
 
-bool L2CA_ConnectFixedChnl(uint16_t fixed_cid, const RawAddress& bd_addr) { return false; }
+bool L2CA_ConnectFixedChnl(uint16_t /*fixed_cid*/, const RawAddress& /*bd_addr*/) { return false; }
 uint16_t BTM_GetHCIConnHandle(RawAddress const&, unsigned char) { return 0xFFFF; }
 
 namespace connection_manager {
@@ -85,7 +86,7 @@ class BleConnectionManager : public testing::Test {
   void SetUp() override {
     localAcceptlistMock = std::make_unique<AcceptlistMock>();
     auto alarm_mock = AlarmMock::Get();
-    ON_CALL(*alarm_mock, AlarmNew(_)).WillByDefault(testing::Invoke([](const char* name) {
+    ON_CALL(*alarm_mock, AlarmNew(_)).WillByDefault(testing::Invoke([](const char* /*name*/) {
       // We must return something from alarm_new in tests, if we just return
       // null, unique_ptr will misbehave.
       return (alarm_t*)new uint8_t[30];
diff --git a/system/stack/test/stack_avdtp_test.cc b/system/stack/test/stack_avdtp_test.cc
index 3ecc82f050..8c9372ec93 100644
--- a/system/stack/test/stack_avdtp_test.cc
+++ b/system/stack/test/stack_avdtp_test.cc
@@ -40,19 +40,20 @@ protected:
   static uint8_t scb_handle_;
 
 protected:
-  static void AvdtConnCallback(uint8_t handle, const RawAddress& bd_addr, uint8_t event,
-                               tAVDT_CTRL* p_data, uint8_t scb_index) {
+  static void AvdtConnCallback(uint8_t /*handle*/, const RawAddress& /*bd_addr*/, uint8_t event,
+                               tAVDT_CTRL* /*p_data*/, uint8_t /*scb_index*/) {
     inc_func_call_count(__func__);
     callback_event_ = event;
   }
 
-  static void StreamCtrlCallback(uint8_t handle, const RawAddress& bd_addr, uint8_t event,
-                                 tAVDT_CTRL* p_data, uint8_t scb_index) {
+  static void StreamCtrlCallback(uint8_t /*handle*/, const RawAddress& /*bd_addr*/, uint8_t event,
+                                 tAVDT_CTRL* /*p_data*/, uint8_t /*scb_index*/) {
     inc_func_call_count(__func__);
     callback_event_ = event;
   }
 
-  static void AvdtReportCallback(uint8_t handle, AVDT_REPORT_TYPE type, tAVDT_REPORT_DATA* p_data) {
+  static void AvdtReportCallback(uint8_t /*handle*/, AVDT_REPORT_TYPE /*type*/,
+                                 tAVDT_REPORT_DATA* /*p_data*/) {
     inc_func_call_count(__func__);
   }
 
diff --git a/system/stack/test/stack_smp_test.cc b/system/stack/test/stack_smp_test.cc
index 31a006d249..c7de45814c 100644
--- a/system/stack/test/stack_smp_test.cc
+++ b/system/stack/test/stack_smp_test.cc
@@ -201,16 +201,16 @@ public:
 TEST_F(SmpCalculateConfirmTest, test_smp_gen_p2_4_confirm_as_central) {
   // Set local_bda to 0xA1A2A3A4A5A6
   test::mock::stack_acl::BTM_ReadConnectionAddr.body =
-          [](const RawAddress& remote_bda, RawAddress& local_conn_addr, tBLE_ADDR_TYPE* p_addr_type,
-             bool ota_address) {
+          [](const RawAddress& /*remote_bda*/, RawAddress& local_conn_addr,
+             tBLE_ADDR_TYPE* p_addr_type, bool /*ota_address*/) {
             local_conn_addr = RawAddress({0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6});
             *p_addr_type = BLE_ADDR_RANDOM;
           };
 
   // Set remote bda to 0xB1B2B3B4B5B6
   test::mock::stack_acl::BTM_ReadRemoteConnectionAddr.body =
-          [](const RawAddress& pseudo_addr, RawAddress& conn_addr, tBLE_ADDR_TYPE* p_addr_type,
-             bool ota_address) {
+          [](const RawAddress& /*pseudo_addr*/, RawAddress& conn_addr, tBLE_ADDR_TYPE* p_addr_type,
+             bool /*ota_address*/) {
             conn_addr = RawAddress({0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6});
             *p_addr_type = BLE_ADDR_PUBLIC;
             return true;
@@ -235,16 +235,16 @@ TEST_F(SmpCalculateConfirmTest, test_smp_gen_p2_4_confirm_as_central) {
 TEST_F(SmpCalculateConfirmTest, test_aes_128_as_central) {
   // Set local_bda to 0xA1A2A3A4A5A6
   test::mock::stack_acl::BTM_ReadConnectionAddr.body =
-          [](const RawAddress& remote_bda, RawAddress& local_conn_addr, tBLE_ADDR_TYPE* p_addr_type,
-             bool ota_address) {
+          [](const RawAddress& /*remote_bda*/, RawAddress& local_conn_addr,
+             tBLE_ADDR_TYPE* p_addr_type, bool /*ota_address*/) {
             local_conn_addr = RawAddress({0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6});
             *p_addr_type = BLE_ADDR_RANDOM;
           };
 
   // Set remote bda to 0xB1B2B3B4B5B6
   test::mock::stack_acl::BTM_ReadRemoteConnectionAddr.body =
-          [](const RawAddress& pseudo_addr, RawAddress& conn_addr, tBLE_ADDR_TYPE* p_addr_type,
-             bool ota_address) {
+          [](const RawAddress& /*pseudo_addr*/, RawAddress& conn_addr, tBLE_ADDR_TYPE* p_addr_type,
+             bool /*ota_address*/) {
             conn_addr = RawAddress({0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6});
             *p_addr_type = BLE_ADDR_PUBLIC;
             return true;
@@ -280,16 +280,16 @@ TEST_F(SmpCalculateConfirmTest, test_aes_128_as_central) {
 TEST_F(SmpCalculateConfirmTest, test_smp_calculate_confirm_as_central) {
   // Set local_bda to 0xA1A2A3A4A5A6
   test::mock::stack_acl::BTM_ReadConnectionAddr.body =
-          [](const RawAddress& remote_bda, RawAddress& local_conn_addr, tBLE_ADDR_TYPE* p_addr_type,
-             bool ota_address) {
+          [](const RawAddress& /*remote_bda*/, RawAddress& local_conn_addr,
+             tBLE_ADDR_TYPE* p_addr_type, bool /*ota_address*/) {
             local_conn_addr = RawAddress({0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6});
             *p_addr_type = BLE_ADDR_RANDOM;
           };
 
   // Set remote bda to 0xB1B2B3B4B5B6
   test::mock::stack_acl::BTM_ReadRemoteConnectionAddr.body =
-          [](const RawAddress& pseudo_addr, RawAddress& conn_addr, tBLE_ADDR_TYPE* p_addr_type,
-             bool ota_address) {
+          [](const RawAddress& /*pseudo_addr*/, RawAddress& conn_addr, tBLE_ADDR_TYPE* p_addr_type,
+             bool /*ota_address*/) {
             conn_addr = RawAddress({0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6});
             *p_addr_type = BLE_ADDR_PUBLIC;
             return true;
diff --git a/system/test/stub/osi.cc b/system/test/stub/osi.cc
index cae495f2ca..fcfa858a91 100644
--- a/system/test/stub/osi.cc
+++ b/system/test/stub/osi.cc
@@ -44,6 +44,7 @@
 
 // TODO(b/369381361) Enfore -Wmissing-prototypes
 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 
 OsiObject::OsiObject(void* ptr) : ptr_(ptr) {}