| /* |
| * 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:45 |
| * |
| * mockcify.pl ver 0.2 |
| */ |
| |
| #include "test/mock/mock_main_shim_l2cap_api.h" |
| |
| #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 |
| |
| // Mocked compile conditionals, if any |
| #ifndef UNUSED_ATTR |
| #define UNUSED_ATTR |
| #endif |
| |
| // Mocked internal structures, if any |
| |
| namespace test { |
| namespace mock { |
| namespace main_shim_l2cap_api { |
| |
| // Function state capture and return values, if needed |
| struct L2CA_ReadRemoteVersion L2CA_ReadRemoteVersion; |
| struct L2CA_ReadRemoteFeatures L2CA_ReadRemoteFeatures; |
| struct L2CA_UseLegacySecurityModule L2CA_UseLegacySecurityModule; |
| struct L2CA_Register L2CA_Register; |
| struct L2CA_Deregister L2CA_Deregister; |
| struct L2CA_ConnectReq L2CA_ConnectReq; |
| struct L2CA_DisconnectReq L2CA_DisconnectReq; |
| struct L2CA_DataWrite L2CA_DataWrite; |
| struct L2CA_ReconfigCreditBasedConnsReq L2CA_ReconfigCreditBasedConnsReq; |
| struct L2CA_ConnectCreditBasedReq L2CA_ConnectCreditBasedReq; |
| struct L2CA_ConnectCreditBasedRsp L2CA_ConnectCreditBasedRsp; |
| struct L2CA_SetIdleTimeoutByBdAddr L2CA_SetIdleTimeoutByBdAddr; |
| struct L2CA_SetAclPriority L2CA_SetAclPriority; |
| struct L2CA_SetAclPriority2 L2CA_SetAclPriority2; |
| struct L2CA_GetPeerFeatures L2CA_GetPeerFeatures; |
| struct L2CA_RegisterFixedChannel L2CA_RegisterFixedChannel; |
| struct L2CA_ConnectFixedChnl L2CA_ConnectFixedChnl; |
| struct L2CA_SendFixedChnlData L2CA_SendFixedChnlData; |
| struct L2CA_RemoveFixedChnl L2CA_RemoveFixedChnl; |
| struct L2CA_GetLeHandle L2CA_GetLeHandle; |
| struct L2CA_LeConnectionUpdate L2CA_LeConnectionUpdate; |
| struct L2CA_EnableUpdateBleConnParams L2CA_EnableUpdateBleConnParams; |
| struct L2CA_GetRemoteCid L2CA_GetRemoteCid; |
| struct L2CA_SetTxPriority L2CA_SetTxPriority; |
| struct L2CA_SetLeGattTimeout L2CA_SetLeGattTimeout; |
| struct L2CA_SetChnlFlushability L2CA_SetChnlFlushability; |
| struct L2CA_FlushChannel L2CA_FlushChannel; |
| struct L2CA_IsLinkEstablished L2CA_IsLinkEstablished; |
| struct L2CA_IsLeLink L2CA_IsLeLink; |
| struct L2CA_ReadConnectionAddr L2CA_ReadConnectionAddr; |
| struct L2CA_ReadRemoteConnectionAddr L2CA_ReadRemoteConnectionAddr; |
| struct L2CA_GetBleConnRole L2CA_GetBleConnRole; |
| struct L2CA_ConnectForSecurity L2CA_ConnectForSecurity; |
| struct L2CA_SetBondingState L2CA_SetBondingState; |
| struct L2CA_DisconnectLink L2CA_DisconnectLink; |
| struct L2CA_GetNumLinks L2CA_GetNumLinks; |
| struct L2CA_AllocateLePSM L2CA_AllocateLePSM; |
| struct L2CA_FreeLePSM L2CA_FreeLePSM; |
| struct L2CA_RegisterLECoc L2CA_RegisterLECoc; |
| struct L2CA_DeregisterLECoc L2CA_DeregisterLECoc; |
| struct L2CA_ConnectLECocReq L2CA_ConnectLECocReq; |
| struct L2CA_GetPeerLECocConfig L2CA_GetPeerLECocConfig; |
| struct L2CA_DisconnectLECocReq L2CA_DisconnectLECocReq; |
| struct L2CA_LECocDataWrite L2CA_LECocDataWrite; |
| struct L2CA_SwitchRoleToCentral L2CA_SwitchRoleToCentral; |
| |
| } // namespace main_shim_l2cap_api |
| } // namespace mock |
| } // namespace test |
| |
| // Mocked functions, if any |
| bool bluetooth::shim::L2CA_ReadRemoteVersion(const RawAddress& addr, |
| uint8_t* lmp_version, |
| uint16_t* manufacturer, |
| uint16_t* lmp_sub_version) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_ReadRemoteVersion( |
| addr, lmp_version, manufacturer, lmp_sub_version); |
| } |
| uint8_t* bluetooth::shim::L2CA_ReadRemoteFeatures(const RawAddress& addr) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_ReadRemoteFeatures(addr); |
| } |
| void bluetooth::shim::L2CA_UseLegacySecurityModule() { |
| mock_function_count_map[__func__]++; |
| test::mock::main_shim_l2cap_api::L2CA_UseLegacySecurityModule(); |
| } |
| uint16_t bluetooth::shim::L2CA_Register( |
| uint16_t client_psm, const tL2CAP_APPL_INFO& callbacks, bool enable_snoop, |
| tL2CAP_ERTM_INFO* p_ertm_info, uint16_t my_mtu, |
| uint16_t required_remote_mtu, uint16_t sec_level) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_Register( |
| client_psm, callbacks, enable_snoop, p_ertm_info, my_mtu, |
| required_remote_mtu, sec_level); |
| } |
| void bluetooth::shim::L2CA_Deregister(uint16_t psm) { |
| mock_function_count_map[__func__]++; |
| test::mock::main_shim_l2cap_api::L2CA_Deregister(psm); |
| } |
| uint16_t bluetooth::shim::L2CA_ConnectReq(uint16_t psm, |
| const RawAddress& raw_address) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_ConnectReq(psm, raw_address); |
| } |
| bool bluetooth::shim::L2CA_DisconnectReq(uint16_t cid) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_DisconnectReq(cid); |
| } |
| uint8_t bluetooth::shim::L2CA_DataWrite(uint16_t cid, BT_HDR* p_data) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_DataWrite(cid, p_data); |
| } |
| bool bluetooth::shim::L2CA_ReconfigCreditBasedConnsReq( |
| const RawAddress& bd_addr, std::vector<uint16_t>& lcids, |
| tL2CAP_LE_CFG_INFO* p_cfg) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_ReconfigCreditBasedConnsReq( |
| bd_addr, lcids, p_cfg); |
| } |
| std::vector<uint16_t> bluetooth::shim::L2CA_ConnectCreditBasedReq( |
| uint16_t psm, const RawAddress& p_bd_addr, tL2CAP_LE_CFG_INFO* p_cfg) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_ConnectCreditBasedReq( |
| psm, p_bd_addr, p_cfg); |
| } |
| bool bluetooth::shim::L2CA_ConnectCreditBasedRsp( |
| const RawAddress& bd_addr, uint8_t id, |
| std::vector<uint16_t>& accepted_lcids, uint16_t result, |
| tL2CAP_LE_CFG_INFO* p_cfg) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_ConnectCreditBasedRsp( |
| bd_addr, id, accepted_lcids, result, p_cfg); |
| } |
| bool bluetooth::shim::L2CA_SetIdleTimeoutByBdAddr(const RawAddress& bd_addr, |
| uint16_t timeout, |
| tBT_TRANSPORT transport) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_SetIdleTimeoutByBdAddr( |
| bd_addr, timeout, transport); |
| } |
| bool bluetooth::shim::L2CA_SetAclPriority(const RawAddress& bd_addr, |
| tL2CAP_PRIORITY priority) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_SetAclPriority2(bd_addr, |
| priority); |
| } |
| bool bluetooth::shim::L2CA_GetPeerFeatures(const RawAddress& bd_addr, |
| uint32_t* p_ext_feat, |
| uint8_t* p_chnl_mask) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_GetPeerFeatures( |
| bd_addr, p_ext_feat, p_chnl_mask); |
| } |
| bool bluetooth::shim::L2CA_RegisterFixedChannel(uint16_t cid, |
| tL2CAP_FIXED_CHNL_REG* p_freg) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_RegisterFixedChannel(cid, |
| p_freg); |
| } |
| bool bluetooth::shim::L2CA_ConnectFixedChnl(uint16_t cid, |
| const RawAddress& rem_bda) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_ConnectFixedChnl(cid, rem_bda); |
| } |
| uint16_t bluetooth::shim::L2CA_SendFixedChnlData(uint16_t cid, |
| const RawAddress& rem_bda, |
| BT_HDR* p_buf) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_SendFixedChnlData(cid, rem_bda, |
| p_buf); |
| } |
| bool bluetooth::shim::L2CA_RemoveFixedChnl(uint16_t cid, |
| const RawAddress& rem_bda) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_RemoveFixedChnl(cid, rem_bda); |
| } |
| uint16_t bluetooth::shim::L2CA_GetLeHandle(const RawAddress& rem_bda) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_GetLeHandle(rem_bda); |
| } |
| void bluetooth::shim::L2CA_LeConnectionUpdate( |
| const RawAddress& rem_bda, 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::main_shim_l2cap_api::L2CA_LeConnectionUpdate( |
| rem_bda, min_int, max_int, latency, timeout, min_ce_len, max_ce_len); |
| } |
| bool bluetooth::shim::L2CA_EnableUpdateBleConnParams(const RawAddress& rem_bda, |
| bool enable) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_EnableUpdateBleConnParams( |
| rem_bda, enable); |
| } |
| bool bluetooth::shim::L2CA_GetRemoteCid(uint16_t lcid, uint16_t* rcid) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_GetRemoteCid(lcid, rcid); |
| } |
| bool bluetooth::shim::L2CA_SetTxPriority(uint16_t cid, |
| tL2CAP_CHNL_PRIORITY priority) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_SetTxPriority(cid, priority); |
| } |
| bool bluetooth::shim::L2CA_SetLeGattTimeout(const RawAddress& rem_bda, |
| uint16_t idle_tout) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_SetLeGattTimeout(rem_bda, |
| idle_tout); |
| } |
| bool bluetooth::shim::L2CA_SetChnlFlushability(uint16_t cid, |
| bool is_flushable) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_SetChnlFlushability( |
| cid, is_flushable); |
| } |
| uint16_t bluetooth::shim::L2CA_FlushChannel(uint16_t lcid, |
| uint16_t num_to_flush) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_FlushChannel(lcid, num_to_flush); |
| } |
| bool bluetooth::shim::L2CA_IsLinkEstablished(const RawAddress& bd_addr, |
| tBT_TRANSPORT transport) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_IsLinkEstablished(bd_addr, |
| transport); |
| } |
| bool bluetooth::shim::L2CA_IsLeLink(uint16_t acl_handle) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_IsLeLink(acl_handle); |
| } |
| void bluetooth::shim::L2CA_ReadConnectionAddr(const RawAddress& pseudo_addr, |
| RawAddress& conn_addr, |
| uint8_t* p_addr_type) { |
| mock_function_count_map[__func__]++; |
| test::mock::main_shim_l2cap_api::L2CA_ReadConnectionAddr( |
| pseudo_addr, conn_addr, p_addr_type); |
| } |
| bool bluetooth::shim::L2CA_ReadRemoteConnectionAddr( |
| const RawAddress& pseudo_addr, RawAddress& conn_addr, |
| uint8_t* p_addr_type) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_ReadRemoteConnectionAddr( |
| pseudo_addr, conn_addr, p_addr_type); |
| } |
| hci_role_t bluetooth::shim::L2CA_GetBleConnRole(const RawAddress& bd_addr) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_GetBleConnRole(bd_addr); |
| } |
| void bluetooth::shim::L2CA_ConnectForSecurity(const RawAddress& bd_addr) { |
| mock_function_count_map[__func__]++; |
| test::mock::main_shim_l2cap_api::L2CA_ConnectForSecurity(bd_addr); |
| } |
| void bluetooth::shim::L2CA_SetBondingState(const RawAddress& bd_addr, |
| bool is_bonding) { |
| mock_function_count_map[__func__]++; |
| test::mock::main_shim_l2cap_api::L2CA_SetBondingState(bd_addr, is_bonding); |
| } |
| void bluetooth::shim::L2CA_DisconnectLink(const RawAddress& remote) { |
| mock_function_count_map[__func__]++; |
| test::mock::main_shim_l2cap_api::L2CA_DisconnectLink(remote); |
| } |
| uint16_t bluetooth::shim::L2CA_GetNumLinks() { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_GetNumLinks(); |
| } |
| uint16_t bluetooth::shim::L2CA_AllocateLePSM() { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_AllocateLePSM(); |
| } |
| void bluetooth::shim::L2CA_FreeLePSM(uint16_t psm) { |
| mock_function_count_map[__func__]++; |
| test::mock::main_shim_l2cap_api::L2CA_FreeLePSM(psm); |
| } |
| uint16_t bluetooth::shim::L2CA_RegisterLECoc(uint16_t psm, |
| const tL2CAP_APPL_INFO& callbacks, |
| uint16_t sec_level, |
| tL2CAP_LE_CFG_INFO cfg) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_RegisterLECoc(psm, callbacks, |
| sec_level, cfg); |
| } |
| void bluetooth::shim::L2CA_DeregisterLECoc(uint16_t psm) { |
| mock_function_count_map[__func__]++; |
| test::mock::main_shim_l2cap_api::L2CA_DeregisterLECoc(psm); |
| } |
| uint16_t bluetooth::shim::L2CA_ConnectLECocReq(uint16_t psm, |
| const RawAddress& p_bd_addr, |
| tL2CAP_LE_CFG_INFO* p_cfg) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_ConnectLECocReq(psm, p_bd_addr, |
| p_cfg); |
| } |
| bool bluetooth::shim::L2CA_GetPeerLECocConfig(uint16_t cid, |
| tL2CAP_LE_CFG_INFO* peer_cfg) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_GetPeerLECocConfig(cid, |
| peer_cfg); |
| } |
| bool bluetooth::shim::L2CA_DisconnectLECocReq(uint16_t cid) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_DisconnectLECocReq(cid); |
| } |
| uint8_t bluetooth::shim::L2CA_LECocDataWrite(uint16_t cid, BT_HDR* p_data) { |
| mock_function_count_map[__func__]++; |
| return test::mock::main_shim_l2cap_api::L2CA_LECocDataWrite(cid, p_data); |
| } |
| void bluetooth::shim::L2CA_SwitchRoleToCentral(const RawAddress& addr) { |
| mock_function_count_map[__func__]++; |
| test::mock::main_shim_l2cap_api::L2CA_SwitchRoleToCentral(addr); |
| } |
| |
| // END mockcify generation |
