| /* |
| * 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:34 |
| * |
| * mockcify.pl ver 0.3.0 |
| */ |
| |
| #include <cstdint> |
| #include <functional> |
| #include <map> |
| #include <string> |
| |
| #include "stack/include/bt_octets.h" |
| |
| 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_api.h" |
| #include "types/raw_address.h" |
| |
| // Mocked internal structures, if any |
| |
| namespace test { |
| namespace mock { |
| namespace bta_dm_api { |
| |
| // Function state capture and return values, if needed |
| struct BTA_DmAddBleDevice BTA_DmAddBleDevice; |
| struct BTA_DmAddBleKey BTA_DmAddBleKey; |
| struct BTA_DmAddDevice BTA_DmAddDevice; |
| struct BTA_DmBleConfigLocalPrivacy BTA_DmBleConfigLocalPrivacy; |
| struct BTA_DmBleConfirmReply BTA_DmBleConfirmReply; |
| struct BTA_DmBleCsisObserve BTA_DmBleCsisObserve; |
| struct BTA_DmBleGetEnergyInfo BTA_DmBleGetEnergyInfo; |
| struct BTA_DmBleObserve BTA_DmBleObserve; |
| struct BTA_DmBlePasskeyReply BTA_DmBlePasskeyReply; |
| struct BTA_DmBleRequestMaxTxDataLength BTA_DmBleRequestMaxTxDataLength; |
| struct BTA_DmBleScan BTA_DmBleScan; |
| struct BTA_DmBleSecurityGrant BTA_DmBleSecurityGrant; |
| struct BTA_DmBleUpdateConnectionParams BTA_DmBleUpdateConnectionParams; |
| struct BTA_DmBond BTA_DmBond; |
| struct BTA_DmBondCancel BTA_DmBondCancel; |
| struct BTA_DmCloseACL BTA_DmCloseACL; |
| struct BTA_DmConfirm BTA_DmConfirm; |
| struct BTA_DmDiscover BTA_DmDiscover; |
| struct BTA_DmGetConnectionState BTA_DmGetConnectionState; |
| struct BTA_DmLocalOob BTA_DmLocalOob; |
| struct BTA_DmPinReply BTA_DmPinReply; |
| struct BTA_DmRemoveDevice BTA_DmRemoveDevice; |
| struct BTA_DmSearch BTA_DmSearch; |
| struct BTA_DmSearchCancel BTA_DmSearchCancel; |
| struct BTA_DmSetBlePrefConnParams BTA_DmSetBlePrefConnParams; |
| struct BTA_DmSetDeviceName BTA_DmSetDeviceName; |
| struct BTA_DmSetEncryption BTA_DmSetEncryption; |
| struct BTA_DmSetLocalDiRecord BTA_DmSetLocalDiRecord; |
| struct BTA_EnableTestMode BTA_EnableTestMode; |
| struct BTA_GetEirService BTA_GetEirService; |
| struct BTA_VendorInit BTA_VendorInit; |
| struct BTA_dm_init BTA_dm_init; |
| |
| } // namespace bta_dm_api |
| } // namespace mock |
| } // namespace test |
| |
| // Mocked functions, if any |
| void BTA_DmAddBleDevice(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, |
| tBT_DEVICE_TYPE dev_type) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmAddBleDevice(bd_addr, addr_type, dev_type); |
| } |
| void BTA_DmAddBleKey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key, |
| tBTM_LE_KEY_TYPE key_type) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmAddBleKey(bd_addr, p_le_key, key_type); |
| } |
| void BTA_DmAddDevice(const RawAddress& bd_addr, DEV_CLASS dev_class, |
| const LinkKey& link_key, uint8_t key_type, |
| uint8_t pin_length) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmAddDevice(bd_addr, dev_class, link_key, |
| key_type, pin_length); |
| } |
| void BTA_DmBleConfigLocalPrivacy(bool privacy_enable) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBleConfigLocalPrivacy(privacy_enable); |
| } |
| void BTA_DmBleConfirmReply(const RawAddress& bd_addr, bool accept) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBleConfirmReply(bd_addr, accept); |
| } |
| void BTA_DmBleCsisObserve(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBleCsisObserve(observe, p_results_cb); |
| } |
| void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBleGetEnergyInfo(p_cmpl_cback); |
| } |
| void BTA_DmBleObserve(bool start, uint8_t duration, |
| tBTA_DM_SEARCH_CBACK* p_results_cb) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBleObserve(start, duration, p_results_cb); |
| } |
| void BTA_DmBlePasskeyReply(const RawAddress& bd_addr, bool accept, |
| uint32_t passkey) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBlePasskeyReply(bd_addr, accept, passkey); |
| } |
| void BTA_DmBleRequestMaxTxDataLength(const RawAddress& remote_device) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBleRequestMaxTxDataLength(remote_device); |
| } |
| void BTA_DmBleScan(bool start, uint8_t duration) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBleScan(start, duration); |
| } |
| void BTA_DmBleSecurityGrant(const RawAddress& bd_addr, |
| tBTA_DM_BLE_SEC_GRANT res) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBleSecurityGrant(bd_addr, res); |
| } |
| void BTA_DmBleUpdateConnectionParams(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_api::BTA_DmBleUpdateConnectionParams( |
| bd_addr, min_int, max_int, latency, timeout, min_ce_len, max_ce_len); |
| } |
| void BTA_DmBond(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_api::BTA_DmBond(bd_addr, addr_type, transport, |
| device_type); |
| } |
| void BTA_DmBondCancel(const RawAddress& bd_addr) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmBondCancel(bd_addr); |
| } |
| void BTA_DmCloseACL(const RawAddress& bd_addr, bool remove_dev, |
| tBT_TRANSPORT transport) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmCloseACL(bd_addr, remove_dev, transport); |
| } |
| void BTA_DmConfirm(const RawAddress& bd_addr, bool accept) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmConfirm(bd_addr, accept); |
| } |
| void BTA_DmDiscover(const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback, |
| tBT_TRANSPORT transport, bool is_bonding_or_sd) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmDiscover(bd_addr, p_cback, transport, |
| is_bonding_or_sd); |
| } |
| bool BTA_DmGetConnectionState(const RawAddress& bd_addr) { |
| mock_function_count_map[__func__]++; |
| return test::mock::bta_dm_api::BTA_DmGetConnectionState(bd_addr); |
| } |
| void BTA_DmLocalOob(void) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmLocalOob(); |
| } |
| void BTA_DmPinReply(const RawAddress& bd_addr, bool accept, uint8_t pin_len, |
| uint8_t* p_pin) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmPinReply(bd_addr, accept, pin_len, p_pin); |
| } |
| tBTA_STATUS BTA_DmRemoveDevice(const RawAddress& bd_addr) { |
| mock_function_count_map[__func__]++; |
| return test::mock::bta_dm_api::BTA_DmRemoveDevice(bd_addr); |
| } |
| void BTA_DmSearch(tBTA_DM_SEARCH_CBACK* p_cback, bool is_bonding_or_sdp) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmSearch(p_cback, is_bonding_or_sdp); |
| } |
| void BTA_DmSearchCancel(void) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmSearchCancel(); |
| } |
| void BTA_DmSetBlePrefConnParams(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::bta_dm_api::BTA_DmSetBlePrefConnParams( |
| bd_addr, min_conn_int, max_conn_int, peripheral_latency, |
| supervision_tout); |
| } |
| void BTA_DmSetDeviceName(char* p_name) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_DmSetDeviceName(p_name); |
| } |
| void BTA_DmSetEncryption(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_api::BTA_DmSetEncryption(bd_addr, transport, p_callback, |
| sec_act); |
| } |
| tBTA_STATUS BTA_DmSetLocalDiRecord(tSDP_DI_RECORD* p_device_info, |
| uint32_t* p_handle) { |
| mock_function_count_map[__func__]++; |
| return test::mock::bta_dm_api::BTA_DmSetLocalDiRecord(p_device_info, |
| p_handle); |
| } |
| void BTA_EnableTestMode(void) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_EnableTestMode(); |
| } |
| void BTA_GetEirService(const uint8_t* p_eir, size_t eir_len, |
| tBTA_SERVICE_MASK* p_services) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_GetEirService(p_eir, eir_len, p_services); |
| } |
| void BTA_VendorInit(void) { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_VendorInit(); |
| } |
| void BTA_dm_init() { |
| mock_function_count_map[__func__]++; |
| test::mock::bta_dm_api::BTA_dm_init(); |
| } |
| |
| // END mockcify generation |