Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 23230633 authored by Chris Manton's avatar Chris Manton
Browse files

mock: Comment out unused variables [main_shim|osi] 

Bug: 322088953
Test: m .
Flag: EXEMPT, testing infrastructure

Change-Id: I20b3015bc0ddec6784408db937ea25633ce95875
parent 8bae9b7a

system/test/fake/fake_osi.cc

+8 −8
Original line number Diff line number Diff line
@@ -26,7 +26,7 @@ struct alarm_t { 
  alarm_callback_t cb;

  void* data;



  alarm_t(const char* name) {

  alarm_t(const char* /* name */) {

    cb = nullptr;

    data = nullptr;

  };
@@ -92,7 +92,7 @@ FakeOsi::FakeOsi() { 
  };



  test::mock::osi_alarm::alarm_set_on_mloop.body =

      [](alarm_t* alarm, uint64_t interval_ms, alarm_callback_t cb,

      [](alarm_t* alarm, uint64_t /* interval_ms */, alarm_callback_t cb,

         void* data) {

        alarm->cb = cb;

        alarm->data = data;
@@ -333,34 +333,34 @@ FakeOsi::FakeOsi() { 
      [](fixed_queue_t* q) { return q ? q->list_ : nullptr; };



  test::mock::osi_fixed_queue::fixed_queue_try_remove_from_queue.body =

      [](fixed_queue_t* q, void* data) {

      [](fixed_queue_t* /* q */, void* /* data */) {

        // not implemented

        abort();

        return nullptr;

      };



  test::mock::osi_fixed_queue::fixed_queue_get_enqueue_fd.body =

      [](const fixed_queue_t* q) {

      [](const fixed_queue_t* /* q */) {

        // not implemented

        abort();

        return 0;

      };



  test::mock::osi_fixed_queue::fixed_queue_get_dequeue_fd.body =

      [](const fixed_queue_t* q) {

      [](const fixed_queue_t* /* q */) {

        // not implemented

        abort();

        return 0;

      };



  test::mock::osi_fixed_queue::fixed_queue_register_dequeue.body =

      [](fixed_queue_t* q, reactor_t* reactor, fixed_queue_cb ready_cb,

         void* context) {

      [](fixed_queue_t* /* q */, reactor_t* /* reactor */,

         fixed_queue_cb /* ready_cb */, void* /* context */) {

        // not implemented

        abort();

      };

  test::mock::osi_fixed_queue::fixed_queue_unregister_dequeue.body =

      [](fixed_queue_t* q) {

      [](fixed_queue_t* /* q */) {

        // not implemented

        abort();

      };

system/test/mock/mock_main_shim_BtifConfigInterface.cc

+31 −33
Original line number Diff line number Diff line
@@ -19,69 +19,67 @@ 
#include "main/shim/config.h"



bool bluetooth::shim::BtifConfigInterface::HasSection(

    const std::string& section) {

    const std::string& /* section */) {

  return false;

}

bool bluetooth::shim::BtifConfigInterface::HasProperty(

    const std::string& section, const std::string& property) {

    const std::string& /* section */, const std::string& /* property */) {

  return false;

}

bool bluetooth::shim::BtifConfigInterface::GetInt(const std::string& section,

                                                  const std::string& key,

                                                  int* value) {

bool bluetooth::shim::BtifConfigInterface::GetInt(

    const std::string& /* section */, const std::string& /* key */,

    int* /* value */) {

  return false;

}

bool bluetooth::shim::BtifConfigInterface::SetInt(const std::string& section,

                                                  const std::string& key,

                                                  int value) {

bool bluetooth::shim::BtifConfigInterface::SetInt(

    const std::string& /* section */, const std::string& /* key */,

    int /* value */) {

  return false;

}

bool bluetooth::shim::BtifConfigInterface::GetUint64(const std::string& section,

                                                     const std::string& key,

                                                     uint64_t* value) {

bool bluetooth::shim::BtifConfigInterface::GetUint64(

    const std::string& /* section */, const std::string& /* key */,

    uint64_t* /* value */) {

  return false;

}

bool bluetooth::shim::BtifConfigInterface::SetUint64(const std::string& section,

                                                     const std::string& key,

                                                     uint64_t value) {

bool bluetooth::shim::BtifConfigInterface::SetUint64(

    const std::string& /* section */, const std::string& /* key */,

    uint64_t /* value */) {

  return false;

}

bool bluetooth::shim::BtifConfigInterface::GetStr(const std::string& section,

                                                  const std::string& key,

                                                  char* value,

                                                  int* size_bytes) {

bool bluetooth::shim::BtifConfigInterface::GetStr(

    const std::string& /* section */, const std::string& /* key */,

    char* /* value */, int* /* size_bytes */) {

  return false;

}

std::optional<std::string> bluetooth::shim::BtifConfigInterface::GetStr(

    const std::string& section, const std::string& key) {

    const std::string& /* section */, const std::string& /* key */) {

  return std::string();

}

bool bluetooth::shim::BtifConfigInterface::SetStr(const std::string& section,

                                                  const std::string& key,

                                                  const std::string& value) {

bool bluetooth::shim::BtifConfigInterface::SetStr(

    const std::string& /* section */, const std::string& /* key */,

    const std::string& /* value */) {

  return false;

}

bool bluetooth::shim::BtifConfigInterface::GetBin(const std::string& section,

                                                  const std::string& key,

                                                  uint8_t* value,

                                                  size_t* length) {

bool bluetooth::shim::BtifConfigInterface::GetBin(

    const std::string& /* section */, const std::string& /* key */,

    uint8_t* /* value */, size_t* /* length */) {

  return false;

}

size_t bluetooth::shim::BtifConfigInterface::GetBinLength(

    const std::string& section, const std::string& key) {

    const std::string& /* section */, const std::string& /* key */) {

  return 0;

}

bool bluetooth::shim::BtifConfigInterface::SetBin(const std::string& section,

                                                  const std::string& key,

                                                  const uint8_t* value,

                                                  size_t length) {

bool bluetooth::shim::BtifConfigInterface::SetBin(

    const std::string& /* section */, const std::string& /* key */,

    const uint8_t* /* value */, size_t /* length */) {

  return false;

}

bool bluetooth::shim::BtifConfigInterface::RemoveProperty(

    const std::string& section, const std::string& key) {

    const std::string& /* section */, const std::string& /* key */) {

  return false;

}

void bluetooth::shim::BtifConfigInterface::RemoveSection(const std::string& section){};

void bluetooth::shim::BtifConfigInterface::RemoveSection(

    const std::string& /* section */){};

std::vector<std::string>

bluetooth::shim::BtifConfigInterface::GetPersistentDevices() {

  return std::vector<std::string>();

system/test/mock/mock_main_shim_acl_api.cc

+32 −28
Original line number Diff line number Diff line
@@ -30,74 +30,78 @@ 
#include "types/raw_address.h"



void bluetooth::shim::ACL_CreateClassicConnection(

    const RawAddress& raw_address) {

    const RawAddress& /* raw_address */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_CancelClassicConnection(

    const RawAddress& raw_address) {

    const RawAddress& /* raw_address */) {

  inc_func_call_count(__func__);

}

bool bluetooth::shim::ACL_AcceptLeConnectionFrom(

    const tBLE_BD_ADDR& legacy_address_with_type, bool is_direct) {

    const tBLE_BD_ADDR& /* legacy_address_with_type */, bool /* is_direct */) {

  inc_func_call_count(__func__);

  return true;

}

void bluetooth::shim::ACL_IgnoreLeConnectionFrom(

    const tBLE_BD_ADDR& legacy_address_with_type) {

    const tBLE_BD_ADDR& /* legacy_address_with_type */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_ConfigureLePrivacy(bool is_le_privacy_enabled) {

void bluetooth::shim::ACL_ConfigureLePrivacy(bool /* is_le_privacy_enabled */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_WriteData(uint16_t handle, BT_HDR* p_buf) {

void bluetooth::shim::ACL_WriteData(uint16_t /* handle */,

                                    BT_HDR* /* p_buf */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_Disconnect(uint16_t handle, bool is_classic,

                                     tHCI_STATUS reason, std::string comment) {

void bluetooth::shim::ACL_Disconnect(uint16_t /* handle */,

                                     bool /* is_classic */,

                                     tHCI_STATUS /* reason */,

                                     std::string /* comment */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_IgnoreAllLeConnections() {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_ReadConnectionAddress(uint16_t handle,

                                                RawAddress& conn_addr,

                                                tBLE_ADDR_TYPE* p_addr_type,

                                                bool ota_address) {

void bluetooth::shim::ACL_ReadConnectionAddress(

    uint16_t /* handle */, RawAddress& /* conn_addr */,

    tBLE_ADDR_TYPE* /* p_addr_type */, bool /* ota_address */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_ReadPeerConnectionAddress(uint16_t handle,

                                                    RawAddress& conn_addr,

                                                    tBLE_ADDR_TYPE* p_addr_type,

                                                    bool ota_address) {

void bluetooth::shim::ACL_ReadPeerConnectionAddress(

    uint16_t /* handle */, RawAddress& /* conn_addr */,

    tBLE_ADDR_TYPE* /* p_addr_type */, bool /* ota_address */) {

  inc_func_call_count(__func__);

}

std::optional<uint8_t> bluetooth::shim::ACL_GetAdvertisingSetConnectedTo(

    const RawAddress& addr) {

    const RawAddress& /* addr */) {

  inc_func_call_count(__func__);

  return std::nullopt;

}

void bluetooth::shim::ACL_AddToAddressResolution(

    const tBLE_BD_ADDR& legacy_address_with_type, const Octet16& peer_irk,

    const Octet16& local_irk) {

    const tBLE_BD_ADDR& /* legacy_address_with_type */,

    const Octet16& /* peer_irk */, const Octet16& /* local_irk */) {

  inc_func_call_count(__func__);

}



void bluetooth::shim::ACL_RemoveFromAddressResolution(

    const tBLE_BD_ADDR& legacy_address_with_type) {

    const tBLE_BD_ADDR& /* legacy_address_with_type */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_ClearAddressResolution() {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_LeSetDefaultSubrate(uint16_t subrate_min,

                                              uint16_t subrate_max,

                                              uint16_t max_latency,

                                              uint16_t cont_num,

                                              uint16_t sup_tout) {

void bluetooth::shim::ACL_LeSetDefaultSubrate(uint16_t /* subrate_min */,

                                              uint16_t /* subrate_max */,

                                              uint16_t /* max_latency */,

                                              uint16_t /* cont_num */,

                                              uint16_t /* sup_tout */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::ACL_LeSubrateRequest(

    uint16_t hci_handle, uint16_t subrate_min, uint16_t subrate_max,

    uint16_t max_latency, uint16_t cont_num, uint16_t sup_tout) {

void bluetooth::shim::ACL_LeSubrateRequest(uint16_t /* hci_handle */,

                                           uint16_t /* subrate_min */,

                                           uint16_t /* subrate_max */,

                                           uint16_t /* max_latency */,

                                           uint16_t /* cont_num */,

                                           uint16_t /* sup_tout */) {

  inc_func_call_count(__func__);

}

system/test/mock/mock_main_shim_btm_api.cc

+63 −64
Original line number Diff line number Diff line
@@ -33,19 +33,19 @@ 


Octet16 octet16;



bool bluetooth::shim::BTM_HasEirService(const uint32_t* p_eir_uuid,

                                        uint16_t uuid16) {

bool bluetooth::shim::BTM_HasEirService(const uint32_t* /* p_eir_uuid */,

                                        uint16_t /* uuid16 */) {

  inc_func_call_count(__func__);

  return false;

}

bool bluetooth::shim::BTM_ReadConnectedTransportAddress(

    RawAddress* remote_bda, tBT_TRANSPORT transport) {

    RawAddress* /* remote_bda */, tBT_TRANSPORT /* transport */) {

  inc_func_call_count(__func__);

  return false;

}

bool bluetooth::shim::BTM_ReadRemoteConnectionAddr(

    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 */) {

  inc_func_call_count(__func__);

  return false;

}
@@ -54,72 +54,72 @@ tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbFirst(void) { 
  inc_func_call_count(__func__);

  return nullptr;

}

tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbNext(tBTM_INQ_INFO* p_cur) {

tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbNext(tBTM_INQ_INFO* /* p_cur */) {

  inc_func_call_count(__func__);

  return nullptr;

}

tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbRead(const RawAddress& p_bda) {

tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbRead(const RawAddress& /* p_bda */) {

  inc_func_call_count(__func__);

  return nullptr;

}

tBTM_STATUS bluetooth::shim::BTM_BleObserve(bool start, uint8_t duration_sec,

                                            tBTM_INQ_RESULTS_CB* p_results_cb,

                                            tBTM_CMPL_CB* p_cmpl_cb) {

tBTM_STATUS bluetooth::shim::BTM_BleObserve(

    bool /* start */, uint8_t /* duration_sec */,

    tBTM_INQ_RESULTS_CB* /* p_results_cb */, tBTM_CMPL_CB* /* p_cmpl_cb */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}

void bluetooth::shim::BTM_BleOpportunisticObserve(

    bool enable, tBTM_INQ_RESULTS_CB* p_results_cb) {

    bool /* enable */, tBTM_INQ_RESULTS_CB* /* p_results_cb */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::BTM_BleTargetAnnouncementObserve(

    bool enable, tBTM_INQ_RESULTS_CB* p_results_cb) {

    bool /* enable */, tBTM_INQ_RESULTS_CB* /* p_results_cb */) {

  inc_func_call_count(__func__);

}

tBTM_STATUS bluetooth::shim::BTM_CancelRemoteDeviceName(void) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}

tBTM_STATUS bluetooth::shim::BTM_ClearInqDb(const RawAddress* p_bda) {

tBTM_STATUS bluetooth::shim::BTM_ClearInqDb(const RawAddress* /* p_bda */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}

tBTM_STATUS bluetooth::shim::BTM_ReadRemoteDeviceName(

    const RawAddress& raw_address, tBTM_NAME_CMPL_CB* callback,

    tBT_TRANSPORT transport) {

    const RawAddress& /* raw_address */, tBTM_NAME_CMPL_CB* /* callback */,

    tBT_TRANSPORT /* transport */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}



tBTM_STATUS bluetooth::shim::BTM_SetConnectability(uint16_t page_mode,

                                                   uint16_t window,

                                                   uint16_t interval) {

tBTM_STATUS bluetooth::shim::BTM_SetConnectability(uint16_t /* page_mode */,

                                                   uint16_t /* window */,

                                                   uint16_t /* interval */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}

tBTM_STATUS bluetooth::shim::BTM_SetDeviceClass(DEV_CLASS dev_class) {

tBTM_STATUS bluetooth::shim::BTM_SetDeviceClass(DEV_CLASS /* dev_class */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}

tBTM_STATUS bluetooth::shim::BTM_SetDiscoverability(uint16_t discoverable_mode,

                                                    uint16_t window,

                                                    uint16_t interval) {

tBTM_STATUS bluetooth::shim::BTM_SetDiscoverability(

    uint16_t /* discoverable_mode */, uint16_t /* window */,

    uint16_t /* interval */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}



tBTM_STATUS bluetooth::shim::BTM_SetInquiryMode(uint8_t inquiry_mode) {

tBTM_STATUS bluetooth::shim::BTM_SetInquiryMode(uint8_t /* inquiry_mode */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}

tBTM_STATUS bluetooth::shim::BTM_StartInquiry(tBTM_INQ_RESULTS_CB* p_results_cb,

                                              tBTM_CMPL_CB* p_cmpl_cb) {

tBTM_STATUS bluetooth::shim::BTM_StartInquiry(

    tBTM_INQ_RESULTS_CB* /* p_results_cb */, tBTM_CMPL_CB* /* p_cmpl_cb */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}



uint16_t bluetooth::shim::BTM_GetHCIConnHandle(const RawAddress& remote_bda,

                                               tBT_TRANSPORT transport) {

uint16_t bluetooth::shim::BTM_GetHCIConnHandle(

    const RawAddress& /* remote_bda */, tBT_TRANSPORT /* transport */) {

  inc_func_call_count(__func__);

  return 0;

}
@@ -132,26 +132,26 @@ uint8_t bluetooth::shim::BTM_BleMaxMultiAdvInstanceCount() { 
  inc_func_call_count(__func__);

  return 0;

}

void bluetooth::shim::BTM_AddEirService(uint32_t* p_eir_uuid, uint16_t uuid16) {

void bluetooth::shim::BTM_AddEirService(uint32_t* /* p_eir_uuid */,

                                        uint16_t /* uuid16 */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::BTM_BleAdvFilterParamSetup(

    tBTM_BLE_SCAN_COND_OP action, tBTM_BLE_PF_FILT_INDEX filt_index,

    std::unique_ptr<btgatt_filt_param_setup_t> p_filt_params,

    tBTM_BLE_PF_PARAM_CB cb) {

    tBTM_BLE_SCAN_COND_OP /* action */, tBTM_BLE_PF_FILT_INDEX /* filt_index */,

    std::unique_ptr<btgatt_filt_param_setup_t> /* p_filt_params */,

    tBTM_BLE_PF_PARAM_CB /* cb */) {

  inc_func_call_count(__func__);

}



void bluetooth::shim::BTM_BleSetConnScanParams(uint32_t scan_interval,

                                               uint32_t scan_window) {

void bluetooth::shim::BTM_BleSetConnScanParams(uint32_t /* scan_interval */,

                                               uint32_t /* scan_window */) {

  inc_func_call_count(__func__);

}



void bluetooth::shim::BTM_BleSetPrefConnParams(const RawAddress& bd_addr,

                                               uint16_t min_conn_int,

                                               uint16_t max_conn_int,

                                               uint16_t peripheral_latency,

                                               uint16_t supervision_tout) {

void bluetooth::shim::BTM_BleSetPrefConnParams(

    const RawAddress& /* bd_addr */, uint16_t /* min_conn_int */,

    uint16_t /* max_conn_int */, uint16_t /* peripheral_latency */,

    uint16_t /* supervision_tout */) {

  inc_func_call_count(__func__);

}
@@ -164,35 +164,34 @@ void bluetooth::shim::BTM_EnableInterlacedPageScan() { 
  inc_func_call_count(__func__);

}



void bluetooth::shim::BTM_ReadConnectionAddr(const RawAddress& remote_bda,

                                             RawAddress& local_conn_addr,

                                             tBLE_ADDR_TYPE* p_addr_type,

                                             bool ota_address) {

void bluetooth::shim::BTM_ReadConnectionAddr(const RawAddress& /* remote_bda */,

                                             RawAddress& /* local_conn_addr */,

                                             tBLE_ADDR_TYPE* /* p_addr_type */,

                                             bool /* ota_address */) {

  inc_func_call_count(__func__);

}



void bluetooth::shim::SendRemoteNameRequest(const RawAddress& raw_address) {

void bluetooth::shim::SendRemoteNameRequest(

    const RawAddress& /* raw_address */) {

  inc_func_call_count(__func__);

}

void btm_api_process_extended_inquiry_result(RawAddress raw_address,

                                             uint8_t page_scan_rep_mode,

                                             DEV_CLASS device_class,

                                             uint16_t clock_offset, int8_t rssi,

                                             const uint8_t* eir_data,

                                             size_t eir_len) {

void btm_api_process_extended_inquiry_result(

    RawAddress /* raw_address */, uint8_t /* page_scan_rep_mode */,

    DEV_CLASS /* device_class */, uint16_t /* clock_offset */,

    int8_t /* rssi */, const uint8_t* /* eir_data */, size_t /* eir_len */) {

  inc_func_call_count(__func__);

}

void btm_api_process_inquiry_result(const RawAddress& raw_address,

                                    uint8_t page_scan_rep_mode,

                                    DEV_CLASS device_class,

                                    uint16_t clock_offset) {

void btm_api_process_inquiry_result(const RawAddress& /* raw_address */,

                                    uint8_t /* page_scan_rep_mode */,

                                    DEV_CLASS /* device_class */,

                                    uint16_t /* clock_offset */) {

  inc_func_call_count(__func__);

}

void btm_api_process_inquiry_result_with_rssi(RawAddress raw_address,

                                              uint8_t page_scan_rep_mode,

                                              DEV_CLASS device_class,

                                              uint16_t clock_offset,

                                              int8_t rssi) {

void btm_api_process_inquiry_result_with_rssi(RawAddress /* raw_address */,

                                              uint8_t /* page_scan_rep_mode */,

                                              DEV_CLASS /* device_class */,

                                              uint16_t /* clock_offset */,

                                              int8_t /* rssi */) {

  inc_func_call_count(__func__);

}
@@ -216,7 +215,7 @@ tBTM_STATUS bluetooth::shim::BTM_DisconnectAllAcls() { 
  return BTM_SUCCESS;

}



tBTM_STATUS bluetooth::shim::BTM_LeRand(LeRandCallback cb) {

tBTM_STATUS bluetooth::shim::BTM_LeRand(LeRandCallback /* cb */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}
@@ -227,20 +226,20 @@ tBTM_STATUS bluetooth::shim::BTM_SetEventFilterConnectionSetupAllDevices() { 
}



tBTM_STATUS bluetooth::shim::BTM_AllowWakeByHid(

    std::vector<RawAddress> classic_hid_devices,

    std::vector<std::pair<RawAddress, uint8_t>> le_hid_devices) {

    std::vector<RawAddress> /* classic_hid_devices */,

    std::vector<std::pair<RawAddress, uint8_t>> /* le_hid_devices */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}



tBTM_STATUS bluetooth::shim::BTM_RestoreFilterAcceptList(

    std::vector<std::pair<RawAddress, uint8_t>> le_devices) {

    std::vector<std::pair<RawAddress, uint8_t>> /* le_devices */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}



tBTM_STATUS bluetooth::shim::BTM_SetDefaultEventMaskExcept(uint64_t mask,

                                                           uint64_t le_mask) {

tBTM_STATUS bluetooth::shim::BTM_SetDefaultEventMaskExcept(

    uint64_t /* mask */, uint64_t /* le_mask */) {

  inc_func_call_count(__func__);

  return BTM_SUCCESS;

}

system/test/mock/mock_main_shim_dumpsys.cc

+4 −4
Original line number Diff line number Diff line
@@ -22,13 +22,13 @@ 
#include "main/shim/dumpsys.h"

#include "test/common/mock_functions.h"



void bluetooth::shim::RegisterDumpsysFunction(const void* token,

                                              DumpsysFunction func) {

void bluetooth::shim::RegisterDumpsysFunction(const void* /* token */,

                                              DumpsysFunction /* func */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::Dump(int fd, const char** args) {

void bluetooth::shim::Dump(int /* fd */, const char** /* args */) {

  inc_func_call_count(__func__);

}

void bluetooth::shim::UnregisterDumpsysFunction(const void* token) {

void bluetooth::shim::UnregisterDumpsysFunction(const void* /* token */) {

  inc_func_call_count(__func__);

}