/*
 * 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:26
 *
 *  mockcify.pl ver 0.5.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/logging.h>
#include <base/strings/string_number_conversions.h>
#include <stdio.h>

#include <string>

#include "bt_target.h"
#include "device/include/controller.h"
#include "l2c_api.h"
#include "main/shim/dumpsys.h"
#include "osi/include/allocator.h"
#include "osi/include/log.h"
#include "stack/gatt/connection_manager.h"
#include "stack/gatt/gatt_int.h"
#include "stack/include/bt_hdr.h"
#include "stack/include/gatt_api.h"
#include "types/bluetooth/uuid.h"
#include "types/bt_transport.h"
#include "types/raw_address.h"

// Original usings
using bluetooth::Uuid;

// Mocked compile conditionals, if any

namespace test {
namespace mock {
namespace stack_gatt_api {

// Shared state between mocked functions and tests
// Name: GATTC_ConfigureMTU
// Params: uint16_t conn_id, uint16_t mtu
// Return: tGATT_STATUS
struct GATTC_ConfigureMTU {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id, uint16_t mtu)> body{
      [](uint16_t conn_id, uint16_t mtu) { return return_value; }};
  tGATT_STATUS operator()(uint16_t conn_id, uint16_t mtu) {
    return body(conn_id, mtu);
  };
};
extern struct GATTC_ConfigureMTU GATTC_ConfigureMTU;

// Name: GATTC_Discover
// Params: uint16_t conn_id, tGATT_DISC_TYPE disc_type, uint16_t start_handle,
// uint16_t end_handle Return: tGATT_STATUS
struct GATTC_Discover {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id, tGATT_DISC_TYPE disc_type,
                             uint16_t start_handle, uint16_t end_handle)>
      body{[](uint16_t conn_id, tGATT_DISC_TYPE disc_type,
              uint16_t start_handle,
              uint16_t end_handle) { return return_value; }};
  tGATT_STATUS operator()(uint16_t conn_id, tGATT_DISC_TYPE disc_type,
                          uint16_t start_handle, uint16_t end_handle) {
    return body(conn_id, disc_type, start_handle, end_handle);
  };
};
extern struct GATTC_Discover GATTC_Discover;

// Name: GATTC_ExecuteWrite
// Params: uint16_t conn_id, bool is_execute
// Return: tGATT_STATUS
struct GATTC_ExecuteWrite {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id, bool is_execute)> body{
      [](uint16_t conn_id, bool is_execute) { return return_value; }};
  tGATT_STATUS operator()(uint16_t conn_id, bool is_execute) {
    return body(conn_id, is_execute);
  };
};
extern struct GATTC_ExecuteWrite GATTC_ExecuteWrite;

// Name: GATTC_Read
// Params: uint16_t conn_id, tGATT_READ_TYPE type, tGATT_READ_PARAM* p_read
// Return: tGATT_STATUS
struct GATTC_Read {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id, tGATT_READ_TYPE type,
                             tGATT_READ_PARAM* p_read)>
      body{[](uint16_t conn_id, tGATT_READ_TYPE type,
              tGATT_READ_PARAM* p_read) { return return_value; }};
  tGATT_STATUS operator()(uint16_t conn_id, tGATT_READ_TYPE type,
                          tGATT_READ_PARAM* p_read) {
    return body(conn_id, type, p_read);
  };
};
extern struct GATTC_Read GATTC_Read;

// Name: GATTC_SendHandleValueConfirm
// Params: uint16_t conn_id, uint16_t cid
// Return: tGATT_STATUS
struct GATTC_SendHandleValueConfirm {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id, uint16_t cid)> body{
      [](uint16_t conn_id, uint16_t cid) { return return_value; }};
  tGATT_STATUS operator()(uint16_t conn_id, uint16_t cid) {
    return body(conn_id, cid);
  };
};
extern struct GATTC_SendHandleValueConfirm GATTC_SendHandleValueConfirm;

// Name: GATTC_Write
// Params: uint16_t conn_id, tGATT_WRITE_TYPE type, tGATT_VALUE* p_write
// Return: tGATT_STATUS
struct GATTC_Write {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id, tGATT_WRITE_TYPE type,
                             tGATT_VALUE* p_write)>
      body{[](uint16_t conn_id, tGATT_WRITE_TYPE type, tGATT_VALUE* p_write) {
        return return_value;
      }};
  tGATT_STATUS operator()(uint16_t conn_id, tGATT_WRITE_TYPE type,
                          tGATT_VALUE* p_write) {
    return body(conn_id, type, p_write);
  };
};
extern struct GATTC_Write GATTC_Write;

// Name: GATTS_AddService
// Params: tGATT_IF gatt_if, btgatt_db_element_t* service, int count
// Return: tGATT_STATUS
struct GATTS_AddService {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(tGATT_IF gatt_if, btgatt_db_element_t* service,
                             int count)>
      body{[](tGATT_IF gatt_if, btgatt_db_element_t* service, int count) {
        return return_value;
      }};
  tGATT_STATUS operator()(tGATT_IF gatt_if, btgatt_db_element_t* service,
                          int count) {
    return body(gatt_if, service, count);
  };
};
extern struct GATTS_AddService GATTS_AddService;

// Name: GATTS_DeleteService
// Params: tGATT_IF gatt_if, Uuid* p_svc_uuid, uint16_t svc_inst
// Return: bool
struct GATTS_DeleteService {
  static bool return_value;
  std::function<bool(tGATT_IF gatt_if, Uuid* p_svc_uuid, uint16_t svc_inst)>
      body{[](tGATT_IF gatt_if, Uuid* p_svc_uuid, uint16_t svc_inst) {
        return return_value;
      }};
  bool operator()(tGATT_IF gatt_if, Uuid* p_svc_uuid, uint16_t svc_inst) {
    return body(gatt_if, p_svc_uuid, svc_inst);
  };
};
extern struct GATTS_DeleteService GATTS_DeleteService;

// Name: GATTS_HandleValueIndication
// Params: uint16_t conn_id, uint16_t attr_handle, uint16_t val_len, uint8_t*
// p_val Return: tGATT_STATUS
struct GATTS_HandleValueIndication {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id, uint16_t attr_handle,
                             uint16_t val_len, uint8_t* p_val)>
      body{[](uint16_t conn_id, uint16_t attr_handle, uint16_t val_len,
              uint8_t* p_val) { return return_value; }};
  tGATT_STATUS operator()(uint16_t conn_id, uint16_t attr_handle,
                          uint16_t val_len, uint8_t* p_val) {
    return body(conn_id, attr_handle, val_len, p_val);
  };
};
extern struct GATTS_HandleValueIndication GATTS_HandleValueIndication;

// Name: GATTS_HandleValueNotification
// Params: uint16_t conn_id, uint16_t attr_handle, uint16_t val_len, uint8_t*
// p_val Return: tGATT_STATUS
struct GATTS_HandleValueNotification {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id, uint16_t attr_handle,
                             uint16_t val_len, uint8_t* p_val)>
      body{[](uint16_t conn_id, uint16_t attr_handle, uint16_t val_len,
              uint8_t* p_val) { return return_value; }};
  tGATT_STATUS operator()(uint16_t conn_id, uint16_t attr_handle,
                          uint16_t val_len, uint8_t* p_val) {
    return body(conn_id, attr_handle, val_len, p_val);
  };
};
extern struct GATTS_HandleValueNotification GATTS_HandleValueNotification;

// Name: GATTS_NVRegister
// Params: tGATT_APPL_INFO* p_cb_info
// Return: bool
struct GATTS_NVRegister {
  static bool return_value;
  std::function<bool(tGATT_APPL_INFO* p_cb_info)> body{
      [](tGATT_APPL_INFO* p_cb_info) { return return_value; }};
  bool operator()(tGATT_APPL_INFO* p_cb_info) { return body(p_cb_info); };
};
extern struct GATTS_NVRegister GATTS_NVRegister;

// Name: GATTS_SendRsp
// Params: uint16_t conn_id, uint32_t trans_id, tGATT_STATUS status, tGATTS_RSP*
// p_msg Return: tGATT_STATUS
struct GATTS_SendRsp {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id, uint32_t trans_id,
                             tGATT_STATUS status, tGATTS_RSP* p_msg)>
      body{[](uint16_t conn_id, uint32_t trans_id, tGATT_STATUS status,
              tGATTS_RSP* p_msg) { return return_value; }};
  tGATT_STATUS operator()(uint16_t conn_id, uint32_t trans_id,
                          tGATT_STATUS status, tGATTS_RSP* p_msg) {
    return body(conn_id, trans_id, status, p_msg);
  };
};
extern struct GATTS_SendRsp GATTS_SendRsp;

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

// Name: GATT_CancelConnect
// Params: tGATT_IF gatt_if, const RawAddress& bd_addr, bool is_direct
// Return: bool
struct GATT_CancelConnect {
  static bool return_value;
  std::function<bool(tGATT_IF gatt_if, const RawAddress& bd_addr,
                     bool is_direct)>
      body{[](tGATT_IF gatt_if, const RawAddress& bd_addr, bool is_direct) {
        return return_value;
      }};
  bool operator()(tGATT_IF gatt_if, const RawAddress& bd_addr, bool is_direct) {
    return body(gatt_if, bd_addr, is_direct);
  };
};
extern struct GATT_CancelConnect GATT_CancelConnect;

// Name: GATT_Connect
// Params: tGATT_IF gatt_if, const RawAddress& bd_addr, bool is_direct,
// tBT_TRANSPORT transport, bool opportunistic, uint8_t initiating_phys Return:
// bool
struct GATT_Connect {
  static bool return_value;
  std::function<bool(tGATT_IF gatt_if, const RawAddress& bd_addr,
                     bool is_direct, tBT_TRANSPORT transport,
                     bool opportunistic, uint8_t initiating_phys)>
      body{[](tGATT_IF gatt_if, const RawAddress& bd_addr, bool is_direct,
              tBT_TRANSPORT transport, bool opportunistic,
              uint8_t initiating_phys) { return return_value; }};
  bool operator()(tGATT_IF gatt_if, const RawAddress& bd_addr, bool is_direct,
                  tBT_TRANSPORT transport, bool opportunistic,
                  uint8_t initiating_phys) {
    return body(gatt_if, bd_addr, is_direct, transport, opportunistic,
                initiating_phys);
  };
};
extern struct GATT_Connect GATT_Connect;

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

// Name: GATT_Disconnect
// Params: uint16_t conn_id
// Return: tGATT_STATUS
struct GATT_Disconnect {
  static tGATT_STATUS return_value;
  std::function<tGATT_STATUS(uint16_t conn_id)> body{
      [](uint16_t conn_id) { return return_value; }};
  tGATT_STATUS operator()(uint16_t conn_id) { return body(conn_id); };
};
extern struct GATT_Disconnect GATT_Disconnect;

// Name: GATT_GetConnIdIfConnected
// Params: tGATT_IF gatt_if, const RawAddress& bd_addr, uint16_t* p_conn_id,
// tBT_TRANSPORT transport Return: bool
struct GATT_GetConnIdIfConnected {
  static bool return_value;
  std::function<bool(tGATT_IF gatt_if, const RawAddress& bd_addr,
                     uint16_t* p_conn_id, tBT_TRANSPORT transport)>
      body{[](tGATT_IF gatt_if, const RawAddress& bd_addr, uint16_t* p_conn_id,
              tBT_TRANSPORT transport) { return return_value; }};
  bool operator()(tGATT_IF gatt_if, const RawAddress& bd_addr,
                  uint16_t* p_conn_id, tBT_TRANSPORT transport) {
    return body(gatt_if, bd_addr, p_conn_id, transport);
  };
};
extern struct GATT_GetConnIdIfConnected GATT_GetConnIdIfConnected;

// Name: GATT_GetConnectionInfor
// Params: uint16_t conn_id, tGATT_IF* p_gatt_if, RawAddress& bd_addr,
// tBT_TRANSPORT* p_transport Return: bool
struct GATT_GetConnectionInfor {
  static bool return_value;
  std::function<bool(uint16_t conn_id, tGATT_IF* p_gatt_if, RawAddress& bd_addr,
                     tBT_TRANSPORT* p_transport)>
      body{[](uint16_t conn_id, tGATT_IF* p_gatt_if, RawAddress& bd_addr,
              tBT_TRANSPORT* p_transport) { return return_value; }};
  bool operator()(uint16_t conn_id, tGATT_IF* p_gatt_if, RawAddress& bd_addr,
                  tBT_TRANSPORT* p_transport) {
    return body(conn_id, p_gatt_if, bd_addr, p_transport);
  };
};
extern struct GATT_GetConnectionInfor GATT_GetConnectionInfor;

// Name: GATT_Register
// Params: const Uuid& app_uuid128, std::string name, tGATT_CBACK* p_cb_info,
// bool eatt_support Return: tGATT_IF
struct GATT_Register {
  static tGATT_IF return_value;
  std::function<tGATT_IF(const Uuid& app_uuid128, std::string name,
                         tGATT_CBACK* p_cb_info, bool eatt_support)>
      body{[](const Uuid& app_uuid128, std::string name, tGATT_CBACK* p_cb_info,
              bool eatt_support) { return return_value; }};
  tGATT_IF operator()(const Uuid& app_uuid128, std::string name,
                      tGATT_CBACK* p_cb_info, bool eatt_support) {
    return body(app_uuid128, name, p_cb_info, eatt_support);
  };
};
extern struct GATT_Register GATT_Register;

// Name: GATT_SetIdleTimeout
// Params: const RawAddress& bd_addr, uint16_t idle_tout, tBT_TRANSPORT
// transport Return: void
struct GATT_SetIdleTimeout {
  std::function<void(const RawAddress& bd_addr, uint16_t idle_tout,
                     tBT_TRANSPORT transport, bool is_active)>
      body{[](const RawAddress& bd_addr, uint16_t idle_tout,
              tBT_TRANSPORT transport, bool is_active) {}};
  void operator()(const RawAddress& bd_addr, uint16_t idle_tout,
                  tBT_TRANSPORT transport, bool is_active) {
    body(bd_addr, idle_tout, transport, is_active);
  };
};
extern struct GATT_SetIdleTimeout GATT_SetIdleTimeout;

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

// // Name: gatt_add_an_item_to_list
// // Params: uint16_t s_handle
// // Return: tGATT_HDL_LIST_ELEM&
// struct gatt_add_an_item_to_list {
//   static tGATT_HDL_LIST_ELEM return_value;
//   std::function<tGATT_HDL_LIST_ELEM&(uint16_t s_handle)> body{
//       [](uint16_t s_handle) { return return_value; }};
//   tGATT_HDL_LIST_ELEM& operator()(uint16_t s_handle) { return body(s_handle);
//   };
// };
// extern struct gatt_add_an_item_to_list gatt_add_an_item_to_list;

// Name: is_active_service
// Params: const Uuid& app_uuid128, Uuid* p_svc_uuid, uint16_t start_handle
// Return: bool
struct is_active_service {
  static bool return_value;
  std::function<bool(const Uuid& app_uuid128, Uuid* p_svc_uuid,
                     uint16_t start_handle)>
      body{[](const Uuid& app_uuid128, Uuid* p_svc_uuid,
              uint16_t start_handle) { return return_value; }};
  bool operator()(const Uuid& app_uuid128, Uuid* p_svc_uuid,
                  uint16_t start_handle) {
    return body(app_uuid128, p_svc_uuid, start_handle);
  };
};
extern struct is_active_service is_active_service;

}  // namespace stack_gatt_api
}  // namespace mock
}  // namespace test

// END mockcify generation