381 lines
15 KiB
C++
381 lines
15 KiB
C++
|
/*
|
||
|
|
* Copyright 2021 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.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Generated mock file from original source file
|
||
|
|
* Functions generated:62
|
||
|
|
*
|
||
|
|
* mockcify.pl ver 0.3.0
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <cstdint>
|
||
|
|
#include <functional>
|
||
|
|
#include <map>
|
||
|
|
#include <string>
|
||
|
|
|
||
|
|
extern std::map<std::string, int> mock_function_count_map;
|
||
|
|
|
||
|
|
// Mock include file to share data between tests and mock
|
||
|
|
#include "test/mock/mock_bta_dm_act.h"
|
||
|
|
#include "types/raw_address.h"
|
||
|
|
|
||
|
|
// Mocked internal structures, if any
|
||
|
|
|
||
|
|
namespace test {
|
||
|
|
namespace mock {
|
||
|
|
namespace bta_dm_act {
|
||
|
|
|
||
|
|
// Function state capture and return values, if needed
|
||
|
|
struct BTA_DmSetVisibility BTA_DmSetVisibility;
|
||
|
|
struct BTA_dm_acl_down BTA_dm_acl_down;
|
||
|
|
struct BTA_dm_acl_up BTA_dm_acl_up;
|
||
|
|
struct BTA_dm_notify_remote_features_complete
|
||
|
|
BTA_dm_notify_remote_features_complete;
|
||
|
|
struct BTA_dm_on_hw_off BTA_dm_on_hw_off;
|
||
|
|
struct BTA_dm_on_hw_on BTA_dm_on_hw_on;
|
||
|
|
struct BTA_dm_report_role_change BTA_dm_report_role_change;
|
||
|
|
struct bta_dm_acl_up bta_dm_acl_up;
|
||
|
|
struct bta_dm_add_ble_device bta_dm_add_ble_device;
|
||
|
|
struct bta_dm_add_blekey bta_dm_add_blekey;
|
||
|
|
struct bta_dm_add_device bta_dm_add_device;
|
||
|
|
struct bta_dm_ble_config_local_privacy bta_dm_ble_config_local_privacy;
|
||
|
|
struct bta_dm_ble_confirm_reply bta_dm_ble_confirm_reply;
|
||
|
|
struct bta_dm_ble_csis_observe bta_dm_ble_csis_observe;
|
||
|
|
struct bta_dm_ble_get_energy_info bta_dm_ble_get_energy_info;
|
||
|
|
struct bta_dm_ble_observe bta_dm_ble_observe;
|
||
|
|
struct bta_dm_ble_passkey_reply bta_dm_ble_passkey_reply;
|
||
|
|
struct bta_dm_ble_scan bta_dm_ble_scan;
|
||
|
|
struct bta_dm_ble_set_conn_params bta_dm_ble_set_conn_params;
|
||
|
|
struct bta_dm_ble_set_data_length bta_dm_ble_set_data_length;
|
||
|
|
struct bta_dm_ble_update_conn_params bta_dm_ble_update_conn_params;
|
||
|
|
struct bta_dm_bond bta_dm_bond;
|
||
|
|
struct bta_dm_bond_cancel bta_dm_bond_cancel;
|
||
|
|
struct bta_dm_check_if_only_hd_connected bta_dm_check_if_only_hd_connected;
|
||
|
|
struct bta_dm_ci_rmt_oob_act bta_dm_ci_rmt_oob_act;
|
||
|
|
struct bta_dm_close_acl bta_dm_close_acl;
|
||
|
|
struct bta_dm_close_gatt_conn bta_dm_close_gatt_conn;
|
||
|
|
struct bta_dm_confirm bta_dm_confirm;
|
||
|
|
struct bta_dm_deinit_cb bta_dm_deinit_cb;
|
||
|
|
struct bta_dm_disable bta_dm_disable;
|
||
|
|
struct bta_dm_disc_result bta_dm_disc_result;
|
||
|
|
struct bta_dm_disc_rmt_name bta_dm_disc_rmt_name;
|
||
|
|
struct bta_dm_discover bta_dm_discover;
|
||
|
|
struct bta_dm_eir_update_cust_uuid bta_dm_eir_update_cust_uuid;
|
||
|
|
struct bta_dm_eir_update_uuid bta_dm_eir_update_uuid;
|
||
|
|
struct bta_dm_enable bta_dm_enable;
|
||
|
|
struct bta_dm_encrypt_cback bta_dm_encrypt_cback;
|
||
|
|
struct bta_dm_execute_queued_request bta_dm_execute_queued_request;
|
||
|
|
struct bta_dm_free_sdp_db bta_dm_free_sdp_db;
|
||
|
|
struct bta_dm_init_cb bta_dm_init_cb;
|
||
|
|
struct bta_dm_inq_cmpl bta_dm_inq_cmpl;
|
||
|
|
struct bta_dm_is_search_request_queued bta_dm_is_search_request_queued;
|
||
|
|
struct bta_dm_pin_reply bta_dm_pin_reply;
|
||
|
|
struct bta_dm_proc_open_evt bta_dm_proc_open_evt;
|
||
|
|
struct bta_dm_process_remove_device bta_dm_process_remove_device;
|
||
|
|
struct bta_dm_queue_disc bta_dm_queue_disc;
|
||
|
|
struct bta_dm_queue_search bta_dm_queue_search;
|
||
|
|
struct bta_dm_remove_device bta_dm_remove_device;
|
||
|
|
struct bta_dm_rm_cback bta_dm_rm_cback;
|
||
|
|
struct bta_dm_rmt_name bta_dm_rmt_name;
|
||
|
|
struct bta_dm_sdp_result bta_dm_sdp_result;
|
||
|
|
struct bta_dm_search_cancel bta_dm_search_cancel;
|
||
|
|
struct bta_dm_search_cancel_notify bta_dm_search_cancel_notify;
|
||
|
|
struct bta_dm_search_clear_queue bta_dm_search_clear_queue;
|
||
|
|
struct bta_dm_search_cmpl bta_dm_search_cmpl;
|
||
|
|
struct bta_dm_search_result bta_dm_search_result;
|
||
|
|
struct bta_dm_search_start bta_dm_search_start;
|
||
|
|
struct bta_dm_set_dev_name bta_dm_set_dev_name;
|
||
|
|
struct bta_dm_set_encryption bta_dm_set_encryption;
|
||
|
|
struct btm_dm_start_gatt_discovery btm_dm_start_gatt_discovery;
|
||
|
|
struct handle_remote_features_complete handle_remote_features_complete;
|
||
|
|
|
||
|
|
} // namespace bta_dm_act
|
||
|
|
} // namespace mock
|
||
|
|
} // namespace test
|
||
|
|
|
||
|
|
// Mocked functions, if any
|
||
|
|
bool BTA_DmSetVisibility(bt_scan_mode_t mode) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
return test::mock::bta_dm_act::BTA_DmSetVisibility(mode);
|
||
|
|
}
|
||
|
|
void BTA_dm_acl_down(const RawAddress bd_addr, tBT_TRANSPORT transport) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::BTA_dm_acl_down(bd_addr, transport);
|
||
|
|
}
|
||
|
|
void BTA_dm_acl_up(const RawAddress bd_addr, tBT_TRANSPORT transport) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::BTA_dm_acl_up(bd_addr, transport);
|
||
|
|
}
|
||
|
|
void BTA_dm_notify_remote_features_complete(const RawAddress bd_addr) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::BTA_dm_notify_remote_features_complete(bd_addr);
|
||
|
|
}
|
||
|
|
void BTA_dm_on_hw_off() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::BTA_dm_on_hw_off();
|
||
|
|
}
|
||
|
|
void BTA_dm_on_hw_on() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::BTA_dm_on_hw_on();
|
||
|
|
}
|
||
|
|
void BTA_dm_report_role_change(const RawAddress bd_addr, tHCI_ROLE new_role,
|
||
|
|
tHCI_STATUS hci_status) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::BTA_dm_report_role_change(bd_addr, new_role,
|
||
|
|
hci_status);
|
||
|
|
}
|
||
|
|
void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_acl_up(bd_addr, transport);
|
||
|
|
}
|
||
|
|
void bta_dm_add_ble_device(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
|
||
|
|
tBT_DEVICE_TYPE dev_type) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_add_ble_device(bd_addr, addr_type, dev_type);
|
||
|
|
}
|
||
|
|
void bta_dm_add_blekey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE blekey,
|
||
|
|
tBTM_LE_KEY_TYPE key_type) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_add_blekey(bd_addr, blekey, key_type);
|
||
|
|
}
|
||
|
|
void bta_dm_add_device(std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_add_device(std::move(msg));
|
||
|
|
}
|
||
|
|
void bta_dm_ble_config_local_privacy(bool privacy_enable) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_config_local_privacy(privacy_enable);
|
||
|
|
}
|
||
|
|
void bta_dm_ble_confirm_reply(const RawAddress& bd_addr, bool accept) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_confirm_reply(bd_addr, accept);
|
||
|
|
}
|
||
|
|
void bta_dm_ble_csis_observe(bool observe, tBTA_DM_SEARCH_CBACK* p_cback) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_csis_observe(observe, p_cback);
|
||
|
|
}
|
||
|
|
void bta_dm_ble_get_energy_info(
|
||
|
|
tBTA_BLE_ENERGY_INFO_CBACK* p_energy_info_cback) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_get_energy_info(p_energy_info_cback);
|
||
|
|
}
|
||
|
|
void bta_dm_ble_observe(bool start, uint8_t duration,
|
||
|
|
tBTA_DM_SEARCH_CBACK* p_cback) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_observe(start, duration, p_cback);
|
||
|
|
}
|
||
|
|
void bta_dm_ble_passkey_reply(const RawAddress& bd_addr, bool accept,
|
||
|
|
uint32_t passkey) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_passkey_reply(bd_addr, accept, passkey);
|
||
|
|
}
|
||
|
|
void bta_dm_ble_scan(bool start, uint8_t duration_sec) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_scan(start, duration_sec);
|
||
|
|
}
|
||
|
|
void bta_dm_ble_set_conn_params(const RawAddress& bd_addr,
|
||
|
|
uint16_t conn_int_min, uint16_t conn_int_max,
|
||
|
|
uint16_t peripheral_latency,
|
||
|
|
uint16_t supervision_tout) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_set_conn_params(
|
||
|
|
bd_addr, conn_int_min, conn_int_max, peripheral_latency,
|
||
|
|
supervision_tout);
|
||
|
|
}
|
||
|
|
void bta_dm_ble_set_data_length(const RawAddress& bd_addr) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_set_data_length(bd_addr);
|
||
|
|
}
|
||
|
|
void bta_dm_ble_update_conn_params(const RawAddress& bd_addr, uint16_t min_int,
|
||
|
|
uint16_t max_int, uint16_t latency,
|
||
|
|
uint16_t timeout, uint16_t min_ce_len,
|
||
|
|
uint16_t max_ce_len) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ble_update_conn_params(
|
||
|
|
bd_addr, min_int, max_int, latency, timeout, min_ce_len, max_ce_len);
|
||
|
|
}
|
||
|
|
void bta_dm_bond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
|
||
|
|
tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_bond(bd_addr, addr_type, transport,
|
||
|
|
device_type);
|
||
|
|
}
|
||
|
|
void bta_dm_bond_cancel(const RawAddress& bd_addr) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_bond_cancel(bd_addr);
|
||
|
|
}
|
||
|
|
bool bta_dm_check_if_only_hd_connected(const RawAddress& peer_addr) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
return test::mock::bta_dm_act::bta_dm_check_if_only_hd_connected(peer_addr);
|
||
|
|
}
|
||
|
|
void bta_dm_ci_rmt_oob_act(std::unique_ptr<tBTA_DM_CI_RMT_OOB> msg) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_ci_rmt_oob_act(std::move(msg));
|
||
|
|
}
|
||
|
|
void bta_dm_close_acl(const RawAddress& bd_addr, bool remove_dev,
|
||
|
|
tBT_TRANSPORT transport) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_close_acl(bd_addr, remove_dev, transport);
|
||
|
|
}
|
||
|
|
void bta_dm_close_gatt_conn(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_close_gatt_conn(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_confirm(const RawAddress& bd_addr, bool accept) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_confirm(bd_addr, accept);
|
||
|
|
}
|
||
|
|
void bta_dm_deinit_cb(void) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_deinit_cb();
|
||
|
|
}
|
||
|
|
void bta_dm_disable() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_disable();
|
||
|
|
}
|
||
|
|
void bta_dm_disc_result(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_disc_result(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_disc_rmt_name(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_disc_rmt_name(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_discover(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_discover(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_eir_update_cust_uuid(const tBTA_CUSTOM_UUID& curr, bool adding) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_eir_update_cust_uuid(curr, adding);
|
||
|
|
}
|
||
|
|
void bta_dm_eir_update_uuid(uint16_t uuid16, bool adding) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_eir_update_uuid(uuid16, adding);
|
||
|
|
}
|
||
|
|
void bta_dm_enable(tBTA_DM_SEC_CBACK* p_sec_cback) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_enable(p_sec_cback);
|
||
|
|
}
|
||
|
|
void bta_dm_encrypt_cback(const RawAddress* bd_addr, tBT_TRANSPORT transport,
|
||
|
|
void* p_ref_data, tBTM_STATUS result) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_encrypt_cback(bd_addr, transport, p_ref_data,
|
||
|
|
result);
|
||
|
|
}
|
||
|
|
void bta_dm_execute_queued_request() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_execute_queued_request();
|
||
|
|
}
|
||
|
|
void bta_dm_free_sdp_db() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_free_sdp_db();
|
||
|
|
}
|
||
|
|
void bta_dm_init_cb(void) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_init_cb();
|
||
|
|
}
|
||
|
|
void bta_dm_inq_cmpl(uint8_t num) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_inq_cmpl(num);
|
||
|
|
}
|
||
|
|
bool bta_dm_is_search_request_queued() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
return test::mock::bta_dm_act::bta_dm_is_search_request_queued();
|
||
|
|
}
|
||
|
|
void bta_dm_pin_reply(std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_pin_reply(std::move(msg));
|
||
|
|
}
|
||
|
|
void bta_dm_proc_open_evt(tBTA_GATTC_OPEN* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_proc_open_evt(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_process_remove_device(const RawAddress& bd_addr) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_process_remove_device(bd_addr);
|
||
|
|
}
|
||
|
|
void bta_dm_queue_disc(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_queue_disc(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_queue_search(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_queue_search(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_remove_device(const RawAddress& bd_addr) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_remove_device(bd_addr);
|
||
|
|
}
|
||
|
|
void bta_dm_rm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, uint8_t app_id,
|
||
|
|
const RawAddress& peer_addr) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_rm_cback(status, id, app_id, peer_addr);
|
||
|
|
}
|
||
|
|
void bta_dm_rmt_name(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_rmt_name(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_sdp_result(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_sdp_result(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_search_cancel() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_search_cancel();
|
||
|
|
}
|
||
|
|
void bta_dm_search_cancel_notify() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_search_cancel_notify();
|
||
|
|
}
|
||
|
|
void bta_dm_search_clear_queue() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_search_clear_queue();
|
||
|
|
}
|
||
|
|
void bta_dm_search_cmpl() {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_search_cmpl();
|
||
|
|
}
|
||
|
|
void bta_dm_search_result(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_search_result(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_search_start(tBTA_DM_MSG* p_data) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_search_start(p_data);
|
||
|
|
}
|
||
|
|
void bta_dm_set_dev_name(const std::vector<uint8_t>& name) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_set_dev_name(name);
|
||
|
|
}
|
||
|
|
void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport,
|
||
|
|
tBTA_DM_ENCRYPT_CBACK* p_callback,
|
||
|
|
tBTM_BLE_SEC_ACT sec_act) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::bta_dm_set_encryption(bd_addr, transport, p_callback,
|
||
|
|
sec_act);
|
||
|
|
}
|
||
|
|
void btm_dm_start_gatt_discovery(const RawAddress& bd_addr) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::btm_dm_start_gatt_discovery(bd_addr);
|
||
|
|
}
|
||
|
|
void handle_remote_features_complete(const RawAddress& bd_addr) {
|
||
|
|
mock_function_count_map[__func__]++;
|
||
|
|
test::mock::bta_dm_act::handle_remote_features_complete(bd_addr);
|
||
|
|
}
|
||
|
|
|
||
|
|
// END mockcify generation
|