Merge "Mock static initialization order 11" (0481df98) · Commits · e / os / android_packages_modules_Bluetooth

system/test/mock/mock_stack_a2dp_api.cc

+7 −7

Original line number	Diff line number	Diff line
		@@ -40,28 +40,28 @@
		tA2DP_STATUS A2DP_AddRecord(uint16_t service_uuid, char* p_service_name,
		char* p_provider_name, uint16_t features,
		uint32_t sdp_handle) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return A2DP_SUCCESS;
		}
		tA2DP_STATUS A2DP_FindService(uint16_t service_uuid, const RawAddress& bd_addr,
		tA2DP_SDP_DB_PARAMS* p_db,
		tA2DP_FIND_CBACK* p_cback) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return A2DP_SUCCESS;
		}
		uint16_t A2DP_GetAvdtpVersion() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		uint8_t A2DP_BitsSet(uint64_t num) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 1;
		}
		uint8_t A2DP_SetTraceLevel(uint8_t new_level) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		void A2DP_Init(void) { mock_function_count_map[__func__]++; }
		void A2DP_Init(void) { inc_func_call_count(__func__); }
		void a2dp_set_avdt_sdp_ver(uint16_t avdt_sdp_ver) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}

system/test/mock/mock_stack_a2dp_codec_config.cc

+68 −70

