468 lines
17 KiB
C++
468 lines
17 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:34
|
|
*
|
|
* mockcify.pl ver 0.3.0
|
|
*/
|
|
|
|
#include <cstdint>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <string>
|
|
|
|
extern std::map<std::string, int> mock_function_count_map;
|
|
|
|
// Original included files, if any
|
|
// NOTE: Since this is a mock file with mock definitions some number of
|
|
// include files may not be required. The include-what-you-use
|
|
// still applies, but crafting proper inclusion is out of scope
|
|
// for this effort. This compilation unit may compile as-is, or
|
|
// may need attention to prune from (or add to ) the inclusion set.
|
|
#include <base/bind.h>
|
|
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "bt_target.h"
|
|
#include "bta/dm/bta_dm_int.h"
|
|
#include "osi/include/allocator.h"
|
|
#include "stack/btm/btm_sec.h"
|
|
#include "stack/include/bt_octets.h"
|
|
#include "stack/include/btm_api.h"
|
|
#include "types/bluetooth/uuid.h"
|
|
#include "types/raw_address.h"
|
|
|
|
// Mocked compile conditionals, if any
|
|
|
|
namespace test {
|
|
namespace mock {
|
|
namespace bta_dm_api {
|
|
|
|
// Name: BTA_DmAddBleDevice
|
|
// Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_DEVICE_TYPE
|
|
// dev_type Return: void
|
|
struct BTA_DmAddBleDevice {
|
|
std::function<void(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
|
|
tBT_DEVICE_TYPE dev_type)>
|
|
body{[](const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
|
|
tBT_DEVICE_TYPE dev_type) {}};
|
|
void operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
|
|
tBT_DEVICE_TYPE dev_type) {
|
|
body(bd_addr, addr_type, dev_type);
|
|
};
|
|
};
|
|
extern struct BTA_DmAddBleDevice BTA_DmAddBleDevice;
|
|
|
|
// Name: BTA_DmAddBleKey
|
|
// Params: const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
|
|
// tBTM_LE_KEY_TYPE key_type Return: void
|
|
struct BTA_DmAddBleKey {
|
|
std::function<void(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
|
|
tBTM_LE_KEY_TYPE key_type)>
|
|
body{[](const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
|
|
tBTM_LE_KEY_TYPE key_type) {}};
|
|
void operator()(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key,
|
|
tBTM_LE_KEY_TYPE key_type) {
|
|
body(bd_addr, p_le_key, key_type);
|
|
};
|
|
};
|
|
extern struct BTA_DmAddBleKey BTA_DmAddBleKey;
|
|
|
|
// Name: BTA_DmAddDevice
|
|
// Params: const RawAddress& bd_addr, DEV_CLASS dev_class, const LinkKey&
|
|
// link_key, uint8_t key_type, uint8_t pin_length Return: void
|
|
struct BTA_DmAddDevice {
|
|
std::function<void(const RawAddress& bd_addr, DEV_CLASS dev_class,
|
|
const LinkKey& link_key, uint8_t key_type,
|
|
uint8_t pin_length)>
|
|
body{[](const RawAddress& bd_addr, DEV_CLASS dev_class,
|
|
const LinkKey& link_key, uint8_t key_type,
|
|
uint8_t pin_length) {}};
|
|
void operator()(const RawAddress& bd_addr, DEV_CLASS dev_class,
|
|
const LinkKey& link_key, uint8_t key_type,
|
|
uint8_t pin_length) {
|
|
body(bd_addr, dev_class, link_key, key_type, pin_length);
|
|
};
|
|
};
|
|
extern struct BTA_DmAddDevice BTA_DmAddDevice;
|
|
|
|
// Name: BTA_DmBleConfigLocalPrivacy
|
|
// Params: bool privacy_enable
|
|
// Return: void
|
|
struct BTA_DmBleConfigLocalPrivacy {
|
|
std::function<void(bool privacy_enable)> body{[](bool privacy_enable) {}};
|
|
void operator()(bool privacy_enable) { body(privacy_enable); };
|
|
};
|
|
extern struct BTA_DmBleConfigLocalPrivacy BTA_DmBleConfigLocalPrivacy;
|
|
|
|
// Name: BTA_DmBleConfirmReply
|
|
// Params: const RawAddress& bd_addr, bool accept
|
|
// Return: void
|
|
struct BTA_DmBleConfirmReply {
|
|
std::function<void(const RawAddress& bd_addr, bool accept)> body{
|
|
[](const RawAddress& bd_addr, bool accept) {}};
|
|
void operator()(const RawAddress& bd_addr, bool accept) {
|
|
body(bd_addr, accept);
|
|
};
|
|
};
|
|
extern struct BTA_DmBleConfirmReply BTA_DmBleConfirmReply;
|
|
|
|
// Name: BTA_DmBleCsisObserve
|
|
// Params: bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb
|
|
// Return: void
|
|
struct BTA_DmBleCsisObserve {
|
|
std::function<void(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb)> body{
|
|
[](bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) {}};
|
|
void operator()(bool observe, tBTA_DM_SEARCH_CBACK* p_results_cb) {
|
|
body(observe, p_results_cb);
|
|
};
|
|
};
|
|
extern struct BTA_DmBleCsisObserve BTA_DmBleCsisObserve;
|
|
|
|
// Name: BTA_DmBleGetEnergyInfo
|
|
// Params: tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback
|
|
// Return: void
|
|
struct BTA_DmBleGetEnergyInfo {
|
|
std::function<void(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback)> body{
|
|
[](tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) {}};
|
|
void operator()(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) {
|
|
body(p_cmpl_cback);
|
|
};
|
|
};
|
|
extern struct BTA_DmBleGetEnergyInfo BTA_DmBleGetEnergyInfo;
|
|
|
|
// Name: BTA_DmBleObserve
|
|
// Params: bool start, uint8_t duration, tBTA_DM_SEARCH_CBACK* p_results_cb
|
|
// Return: void
|
|
struct BTA_DmBleObserve {
|
|
std::function<void(bool start, uint8_t duration,
|
|
tBTA_DM_SEARCH_CBACK* p_results_cb)>
|
|
body{[](bool start, uint8_t duration,
|
|
tBTA_DM_SEARCH_CBACK* p_results_cb) {}};
|
|
void operator()(bool start, uint8_t duration,
|
|
tBTA_DM_SEARCH_CBACK* p_results_cb) {
|
|
body(start, duration, p_results_cb);
|
|
};
|
|
};
|
|
extern struct BTA_DmBleObserve BTA_DmBleObserve;
|
|
|
|
// Name: BTA_DmBlePasskeyReply
|
|
// Params: const RawAddress& bd_addr, bool accept, uint32_t passkey
|
|
// Return: void
|
|
struct BTA_DmBlePasskeyReply {
|
|
std::function<void(const RawAddress& bd_addr, bool accept, uint32_t passkey)>
|
|
body{[](const RawAddress& bd_addr, bool accept, uint32_t passkey) {}};
|
|
void operator()(const RawAddress& bd_addr, bool accept, uint32_t passkey) {
|
|
body(bd_addr, accept, passkey);
|
|
};
|
|
};
|
|
extern struct BTA_DmBlePasskeyReply BTA_DmBlePasskeyReply;
|
|
|
|
// Name: BTA_DmBleRequestMaxTxDataLength
|
|
// Params: const RawAddress& remote_device
|
|
// Return: void
|
|
struct BTA_DmBleRequestMaxTxDataLength {
|
|
std::function<void(const RawAddress& remote_device)> body{
|
|
[](const RawAddress& remote_device) {}};
|
|
void operator()(const RawAddress& remote_device) { body(remote_device); };
|
|
};
|
|
extern struct BTA_DmBleRequestMaxTxDataLength BTA_DmBleRequestMaxTxDataLength;
|
|
|
|
// Name: BTA_DmBleScan
|
|
// Params: bool start, uint8_t duration
|
|
// Return: void
|
|
struct BTA_DmBleScan {
|
|
std::function<void(bool start, uint8_t duration)> body{
|
|
[](bool start, uint8_t duration) {}};
|
|
void operator()(bool start, uint8_t duration) { body(start, duration); };
|
|
};
|
|
extern struct BTA_DmBleScan BTA_DmBleScan;
|
|
|
|
// Name: BTA_DmBleSecurityGrant
|
|
// Params: const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res
|
|
// Return: void
|
|
struct BTA_DmBleSecurityGrant {
|
|
std::function<void(const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res)>
|
|
body{[](const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res) {}};
|
|
void operator()(const RawAddress& bd_addr, tBTA_DM_BLE_SEC_GRANT res) {
|
|
body(bd_addr, res);
|
|
};
|
|
};
|
|
extern struct BTA_DmBleSecurityGrant BTA_DmBleSecurityGrant;
|
|
|
|
// Name: BTA_DmBleUpdateConnectionParams
|
|
// 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
|
|
// Return: void
|
|
struct BTA_DmBleUpdateConnectionParams {
|
|
std::function<void(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)>
|
|
body{[](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) {}};
|
|
void operator()(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) {
|
|
body(bd_addr, min_int, max_int, latency, timeout, min_ce_len, max_ce_len);
|
|
};
|
|
};
|
|
extern struct BTA_DmBleUpdateConnectionParams BTA_DmBleUpdateConnectionParams;
|
|
|
|
// Name: BTA_DmBond
|
|
// Params: const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, tBT_TRANSPORT
|
|
// transport, tBT_DEVICE_TYPE device_type Return: void
|
|
struct BTA_DmBond {
|
|
std::function<void(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
|
|
tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type)>
|
|
body{[](const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
|
|
tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {}};
|
|
void operator()(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
|
|
tBT_TRANSPORT transport, tBT_DEVICE_TYPE device_type) {
|
|
body(bd_addr, addr_type, transport, device_type);
|
|
};
|
|
};
|
|
extern struct BTA_DmBond BTA_DmBond;
|
|
|
|
// Name: BTA_DmBondCancel
|
|
// Params: const RawAddress& bd_addr
|
|
// Return: void
|
|
struct BTA_DmBondCancel {
|
|
std::function<void(const RawAddress& bd_addr)> body{
|
|
[](const RawAddress& bd_addr) {}};
|
|
void operator()(const RawAddress& bd_addr) { body(bd_addr); };
|
|
};
|
|
extern struct BTA_DmBondCancel BTA_DmBondCancel;
|
|
|
|
// Name: BTA_DmCloseACL
|
|
// Params: const RawAddress& bd_addr, bool remove_dev, tBT_TRANSPORT transport
|
|
// Return: void
|
|
struct BTA_DmCloseACL {
|
|
std::function<void(const RawAddress& bd_addr, bool remove_dev,
|
|
tBT_TRANSPORT transport)>
|
|
body{[](const RawAddress& bd_addr, bool remove_dev,
|
|
tBT_TRANSPORT transport) {}};
|
|
void operator()(const RawAddress& bd_addr, bool remove_dev,
|
|
tBT_TRANSPORT transport) {
|
|
body(bd_addr, remove_dev, transport);
|
|
};
|
|
};
|
|
extern struct BTA_DmCloseACL BTA_DmCloseACL;
|
|
|
|
// Name: BTA_DmConfirm
|
|
// Params: const RawAddress& bd_addr, bool accept
|
|
// Return: void
|
|
struct BTA_DmConfirm {
|
|
std::function<void(const RawAddress& bd_addr, bool accept)> body{
|
|
[](const RawAddress& bd_addr, bool accept) {}};
|
|
void operator()(const RawAddress& bd_addr, bool accept) {
|
|
body(bd_addr, accept);
|
|
};
|
|
};
|
|
extern struct BTA_DmConfirm BTA_DmConfirm;
|
|
|
|
// Name: BTA_DmDiscover
|
|
// Params: const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
|
|
// tBT_TRANSPORT transport Return: void
|
|
struct BTA_DmDiscover {
|
|
std::function<void(const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
|
|
tBT_TRANSPORT transport)>
|
|
body{[](const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
|
|
tBT_TRANSPORT transport) {}};
|
|
void operator()(const RawAddress& bd_addr, tBTA_DM_SEARCH_CBACK* p_cback,
|
|
tBT_TRANSPORT transport) {
|
|
body(bd_addr, p_cback, transport);
|
|
};
|
|
};
|
|
extern struct BTA_DmDiscover BTA_DmDiscover;
|
|
|
|
// Name: BTA_DmGetConnectionState
|
|
// Params: const RawAddress& bd_addr
|
|
// Return: bool
|
|
struct BTA_DmGetConnectionState {
|
|
bool return_value{false};
|
|
std::function<bool(const RawAddress& bd_addr)> body{
|
|
[this](const RawAddress& bd_addr) { return return_value; }};
|
|
bool operator()(const RawAddress& bd_addr) { return body(bd_addr); };
|
|
};
|
|
extern struct BTA_DmGetConnectionState BTA_DmGetConnectionState;
|
|
|
|
// Name: BTA_DmLocalOob
|
|
// Params: void
|
|
// Return: void
|
|
struct BTA_DmLocalOob {
|
|
std::function<void(void)> body{[](void) {}};
|
|
void operator()(void) { body(); };
|
|
};
|
|
extern struct BTA_DmLocalOob BTA_DmLocalOob;
|
|
|
|
// Name: BTA_DmPinReply
|
|
// Params: const RawAddress& bd_addr, bool accept, uint8_t pin_len, uint8_t*
|
|
// p_pin Return: void
|
|
struct BTA_DmPinReply {
|
|
std::function<void(const RawAddress& bd_addr, bool accept, uint8_t pin_len,
|
|
uint8_t* p_pin)>
|
|
body{[](const RawAddress& bd_addr, bool accept, uint8_t pin_len,
|
|
uint8_t* p_pin) {}};
|
|
void operator()(const RawAddress& bd_addr, bool accept, uint8_t pin_len,
|
|
uint8_t* p_pin) {
|
|
body(bd_addr, accept, pin_len, p_pin);
|
|
};
|
|
};
|
|
extern struct BTA_DmPinReply BTA_DmPinReply;
|
|
|
|
// Name: BTA_DmRemoveDevice
|
|
// Params: const RawAddress& bd_addr
|
|
// Return: tBTA_STATUS
|
|
struct BTA_DmRemoveDevice {
|
|
tBTA_STATUS return_value{0};
|
|
std::function<tBTA_STATUS(const RawAddress& bd_addr)> body{
|
|
[this](const RawAddress& bd_addr) { return return_value; }};
|
|
tBTA_STATUS operator()(const RawAddress& bd_addr) { return body(bd_addr); };
|
|
};
|
|
extern struct BTA_DmRemoveDevice BTA_DmRemoveDevice;
|
|
|
|
// Name: BTA_DmSearch
|
|
// Params: tBTA_DM_SEARCH_CBACK* p_cback
|
|
// Return: void
|
|
struct BTA_DmSearch {
|
|
std::function<void(tBTA_DM_SEARCH_CBACK* p_cback)> body{
|
|
[](tBTA_DM_SEARCH_CBACK* p_cback) {}};
|
|
void operator()(tBTA_DM_SEARCH_CBACK* p_cback) { body(p_cback); };
|
|
};
|
|
extern struct BTA_DmSearch BTA_DmSearch;
|
|
|
|
// Name: BTA_DmSearchCancel
|
|
// Params: void
|
|
// Return: void
|
|
struct BTA_DmSearchCancel {
|
|
std::function<void(void)> body{[](void) {}};
|
|
void operator()(void) { body(); };
|
|
};
|
|
extern struct BTA_DmSearchCancel BTA_DmSearchCancel;
|
|
|
|
// Name: BTA_DmSetBlePrefConnParams
|
|
// Params: const RawAddress& bd_addr, uint16_t min_conn_int, uint16_t
|
|
// max_conn_int, uint16_t peripheral_latency, uint16_t supervision_tout Return:
|
|
// void
|
|
struct BTA_DmSetBlePrefConnParams {
|
|
std::function<void(const RawAddress& bd_addr, uint16_t min_conn_int,
|
|
uint16_t max_conn_int, uint16_t peripheral_latency,
|
|
uint16_t supervision_tout)>
|
|
body{[](const RawAddress& bd_addr, uint16_t min_conn_int,
|
|
uint16_t max_conn_int, uint16_t peripheral_latency,
|
|
uint16_t supervision_tout) {}};
|
|
void operator()(const RawAddress& bd_addr, uint16_t min_conn_int,
|
|
uint16_t max_conn_int, uint16_t peripheral_latency,
|
|
uint16_t supervision_tout) {
|
|
body(bd_addr, min_conn_int, max_conn_int, peripheral_latency,
|
|
supervision_tout);
|
|
};
|
|
};
|
|
extern struct BTA_DmSetBlePrefConnParams BTA_DmSetBlePrefConnParams;
|
|
|
|
// Name: BTA_DmSetDeviceName
|
|
// Params: char* p_name
|
|
// Return: void
|
|
struct BTA_DmSetDeviceName {
|
|
std::function<void(const char* p_name)> body{[](const char* p_name) {}};
|
|
void operator()(const char* p_name) { body(p_name); };
|
|
};
|
|
extern struct BTA_DmSetDeviceName BTA_DmSetDeviceName;
|
|
|
|
// Name: BTA_DmSetEncryption
|
|
// Params: const RawAddress& bd_addr, tBT_TRANSPORT transport,
|
|
// tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act Return: void
|
|
struct BTA_DmSetEncryption {
|
|
std::function<void(const RawAddress& bd_addr, tBT_TRANSPORT transport,
|
|
tBTA_DM_ENCRYPT_CBACK* p_callback,
|
|
tBTM_BLE_SEC_ACT sec_act)>
|
|
body{[](const RawAddress& bd_addr, tBT_TRANSPORT transport,
|
|
tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act) {}};
|
|
void operator()(const RawAddress& bd_addr, tBT_TRANSPORT transport,
|
|
tBTA_DM_ENCRYPT_CBACK* p_callback, tBTM_BLE_SEC_ACT sec_act) {
|
|
body(bd_addr, transport, p_callback, sec_act);
|
|
};
|
|
};
|
|
extern struct BTA_DmSetEncryption BTA_DmSetEncryption;
|
|
|
|
// Name: BTA_DmSetLocalDiRecord
|
|
// Params: tSDP_DI_RECORD* p_device_info, uint32_t* p_handle
|
|
// Return: tBTA_STATUS
|
|
struct BTA_DmSetLocalDiRecord {
|
|
tBTA_STATUS return_value{0};
|
|
std::function<tBTA_STATUS(tSDP_DI_RECORD* p_device_info, uint32_t* p_handle)>
|
|
body{[this](tSDP_DI_RECORD* p_device_info, uint32_t* p_handle) {
|
|
return return_value;
|
|
}};
|
|
tBTA_STATUS operator()(tSDP_DI_RECORD* p_device_info, uint32_t* p_handle) {
|
|
return body(p_device_info, p_handle);
|
|
};
|
|
};
|
|
extern struct BTA_DmSetLocalDiRecord BTA_DmSetLocalDiRecord;
|
|
|
|
// Name: BTA_EnableTestMode
|
|
// Params: void
|
|
// Return: void
|
|
struct BTA_EnableTestMode {
|
|
std::function<void(void)> body{[](void) {}};
|
|
void operator()(void) { body(); };
|
|
};
|
|
extern struct BTA_EnableTestMode BTA_EnableTestMode;
|
|
|
|
// Name: BTA_GetEirService
|
|
// Params: uint8_t* p_eir, size_t eir_len, tBTA_SERVICE_MASK* p_services
|
|
// Return: void
|
|
struct BTA_GetEirService {
|
|
std::function<void(const uint8_t* p_eir, size_t eir_len,
|
|
tBTA_SERVICE_MASK* p_services)>
|
|
body{[](const uint8_t* p_eir, size_t eir_len,
|
|
tBTA_SERVICE_MASK* p_services) {}};
|
|
void operator()(const uint8_t* p_eir, size_t eir_len,
|
|
tBTA_SERVICE_MASK* p_services) {
|
|
body(p_eir, eir_len, p_services);
|
|
};
|
|
};
|
|
extern struct BTA_GetEirService BTA_GetEirService;
|
|
|
|
// Name: BTA_VendorInit
|
|
// Params: void
|
|
// Return: void
|
|
struct BTA_VendorInit {
|
|
std::function<void(void)> body{[](void) {}};
|
|
void operator()(void) { body(); };
|
|
};
|
|
extern struct BTA_VendorInit BTA_VendorInit;
|
|
|
|
// Name: BTA_dm_init
|
|
// Params:
|
|
// Return: void
|
|
struct BTA_dm_init {
|
|
std::function<void()> body{[]() {}};
|
|
void operator()() { body(); };
|
|
};
|
|
extern struct BTA_dm_init BTA_dm_init;
|
|
|
|
} // namespace bta_dm_api
|
|
} // namespace mock
|
|
} // namespace test
|
|
|
|
// END mockcify generation
|