testing: Update mock_stack_btm_ble

/*

 * Copyright 2021 The Android Open Source Project

 * Copyright 2022 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/*

 * Generated mock file from original source file

 *   Functions generated:50

 *   Functions generated:52

 *

 *  mockcify.pl ver 0.5.0

 */

#include <cstdint>

#include <functional>

#include <map>

#include <string>

extern std::map<std::string, int> mock_function_count_map;

#include <cstdint>

#include "device/include/controller.h"

#include "main/shim/btm_api.h"

#include "main/shim/l2c_api.h"

#include "main/shim/shim.h"

#include "stack/btm/btm_dev.h"

#include "stack/btm/btm_int_types.h"

#include "stack/btm/security_device_record.h"

#include "stack/crypto_toolbox/crypto_toolbox.h"

#include "stack/include/acl_api.h"

#include "stack/include/btm_api.h"

#include "stack/include/gatt_api.h"

#include "stack/include/l2cap_security_interface.h"

#include "stack/include/l2cdefs.h"

#include "stack/include/smp_api.h"

#include "types/raw_address.h"

// Mock include file to share data between tests and mock

#include "test/mock/mock_stack_btm_ble.h"

#ifndef UNUSED_ATTR

#define UNUSED_ATTR

#endif

// Original usings

bool BTM_BleDataSignature(const RawAddress& bd_addr, uint8_t* p_text,

                          uint16_t len, BLE_SIGNATURE signature) {

  mock_function_count_map[__func__]++;

  return false;

}

bool BTM_BleVerifySignature(const RawAddress& bd_addr, uint8_t* p_orig,

                            uint16_t len, uint32_t counter, uint8_t* p_comp) {

  mock_function_count_map[__func__]++;

  return false;

}

bool BTM_ReadConnectedTransportAddress(RawAddress* remote_bda,

                                       tBT_TRANSPORT transport) {

  mock_function_count_map[__func__]++;

  return false;

}

bool BTM_UseLeLink(const RawAddress& bd_addr) {

  mock_function_count_map[__func__]++;

  return false;

}

bool btm_ble_get_acl_remote_addr(uint16_t hci_handle, RawAddress& conn_addr,

                                 tBLE_ADDR_TYPE* p_addr_type) {

  mock_function_count_map[__func__]++;

  return false;

}

bool btm_ble_get_enc_key_type(const RawAddress& bd_addr, uint8_t* p_key_types) {

  mock_function_count_map[__func__]++;

  return false;

}

bool btm_get_local_div(const RawAddress& bd_addr, uint16_t* p_div) {

  mock_function_count_map[__func__]++;

  return false;

}

static Octet16 octet16;

// Mocked internal structures, if any

const Octet16& BTM_GetDeviceDHK() {

  mock_function_count_map[__func__]++;

  return octet16;

}

const Octet16& BTM_GetDeviceEncRoot() {

  mock_function_count_map[__func__]++;

  return octet16;

}

const Octet16& BTM_GetDeviceIDRoot() {

  mock_function_count_map[__func__]++;

  return octet16;

}

tBTM_SEC_ACTION btm_ble_determine_security_act(bool is_originator,

                                               const RawAddress& bdaddr,

                                               uint16_t security_required) {

  mock_function_count_map[__func__]++;

  return 0;

}

tBTM_STATUS BTM_SetBleDataLength(const RawAddress& bd_addr,

                                 uint16_t tx_pdu_length) {

  mock_function_count_map[__func__]++;

  return 0;

}

tBTM_STATUS btm_ble_set_encryption(const RawAddress& bd_addr,

                                   tBTM_BLE_SEC_ACT sec_act,

                                   uint8_t link_role) {

  mock_function_count_map[__func__]++;

  return 0;

}

tBTM_STATUS btm_ble_start_encrypt(const RawAddress& bda, bool use_stk,

                                  Octet16* p_stk) {

  mock_function_count_map[__func__]++;

  return 0;

}

tBTM_STATUS btm_proc_smp_cback(tSMP_EVT event, const RawAddress& bd_addr,

                               tSMP_EVT_DATA* p_data) {

  mock_function_count_map[__func__]++;

  return 0;

}

tL2CAP_LE_RESULT_CODE btm_ble_start_sec_check(const RawAddress& bd_addr,

                                              uint16_t psm, bool is_originator,

                                              tBTM_SEC_CALLBACK* p_callback,

                                              void* p_ref_data) {

  mock_function_count_map[__func__]++;

  return L2CAP_LE_RESULT_CONN_OK;

}

