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