Original line number	Diff line number	Diff line
		@@ -42,16 +42,16 @@
		A2dpCodecConfig* A2dpCodecConfig::createCodec(
		btav_a2dp_codec_index_t codec_index,
		btav_a2dp_codec_priority_t codec_priority) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return nullptr;
		}
		A2dpCodecConfig* A2dpCodecs::findSinkCodecConfig(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return nullptr;
		}
		A2dpCodecConfig* A2dpCodecs::findSourceCodecConfig(
		const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return nullptr;
		}
		A2dpCodecConfig::A2dpCodecConfig(btav_a2dp_codec_index_t codec_index,
		@@ -60,97 +60,97 @@ A2dpCodecConfig::A2dpCodecConfig(btav_a2dp_codec_index_t codec_index,
		: codec_index_(codec_index),
		name_(name),
		default_codec_priority_(codec_priority) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		A2dpCodecConfig::~A2dpCodecConfig() { mock_function_count_map[__func__]++; }
		A2dpCodecConfig::~A2dpCodecConfig() { inc_func_call_count(__func__); }
		A2dpCodecs::A2dpCodecs(
		const std::vector<btav_a2dp_codec_config_t>& codec_priorities)
		: current_codec_config_(nullptr) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		A2dpCodecs::~A2dpCodecs() { mock_function_count_map[__func__]++; }
		A2dpCodecs::~A2dpCodecs() { inc_func_call_count(__func__); }
		bool A2DP_AdjustCodec(uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_BuildCodecHeader(const uint8_t* p_codec_info, BT_HDR* p_buf,
		uint16_t frames_per_packet) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_CodecEquals(const uint8_t* p_codec_info_a,
		const uint8_t* p_codec_info_b) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_CodecTypeEquals(const uint8_t* p_codec_info_a,
		const uint8_t* p_codec_info_b) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_GetPacketTimestamp(const uint8_t* p_codec_info, const uint8_t* p_data,
		uint32_t* p_timestamp) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_InitCodecConfig(btav_a2dp_codec_index_t codec_index,
		AvdtpSepConfig* p_cfg) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		int A2DP_GetEecoderEffectiveFrameSize(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		bool A2DP_IsPeerSinkCodecValid(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_IsPeerSourceCodecSupported(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_IsPeerSourceCodecValid(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_IsSinkCodecSupported(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_IsSinkCodecValid(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_IsSourceCodecValid(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2DP_UsesRtpHeader(bool content_protection_enabled,
		const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecConfig::codecConfigIsValid(
		const btav_a2dp_codec_config_t& codec_config) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecConfig::copyOutOtaCodecConfig(uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecConfig::getCodecSpecificConfig(tBT_A2DP_OFFLOAD* p_a2dp_offload) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecConfig::isCodecConfigEmpty(
		const btav_a2dp_codec_config_t& codec_config) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecConfig::isValid() const {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecConfig::setCodecUserConfig(
		@@ -160,22 +160,22 @@ bool A2dpCodecConfig::setCodecUserConfig(
		const uint8_t* p_peer_codec_info, bool is_capability,
		uint8_t* p_result_codec_config, bool* p_restart_input,
		bool* p_restart_output, bool* p_config_updated) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::getCodecConfigAndCapabilities(
		btav_a2dp_codec_config_t* p_codec_config,
		std::vector<btav_a2dp_codec_config_t>* p_codecs_local_capabilities,
		std::vector<btav_a2dp_codec_config_t>* p_codecs_selectable_capabilities) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::init() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::isSupportedCodec(btav_a2dp_codec_index_t codec_index) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::setCodecAudioConfig(
		@@ -183,14 +183,14 @@ bool A2dpCodecs::setCodecAudioConfig(
		const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params,
		const uint8_t* p_peer_sink_capabilities, uint8_t* p_result_codec_config,
		bool* p_restart_output, bool* p_config_updated) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::setCodecConfig(const uint8_t* p_peer_codec_info,
		bool is_capability,
		uint8_t* p_result_codec_config,
		bool select_current_codec) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::setCodecOtaConfig(
		@@ -198,7 +198,7 @@ bool A2dpCodecs::setCodecOtaConfig(
		const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params,
		uint8_t* p_result_codec_config, bool* p_restart_input,
		bool* p_restart_output, bool* p_config_updated) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::setCodecUserConfig(
		@@ -206,155 +206,153 @@ bool A2dpCodecs::setCodecUserConfig(
		const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params,
		const uint8_t* p_peer_sink_capabilities, uint8_t* p_result_codec_config,
		bool* p_restart_input, bool* p_restart_output, bool* p_config_updated) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::setPeerSinkCodecCapabilities(
		const uint8_t* p_peer_codec_capabilities) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::setPeerSourceCodecCapabilities(
		const uint8_t* p_peer_codec_capabilities) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool A2dpCodecs::setSinkCodecConfig(const uint8_t* p_peer_codec_info,
		bool is_capability,
		uint8_t* p_result_codec_config,
		bool select_current_codec) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		btav_a2dp_codec_config_t A2dpCodecConfig::getCodecAudioConfig() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		btav_a2dp_codec_config_t config;
		return config;
		}
		btav_a2dp_codec_config_t A2dpCodecConfig::getCodecCapability() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		btav_a2dp_codec_config_t config;
		return config;
		}
		btav_a2dp_codec_config_t A2dpCodecConfig::getCodecConfig() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		btav_a2dp_codec_config_t config;
		return config;
		}
		btav_a2dp_codec_config_t A2dpCodecConfig::getCodecLocalCapability() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		btav_a2dp_codec_config_t config;
		return config;
		}
		btav_a2dp_codec_config_t A2dpCodecConfig::getCodecSelectableCapability() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		btav_a2dp_codec_config_t config;
		return config;
		}
		btav_a2dp_codec_config_t A2dpCodecConfig::getCodecUserConfig() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		btav_a2dp_codec_config_t config;
		return config;
		}
		btav_a2dp_codec_index_t A2DP_SinkCodecIndex(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return BTAV_A2DP_CODEC_INDEX_MAX;
		}
		btav_a2dp_codec_index_t A2DP_SourceCodecIndex(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return BTAV_A2DP_CODEC_INDEX_MAX;
		}
		const char* A2DP_CodecIndexStr(btav_a2dp_codec_index_t codec_index) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return nullptr;
		}
		const char* A2DP_CodecName(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return nullptr;
		}
		const tA2DP_DECODER_INTERFACE* A2DP_GetDecoderInterface(
		const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return nullptr;
		}
		const tA2DP_ENCODER_INTERFACE* A2DP_GetEncoderInterface(
		const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return nullptr;
		}
		int A2DP_GetSinkTrackChannelType(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		int A2DP_GetTrackBitsPerSample(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		int A2DP_GetTrackChannelCount(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		int A2DP_GetTrackSampleRate(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		int A2dpCodecConfig::getTrackBitRate() const {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		std::string A2DP_CodecInfoString(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		std::string A2dpCodecConfig::codecBitsPerSample2Str(
		btav_a2dp_codec_bits_per_sample_t codec_bits_per_sample) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		std::string A2dpCodecConfig::codecChannelMode2Str(
		btav_a2dp_codec_channel_mode_t codec_channel_mode) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		std::string A2dpCodecConfig::codecConfig2Str(
		const btav_a2dp_codec_config_t& codec_config) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		std::string A2dpCodecConfig::codecSampleRate2Str(
		btav_a2dp_codec_sample_rate_t codec_sample_rate) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		tA2DP_CODEC_TYPE A2DP_GetCodecType(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		uint8_t A2DP_GetMediaType(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		uint8_t A2dpCodecConfig::getAudioBitsPerSample() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		void A2DP_InitDefaultCodec(uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void A2dpCodecConfig::debug_codec_dump(int fd) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		int A2DP_IotGetPeerSinkCodecType(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		void A2dpCodecConfig::setCodecPriority(
		btav_a2dp_codec_priority_t codec_priority) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void A2dpCodecConfig::setDefaultCodecPriority() {
		mock_function_count_map[__func__]++;
		}
		void A2dpCodecs::debug_codec_dump(int fd) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void A2dpCodecs::debug_codec_dump(int fd) { inc_func_call_count(__func__); }

system/test/mock/mock_stack_a2dp_sbc.cc

+34 −34

Original line number	Diff line number	Diff line
		@@ -125,155 +125,155 @@ btav_a2dp_codec_index_t A2DP_SourceCodecIndexSbc::return_value =

		// Mocked functions, if any
		bool A2DP_AdjustCodecSbc(uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_AdjustCodecSbc(p_codec_info);
		}
		bool A2DP_BuildCodecHeaderSbc(const uint8_t* p_codec_info, BT_HDR* p_buf,
		uint16_t frames_per_packet) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_BuildCodecHeaderSbc(
		p_codec_info, p_buf, frames_per_packet);
		}
		bool A2DP_CodecEqualsSbc(const uint8_t* p_codec_info_a,
		const uint8_t* p_codec_info_b) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_CodecEqualsSbc(p_codec_info_a,
		p_codec_info_b);
		}
		const char* A2DP_CodecIndexStrSbc(void) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_CodecIndexStrSbc();
		}
		const char* A2DP_CodecIndexStrSbcSink(void) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_CodecIndexStrSbcSink();
		}
		std::string A2DP_CodecInfoStringSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_CodecInfoStringSbc(p_codec_info);
		}
		const char* A2DP_CodecNameSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_CodecNameSbc(p_codec_info);
		}
		bool A2DP_CodecTypeEqualsSbc(const uint8_t* p_codec_info_a,
		const uint8_t* p_codec_info_b) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_CodecTypeEqualsSbc(p_codec_info_a,
		p_codec_info_b);
		}
		int A2DP_GetAllocationMethodCodeSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetAllocationMethodCodeSbc(
		p_codec_info);
		}
		uint32_t A2DP_GetBitrateSbc() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetBitrateSbc();
		}
		int A2DP_GetChannelModeCodeSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetChannelModeCodeSbc(p_codec_info);
		}
		const tA2DP_DECODER_INTERFACE* A2DP_GetDecoderInterfaceSbc(
		const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetDecoderInterfaceSbc(p_codec_info);
		}
		const tA2DP_ENCODER_INTERFACE* A2DP_GetEncoderInterfaceSbc(
		const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetEncoderInterfaceSbc(p_codec_info);
		}
		int A2DP_GetMaxBitpoolSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetMaxBitpoolSbc(p_codec_info);
		}
		int A2DP_GetMinBitpoolSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetMinBitpoolSbc(p_codec_info);
		}
		int A2DP_GetNumberOfBlocksSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetNumberOfBlocksSbc(p_codec_info);
		}
		int A2DP_GetNumberOfSubbandsSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetNumberOfSubbandsSbc(p_codec_info);
		}
		bool A2DP_GetPacketTimestampSbc(const uint8_t* p_codec_info,
		const uint8_t* p_data, uint32_t* p_timestamp) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetPacketTimestampSbc(
		p_codec_info, p_data, p_timestamp);
		}
		int A2DP_GetSamplingFrequencyCodeSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetSamplingFrequencyCodeSbc(
		p_codec_info);
		}
		int A2DP_GetSinkTrackChannelTypeSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetSinkTrackChannelTypeSbc(
		p_codec_info);
		}
		int A2DP_GetTrackBitsPerSampleSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetTrackBitsPerSampleSbc(
		p_codec_info);
		}
		int A2DP_GetTrackChannelCountSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetTrackChannelCountSbc(p_codec_info);
		}
		int A2DP_GetTrackSampleRateSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_GetTrackSampleRateSbc(p_codec_info);
		}
		bool A2DP_InitCodecConfigSbc(AvdtpSepConfig* p_cfg) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_InitCodecConfigSbc(p_cfg);
		}
		bool A2DP_InitCodecConfigSbcSink(AvdtpSepConfig* p_cfg) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_InitCodecConfigSbcSink(p_cfg);
		}
		void A2DP_InitDefaultCodecSbc(uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		test::mock::stack_a2dp_sbc::A2DP_InitDefaultCodecSbc(p_codec_info);
		}
		bool A2DP_IsPeerSinkCodecValidSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_IsPeerSinkCodecValidSbc(p_codec_info);
		}
		bool A2DP_IsPeerSourceCodecSupportedSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_IsPeerSourceCodecSupportedSbc(
		p_codec_info);
		}
		bool A2DP_IsPeerSourceCodecValidSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_IsPeerSourceCodecValidSbc(
		p_codec_info);
		}
		bool A2DP_IsSinkCodecSupportedSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_IsSinkCodecSupportedSbc(p_codec_info);
		}
		bool A2DP_IsSinkCodecValidSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_IsSinkCodecValidSbc(p_codec_info);
		}
		bool A2DP_IsSourceCodecValidSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_IsSourceCodecValidSbc(p_codec_info);
		}
		btav_a2dp_codec_index_t A2DP_SinkCodecIndexSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_SinkCodecIndexSbc(p_codec_info);
		}
		btav_a2dp_codec_index_t A2DP_SourceCodecIndexSbc(const uint8_t* p_codec_info) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_a2dp_sbc::A2DP_SourceCodecIndexSbc(p_codec_info);
		}
		// Mocked functions complete