uint8_t btm_ble_br_keys_req(tBTM_SEC_DEV_REC* p_dev_rec,

                            tBTM_LE_IO_REQ* p_data) {

  mock_function_count_map[__func__]++;

  return 0;

}

uint8_t btm_ble_io_capabilities_req(tBTM_SEC_DEV_REC* p_dev_rec,

                                    tBTM_LE_IO_REQ* p_data) {

  mock_function_count_map[__func__]++;

  return 0;

}

uint8_t btm_ble_read_sec_key_size(const RawAddress& bd_addr) {

namespace test {

namespace mock {

namespace stack_btm_ble {

// Function state capture and return values, if needed

struct BTM_BleConfirmReply BTM_BleConfirmReply;

struct BTM_BleDataSignature BTM_BleDataSignature;

struct BTM_BleLoadLocalKeys BTM_BleLoadLocalKeys;

struct BTM_BleOobDataReply BTM_BleOobDataReply;

struct BTM_BlePasskeyReply BTM_BlePasskeyReply;

struct BTM_BleReadPhy BTM_BleReadPhy;

struct BTM_BleReceiverTest BTM_BleReceiverTest;

struct BTM_BleSecureConnectionOobDataReply BTM_BleSecureConnectionOobDataReply;

struct BTM_BleSetPhy BTM_BleSetPhy;

struct BTM_BleSetPrefConnParams BTM_BleSetPrefConnParams;

struct BTM_BleTestEnd BTM_BleTestEnd;

struct BTM_BleTransmitterTest BTM_BleTransmitterTest;

struct BTM_BleVerifySignature BTM_BleVerifySignature;

struct BTM_GetDeviceDHK BTM_GetDeviceDHK;

struct BTM_GetDeviceEncRoot BTM_GetDeviceEncRoot;

struct BTM_GetDeviceIDRoot BTM_GetDeviceIDRoot;

struct BTM_ReadConnectedTransportAddress BTM_ReadConnectedTransportAddress;

struct BTM_ReadDevInfo BTM_ReadDevInfo;

struct BTM_SecAddBleDevice BTM_SecAddBleDevice;

struct BTM_SecAddBleKey BTM_SecAddBleKey;

struct BTM_SecurityGrant BTM_SecurityGrant;

struct BTM_SetBleDataLength BTM_SetBleDataLength;

struct BTM_UseLeLink BTM_UseLeLink;

struct btm_ble_br_keys_req btm_ble_br_keys_req;

struct btm_ble_connected btm_ble_connected;

struct btm_ble_connected_from_address_with_type

    btm_ble_connected_from_address_with_type;

struct btm_ble_determine_security_act btm_ble_determine_security_act;

struct btm_ble_get_acl_remote_addr btm_ble_get_acl_remote_addr;

struct btm_ble_get_enc_key_type btm_ble_get_enc_key_type;

struct btm_ble_increment_sign_ctr btm_ble_increment_sign_ctr;

struct btm_ble_io_capabilities_req btm_ble_io_capabilities_req;

struct btm_ble_link_encrypted btm_ble_link_encrypted;

struct btm_ble_link_sec_check btm_ble_link_sec_check;

struct btm_ble_ltk_request btm_ble_ltk_request;

struct btm_ble_ltk_request_reply btm_ble_ltk_request_reply;

struct btm_ble_rand_enc_complete btm_ble_rand_enc_complete;

struct btm_ble_read_sec_key_size btm_ble_read_sec_key_size;

struct btm_ble_reset_id btm_ble_reset_id;

struct btm_ble_set_encryption btm_ble_set_encryption;

struct btm_ble_set_keep_rfu_in_auth_req btm_ble_set_keep_rfu_in_auth_req;

struct btm_ble_set_no_disc_if_pair_fail btm_ble_set_no_disc_if_pair_fail;

struct btm_ble_set_test_local_sign_cntr_value

    btm_ble_set_test_local_sign_cntr_value;

struct btm_ble_set_test_mac_value btm_ble_set_test_mac_value;

struct btm_ble_start_encrypt btm_ble_start_encrypt;

struct btm_ble_start_sec_check btm_ble_start_sec_check;

struct btm_ble_test_command_complete btm_ble_test_command_complete;

struct btm_ble_update_sec_key_size btm_ble_update_sec_key_size;

struct btm_get_local_div btm_get_local_div;

struct btm_proc_smp_cback btm_proc_smp_cback;

struct btm_sec_save_le_key btm_sec_save_le_key;

struct doNothing doNothing;

struct read_phy_cb read_phy_cb;

}  // namespace stack_btm_ble

}  // namespace mock

}  // namespace test

// Mocked function return values, if any

namespace test {

namespace mock {

namespace stack_btm_ble {

bool BTM_BleDataSignature::return_value = false;

bool BTM_BleVerifySignature::return_value = false;

const Octet16 BTM_GetDeviceDHK::return_value{0xd5, 0xcb, 0x84, 0x54, 0xd1, 0x77,

                                             0x73, 0x3e, 0xff, 0xff, 0xb2, 0xec,

                                             0x71, 0x2b, 0xae, 0xab};

const Octet16 BTM_GetDeviceEncRoot::return_value{

    0xd5, 0xcb, 0x84, 0x54, 0xd1, 0x77, 0x73, 0x3e,

    0xff, 0xff, 0xb2, 0xec, 0x71, 0x2b, 0xae, 0xab};

const Octet16 BTM_GetDeviceIDRoot::return_value{

    0xd5, 0xcb, 0x84, 0x54, 0xd1, 0x77, 0x73, 0x3e,

    0xff, 0xff, 0xb2, 0xec, 0x71, 0x2b, 0xae, 0xab};

bool BTM_ReadConnectedTransportAddress::return_value = false;

tBTM_STATUS BTM_SetBleDataLength::return_value = 0;

bool BTM_UseLeLink::return_value = false;

uint8_t btm_ble_br_keys_req::return_value = 0;

tBTM_SEC_ACTION btm_ble_determine_security_act::return_value = 0;

bool btm_ble_get_acl_remote_addr::return_value = false;

bool btm_ble_get_enc_key_type::return_value = false;

uint8_t btm_ble_io_capabilities_req::return_value = 0;

uint8_t btm_ble_read_sec_key_size::return_value = 0;

tBTM_STATUS btm_ble_set_encryption::return_value = 0;

tBTM_STATUS btm_ble_start_encrypt::return_value = 0;

tL2CAP_LE_RESULT_CODE btm_ble_start_sec_check::return_value =

    L2CAP_LE_RESULT_CONN_OK;

bool btm_get_local_div::return_value = false;

tBTM_STATUS btm_proc_smp_cback::return_value = 0;

}  // namespace stack_btm_ble

}  // namespace mock

}  // namespace test

// Mocked functions, if any

void BTM_BleConfirmReply(const RawAddress& bd_addr, uint8_t res) {

  mock_function_count_map[__func__]++;

  return 0;

  test::mock::stack_btm_ble::BTM_BleConfirmReply(bd_addr, res);

}

void BTM_BleConfirmReply(const RawAddress& bd_addr, uint8_t res) {

bool BTM_BleDataSignature(const RawAddress& bd_addr, uint8_t* p_text,

                          uint16_t len, BLE_SIGNATURE signature) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::BTM_BleDataSignature(bd_addr, p_text, len,

                                                         signature);

}

void BTM_BleLoadLocalKeys(uint8_t key_type, tBTM_BLE_LOCAL_KEYS* p_key) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BleLoadLocalKeys(key_type, p_key);

}

