mock: Update mock_bta_av_api (28e1e70a) · Commits · e / os / android_packages_modules_Bluetooth

system/test/mock/mock_bta_av_api.cc

+109 −26

Original line number	Diff line number	Diff line
		/*
		* Copyright 2021 The Android Open Source Project
		* Copyright 2023 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.
		@@ -13,95 +13,178 @@
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		/*
		* Generated mock file from original source file
		* Functions generated:23
		* Functions generated:24
		*
		* mockcify.pl ver 0.6.1
		*/

		#include <map>
		#include <string>
		#include <cstdint>

		#include "bt_target.h"
		#include "bta/av/bta_av_int.h"
		#include "osi/include/allocator.h"
		#include "osi/include/compat.h"
		#include "osi/include/log.h"
		#include "stack/include/bt_hdr.h"
		// Mock include file to share data between tests and mock
		#include "test/common/mock_functions.h"
		#include "types/raw_address.h"
		#include "test/mock/mock_bta_av_api.h"

		#ifndef UNUSED_ATTR
		#define UNUSED_ATTR
		#endif
		// Original usings

		void BTA_AvEnable(tBTA_AV_FEAT features, tBTA_AV_CBACK* p_cback) {
		// Mocked internal structures, if any

		namespace test {
		namespace mock {
		namespace bta_av_api {

		// Function state capture and return values, if needed
		struct BTA_AvClose BTA_AvClose;
		struct BTA_AvCloseRc BTA_AvCloseRc;
		struct BTA_AvDeregister BTA_AvDeregister;
		struct BTA_AvDisable BTA_AvDisable;
		struct BTA_AvDisconnect BTA_AvDisconnect;
		struct BTA_AvEnable BTA_AvEnable;
		struct BTA_AvMetaCmd BTA_AvMetaCmd;
		struct BTA_AvMetaRsp BTA_AvMetaRsp;
		struct BTA_AvOffloadStart BTA_AvOffloadStart;
		struct BTA_AvOffloadStartRsp BTA_AvOffloadStartRsp;
		struct BTA_AvOpen BTA_AvOpen;
		struct BTA_AvOpenRc BTA_AvOpenRc;
		struct BTA_AvProtectReq BTA_AvProtectReq;
		struct BTA_AvProtectRsp BTA_AvProtectRsp;
		struct BTA_AvReconfig BTA_AvReconfig;
		struct BTA_AvRegister BTA_AvRegister;
		struct BTA_AvRemoteCmd BTA_AvRemoteCmd;
		struct BTA_AvRemoteVendorUniqueCmd BTA_AvRemoteVendorUniqueCmd;
		struct BTA_AvSetLatency BTA_AvSetLatency;
		struct BTA_AvSetPeerSep BTA_AvSetPeerSep;
		struct BTA_AvStart BTA_AvStart;
		struct BTA_AvStop BTA_AvStop;
		struct BTA_AvVendorCmd BTA_AvVendorCmd;
		struct BTA_AvVendorRsp BTA_AvVendorRsp;

		} // namespace bta_av_api
		} // namespace mock
		} // namespace test

		// Mocked function return values, if any
		namespace test {
		namespace mock {
		namespace bta_av_api {} // namespace bta_av_api
		} // namespace mock
		} // namespace test

		// Mocked functions, if any
		void BTA_AvClose(tBTA_AV_HNDL handle) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvClose(handle);
		}
		void BTA_AvClose(tBTA_AV_HNDL handle) { inc_func_call_count(__func__); }
		void BTA_AvCloseRc(uint8_t rc_handle) { inc_func_call_count(__func__); }
		void BTA_AvDeregister(tBTA_AV_HNDL hndl) { inc_func_call_count(__func__); }
		void BTA_AvDisable(void) { inc_func_call_count(__func__); }
		void BTA_AvDisconnect(const RawAddress& bd_addr) {
		void BTA_AvCloseRc(uint8_t rc_handle) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvCloseRc(rc_handle);
		}
		void BTA_AvDeregister(tBTA_AV_HNDL hndl) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvDeregister(hndl);
		}
		void BTA_AvDisable(void) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvDisable();
		}
		void BTA_AvDisconnect(tBTA_AV_HNDL handle) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvDisconnect(handle);
		}
		void BTA_AvEnable(tBTA_AV_FEAT features, tBTA_AV_CBACK* p_cback) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvEnable(features, p_cback);
		}
		void BTA_AvMetaCmd(uint8_t rc_handle, uint8_t label, tBTA_AV_CMD cmd_code,
		BT_HDR* p_pkt) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvMetaCmd(rc_handle, label, cmd_code, p_pkt);
		}
		void BTA_AvMetaRsp(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
		BT_HDR* p_pkt) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvMetaRsp(rc_handle, label, rsp_code, p_pkt);
		}
		void BTA_AvOffloadStart(tBTA_AV_HNDL hndl) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvOffloadStart(hndl);
		}
		void BTA_AvOffloadStart(tBTA_AV_HNDL hndl) { inc_func_call_count(__func__); }
		void BTA_AvOffloadStartRsp(tBTA_AV_HNDL hndl, tBTA_AV_STATUS status) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvOffloadStartRsp(hndl, status);
		}
		void BTA_AvOpen(const RawAddress& bd_addr, tBTA_AV_HNDL handle, bool use_rc,
		uint16_t uuid) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvOpen(bd_addr, handle, use_rc, uuid);
		}
		void BTA_AvOpenRc(tBTA_AV_HNDL handle) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvOpenRc(handle);
		}
		void BTA_AvOpenRc(tBTA_AV_HNDL handle) { inc_func_call_count(__func__); }
		void BTA_AvProtectReq(tBTA_AV_HNDL hndl, uint8_t* p_data, uint16_t len) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvProtectReq(hndl, p_data, len);
		}
		void BTA_AvProtectRsp(tBTA_AV_HNDL hndl, uint8_t error_code, uint8_t* p_data,
		uint16_t len) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvProtectRsp(hndl, error_code, p_data, len);
		}
		void BTA_AvReconfig(tBTA_AV_HNDL hndl, bool suspend, uint8_t sep_info_idx,
		uint8_t* p_codec_info, uint8_t num_protect,
		const uint8_t* p_protect_info) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvReconfig(
		hndl, suspend, sep_info_idx, p_codec_info, num_protect, p_protect_info);
		}
		void BTA_AvRegister(tBTA_AV_CHNL chnl, const char* p_service_name,
		uint8_t app_id, tBTA_AV_SINK_DATA_CBACK* p_sink_data_cback,
		uint16_t service_uuid) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvRegister(chnl, p_service_name, app_id,
		p_sink_data_cback, service_uuid);
		}
		void BTA_AvRemoteCmd(uint8_t rc_handle, uint8_t label, tBTA_AV_RC rc_id,
		tBTA_AV_STATE key_state) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvRemoteCmd(rc_handle, label, rc_id, key_state);
		}
		void BTA_AvRemoteVendorUniqueCmd(uint8_t rc_handle, uint8_t label,
		tBTA_AV_STATE key_state, uint8_t* p_msg,
		uint8_t buf_len) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvRemoteVendorUniqueCmd(
		rc_handle, label, key_state, p_msg, buf_len);
		}
		void BTA_AvSetLatency(tBTA_AV_HNDL handle, bool is_low_latency) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvSetLatency(handle, is_low_latency);
		}
		void BTA_AvSetPeerSep(const RawAddress& bdaddr, uint8_t sep) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvSetPeerSep(bdaddr, sep);
		}
		void BTA_AvStart(tBTA_AV_HNDL handle, bool use_latency_mode) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvStart(handle, use_latency_mode);
		}
		void BTA_AvStop(tBTA_AV_HNDL handle, bool suspend) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvStop(handle, suspend);
		}
		void BTA_AvVendorCmd(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE cmd_code,
		uint8_t* p_data, uint16_t len) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvVendorCmd(rc_handle, label, cmd_code, p_data,
		len);
		}
		void BTA_AvVendorRsp(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
		uint8_t* p_data, uint16_t len, uint32_t company_id) {
		inc_func_call_count(__func__);
		test::mock::bta_av_api::BTA_AvVendorRsp(rc_handle, label, rsp_code, p_data,
		len, company_id);
		}
		void BTA_AvSetLatency(tBTA_AV_HNDL handle, bool is_low_latency) {
		inc_func_call_count(__func__);
		}
		// Mocked functions complete
		// END mockcify generation

