/*
 * Copyright 2022 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.
 */
#pragma once

/*
 * Generated mock file from original source file
 *   Functions generated:14
 *
 *  mockcify.pl ver 0.5.0
 */

#include <cstdint>
#include <functional>
#include <optional>
#include <string>

// Original included files, if any
#include "stack/include/bt_hdr.h"
#include "stack/include/bt_octets.h"
#include "stack/include/hci_error_code.h"
#include "types/ble_address_with_type.h"
#include "types/raw_address.h"

// Original usings

// Mocked compile conditionals, if any

namespace test {
namespace mock {
namespace main_shim_acl_api {

// Shared state between mocked functions and tests
// Name: ACL_AcceptLeConnectionFrom
// Params: const tBLE_BD_ADDR& legacy_address_with_type, bool is_direct
// Return: bool
struct ACL_AcceptLeConnectionFrom {
  static bool return_value;
  std::function<bool(const tBLE_BD_ADDR& legacy_address_with_type,
                     bool is_direct)>
      body{[](const tBLE_BD_ADDR& legacy_address_with_type, bool is_direct) {
        return return_value;
      }};
  bool operator()(const tBLE_BD_ADDR& legacy_address_with_type,
                  bool is_direct) {
    return body(legacy_address_with_type, is_direct);
  };
};
extern struct ACL_AcceptLeConnectionFrom ACL_AcceptLeConnectionFrom;

// Name: ACL_AddToAddressResolution
// Params: const tBLE_BD_ADDR& legacy_address_with_type, const Octet16&
// peer_irk, const Octet16& local_irk Return: void
struct ACL_AddToAddressResolution {
  std::function<void(const tBLE_BD_ADDR& legacy_address_with_type,
                     const Octet16& peer_irk, const Octet16& local_irk)>
      body{[](const tBLE_BD_ADDR& legacy_address_with_type,
              const Octet16& peer_irk, const Octet16& local_irk) {}};
  void operator()(const tBLE_BD_ADDR& legacy_address_with_type,
                  const Octet16& peer_irk, const Octet16& local_irk) {
    body(legacy_address_with_type, peer_irk, local_irk);
  };
};
extern struct ACL_AddToAddressResolution ACL_AddToAddressResolution;

// Name: ACL_CancelClassicConnection
// Params: const RawAddress& raw_address
// Return: void
struct ACL_CancelClassicConnection {
  std::function<void(const RawAddress& raw_address)> body{
      [](const RawAddress& raw_address) {}};
  void operator()(const RawAddress& raw_address) { body(raw_address); };
};
extern struct ACL_CancelClassicConnection ACL_CancelClassicConnection;

// Name: ACL_ClearAddressResolution
// Params:
// Return: void
struct ACL_ClearAddressResolution {
  std::function<void()> body{[]() {}};
  void operator()() { body(); };
};
extern struct ACL_ClearAddressResolution ACL_ClearAddressResolution;

// Name: ACL_ClearFilterAcceptList
// Params:
// Return: void
struct ACL_ClearFilterAcceptList {
  std::function<void()> body{[]() {}};
  void operator()() { body(); };
};
extern struct ACL_ClearFilterAcceptList ACL_ClearFilterAcceptList;

// Name: ACL_LeSetDefaultSubrate
// Params:
// Return: void
struct ACL_LeSetDefaultSubrate {
  std::function<void(uint16_t subrate_min, uint16_t subrate_max,
                     uint16_t max_latency, uint16_t cont_num,
                     uint16_t sup_tout)>
      body{[](uint16_t subrate_min, uint16_t subrate_max, uint16_t max_latency,
              uint16_t cont_num, uint16_t sup_tout) {}};
  void operator()(uint16_t subrate_min, uint16_t subrate_max,
                  uint16_t max_latency, uint16_t cont_num, uint16_t sup_tout) {
    body(subrate_min, subrate_max, max_latency, cont_num, sup_tout);
  };
};
extern struct ACL_LeSetDefaultSubrate ACL_LeSetDefaultSubrate;

// Name: ACL_LeSubrateRequest
// Params:
// Return: void
struct ACL_LeSubrateRequest {
  std::function<void(uint16_t hci_handle, uint16_t subrate_min,
                     uint16_t subrate_max, uint16_t max_latency,
                     uint16_t cont_num, uint16_t sup_tout)>
      body{[](uint16_t hci_handle, uint16_t subrate_min, uint16_t subrate_max,
              uint16_t max_latency, uint16_t cont_num, uint16_t sup_tout) {}};
  void operator()(uint16_t hci_handle, uint16_t subrate_min,
                  uint16_t subrate_max, uint16_t max_latency, uint16_t cont_num,
                  uint16_t sup_tout) {
    body(hci_handle, subrate_min, subrate_max, max_latency, cont_num, sup_tout);
  };
};
extern struct ACL_LeSubrateRequest ACL_LeSubrateRequest;

// Name: ACL_ConfigureLePrivacy
// Params: bool is_le_privacy_enabled
// Return: void
struct ACL_ConfigureLePrivacy {
  std::function<void(bool is_le_privacy_enabled)> body{
      [](bool is_le_privacy_enabled) {}};
  void operator()(bool is_le_privacy_enabled) { body(is_le_privacy_enabled); };
};
extern struct ACL_ConfigureLePrivacy ACL_ConfigureLePrivacy;

// Name: ACL_CreateClassicConnection
// Params: const RawAddress& raw_address
// Return: void
struct ACL_CreateClassicConnection {
  std::function<void(const RawAddress& raw_address)> body{
      [](const RawAddress& raw_address) {}};
  void operator()(const RawAddress& raw_address) { body(raw_address); };
};
extern struct ACL_CreateClassicConnection ACL_CreateClassicConnection;

// Name: ACL_Disconnect
// Params: uint16_t handle, bool is_classic, tHCI_STATUS reason, std::string
// comment Return: void
struct ACL_Disconnect {
  std::function<void(uint16_t handle, bool is_classic, tHCI_STATUS reason,
                     std::string comment)>
      body{[](uint16_t handle, bool is_classic, tHCI_STATUS reason,
              std::string comment) {}};
  void operator()(uint16_t handle, bool is_classic, tHCI_STATUS reason,
                  std::string comment) {
    body(handle, is_classic, reason, comment);
  };
};
extern struct ACL_Disconnect ACL_Disconnect;

// Name: ACL_IgnoreAllLeConnections
// Params:
// Return: void
struct ACL_IgnoreAllLeConnections {
  std::function<void()> body{[]() {}};
  void operator()() { body(); };
};
extern struct ACL_IgnoreAllLeConnections ACL_IgnoreAllLeConnections;

// Name: ACL_IgnoreLeConnectionFrom
// Params: const tBLE_BD_ADDR& legacy_address_with_type
// Return: void
struct ACL_IgnoreLeConnectionFrom {
  std::function<void(const tBLE_BD_ADDR& legacy_address_with_type)> body{
      [](const tBLE_BD_ADDR& legacy_address_with_type) {}};
  void operator()(const tBLE_BD_ADDR& legacy_address_with_type) {
    body(legacy_address_with_type);
  };
};
extern struct ACL_IgnoreLeConnectionFrom ACL_IgnoreLeConnectionFrom;

// Name: ACL_ReadConnectionAddress
// Params: uint16_t handle, RawAddress& conn_addr, tBLE_ADDR_TYPE*, bool
// p_addr_type Return: void
struct ACL_ReadConnectionAddress {
  std::function<void(uint16_t handle, RawAddress& conn_addr,
                     tBLE_ADDR_TYPE* p_addr_type, bool ota_address)>
      body{[](uint16_t handle, RawAddress& conn_addr,
              tBLE_ADDR_TYPE* p_addr_type, bool ota_address) {}};
  void operator()(uint16_t handle, RawAddress& conn_addr,
                  tBLE_ADDR_TYPE* p_addr_type, bool ota_address) {
    body(handle, conn_addr, p_addr_type, ota_address);
  };
};
extern struct ACL_ReadConnectionAddress ACL_ReadConnectionAddress;

// Name: ACL_ReadPeerConnectionAddress
// Params: uint16_t handle, RawAddress& conn_addr, tBLE_ADDR_TYPE*, bool
// p_addr_type Return: void
struct ACL_ReadPeerConnectionAddress {
  std::function<void(uint16_t handle, RawAddress& conn_addr,
                     tBLE_ADDR_TYPE* p_addr_type, bool ota_address)>
      body{[](uint16_t handle, RawAddress& conn_addr,
              tBLE_ADDR_TYPE* p_addr_type, bool ota_address) {}};
  void operator()(uint16_t handle, RawAddress& conn_addr,
                  tBLE_ADDR_TYPE* p_addr_type, bool ota_address) {
    body(handle, conn_addr, p_addr_type, ota_address);
  };
};
extern struct ACL_ReadPeerConnectionAddress ACL_ReadPeerConnectionAddress;

// Name: ACL_GetAdvertisingSetConnectedTo
// Params: const RawAddress& addr
// Return: std::optional<uint8_t>
struct ACL_GetAdvertisingSetConnectedTo {
  static std::optional<uint8_t> return_value;
  std::function<std::optional<uint8_t>(const RawAddress& addr)> body{
      [](const RawAddress& addr) { return return_value; }};
  std::optional<uint8_t> operator()(const RawAddress& addr) {
    return body(addr);
  };
};
extern struct ACL_GetAdvertisingSetConnectedTo ACL_GetAdvertisingSetConnectedTo;

// Name: ACL_RemoveFromAddressResolution
// Params: const tBLE_BD_ADDR& legacy_address_with_type
// Return: void
struct ACL_RemoveFromAddressResolution {
  std::function<void(const tBLE_BD_ADDR& legacy_address_with_type)> body{
      [](const tBLE_BD_ADDR& legacy_address_with_type) {}};
  void operator()(const tBLE_BD_ADDR& legacy_address_with_type) {
    body(legacy_address_with_type);
  };
};
extern struct ACL_RemoveFromAddressResolution ACL_RemoveFromAddressResolution;

// Name: ACL_Shutdown
// Params:
// Return: void
struct ACL_Shutdown {
  std::function<void()> body{[]() {}};
  void operator()() { body(); };
};
extern struct ACL_Shutdown ACL_Shutdown;

// Name: ACL_WriteData
// Params: uint16_t handle, BT_HDR* p_buf
// Return: void
struct ACL_WriteData {
  std::function<void(uint16_t handle, BT_HDR* p_buf)> body{
      [](uint16_t handle, BT_HDR* p_buf) {}};
  void operator()(uint16_t handle, BT_HDR* p_buf) { body(handle, p_buf); };
};
extern struct ACL_WriteData ACL_WriteData;

// Name: ACL_Flush
// Params: uint16_t handle
// Return: void
struct ACL_Flush {
  std::function<void(uint16_t handle)> body{[](uint16_t /* handle */) {}};
  void operator()(uint16_t handle) { body(handle); };
};
extern struct ACL_Flush ACL_Flush;

// Name: ACL_SendConnectionParameterUpdateRequest
// Params: uint16_t handle
// Params: uint16_t conn_int_min
// Params: uint16_t conn_int_max
// Params: uint16_t conn_latency
// Params: uint16_t conn_timeout
// Params: uint16_t min_ce_len
// Params: uint16_t max_ce_len
// Return: void
struct ACL_SendConnectionParameterUpdateRequest {
  std::function<void(uint16_t handle, uint16_t conn_int_min,
                     uint16_t conn_int_max, uint16_t conn_latency,
                     uint16_t conn_timeout, uint16_t min_ce_len,
                     uint16_t max_ce_len)>
      body{[](uint16_t /* handle */, uint16_t /* conn_int_min */,
              uint16_t /* conn_int_max */, uint16_t /* conn_latency */,
              uint16_t /* conn_timeout */, uint16_t /* min_ce_len */,
              uint16_t /* max_ce_len */) {}};
  void operator()(uint16_t handle, uint16_t conn_int_min, uint16_t conn_int_max,
                  uint16_t conn_latency, uint16_t conn_timeout,
                  uint16_t min_ce_len, uint16_t max_ce_len) {
    body(handle, conn_int_min, conn_int_max, conn_latency, conn_timeout,
         min_ce_len, max_ce_len);
  };
};
extern struct ACL_SendConnectionParameterUpdateRequest
    ACL_SendConnectionParameterUpdateRequest;
}  // namespace main_shim_acl_api
}  // namespace mock
}  // namespace test

// END mockcify generation