void BTM_BleOobDataReply(const RawAddress& bd_addr, uint8_t res, uint8_t len,

                         uint8_t* p_data) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BleOobDataReply(bd_addr, res, len, p_data);

}

void BTM_BlePasskeyReply(const RawAddress& bd_addr, uint8_t res,

                         uint32_t passkey) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BlePasskeyReply(bd_addr, res, passkey);

}

void BTM_BleReadPhy(

    const RawAddress& bd_addr,

    base::Callback<void(uint8_t tx_phy, uint8_t rx_phy, uint8_t status)> cb) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BleReadPhy(bd_addr, cb);

}

void BTM_BleReceiverTest(uint8_t rx_freq, tBTM_CMPL_CB* p_cmd_cmpl_cback) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BleReceiverTest(rx_freq, p_cmd_cmpl_cback);

}

void BTM_BleSecureConnectionOobDataReply(const RawAddress& bd_addr,

                                         uint8_t* p_c, uint8_t* p_r) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BleSecureConnectionOobDataReply(bd_addr, p_c,

                                                                 p_r);

}

void BTM_BleSetPhy(const RawAddress& bd_addr, uint8_t tx_phys, uint8_t rx_phys,

                   uint16_t phy_options) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BleSetPhy(bd_addr, tx_phys, rx_phys,

                                           phy_options);

}

