• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2021 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 /*
18  * Generated mock file from original source file
19  *   Functions generated:85
20  */
21 
22 #include <cstdint>
23 #include <map>
24 #include <string>
25 
26 extern std::map<std::string, int> mock_function_count_map;
27 
28 #include <base/bind.h>
29 #include <base/callback.h>
30 
31 #include "main/shim/btm_api.h"
32 #include "stack/include/bt_hdr.h"
33 #include "stack/include/bt_octets.h"
34 #include "stack/include/btm_ble_api_types.h"
35 #include "types/bluetooth/uuid.h"
36 #include "types/bt_transport.h"
37 #include "types/raw_address.h"
38 
39 #ifndef UNUSED_ATTR
40 #define UNUSED_ATTR
41 #endif
42 
43 Octet16 octet16;
44 
BTM_BleDataSignature(const RawAddress & bd_addr,uint8_t * p_text,uint16_t len,BLE_SIGNATURE signature)45 bool bluetooth::shim::BTM_BleDataSignature(const RawAddress& bd_addr,
46                                            uint8_t* p_text, uint16_t len,
47                                            BLE_SIGNATURE signature) {
48   mock_function_count_map[__func__]++;
49   return false;
50 }
BTM_BleLocalPrivacyEnabled(void)51 bool bluetooth::shim::BTM_BleLocalPrivacyEnabled(void) {
52   mock_function_count_map[__func__]++;
53   return false;
54 }
BTM_BleSecurityProcedureIsRunning(const RawAddress & bd_addr)55 bool bluetooth::shim::BTM_BleSecurityProcedureIsRunning(
56     const RawAddress& bd_addr) {
57   mock_function_count_map[__func__]++;
58   return false;
59 }
BTM_BleVerifySignature(const RawAddress & bd_addr,uint8_t * p_orig,uint16_t len,uint32_t counter,uint8_t * p_comp)60 bool bluetooth::shim::BTM_BleVerifySignature(const RawAddress& bd_addr,
61                                              uint8_t* p_orig, uint16_t len,
62                                              uint32_t counter,
63                                              uint8_t* p_comp) {
64   mock_function_count_map[__func__]++;
65   return false;
66 }
BTM_GetLeSecurityState(const RawAddress & bd_addr,uint8_t * p_le_dev_sec_flags,uint8_t * p_le_key_size)67 bool bluetooth::shim::BTM_GetLeSecurityState(const RawAddress& bd_addr,
68                                              uint8_t* p_le_dev_sec_flags,
69                                              uint8_t* p_le_key_size) {
70   mock_function_count_map[__func__]++;
71   return false;
72 }
BTM_HasEirService(const uint32_t * p_eir_uuid,uint16_t uuid16)73 bool bluetooth::shim::BTM_HasEirService(const uint32_t* p_eir_uuid,
74                                         uint16_t uuid16) {
75   mock_function_count_map[__func__]++;
76   return false;
77 }
BTM_ReadConnectedTransportAddress(RawAddress * remote_bda,tBT_TRANSPORT transport)78 bool bluetooth::shim::BTM_ReadConnectedTransportAddress(
79     RawAddress* remote_bda, tBT_TRANSPORT transport) {
80   mock_function_count_map[__func__]++;
81   return false;
82 }
BTM_ReadRemoteConnectionAddr(const RawAddress & pseudo_addr,RawAddress & conn_addr,tBLE_ADDR_TYPE * p_addr_type)83 bool bluetooth::shim::BTM_ReadRemoteConnectionAddr(
84     const RawAddress& pseudo_addr, RawAddress& conn_addr,
85     tBLE_ADDR_TYPE* p_addr_type) {
86   mock_function_count_map[__func__]++;
87   return false;
88 }
BTM_SecAddDevice(const RawAddress & bd_addr,DEV_CLASS dev_class,const BD_NAME & bd_name,uint8_t * features,LinkKey * link_key,uint8_t key_type,uint8_t pin_length)89 bool bluetooth::shim::BTM_SecAddDevice(const RawAddress& bd_addr,
90                                        DEV_CLASS dev_class,
91                                        const BD_NAME& bd_name,
92                                        uint8_t* features, LinkKey* link_key,
93                                        uint8_t key_type, uint8_t pin_length) {
94   mock_function_count_map[__func__]++;
95   return false;
96 }
BTM_SecAddRmtNameNotifyCallback(tBTM_RMT_NAME_CALLBACK * p_callback)97 bool bluetooth::shim::BTM_SecAddRmtNameNotifyCallback(
98     tBTM_RMT_NAME_CALLBACK* p_callback) {
99   mock_function_count_map[__func__]++;
100   return false;
101 }
BTM_SecDeleteDevice(const RawAddress & bd_addr)102 bool bluetooth::shim::BTM_SecDeleteDevice(const RawAddress& bd_addr) {
103   mock_function_count_map[__func__]++;
104   return false;
105 }
BTM_SecDeleteRmtNameNotifyCallback(tBTM_RMT_NAME_CALLBACK * p_callback)106 bool bluetooth::shim::BTM_SecDeleteRmtNameNotifyCallback(
107     tBTM_RMT_NAME_CALLBACK* p_callback) {
108   mock_function_count_map[__func__]++;
109   return false;
110 }
BTM_SecRegister(const tBTM_APPL_INFO * bta_callbacks)111 bool bluetooth::shim::BTM_SecRegister(const tBTM_APPL_INFO* bta_callbacks) {
112   mock_function_count_map[__func__]++;
113   return false;
114 }
BTM_UseLeLink(const RawAddress & raw_address)115 bool bluetooth::shim::BTM_UseLeLink(const RawAddress& raw_address) {
116   mock_function_count_map[__func__]++;
117   return false;
118 }
BTM_SecReadDevName(const RawAddress & address)119 char* bluetooth::shim::BTM_SecReadDevName(const RawAddress& address) {
120   mock_function_count_map[__func__]++;
121   return nullptr;
122 }
BTM_GetDeviceEncRoot()123 const Octet16& bluetooth::shim::BTM_GetDeviceEncRoot() {
124   mock_function_count_map[__func__]++;
125   return octet16;
126 }
BTM_GetDeviceDHK()127 const Octet16& bluetooth::shim::BTM_GetDeviceDHK() {
128   mock_function_count_map[__func__]++;
129   return octet16;
130 }
BTM_GetDeviceIDRoot()131 const Octet16& bluetooth::shim::BTM_GetDeviceIDRoot() {
132   mock_function_count_map[__func__]++;
133   return octet16;
134 }
BTM_HasInquiryEirService(tBTM_INQ_RESULTS * p_results,uint16_t uuid16)135 tBTM_EIR_SEARCH_RESULT bluetooth::shim::BTM_HasInquiryEirService(
136     tBTM_INQ_RESULTS* p_results, uint16_t uuid16) {
137   mock_function_count_map[__func__]++;
138   return 0;
139 }
BTM_InqDbFirst(void)140 tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbFirst(void) {
141   mock_function_count_map[__func__]++;
142   return nullptr;
143 }
BTM_InqDbNext(tBTM_INQ_INFO * p_cur)144 tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbNext(tBTM_INQ_INFO* p_cur) {
145   mock_function_count_map[__func__]++;
146   return nullptr;
147 }
BTM_InqDbRead(const RawAddress & p_bda)148 tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbRead(const RawAddress& p_bda) {
149   mock_function_count_map[__func__]++;
150   return nullptr;
151 }
BTM_BleObserve(bool start,uint8_t duration_sec,tBTM_INQ_RESULTS_CB * p_results_cb,tBTM_CMPL_CB * p_cmpl_cb)152 tBTM_STATUS bluetooth::shim::BTM_BleObserve(bool start, uint8_t duration_sec,
153                                             tBTM_INQ_RESULTS_CB* p_results_cb,
154                                             tBTM_CMPL_CB* p_cmpl_cb) {
155   mock_function_count_map[__func__]++;
156   return BTM_SUCCESS;
157 }
BTM_BleOpportunisticObserve(bool enable,tBTM_INQ_RESULTS_CB * p_results_cb)158 void bluetooth::shim::BTM_BleOpportunisticObserve(
159     bool enable, tBTM_INQ_RESULTS_CB* p_results_cb) {
160   mock_function_count_map[__func__]++;
161 }
BTM_BleTargetAnnouncementObserve(bool enable,tBTM_INQ_RESULTS_CB * p_results_cb)162 void bluetooth::shim::BTM_BleTargetAnnouncementObserve(
163     bool enable, tBTM_INQ_RESULTS_CB* p_results_cb) {
164   mock_function_count_map[__func__]++;
165 }
BTM_CancelRemoteDeviceName(void)166 tBTM_STATUS bluetooth::shim::BTM_CancelRemoteDeviceName(void) {
167   mock_function_count_map[__func__]++;
168   return BTM_SUCCESS;
169 }
BTM_ClearInqDb(const RawAddress * p_bda)170 tBTM_STATUS bluetooth::shim::BTM_ClearInqDb(const RawAddress* p_bda) {
171   mock_function_count_map[__func__]++;
172   return BTM_SUCCESS;
173 }
BTM_ReadRemoteDeviceName(const RawAddress & raw_address,tBTM_CMPL_CB * callback,tBT_TRANSPORT transport)174 tBTM_STATUS bluetooth::shim::BTM_ReadRemoteDeviceName(
175     const RawAddress& raw_address, tBTM_CMPL_CB* callback,
176     tBT_TRANSPORT transport) {
177   mock_function_count_map[__func__]++;
178   return BTM_SUCCESS;
179 }
BTM_SecBond(const RawAddress & bd_addr,tBLE_ADDR_TYPE addr_type,tBT_TRANSPORT transport,tBT_DEVICE_TYPE device_type)180 tBTM_STATUS bluetooth::shim::BTM_SecBond(const RawAddress& bd_addr,
181                                          tBLE_ADDR_TYPE addr_type,
182                                          tBT_TRANSPORT transport,
183                                          tBT_DEVICE_TYPE device_type) {
184   mock_function_count_map[__func__]++;
185   return BTM_SUCCESS;
186 }
BTM_SecBondCancel(const RawAddress & bd_addr)187 tBTM_STATUS bluetooth::shim::BTM_SecBondCancel(const RawAddress& bd_addr) {
188   mock_function_count_map[__func__]++;
189   return BTM_SUCCESS;
190 }
BTM_SetConnectability(uint16_t page_mode,uint16_t window,uint16_t interval)191 tBTM_STATUS bluetooth::shim::BTM_SetConnectability(uint16_t page_mode,
192                                                    uint16_t window,
193                                                    uint16_t interval) {
194   mock_function_count_map[__func__]++;
195   return BTM_SUCCESS;
196 }
BTM_SetDeviceClass(DEV_CLASS dev_class)197 tBTM_STATUS bluetooth::shim::BTM_SetDeviceClass(DEV_CLASS dev_class) {
198   mock_function_count_map[__func__]++;
199   return BTM_SUCCESS;
200 }
BTM_SetDiscoverability(uint16_t discoverable_mode,uint16_t window,uint16_t interval)201 tBTM_STATUS bluetooth::shim::BTM_SetDiscoverability(uint16_t discoverable_mode,
202                                                     uint16_t window,
203                                                     uint16_t interval) {
204   mock_function_count_map[__func__]++;
205   return BTM_SUCCESS;
206 }
BTM_SetEncryption(const RawAddress & bd_addr,tBT_TRANSPORT transport,tBTM_SEC_CALLBACK * p_callback,void * p_ref_data,tBTM_BLE_SEC_ACT sec_act)207 tBTM_STATUS bluetooth::shim::BTM_SetEncryption(const RawAddress& bd_addr,
208                                                tBT_TRANSPORT transport,
209                                                tBTM_SEC_CALLBACK* p_callback,
210                                                void* p_ref_data,
211                                                tBTM_BLE_SEC_ACT sec_act) {
212   mock_function_count_map[__func__]++;
213   return BTM_SUCCESS;
214 }
BTM_SetInquiryMode(uint8_t inquiry_mode)215 tBTM_STATUS bluetooth::shim::BTM_SetInquiryMode(uint8_t inquiry_mode) {
216   mock_function_count_map[__func__]++;
217   return BTM_SUCCESS;
218 }
BTM_StartInquiry(tBTM_INQ_RESULTS_CB * p_results_cb,tBTM_CMPL_CB * p_cmpl_cb)219 tBTM_STATUS bluetooth::shim::BTM_StartInquiry(tBTM_INQ_RESULTS_CB* p_results_cb,
220                                               tBTM_CMPL_CB* p_cmpl_cb) {
221   mock_function_count_map[__func__]++;
222   return BTM_SUCCESS;
223 }
btm_sec_mx_access_request(const RawAddress & bd_addr,bool is_originator,uint16_t security_requirement,tBTM_SEC_CALLBACK * p_callback,void * p_ref_data)224 tBTM_STATUS bluetooth::shim::btm_sec_mx_access_request(
225     const RawAddress& bd_addr, bool is_originator,
226     uint16_t security_requirement, tBTM_SEC_CALLBACK* p_callback,
227     void* p_ref_data) {
228   mock_function_count_map[__func__]++;
229   return BTM_SUCCESS;
230 }
BTM_GetHCIConnHandle(const RawAddress & remote_bda,tBT_TRANSPORT transport)231 uint16_t bluetooth::shim::BTM_GetHCIConnHandle(const RawAddress& remote_bda,
232                                                tBT_TRANSPORT transport) {
233   mock_function_count_map[__func__]++;
234   return 0;
235 }
BTM_IsInquiryActive(void)236 uint16_t bluetooth::shim::BTM_IsInquiryActive(void) {
237   mock_function_count_map[__func__]++;
238   return 0;
239 }
BTM_BleGetSupportedKeySize(const RawAddress & bd_addr)240 uint8_t bluetooth::shim::BTM_BleGetSupportedKeySize(const RawAddress& bd_addr) {
241   mock_function_count_map[__func__]++;
242   return 0;
243 }
BTM_BleMaxMultiAdvInstanceCount()244 uint8_t bluetooth::shim::BTM_BleMaxMultiAdvInstanceCount() {
245   mock_function_count_map[__func__]++;
246   return 0;
247 }
BTM_AddEirService(uint32_t * p_eir_uuid,uint16_t uuid16)248 void bluetooth::shim::BTM_AddEirService(uint32_t* p_eir_uuid, uint16_t uuid16) {
249   mock_function_count_map[__func__]++;
250 }
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)251 void bluetooth::shim::BTM_BleAdvFilterParamSetup(
252     tBTM_BLE_SCAN_COND_OP action, tBTM_BLE_PF_FILT_INDEX filt_index,
253     std::unique_ptr<btgatt_filt_param_setup_t> p_filt_params,
254     tBTM_BLE_PF_PARAM_CB cb) {
255   mock_function_count_map[__func__]++;
256 }
BTM_BleEnableDisableFilterFeature(uint8_t enable,tBTM_BLE_PF_STATUS_CBACK p_stat_cback)257 void bluetooth::shim::BTM_BleEnableDisableFilterFeature(
258     uint8_t enable, tBTM_BLE_PF_STATUS_CBACK p_stat_cback) {
259   mock_function_count_map[__func__]++;
260 }
BTM_BleLoadLocalKeys(uint8_t key_type,tBTM_BLE_LOCAL_KEYS * p_key)261 void bluetooth::shim::BTM_BleLoadLocalKeys(uint8_t key_type,
262                                            tBTM_BLE_LOCAL_KEYS* p_key) {
263   mock_function_count_map[__func__]++;
264 }
BTM_BleOobDataReply(const RawAddress & bd_addr,uint8_t res,uint8_t len,uint8_t * p_data)265 void bluetooth::shim::BTM_BleOobDataReply(const RawAddress& bd_addr,
266                                           uint8_t res, uint8_t len,
267                                           uint8_t* p_data) {
268   mock_function_count_map[__func__]++;
269 }
BTM_BleReadPhy(const RawAddress & bd_addr,base::Callback<void (uint8_t tx_phy,uint8_t rx_phy,uint8_t status)> cb)270 void bluetooth::shim::BTM_BleReadPhy(
271     const RawAddress& bd_addr,
272     base::Callback<void(uint8_t tx_phy, uint8_t rx_phy, uint8_t status)> cb) {
273   mock_function_count_map[__func__]++;
274 }
BTM_BleReceiverTest(uint8_t rx_freq,tBTM_CMPL_CB * p_cmd_cmpl_cback)275 void bluetooth::shim::BTM_BleReceiverTest(uint8_t rx_freq,
276                                           tBTM_CMPL_CB* p_cmd_cmpl_cback) {
277   mock_function_count_map[__func__]++;
278 }
BTM_BleSecureConnectionOobDataReply(const RawAddress & bd_addr,uint8_t * p_c,uint8_t * p_r)279 void bluetooth::shim::BTM_BleSecureConnectionOobDataReply(
280     const RawAddress& bd_addr, uint8_t* p_c, uint8_t* p_r) {
281   mock_function_count_map[__func__]++;
282 }
BTM_BleSetConnScanParams(uint32_t scan_interval,uint32_t scan_window)283 void bluetooth::shim::BTM_BleSetConnScanParams(uint32_t scan_interval,
284                                                uint32_t scan_window) {
285   mock_function_count_map[__func__]++;
286 }
BTM_BleSetPhy(const RawAddress & bd_addr,uint8_t tx_phys,uint8_t rx_phys,uint16_t phy_options)287 void bluetooth::shim::BTM_BleSetPhy(const RawAddress& bd_addr, uint8_t tx_phys,
288                                     uint8_t rx_phys, uint16_t phy_options) {
289   mock_function_count_map[__func__]++;
290 }
BTM_BleSetPrefConnParams(const RawAddress & bd_addr,uint16_t min_conn_int,uint16_t max_conn_int,uint16_t peripheral_latency,uint16_t supervision_tout)291 void bluetooth::shim::BTM_BleSetPrefConnParams(const RawAddress& bd_addr,
292                                                uint16_t min_conn_int,
293                                                uint16_t max_conn_int,
294                                                uint16_t peripheral_latency,
295                                                uint16_t supervision_tout) {
296   mock_function_count_map[__func__]++;
297 }
BTM_BleTestEnd(tBTM_CMPL_CB * p_cmd_cmpl_cback)298 void bluetooth::shim::BTM_BleTestEnd(tBTM_CMPL_CB* p_cmd_cmpl_cback) {
299   mock_function_count_map[__func__]++;
300 }
BTM_BleTransmitterTest(uint8_t tx_freq,uint8_t test_data_len,uint8_t packet_payload,tBTM_CMPL_CB * p_cmd_cmpl_cback)301 void bluetooth::shim::BTM_BleTransmitterTest(uint8_t tx_freq,
302                                              uint8_t test_data_len,
303                                              uint8_t packet_payload,
304                                              tBTM_CMPL_CB* p_cmd_cmpl_cback) {
305   mock_function_count_map[__func__]++;
306 }
BTM_BleUpdateAdvFilterPolicy(tBTM_BLE_AFP adv_policy)307 void bluetooth::shim::BTM_BleUpdateAdvFilterPolicy(tBTM_BLE_AFP adv_policy) {
308   mock_function_count_map[__func__]++;
309 }
BTM_CancelInquiry(void)310 void bluetooth::shim::BTM_CancelInquiry(void) {
311   mock_function_count_map[__func__]++;
312 }
BTM_ConfirmReqReply(tBTM_STATUS res,const RawAddress & bd_addr)313 void bluetooth::shim::BTM_ConfirmReqReply(tBTM_STATUS res,
314                                           const RawAddress& bd_addr) {
315   mock_function_count_map[__func__]++;
316 }
BTM_EnableInterlacedInquiryScan()317 void bluetooth::shim::BTM_EnableInterlacedInquiryScan() {
318   mock_function_count_map[__func__]++;
319 }
BTM_EnableInterlacedPageScan()320 void bluetooth::shim::BTM_EnableInterlacedPageScan() {
321   mock_function_count_map[__func__]++;
322 }
BTM_LE_PF_addr_filter(tBTM_BLE_SCAN_COND_OP action,tBTM_BLE_PF_FILT_INDEX filt_index,tBLE_BD_ADDR addr,tBTM_BLE_PF_CFG_CBACK cb)323 void bluetooth::shim::BTM_LE_PF_addr_filter(tBTM_BLE_SCAN_COND_OP action,
324                                             tBTM_BLE_PF_FILT_INDEX filt_index,
325                                             tBLE_BD_ADDR addr,
326                                             tBTM_BLE_PF_CFG_CBACK cb) {
327   mock_function_count_map[__func__]++;
328 }
BTM_LE_PF_clear(tBTM_BLE_PF_FILT_INDEX filt_index,tBTM_BLE_PF_CFG_CBACK cb)329 void bluetooth::shim::BTM_LE_PF_clear(tBTM_BLE_PF_FILT_INDEX filt_index,
330                                       tBTM_BLE_PF_CFG_CBACK cb) {
331   mock_function_count_map[__func__]++;
332 }
BTM_LE_PF_local_name(tBTM_BLE_SCAN_COND_OP action,tBTM_BLE_PF_FILT_INDEX filt_index,std::vector<uint8_t> name,tBTM_BLE_PF_CFG_CBACK cb)333 void bluetooth::shim::BTM_LE_PF_local_name(tBTM_BLE_SCAN_COND_OP action,
334                                            tBTM_BLE_PF_FILT_INDEX filt_index,
335                                            std::vector<uint8_t> name,
336                                            tBTM_BLE_PF_CFG_CBACK cb) {
337   mock_function_count_map[__func__]++;
338 }
BTM_LE_PF_manu_data(tBTM_BLE_SCAN_COND_OP action,tBTM_BLE_PF_FILT_INDEX filt_index,uint16_t company_id,uint16_t company_id_mask,std::vector<uint8_t> data,std::vector<uint8_t> data_mask,tBTM_BLE_PF_CFG_CBACK cb)339 void bluetooth::shim::BTM_LE_PF_manu_data(
340     tBTM_BLE_SCAN_COND_OP action, tBTM_BLE_PF_FILT_INDEX filt_index,
341     uint16_t company_id, uint16_t company_id_mask, std::vector<uint8_t> data,
342     std::vector<uint8_t> data_mask, tBTM_BLE_PF_CFG_CBACK cb) {
343   mock_function_count_map[__func__]++;
344 }
BTM_LE_PF_set(tBTM_BLE_PF_FILT_INDEX filt_index,std::vector<ApcfCommand> commands,tBTM_BLE_PF_CFG_CBACK cb)345 void bluetooth::shim::BTM_LE_PF_set(tBTM_BLE_PF_FILT_INDEX filt_index,
346                                     std::vector<ApcfCommand> commands,
347                                     tBTM_BLE_PF_CFG_CBACK cb) {
348   mock_function_count_map[__func__]++;
349 }
BTM_LE_PF_srvc_data(tBTM_BLE_SCAN_COND_OP action,tBTM_BLE_PF_FILT_INDEX filt_index)350 void bluetooth::shim::BTM_LE_PF_srvc_data(tBTM_BLE_SCAN_COND_OP action,
351                                           tBTM_BLE_PF_FILT_INDEX filt_index) {
352   mock_function_count_map[__func__]++;
353 }
BTM_LE_PF_srvc_data_pattern(tBTM_BLE_SCAN_COND_OP action,tBTM_BLE_PF_FILT_INDEX filt_index,std::vector<uint8_t> data,std::vector<uint8_t> data_mask,tBTM_BLE_PF_CFG_CBACK cb)354 void bluetooth::shim::BTM_LE_PF_srvc_data_pattern(
355     tBTM_BLE_SCAN_COND_OP action, tBTM_BLE_PF_FILT_INDEX filt_index,
356     std::vector<uint8_t> data, std::vector<uint8_t> data_mask,
357     tBTM_BLE_PF_CFG_CBACK cb) {
358   mock_function_count_map[__func__]++;
359 }
BTM_LE_PF_uuid_filter(tBTM_BLE_SCAN_COND_OP action,tBTM_BLE_PF_FILT_INDEX filt_index,tBTM_BLE_PF_COND_TYPE filter_type,const bluetooth::Uuid & uuid,tBTM_BLE_PF_LOGIC_TYPE cond_logic,const bluetooth::Uuid & uuid_mask,tBTM_BLE_PF_CFG_CBACK cb)360 void bluetooth::shim::BTM_LE_PF_uuid_filter(tBTM_BLE_SCAN_COND_OP action,
361                                             tBTM_BLE_PF_FILT_INDEX filt_index,
362                                             tBTM_BLE_PF_COND_TYPE filter_type,
363                                             const bluetooth::Uuid& uuid,
364                                             tBTM_BLE_PF_LOGIC_TYPE cond_logic,
365                                             const bluetooth::Uuid& uuid_mask,
366                                             tBTM_BLE_PF_CFG_CBACK cb) {
367   mock_function_count_map[__func__]++;
368 }
BTM_PINCodeReply(const RawAddress & bd_addr,tBTM_STATUS res,uint8_t pin_len,uint8_t * p_pin)369 void bluetooth::shim::BTM_PINCodeReply(const RawAddress& bd_addr,
370                                        tBTM_STATUS res, uint8_t pin_len,
371                                        uint8_t* p_pin) {
372   mock_function_count_map[__func__]++;
373 }
BTM_ReadConnectionAddr(const RawAddress & remote_bda,RawAddress & local_conn_addr,tBLE_ADDR_TYPE * p_addr_type)374 void bluetooth::shim::BTM_ReadConnectionAddr(const RawAddress& remote_bda,
375                                              RawAddress& local_conn_addr,
376                                              tBLE_ADDR_TYPE* p_addr_type) {
377   mock_function_count_map[__func__]++;
378 }
BTM_ReadDevInfo(const RawAddress & remote_bda,tBT_DEVICE_TYPE * p_dev_type,tBLE_ADDR_TYPE * p_addr_type)379 void bluetooth::shim::BTM_ReadDevInfo(const RawAddress& remote_bda,
380                                       tBT_DEVICE_TYPE* p_dev_type,
381                                       tBLE_ADDR_TYPE* p_addr_type) {
382   mock_function_count_map[__func__]++;
383 }
BTM_RemoteOobDataReply(tBTM_STATUS res,const RawAddress & bd_addr,const Octet16 & c,const Octet16 & r)384 void bluetooth::shim::BTM_RemoteOobDataReply(tBTM_STATUS res,
385                                              const RawAddress& bd_addr,
386                                              const Octet16& c,
387                                              const Octet16& r) {
388   mock_function_count_map[__func__]++;
389 }
BTM_SecAddBleDevice(const RawAddress & bd_addr,tBT_DEVICE_TYPE dev_type,tBLE_ADDR_TYPE addr_type)390 void bluetooth::shim::BTM_SecAddBleDevice(const RawAddress& bd_addr,
391                                           tBT_DEVICE_TYPE dev_type,
392                                           tBLE_ADDR_TYPE addr_type) {
393   mock_function_count_map[__func__]++;
394 }
BTM_SecAddBleKey(const RawAddress & bd_addr,tBTM_LE_KEY_VALUE * p_le_key,tBTM_LE_KEY_TYPE key_type)395 void bluetooth::shim::BTM_SecAddBleKey(const RawAddress& bd_addr,
396                                        tBTM_LE_KEY_VALUE* p_le_key,
397                                        tBTM_LE_KEY_TYPE key_type) {
398   mock_function_count_map[__func__]++;
399 }
BTM_SecClearSecurityFlags(const RawAddress & bd_addr)400 void bluetooth::shim::BTM_SecClearSecurityFlags(const RawAddress& bd_addr) {
401   mock_function_count_map[__func__]++;
402 }
BTM_SecurityGrant(const RawAddress & bd_addr,uint8_t res)403 void bluetooth::shim::BTM_SecurityGrant(const RawAddress& bd_addr,
404                                         uint8_t res) {
405   mock_function_count_map[__func__]++;
406 }
SendRemoteNameRequest(const RawAddress & raw_address)407 void bluetooth::shim::SendRemoteNameRequest(const RawAddress& raw_address) {
408   mock_function_count_map[__func__]++;
409 }
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)410 void btm_api_process_extended_inquiry_result(RawAddress raw_address,
411                                              uint8_t page_scan_rep_mode,
412                                              DEV_CLASS device_class,
413                                              uint16_t clock_offset, int8_t rssi,
414                                              const uint8_t* eir_data,
415                                              size_t eir_len) {
416   mock_function_count_map[__func__]++;
417 }
btm_api_process_inquiry_result(const RawAddress & raw_address,uint8_t page_scan_rep_mode,DEV_CLASS device_class,uint16_t clock_offset)418 void btm_api_process_inquiry_result(const RawAddress& raw_address,
419                                     uint8_t page_scan_rep_mode,
420                                     DEV_CLASS device_class,
421                                     uint16_t clock_offset) {
422   mock_function_count_map[__func__]++;
423 }
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)424 void btm_api_process_inquiry_result_with_rssi(RawAddress raw_address,
425                                               uint8_t page_scan_rep_mode,
426                                               DEV_CLASS device_class,
427                                               uint16_t clock_offset,
428                                               int8_t rssi) {
429   mock_function_count_map[__func__]++;
430 }
431 
BTM_ClearEventFilter()432 tBTM_STATUS bluetooth::shim::BTM_ClearEventFilter() {
433   mock_function_count_map[__func__]++;
434   return BTM_SUCCESS;
435 }
436 
BTM_BleResetId()437 tBTM_STATUS bluetooth::shim::BTM_BleResetId() {
438   mock_function_count_map[__func__]++;
439   return BTM_SUCCESS;
440 }
441