system/test/mock/mock_bta_av_api.h

0 → 100644

+352 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2023 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:24
		*
		* mockcify.pl ver 0.6.1
		*/

		#include <cstdint>
		#include <functional>

		// 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 "bta/include/bta_av_api.h"
		#include "stack/include/bt_hdr.h"
		#include "types/raw_address.h"

		// Original usings

		// Mocked compile conditionals, if any

		namespace test {
		namespace mock {
		namespace bta_av_api {

		// Shared state between mocked functions and tests
		// Name: BTA_AvClose
		// Params: tBTA_AV_HNDL handle
		// Return: void
		struct BTA_AvClose {
		std::function<void(tBTA_AV_HNDL handle)> body{[](tBTA_AV_HNDL handle) {}};
		void operator()(tBTA_AV_HNDL handle) { body(handle); };
		};
		extern struct BTA_AvClose BTA_AvClose;

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

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

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

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

		// Name: BTA_AvEnable
		// Params: tBTA_AV_FEAT features, tBTA_AV_CBACK* p_cback
		// Return: void
		struct BTA_AvEnable {
		std::function<void(tBTA_AV_FEAT features, tBTA_AV_CBACK* p_cback)> body{
		[](tBTA_AV_FEAT features, tBTA_AV_CBACK* p_cback) {}};
		void operator()(tBTA_AV_FEAT features, tBTA_AV_CBACK* p_cback) {
		body(features, p_cback);
		};
		};
		extern struct BTA_AvEnable BTA_AvEnable;

		// Name: BTA_AvMetaCmd
		// Params: uint8_t rc_handle, uint8_t label, tBTA_AV_CMD cmd_code, BT_HDR* p_pkt
		// Return: void
		struct BTA_AvMetaCmd {
		std::function<void(uint8_t rc_handle, uint8_t label, tBTA_AV_CMD cmd_code,
		BT_HDR* p_pkt)>
		body{[](uint8_t rc_handle, uint8_t label, tBTA_AV_CMD cmd_code,
		BT_HDR* p_pkt) {}};
		void operator()(uint8_t rc_handle, uint8_t label, tBTA_AV_CMD cmd_code,
		BT_HDR* p_pkt) {
		body(rc_handle, label, cmd_code, p_pkt);
		};
		};
		extern struct BTA_AvMetaCmd BTA_AvMetaCmd;

		// Name: BTA_AvMetaRsp
		// Params: uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code, BT_HDR*
		// p_pkt Return: void
		struct BTA_AvMetaRsp {
		std::function<void(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
		BT_HDR* p_pkt)>
		body{[](uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
		BT_HDR* p_pkt) {}};
		void operator()(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
		BT_HDR* p_pkt) {
		body(rc_handle, label, rsp_code, p_pkt);
		};
		};
		extern struct BTA_AvMetaRsp BTA_AvMetaRsp;

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

		// Name: BTA_AvOffloadStartRsp
		// Params: tBTA_AV_HNDL hndl, tBTA_AV_STATUS status
		// Return: void
		struct BTA_AvOffloadStartRsp {
		std::function<void(tBTA_AV_HNDL hndl, tBTA_AV_STATUS status)> body{
		[](tBTA_AV_HNDL hndl, tBTA_AV_STATUS status) {}};
		void operator()(tBTA_AV_HNDL hndl, tBTA_AV_STATUS status) {
		body(hndl, status);
		};
		};
		extern struct BTA_AvOffloadStartRsp BTA_AvOffloadStartRsp;

		// Name: BTA_AvOpen
		// Params: const RawAddress& bd_addr, tBTA_AV_HNDL handle, bool use_rc, uint16_t
		// uuid Return: void
		struct BTA_AvOpen {
		std::function<void(const RawAddress& bd_addr, tBTA_AV_HNDL handle,
		bool use_rc, uint16_t uuid)>
		body{[](const RawAddress& bd_addr, tBTA_AV_HNDL handle, bool use_rc,
		uint16_t uuid) {}};
		void operator()(const RawAddress& bd_addr, tBTA_AV_HNDL handle, bool use_rc,
		uint16_t uuid) {
		body(bd_addr, handle, use_rc, uuid);
		};
		};
		extern struct BTA_AvOpen BTA_AvOpen;

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

		// Name: BTA_AvProtectReq
		// Params: tBTA_AV_HNDL hndl, uint8_t* p_data, uint16_t len
		// Return: void
		struct BTA_AvProtectReq {
		std::function<void(tBTA_AV_HNDL hndl, uint8_t* p_data, uint16_t len)> body{
		[](tBTA_AV_HNDL hndl, uint8_t* p_data, uint16_t len) {}};
		void operator()(tBTA_AV_HNDL hndl, uint8_t* p_data, uint16_t len) {
		body(hndl, p_data, len);
		};
		};
		extern struct BTA_AvProtectReq BTA_AvProtectReq;

		// Name: BTA_AvProtectRsp
		// Params: tBTA_AV_HNDL hndl, uint8_t error_code, uint8_t* p_data, uint16_t len
		// Return: void
		struct BTA_AvProtectRsp {
		std::function<void(tBTA_AV_HNDL hndl, uint8_t error_code, uint8_t* p_data,
		uint16_t len)>
		body{[](tBTA_AV_HNDL hndl, uint8_t error_code, uint8_t* p_data,
		uint16_t len) {}};
		void operator()(tBTA_AV_HNDL hndl, uint8_t error_code, uint8_t* p_data,
		uint16_t len) {
		body(hndl, error_code, p_data, len);
		};
		};
		extern struct BTA_AvProtectRsp BTA_AvProtectRsp;

		// Name: BTA_AvReconfig
		// Params: tBTA_AV_HNDL hndl, bool suspend, uint8_t sep_info_idx, uint8_t*
		// p_codec_info, uint8_t num_protect, const uint8_t* p_protect_info Return: void
		struct BTA_AvReconfig {
		std::function<void(tBTA_AV_HNDL hndl, bool suspend, uint8_t sep_info_idx,
		uint8_t* p_codec_info, uint8_t num_protect,
		const uint8_t* p_protect_info)>
		body{[](tBTA_AV_HNDL hndl, bool suspend, uint8_t sep_info_idx,
		uint8_t* p_codec_info, uint8_t num_protect,
		const uint8_t* p_protect_info) {}};
		void operator()(tBTA_AV_HNDL hndl, bool suspend, uint8_t sep_info_idx,
		uint8_t* p_codec_info, uint8_t num_protect,
		const uint8_t* p_protect_info) {
		body(hndl, suspend, sep_info_idx, p_codec_info, num_protect,
		p_protect_info);
		};
		};
		extern struct BTA_AvReconfig BTA_AvReconfig;

		// Name: BTA_AvRegister
		// Params: tBTA_AV_CHNL chnl, const char* p_service_name, uint8_t app_id,
		// tBTA_AV_SINK_DATA_CBACK* p_sink_data_cback, uint16_t service_uuid Return:
		// void
		struct BTA_AvRegister {
		std::function<void(tBTA_AV_CHNL chnl, const char* p_service_name,
		uint8_t app_id, tBTA_AV_SINK_DATA_CBACK* p_sink_data_cback,
		uint16_t service_uuid)>
		body{[](tBTA_AV_CHNL chnl, const char* p_service_name, uint8_t app_id,
		tBTA_AV_SINK_DATA_CBACK* p_sink_data_cback,
		uint16_t service_uuid) {}};
		void operator()(tBTA_AV_CHNL chnl, const char* p_service_name, uint8_t app_id,
		tBTA_AV_SINK_DATA_CBACK* p_sink_data_cback,
		uint16_t service_uuid) {
		body(chnl, p_service_name, app_id, p_sink_data_cback, service_uuid);
		};
		};
		extern struct BTA_AvRegister BTA_AvRegister;

		// Name: BTA_AvRemoteCmd
		// Params: uint8_t rc_handle, uint8_t label, tBTA_AV_RC rc_id, tBTA_AV_STATE
		// key_state Return: void
		struct BTA_AvRemoteCmd {
		std::function<void(uint8_t rc_handle, uint8_t label, tBTA_AV_RC rc_id,
		tBTA_AV_STATE key_state)>
		body{[](uint8_t rc_handle, uint8_t label, tBTA_AV_RC rc_id,
		tBTA_AV_STATE key_state) {}};
		void operator()(uint8_t rc_handle, uint8_t label, tBTA_AV_RC rc_id,
		tBTA_AV_STATE key_state) {
		body(rc_handle, label, rc_id, key_state);
		};
		};
		extern struct BTA_AvRemoteCmd BTA_AvRemoteCmd;

		// Name: BTA_AvRemoteVendorUniqueCmd
		// Params: uint8_t rc_handle, uint8_t label, tBTA_AV_STATE key_state, uint8_t*
		// p_msg, uint8_t buf_len Return: void
		struct BTA_AvRemoteVendorUniqueCmd {
		std::function<void(uint8_t rc_handle, uint8_t label, tBTA_AV_STATE key_state,
		uint8_t* p_msg, uint8_t buf_len)>
		body{[](uint8_t rc_handle, uint8_t label, tBTA_AV_STATE key_state,
		uint8_t* p_msg, uint8_t buf_len) {}};
		void operator()(uint8_t rc_handle, uint8_t label, tBTA_AV_STATE key_state,
		uint8_t* p_msg, uint8_t buf_len) {
		body(rc_handle, label, key_state, p_msg, buf_len);
		};
		};
		extern struct BTA_AvRemoteVendorUniqueCmd BTA_AvRemoteVendorUniqueCmd;

		// Name: BTA_AvSetLatency
		// Params: tBTA_AV_HNDL handle, bool is_low_latency
		// Return: void
		struct BTA_AvSetLatency {
		std::function<void(tBTA_AV_HNDL handle, bool is_low_latency)> body{
		[](tBTA_AV_HNDL handle, bool is_low_latency) {}};
		void operator()(tBTA_AV_HNDL handle, bool is_low_latency) {
		body(handle, is_low_latency);
		};
		};
		extern struct BTA_AvSetLatency BTA_AvSetLatency;

		// Name: BTA_AvSetPeerSep
		// Params: const RawAddress& bdaddr, uint8_t sep
		// Return: void
		struct BTA_AvSetPeerSep {
		std::function<void(const RawAddress& bdaddr, uint8_t sep)> body{
		[](const RawAddress& bdaddr, uint8_t sep) {}};
		void operator()(const RawAddress& bdaddr, uint8_t sep) { body(bdaddr, sep); };
		};
		extern struct BTA_AvSetPeerSep BTA_AvSetPeerSep;

		// Name: BTA_AvStart
		// Params: tBTA_AV_HNDL handle, bool use_latency_mode
		// Return: void
		struct BTA_AvStart {
		std::function<void(tBTA_AV_HNDL handle, bool use_latency_mode)> body{
		[](tBTA_AV_HNDL handle, bool use_latency_mode) {}};
		void operator()(tBTA_AV_HNDL handle, bool use_latency_mode) {
		body(handle, use_latency_mode);
		};
		};
		extern struct BTA_AvStart BTA_AvStart;

		// Name: BTA_AvStop
		// Params: tBTA_AV_HNDL handle, bool suspend
		// Return: void
		struct BTA_AvStop {
		std::function<void(tBTA_AV_HNDL handle, bool suspend)> body{
		[](tBTA_AV_HNDL handle, bool suspend) {}};
		void operator()(tBTA_AV_HNDL handle, bool suspend) { body(handle, suspend); };
		};
		extern struct BTA_AvStop BTA_AvStop;

		// Name: BTA_AvVendorCmd
		// Params: uint8_t rc_handle, uint8_t label, tBTA_AV_CODE cmd_code, uint8_t*
		// p_data, uint16_t len Return: void
		struct BTA_AvVendorCmd {
		std::function<void(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE cmd_code,
		uint8_t* p_data, uint16_t len)>
		body{[](uint8_t rc_handle, uint8_t label, tBTA_AV_CODE cmd_code,
		uint8_t* p_data, uint16_t len) {}};
		void operator()(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE cmd_code,
		uint8_t* p_data, uint16_t len) {
		body(rc_handle, label, cmd_code, p_data, len);
		};
		};
		extern struct BTA_AvVendorCmd BTA_AvVendorCmd;

		// Name: BTA_AvVendorRsp
		// Params: uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code, uint8_t*
		// p_data, uint16_t len, uint32_t company_id Return: void
		struct BTA_AvVendorRsp {
		std::function<void(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
		uint8_t* p_data, uint16_t len, uint32_t company_id)>
		body{[](uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
		uint8_t* p_data, uint16_t len, uint32_t company_id) {}};
		void operator()(uint8_t rc_handle, uint8_t label, tBTA_AV_CODE rsp_code,
		uint8_t* p_data, uint16_t len, uint32_t company_id) {
		body(rc_handle, label, rsp_code, p_data, len, company_id);
		};
		};
		extern struct BTA_AvVendorRsp BTA_AvVendorRsp;

		} // namespace bta_av_api
		} // namespace mock
		} // namespace test

		// END mockcify generation