void BTM_BleSetPrefConnParams(const RawAddress& bd_addr, uint16_t min_conn_int,

                              uint16_t max_conn_int,

                              uint16_t peripheral_latency,

                              uint16_t supervision_tout) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BleSetPrefConnParams(

      bd_addr, min_conn_int, max_conn_int, peripheral_latency,

      supervision_tout);

}

void BTM_BleTestEnd(tBTM_CMPL_CB* p_cmd_cmpl_cback) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BleTestEnd(p_cmd_cmpl_cback);

}

void BTM_BleTransmitterTest(uint8_t tx_freq, uint8_t test_data_len,

                            uint8_t packet_payload,

                            tBTM_CMPL_CB* p_cmd_cmpl_cback) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_BleTransmitterTest(

      tx_freq, test_data_len, packet_payload, p_cmd_cmpl_cback);

}

bool BTM_BleVerifySignature(const RawAddress& bd_addr, uint8_t* p_orig,

                            uint16_t len, uint32_t counter, uint8_t* p_comp) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::BTM_BleVerifySignature(bd_addr, p_orig, len,

                                                           counter, p_comp);

}

const Octet16& BTM_GetDeviceDHK() {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::BTM_GetDeviceDHK();

}

const Octet16& BTM_GetDeviceEncRoot() {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::BTM_GetDeviceEncRoot();

}

const Octet16& BTM_GetDeviceIDRoot() {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::BTM_GetDeviceIDRoot();

}

bool BTM_ReadConnectedTransportAddress(RawAddress* remote_bda,

                                       tBT_TRANSPORT transport) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::BTM_ReadConnectedTransportAddress(

      remote_bda, transport);

}

void BTM_ReadDevInfo(const RawAddress& remote_bda, tBT_DEVICE_TYPE* p_dev_type,

                     tBLE_ADDR_TYPE* p_addr_type) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_ReadDevInfo(remote_bda, p_dev_type,

                                             p_addr_type);

}

void BTM_SecAddBleDevice(const RawAddress& bd_addr, tBT_DEVICE_TYPE dev_type,

                         tBLE_ADDR_TYPE addr_type) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_SecAddBleDevice(bd_addr, dev_type, addr_type);

}

void BTM_SecAddBleKey(const RawAddress& bd_addr, tBTM_LE_KEY_VALUE* p_le_key,

                      tBTM_LE_KEY_TYPE key_type) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_SecAddBleKey(bd_addr, p_le_key, key_type);

}

void BTM_SecurityGrant(const RawAddress& bd_addr, uint8_t res) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::BTM_SecurityGrant(bd_addr, res);

}

tBTM_STATUS BTM_SetBleDataLength(const RawAddress& bd_addr,

                                 uint16_t tx_pdu_length) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::BTM_SetBleDataLength(bd_addr,

                                                         tx_pdu_length);

}

bool BTM_UseLeLink(const RawAddress& bd_addr) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::BTM_UseLeLink(bd_addr);

}

uint8_t btm_ble_br_keys_req(tBTM_SEC_DEV_REC* p_dev_rec,

                            tBTM_LE_IO_REQ* p_data) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_ble_br_keys_req(p_dev_rec, p_data);

}

void btm_ble_connected(const RawAddress& bda, uint16_t handle, uint8_t enc_mode,

                       uint8_t role, tBLE_ADDR_TYPE addr_type,

                       bool addr_matched) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_connected(bda, handle, enc_mode, role,

                                               addr_type, addr_matched);

}

void btm_ble_connected_from_address_with_type(

    const tBLE_BD_ADDR& address_with_type, uint16_t handle, uint8_t enc_mode,

    uint8_t role, bool addr_matched) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_connected_from_address_with_type(

      address_with_type, handle, enc_mode, role, addr_matched);

}

tBTM_SEC_ACTION btm_ble_determine_security_act(bool is_originator,

                                               const RawAddress& bdaddr,

                                               uint16_t security_required) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_ble_determine_security_act(

      is_originator, bdaddr, security_required);

}

bool btm_ble_get_acl_remote_addr(uint16_t hci_handle, RawAddress& conn_addr,

                                 tBLE_ADDR_TYPE* p_addr_type) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_ble_get_acl_remote_addr(

      hci_handle, conn_addr, p_addr_type);

}

bool btm_ble_get_enc_key_type(const RawAddress& bd_addr, uint8_t* p_key_types) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_ble_get_enc_key_type(bd_addr,

                                                             p_key_types);

}

void btm_ble_increment_sign_ctr(const RawAddress& bd_addr, bool is_local) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_increment_sign_ctr(bd_addr, is_local);

}

