Merge "Mock static initialization order 18" (b4d83ead) · Commits · e / os / android_packages_modules_Bluetooth

system/test/mock/mock_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 0;
		}
		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_a2dp_codec_config.cc

+67 −69

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,151 +206,149 @@ 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__);
		}
		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_common_address_obfuscator.cc

+4 −4

Original line number	Diff line number	Diff line
		@@ -38,19 +38,19 @@ namespace bluetooth {
		namespace common {

		bool AddressObfuscator::IsInitialized() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool AddressObfuscator::IsSaltValid(const Octet32& salt_256bit) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		std::string AddressObfuscator::Obfuscate(const RawAddress& address) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		void AddressObfuscator::Initialize(const Octet32& salt_256bit) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		salt_256bit_ = salt_256bit;
		}

system/test/mock/mock_common_metric_id_allocator.cc

+9 −9

Original line number	Diff line number	Diff line
		@@ -63,42 +63,42 @@ class MockMetricIdAllocator : public MetricIdAllocator {
		MockMetricIdAllocator metric_id_allocator;

		MetricIdAllocator& MetricIdAllocator::GetInstance() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return metric_id_allocator;
		}
		MetricIdAllocator::~MetricIdAllocator() {}
		bool MetricIdAllocator::Close() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool MetricIdAllocator::Init(
		const std::unordered_map<RawAddress, int>& paired_device_map,
		Callback save_id_callback, Callback forget_device_callback) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool MetricIdAllocator::IsEmpty() const {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool MetricIdAllocator::IsValidId(const int id) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		bool MetricIdAllocator::SaveDevice(const RawAddress& mac_address) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return false;
		}
		int MetricIdAllocator::AllocateId(const RawAddress& mac_address) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		return 0;
		}
		void MetricIdAllocator::ForgetDevice(const RawAddress& mac_address) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void MetricIdAllocator::ForgetDevicePostprocess(const RawAddress& mac_address,
		const int id) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}

		} // namespace common

system/test/mock/mock_common_metrics.cc

+34 −40

