You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
322 lines
14 KiB
322 lines
14 KiB
/*
|
|
* 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:22
|
|
*
|
|
* mockcify.pl ver 0.2
|
|
*/
|
|
|
|
#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 the inclusion set.
|
|
#include "stack/include/l2c_api.h"
|
|
#include "stack/l2cap/l2c_int.h"
|
|
#include "types/ble_address_with_type.h"
|
|
#include "types/hci_role.h"
|
|
#include "types/raw_address.h"
|
|
|
|
// Mocked compile conditionals, if any
|
|
#ifndef UNUSED_ATTR
|
|
#define UNUSED_ATTR
|
|
#endif
|
|
|
|
namespace test {
|
|
namespace mock {
|
|
namespace stack_l2cap_ble {
|
|
|
|
// Shared state between mocked functions and tests
|
|
// Name: L2CA_UpdateBleConnParams
|
|
// Params: 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
|
|
// Returns: bool
|
|
struct L2CA_UpdateBleConnParams {
|
|
std::function<bool(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)>
|
|
body{[](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) { return false; }};
|
|
bool operator()(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) {
|
|
return body(rem_bda, min_int, max_int, latency, timeout, min_ce_len,
|
|
max_ce_len);
|
|
};
|
|
};
|
|
extern struct L2CA_UpdateBleConnParams L2CA_UpdateBleConnParams;
|
|
// Name: L2CA_EnableUpdateBleConnParams
|
|
// Params: const RawAddress& rem_bda, bool enable
|
|
// Returns: bool
|
|
struct L2CA_EnableUpdateBleConnParams {
|
|
std::function<bool(const RawAddress& rem_bda, bool enable)> body{
|
|
[](const RawAddress& rem_bda, bool enable) { return false; }};
|
|
bool operator()(const RawAddress& rem_bda, bool enable) {
|
|
return body(rem_bda, enable);
|
|
};
|
|
};
|
|
extern struct L2CA_EnableUpdateBleConnParams L2CA_EnableUpdateBleConnParams;
|
|
// Name: L2CA_GetBleConnRole
|
|
// Params: const RawAddress& bd_addr
|
|
// Returns: hci_role_t
|
|
struct L2CA_GetBleConnRole {
|
|
std::function<hci_role_t(const RawAddress& bd_addr)> body{
|
|
[](const RawAddress& bd_addr) { return HCI_ROLE_CENTRAL; }};
|
|
hci_role_t operator()(const RawAddress& bd_addr) { return body(bd_addr); };
|
|
};
|
|
extern struct L2CA_GetBleConnRole L2CA_GetBleConnRole;
|
|
// Name: l2cble_notify_le_connection
|
|
// Params: const RawAddress& bda
|
|
// Returns: void
|
|
struct l2cble_notify_le_connection {
|
|
std::function<void(const RawAddress& bda)> body{[](const RawAddress& bda) {}};
|
|
void operator()(const RawAddress& bda) { body(bda); };
|
|
};
|
|
extern struct l2cble_notify_le_connection l2cble_notify_le_connection;
|
|
// Name: l2cble_conn_comp
|
|
// Params: uint16_t handle, uint8_t role, const RawAddress& bda, tBLE_ADDR_TYPE
|
|
// type, uint16_t conn_interval, uint16_t conn_latency, uint16_t conn_timeout
|
|
// Returns: bool
|
|
struct l2cble_conn_comp {
|
|
std::function<bool(uint16_t handle, uint8_t role, const RawAddress& bda,
|
|
tBLE_ADDR_TYPE type, uint16_t conn_interval,
|
|
uint16_t conn_latency, uint16_t conn_timeout)>
|
|
body{[](uint16_t handle, uint8_t role, const RawAddress& bda,
|
|
tBLE_ADDR_TYPE type, uint16_t conn_interval,
|
|
uint16_t conn_latency, uint16_t conn_timeout) { return false; }};
|
|
bool operator()(uint16_t handle, uint8_t role, const RawAddress& bda,
|
|
tBLE_ADDR_TYPE type, uint16_t conn_interval,
|
|
uint16_t conn_latency, uint16_t conn_timeout) {
|
|
return body(handle, role, bda, type, conn_interval, conn_latency,
|
|
conn_timeout);
|
|
};
|
|
};
|
|
extern struct l2cble_conn_comp l2cble_conn_comp;
|
|
// Name: l2cble_conn_comp_from_address_with_type
|
|
// Params: uint16_t handle, uint8_t role, const tBLE_BD_ADDR&
|
|
// address_with_type, uint16_t conn_interval, uint16_t conn_latency, uint16_t
|
|
// conn_timeout Returns: bool
|
|
struct l2cble_conn_comp_from_address_with_type {
|
|
std::function<bool(
|
|
uint16_t handle, uint8_t role, const tBLE_BD_ADDR& address_with_type,
|
|
uint16_t conn_interval, uint16_t conn_latency, uint16_t conn_timeout)>
|
|
body{[](uint16_t handle, uint8_t role,
|
|
const tBLE_BD_ADDR& address_with_type, uint16_t conn_interval,
|
|
uint16_t conn_latency, uint16_t conn_timeout) { return false; }};
|
|
bool operator()(uint16_t handle, uint8_t role,
|
|
const tBLE_BD_ADDR& address_with_type, uint16_t conn_interval,
|
|
uint16_t conn_latency, uint16_t conn_timeout) {
|
|
return body(handle, role, address_with_type, conn_interval, conn_latency,
|
|
conn_timeout);
|
|
};
|
|
};
|
|
extern struct l2cble_conn_comp_from_address_with_type
|
|
l2cble_conn_comp_from_address_with_type;
|
|
// Name: l2cble_process_conn_update_evt
|
|
// Params: uint16_t handle, uint8_t status, uint16_t interval, uint16_t latency,
|
|
// uint16_t timeout Returns: void
|
|
struct l2cble_process_conn_update_evt {
|
|
std::function<void(uint16_t handle, uint8_t status, uint16_t interval,
|
|
uint16_t latency, uint16_t timeout)>
|
|
body{[](uint16_t handle, uint8_t status, uint16_t interval,
|
|
uint16_t latency, uint16_t timeout) {}};
|
|
void operator()(uint16_t handle, uint8_t status, uint16_t interval,
|
|
uint16_t latency, uint16_t timeout) {
|
|
body(handle, status, interval, latency, timeout);
|
|
};
|
|
};
|
|
extern struct l2cble_process_conn_update_evt l2cble_process_conn_update_evt;
|
|
// Name: l2cble_process_sig_cmd
|
|
// Params: tL2C_LCB* p_lcb, uint8_t* p, uint16_t pkt_len
|
|
// Returns: void
|
|
struct l2cble_process_sig_cmd {
|
|
std::function<void(tL2C_LCB* p_lcb, uint8_t* p, uint16_t pkt_len)> body{
|
|
[](tL2C_LCB* p_lcb, uint8_t* p, uint16_t pkt_len) {}};
|
|
void operator()(tL2C_LCB* p_lcb, uint8_t* p, uint16_t pkt_len) {
|
|
body(p_lcb, p, pkt_len);
|
|
};
|
|
};
|
|
extern struct l2cble_process_sig_cmd l2cble_process_sig_cmd;
|
|
// Name: l2cble_create_conn
|
|
// Params: tL2C_LCB* p_lcb
|
|
// Returns: bool
|
|
struct l2cble_create_conn {
|
|
std::function<bool(tL2C_LCB* p_lcb)> body{
|
|
[](tL2C_LCB* p_lcb) { return false; }};
|
|
bool operator()(tL2C_LCB* p_lcb) { return body(p_lcb); };
|
|
};
|
|
extern struct l2cble_create_conn l2cble_create_conn;
|
|
// Name: l2c_link_processs_ble_num_bufs
|
|
// Params: uint16_t num_lm_ble_bufs
|
|
// Returns: void
|
|
struct l2c_link_processs_ble_num_bufs {
|
|
std::function<void(uint16_t num_lm_ble_bufs)> body{
|
|
[](uint16_t num_lm_ble_bufs) {}};
|
|
void operator()(uint16_t num_lm_ble_bufs) { body(num_lm_ble_bufs); };
|
|
};
|
|
extern struct l2c_link_processs_ble_num_bufs l2c_link_processs_ble_num_bufs;
|
|
// Name: l2c_ble_link_adjust_allocation
|
|
// Params: void
|
|
// Returns: void
|
|
struct l2c_ble_link_adjust_allocation {
|
|
std::function<void(void)> body{[](void) {}};
|
|
void operator()(void) { body(); };
|
|
};
|
|
extern struct l2c_ble_link_adjust_allocation l2c_ble_link_adjust_allocation;
|
|
// Name: l2cble_process_rc_param_request_evt
|
|
// Params: uint16_t handle, uint16_t int_min, uint16_t int_max, uint16_t
|
|
// latency, uint16_t timeout Returns: void
|
|
struct l2cble_process_rc_param_request_evt {
|
|
std::function<void(uint16_t handle, uint16_t int_min, uint16_t int_max,
|
|
uint16_t latency, uint16_t timeout)>
|
|
body{[](uint16_t handle, uint16_t int_min, uint16_t int_max,
|
|
uint16_t latency, uint16_t timeout) {}};
|
|
void operator()(uint16_t handle, uint16_t int_min, uint16_t int_max,
|
|
uint16_t latency, uint16_t timeout) {
|
|
body(handle, int_min, int_max, latency, timeout);
|
|
};
|
|
};
|
|
extern struct l2cble_process_rc_param_request_evt
|
|
l2cble_process_rc_param_request_evt;
|
|
// Name: l2cble_update_data_length
|
|
// Params: tL2C_LCB* p_lcb
|
|
// Returns: void
|
|
struct l2cble_update_data_length {
|
|
std::function<void(tL2C_LCB* p_lcb)> body{[](tL2C_LCB* p_lcb) {}};
|
|
void operator()(tL2C_LCB* p_lcb) { body(p_lcb); };
|
|
};
|
|
extern struct l2cble_update_data_length l2cble_update_data_length;
|
|
// Name: l2cble_process_data_length_change_event
|
|
// Params: uint16_t handle, uint16_t tx_data_len, uint16_t rx_data_len
|
|
// Returns: void
|
|
struct l2cble_process_data_length_change_event {
|
|
std::function<void(uint16_t handle, uint16_t tx_data_len,
|
|
uint16_t rx_data_len)>
|
|
body{[](uint16_t handle, uint16_t tx_data_len, uint16_t rx_data_len) {}};
|
|
void operator()(uint16_t handle, uint16_t tx_data_len, uint16_t rx_data_len) {
|
|
body(handle, tx_data_len, rx_data_len);
|
|
};
|
|
};
|
|
extern struct l2cble_process_data_length_change_event
|
|
l2cble_process_data_length_change_event;
|
|
// Name: l2cble_credit_based_conn_req
|
|
// Params: tL2C_CCB* p_ccb
|
|
// Returns: void
|
|
struct l2cble_credit_based_conn_req {
|
|
std::function<void(tL2C_CCB* p_ccb)> body{[](tL2C_CCB* p_ccb) {}};
|
|
void operator()(tL2C_CCB* p_ccb) { body(p_ccb); };
|
|
};
|
|
extern struct l2cble_credit_based_conn_req l2cble_credit_based_conn_req;
|
|
// Name: l2cble_credit_based_conn_res
|
|
// Params: tL2C_CCB* p_ccb, uint16_t result
|
|
// Returns: void
|
|
struct l2cble_credit_based_conn_res {
|
|
std::function<void(tL2C_CCB* p_ccb, uint16_t result)> body{
|
|
[](tL2C_CCB* p_ccb, uint16_t result) {}};
|
|
void operator()(tL2C_CCB* p_ccb, uint16_t result) { body(p_ccb, result); };
|
|
};
|
|
extern struct l2cble_credit_based_conn_res l2cble_credit_based_conn_res;
|
|
// Name: l2cble_send_flow_control_credit
|
|
// Params: tL2C_CCB* p_ccb, uint16_t credit_value
|
|
// Returns: void
|
|
struct l2cble_send_flow_control_credit {
|
|
std::function<void(tL2C_CCB* p_ccb, uint16_t credit_value)> body{
|
|
[](tL2C_CCB* p_ccb, uint16_t credit_value) {}};
|
|
void operator()(tL2C_CCB* p_ccb, uint16_t credit_value) {
|
|
body(p_ccb, credit_value);
|
|
};
|
|
};
|
|
extern struct l2cble_send_flow_control_credit l2cble_send_flow_control_credit;
|
|
// Name: l2cble_send_peer_disc_req
|
|
// Params: tL2C_CCB* p_ccb
|
|
// Returns: void
|
|
struct l2cble_send_peer_disc_req {
|
|
std::function<void(tL2C_CCB* p_ccb)> body{[](tL2C_CCB* p_ccb) {}};
|
|
void operator()(tL2C_CCB* p_ccb) { body(p_ccb); };
|
|
};
|
|
extern struct l2cble_send_peer_disc_req l2cble_send_peer_disc_req;
|
|
// Name: l2cble_sec_comp
|
|
// Params: const RawAddress* bda, tBT_TRANSPORT transport, void* p_ref_data,
|
|
// tBTM_STATUS status Returns: void
|
|
struct l2cble_sec_comp {
|
|
std::function<void(const RawAddress* bda, tBT_TRANSPORT transport,
|
|
void* p_ref_data, tBTM_STATUS status)>
|
|
body{[](const RawAddress* bda, tBT_TRANSPORT transport, void* p_ref_data,
|
|
tBTM_STATUS status) {}};
|
|
void operator()(const RawAddress* bda, tBT_TRANSPORT transport,
|
|
void* p_ref_data, tBTM_STATUS status) {
|
|
body(bda, transport, p_ref_data, status);
|
|
};
|
|
};
|
|
extern struct l2cble_sec_comp l2cble_sec_comp;
|
|
// Name: l2ble_sec_access_req
|
|
// Params: const RawAddress& bd_addr, uint16_t psm, bool is_originator,
|
|
// tL2CAP_SEC_CBACK* p_callback, void* p_ref_data Returns: tL2CAP_LE_RESULT_CODE
|
|
struct l2ble_sec_access_req {
|
|
std::function<tL2CAP_LE_RESULT_CODE(
|
|
const RawAddress& bd_addr, uint16_t psm, bool is_originator,
|
|
tL2CAP_SEC_CBACK* p_callback, void* p_ref_data)>
|
|
body{[](const RawAddress& bd_addr, uint16_t psm, bool is_originator,
|
|
tL2CAP_SEC_CBACK* p_callback,
|
|
void* p_ref_data) { return L2CAP_LE_RESULT_CONN_OK; }};
|
|
tL2CAP_LE_RESULT_CODE operator()(const RawAddress& bd_addr, uint16_t psm,
|
|
bool is_originator,
|
|
tL2CAP_SEC_CBACK* p_callback,
|
|
void* p_ref_data) {
|
|
return body(bd_addr, psm, is_originator, p_callback, p_ref_data);
|
|
};
|
|
};
|
|
extern struct l2ble_sec_access_req l2ble_sec_access_req;
|
|
// Name: L2CA_AdjustConnectionIntervals
|
|
// Params: uint16_t* min_interval, uint16_t* max_interval, uint16_t
|
|
// floor_interval Returns: void
|
|
struct L2CA_AdjustConnectionIntervals {
|
|
std::function<void(uint16_t* min_interval, uint16_t* max_interval,
|
|
uint16_t floor_interval)>
|
|
body{[](uint16_t* min_interval, uint16_t* max_interval,
|
|
uint16_t floor_interval) {}};
|
|
void operator()(uint16_t* min_interval, uint16_t* max_interval,
|
|
uint16_t floor_interval) {
|
|
body(min_interval, max_interval, floor_interval);
|
|
};
|
|
};
|
|
extern struct L2CA_AdjustConnectionIntervals L2CA_AdjustConnectionIntervals;
|
|
// Name: l2cble_use_preferred_conn_params
|
|
// Params: const RawAddress& bda
|
|
// Returns: void
|
|
struct l2cble_use_preferred_conn_params {
|
|
std::function<void(const RawAddress& bda)> body{[](const RawAddress& bda) {}};
|
|
void operator()(const RawAddress& bda) { body(bda); };
|
|
};
|
|
extern struct l2cble_use_preferred_conn_params l2cble_use_preferred_conn_params;
|
|
|
|
} // namespace stack_l2cap_ble
|
|
} // namespace mock
|
|
} // namespace test
|
|
|
|
// END mockcify generation
|