uint8_t btm_ble_io_capabilities_req(tBTM_SEC_DEV_REC* p_dev_rec,

                                    tBTM_LE_IO_REQ* p_data) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_ble_io_capabilities_req(p_dev_rec,

                                                                p_data);

}

void btm_ble_link_encrypted(const RawAddress& bd_addr, uint8_t encr_enable) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_link_encrypted(bd_addr, encr_enable);

}

void btm_ble_link_sec_check(const RawAddress& bd_addr,

                            tBTM_LE_AUTH_REQ auth_req,

                            tBTM_BLE_SEC_REQ_ACT* p_sec_req_act) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_link_sec_check(bd_addr, auth_req,

                                                    p_sec_req_act);

}

void btm_ble_ltk_request(uint16_t handle, uint8_t rand[8], uint16_t ediv) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_ltk_request(handle, rand, ediv);

}

void btm_ble_ltk_request_reply(const RawAddress& bda, bool use_stk,

                               const Octet16& stk) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_ltk_request_reply(bda, use_stk, stk);

}

void btm_ble_rand_enc_complete(uint8_t* p, uint16_t op_code,

                               tBTM_RAND_ENC_CB* p_enc_cplt_cback) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_rand_enc_complete(p, op_code,

                                                       p_enc_cplt_cback);

}

uint8_t btm_ble_read_sec_key_size(const RawAddress& bd_addr) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_ble_read_sec_key_size(bd_addr);

}

void btm_ble_reset_id(void) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_reset_id();

}

tBTM_STATUS btm_ble_set_encryption(const RawAddress& bd_addr,

                                   tBTM_BLE_SEC_ACT sec_act,

                                   uint8_t link_role) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_ble_set_encryption(bd_addr, sec_act,

                                                           link_role);

}

void btm_ble_set_keep_rfu_in_auth_req(bool keep_rfu) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_set_keep_rfu_in_auth_req(keep_rfu);

}

void btm_ble_set_no_disc_if_pair_fail(bool disable_disc) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_set_no_disc_if_pair_fail(disable_disc);

}

void btm_ble_set_test_local_sign_cntr_value(bool enable,

                                            uint32_t test_local_sign_cntr) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_set_test_local_sign_cntr_value(

      enable, test_local_sign_cntr);

}

void btm_ble_set_test_mac_value(bool enable, uint8_t* p_test_mac_val) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_set_test_mac_value(enable, p_test_mac_val);

}

tBTM_STATUS btm_ble_start_encrypt(const RawAddress& bda, bool use_stk,

                                  Octet16* p_stk) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_ble_start_encrypt(bda, use_stk, p_stk);

}

tL2CAP_LE_RESULT_CODE btm_ble_start_sec_check(const RawAddress& bd_addr,

                                              uint16_t psm, bool is_originator,

                                              tBTM_SEC_CALLBACK* p_callback,

                                              void* p_ref_data) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_ble_start_sec_check(

      bd_addr, psm, is_originator, p_callback, p_ref_data);

}

void btm_ble_test_command_complete(uint8_t* p) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_test_command_complete(p);

}

void btm_ble_update_sec_key_size(const RawAddress& bd_addr,

                                 uint8_t enc_key_size) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_ble_update_sec_key_size(bd_addr, enc_key_size);

}

bool btm_get_local_div(const RawAddress& bd_addr, uint16_t* p_div) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_get_local_div(bd_addr, p_div);

}

tBTM_STATUS btm_proc_smp_cback(tSMP_EVT event, const RawAddress& bd_addr,

                               const tSMP_EVT_DATA* p_data) {

  mock_function_count_map[__func__]++;

  return test::mock::stack_btm_ble::btm_proc_smp_cback(event, bd_addr, p_data);

}

void btm_sec_save_le_key(const RawAddress& bd_addr, tBTM_LE_KEY_TYPE key_type,

                         tBTM_LE_KEY_VALUE* p_keys, bool pass_to_application) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::btm_sec_save_le_key(bd_addr, key_type, p_keys,

                                                 pass_to_application);

}

void doNothing(uint8_t* data, uint16_t len) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::doNothing(data, len);

}

void read_phy_cb(

    base::Callback<void(uint8_t tx_phy, uint8_t rx_phy, uint8_t status)> cb,

    uint8_t* data, uint16_t len) {

  mock_function_count_map[__func__]++;

  test::mock::stack_btm_ble::read_phy_cb(cb, data, len);

}

void btm_ble_reset_id(void) {

  mock_function_count_map[__func__]++;

}

// Mocked functions complete

// END mockcify generation