Original line number	Diff line number	Diff line
		@@ -57,7 +57,7 @@ namespace bluetooth {
		namespace common {

		void A2dpSessionMetrics::Update(const A2dpSessionMetrics& metrics) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}

		struct BluetoothMetricsLogger::impl {
		@@ -65,98 +65,92 @@ struct BluetoothMetricsLogger::impl {
		};

		BluetoothMetricsLogger::BluetoothMetricsLogger() {}
		void BluetoothMetricsLogger::Build() { mock_function_count_map[__func__]++; }
		void BluetoothMetricsLogger::CutoffSession() {
		mock_function_count_map[__func__]++;
		}
		void BluetoothMetricsLogger::Build() { inc_func_call_count(__func__); }
		void BluetoothMetricsLogger::CutoffSession() { inc_func_call_count(__func__); }
		void BluetoothMetricsLogger::LogA2dpSession(
		const A2dpSessionMetrics& a2dp_session_metrics) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::LogBluetoothSessionDeviceInfo(
		uint32_t device_class, device_type_t device_type) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::LogBluetoothSessionEnd(
		disconnect_reason_t disconnect_reason, uint64_t timestamp_ms) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::LogBluetoothSessionStart(
		connection_tech_t connection_tech_type, uint64_t timestamp_ms) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::LogHeadsetProfileRfcConnection(
		tBTA_SERVICE_ID service_id) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::LogPairEvent(uint32_t disconnect_reason,
		uint64_t timestamp_ms,
		uint32_t device_class,
		device_type_t device_type) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::LogScanEvent(bool start,
		const std::string& initator,
		scan_tech_t type, uint32_t results,
		uint64_t timestamp_ms) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::LogWakeEvent(wake_event_type_t type,
		const std::string& requestor,
		const std::string& name,
		uint64_t timestamp_ms) {
		mock_function_count_map[__func__]++;
		}
		void BluetoothMetricsLogger::Reset() { mock_function_count_map[__func__]++; }
		void BluetoothMetricsLogger::ResetLog() { mock_function_count_map[__func__]++; }
		void BluetoothMetricsLogger::ResetSession() {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::Reset() { inc_func_call_count(__func__); }
		void BluetoothMetricsLogger::ResetLog() { inc_func_call_count(__func__); }
		void BluetoothMetricsLogger::ResetSession() { inc_func_call_count(__func__); }
		void BluetoothMetricsLogger::WriteBase64(int fd) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::WriteBase64String(std::string* serialized) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void BluetoothMetricsLogger::WriteString(std::string* serialized) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogA2dpAudioOverrunEvent(const RawAddress& address,
		uint64_t encoding_interval_millis,
		int num_dropped_buffers,
		int num_dropped_encoded_frames,
		int num_dropped_encoded_bytes) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogA2dpAudioUnderrunEvent(const RawAddress& address,
		uint64_t encoding_interval_millis,
		int num_missing_pcm_bytes) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogA2dpPlaybackEvent(const RawAddress& address, int playback_state,
		int audio_coding_mode) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogBluetoothHalCrashReason(const RawAddress& address, uint32_t error_code,
		uint32_t vendor_error_code) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogClassicPairingEvent(const RawAddress& address, uint16_t handle,
		uint32_t hci_cmd, uint16_t hci_event,
		uint16_t cmd_status, uint16_t reason_code,
		int64_t event_value) {
		mock_function_count_map[__func__]++;
		}
		void LogHciTimeoutEvent(uint32_t hci_cmd) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogHciTimeoutEvent(uint32_t hci_cmd) { inc_func_call_count(__func__); }
		void LogLinkLayerConnectionEvent(const RawAddress* address,
		uint32_t connection_handle,
		android::bluetooth::DirectionEnum direction,
		uint16_t link_type, uint32_t hci_cmd,
		uint16_t hci_event, uint16_t hci_ble_event,
		uint16_t cmd_status, uint16_t reason_code) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogManufacturerInfo(const RawAddress& address,
		android::bluetooth::DeviceInfoSrcEnum source_type,
		@@ -165,42 +159,42 @@ void LogManufacturerInfo(const RawAddress& address,
		const std::string& model,
		const std::string& hardware_version,
		const std::string& software_version) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogReadFailedContactCounterResult(const RawAddress& address,
		uint16_t handle, uint32_t cmd_status,
		int32_t failed_contact_counter) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogReadRssiResult(const RawAddress& address, uint16_t handle,
		uint32_t cmd_status, int8_t rssi) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogReadTxPowerLevelResult(const RawAddress& address, uint16_t handle,
		uint32_t cmd_status,
		int32_t transmit_power_level) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogRemoteVersionInfo(uint16_t handle, uint8_t status, uint8_t version,
		uint16_t manufacturer_name, uint16_t subversion) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogSdpAttribute(const RawAddress& address, uint16_t protocol_uuid,
		uint16_t attribute_id, size_t attribute_size,
		const char* attribute_value) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogSmpPairingEvent(const RawAddress& address, uint8_t smp_cmd,
		android::bluetooth::DirectionEnum direction,
		uint8_t smp_fail_reason) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}
		void LogSocketConnectionState(
		const RawAddress& address, int port, int type,
		android::bluetooth::SocketConnectionstateEnum connection_state,
		int64_t tx_bytes, int64_t rx_bytes, int uid, int server_port,
		android::bluetooth::SocketRoleEnum socket_role) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}

		void LogLeAudioConnectionSessionReported(
		@@ -215,11 +209,11 @@ void LogLeAudioConnectionSessionReported(
		std::vector<int64_t>& streaming_offset_nanos,
		std::vector<int64_t>& streaming_duration_nanos,
		std::vector<int32_t>& streaming_context_type) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}

		void LogLeAudioBroadcastSessionReported(int64_t duration_nanos) {
		mock_function_count_map[__func__]++;
		inc_func_call_count(__func__);
		}

		} // namespace common