system/test/mock/mock_stack_acl_ble.cc

+5 −5

Original line number	Diff line number	Diff line
		@@ -42,7 +42,7 @@
		void acl_ble_connection_fail(const tBLE_BD_ADDR& address_with_type,
		uint16_t handle, bool enhanced, tHCI_STATUS status,
		bool locally_initiated) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void acl_ble_enhanced_connection_complete(
		const tBLE_BD_ADDR& address_with_type, uint16_t handle, tHCI_ROLE role,
		@@ -50,14 +50,14 @@ void acl_ble_enhanced_connection_complete(
		uint16_t conn_timeout, const RawAddress& local_rpa,
		const RawAddress& peer_rpa, uint8_t peer_addr_type,
		bool can_read_discoverable_characteristics) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void acl_ble_enhanced_connection_complete_from_shim(
		const tBLE_BD_ADDR& address_with_type, uint16_t handle, tHCI_ROLE role,
		uint16_t conn_interval, uint16_t conn_latency, uint16_t conn_timeout,
		const RawAddress& local_rpa, const RawAddress& peer_rpa,
		tBLE_ADDR_TYPE peer_addr_type, bool can_read_discoverable_characteristics) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}

		void gatt_notify_conn_update(const RawAddress& remote, uint16_t interval,
		@@ -66,12 +66,12 @@ void gatt_notify_conn_update(const RawAddress& remote, uint16_t interval,
		void acl_ble_update_event_received(tHCI_STATUS status, uint16_t handle,
		uint16_t interval, uint16_t latency,
		uint16_t timeout) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}

		void acl_ble_data_length_change_event(uint16_t handle, uint16_t max_tx_octets,
		uint16_t max_tx_time,
		uint16_t max_rx_octets,
		uint16_t max_rx_time) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}

system/test/mock/mock_stack_acl_btm_ble_connection_establishment.cc

+3 −3

Original line number	Diff line number	Diff line
		@@ -57,17 +57,17 @@ struct btm_ble_conn_complete btm_ble_conn_complete;
		} // namespace test

		void btm_ble_create_ll_conn_complete(tHCI_STATUS status) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		test::mock::stack_acl_btm_ble_connection_establishment::
		btm_ble_create_ll_conn_complete(status);
		}
		bool maybe_resolve_address(RawAddress* bda, tBLE_ADDR_TYPE* bda_type) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return test::mock::stack_acl_btm_ble_connection_establishment::
		maybe_resolve_address(bda, bda_type);
		}
		void btm_ble_conn_complete(uint8_t* p, uint16_t evt_len, bool enhanced) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		test::mock::stack_acl_btm_ble_connection_establishment::btm_ble_conn_complete(
		p, evt_len, enhanced);
		}