Merge "unittest: test btif___text macros" into tm-qpr-dev (9fe82b4c) · Commits · e / os / android_packages_modules_Bluetooth

system/btif/src/btif_av.cc

+4 −0

Original line number	Diff line number	Diff line
		@@ -790,6 +790,10 @@ const char* dump_av_sm_event_name(btif_av_sm_event_t event) {
		}
		}

		const char* dump_av_sm_event_name(int event) {
		return dump_av_sm_event_name(static_cast<btif_av_sm_event_t>(event));
		}

		BtifAvEvent::BtifAvEvent(uint32_t event, const void* p_data, size_t data_length)
		: event_(event), data_(nullptr), data_length_(0) {
		DeepCopy(event, p_data, data_length);

system/btif/test/btif_core_test.cc

+460 −0

Original line number	Diff line number	Diff line
		@@ -20,9 +20,16 @@
		#include <map>

		#include "bta/include/bta_ag_api.h"
		#include "bta/include/bta_av_api.h"
		#include "bta/include/bta_hd_api.h"
		#include "bta/include/bta_hf_client_api.h"
		#include "bta/include/bta_hh_api.h"
		#include "btcore/include/module.h"
		#include "btif/include/btif_api.h"
		#include "btif/include/btif_common.h"
		#include "btif/include/btif_util.h"
		#include "include/hardware/bluetooth.h"
		#include "include/hardware/bt_av.h"
		#include "types/raw_address.h"

		void set_hal_cbacks(bt_callbacks_t* callbacks);
		@@ -174,3 +181,456 @@ TEST_F(BtifCoreTest, test_post_on_bt_jni_simple3) {
		ASSERT_EQ(std::future_status::ready, future.wait_for(timeout_time));
		ASSERT_EQ(val, future.get());
		}

		extern const char* dump_av_sm_event_name(int event);
		TEST_F(BtifCoreTest, dump_av_sm_event_name) {
		std::vector<std::pair<int, std::string>> events = {
		std::make_pair(BTA_AV_ENABLE_EVT, "BTA_AV_ENABLE_EVT"),
		std::make_pair(BTA_AV_REGISTER_EVT, "BTA_AV_REGISTER_EVT"),
		std::make_pair(BTA_AV_OPEN_EVT, "BTA_AV_OPEN_EVT"),
		std::make_pair(BTA_AV_CLOSE_EVT, "BTA_AV_CLOSE_EVT"),
		std::make_pair(BTA_AV_START_EVT, "BTA_AV_START_EVT"),
		std::make_pair(BTA_AV_STOP_EVT, "BTA_AV_STOP_EVT"),
		std::make_pair(BTA_AV_PROTECT_REQ_EVT, "BTA_AV_PROTECT_REQ_EVT"),
		std::make_pair(BTA_AV_PROTECT_RSP_EVT, "BTA_AV_PROTECT_RSP_EVT"),
		std::make_pair(BTA_AV_RC_OPEN_EVT, "BTA_AV_RC_OPEN_EVT"),
		std::make_pair(BTA_AV_RC_CLOSE_EVT, "BTA_AV_RC_CLOSE_EVT"),
		std::make_pair(BTA_AV_RC_BROWSE_OPEN_EVT, "BTA_AV_RC_BROWSE_OPEN_EVT"),
		std::make_pair(BTA_AV_RC_BROWSE_CLOSE_EVT, "BTA_AV_RC_BROWSE_CLOSE_EVT"),
		std::make_pair(BTA_AV_REMOTE_CMD_EVT, "BTA_AV_REMOTE_CMD_EVT"),
		std::make_pair(BTA_AV_REMOTE_RSP_EVT, "BTA_AV_REMOTE_RSP_EVT"),
		std::make_pair(BTA_AV_VENDOR_CMD_EVT, "BTA_AV_VENDOR_CMD_EVT"),
		std::make_pair(BTA_AV_VENDOR_RSP_EVT, "BTA_AV_VENDOR_RSP_EVT"),
		std::make_pair(BTA_AV_RECONFIG_EVT, "BTA_AV_RECONFIG_EVT"),
		std::make_pair(BTA_AV_SUSPEND_EVT, "BTA_AV_SUSPEND_EVT"),
		std::make_pair(BTA_AV_PENDING_EVT, "BTA_AV_PENDING_EVT"),
		std::make_pair(BTA_AV_META_MSG_EVT, "BTA_AV_META_MSG_EVT"),
		std::make_pair(BTA_AV_REJECT_EVT, "BTA_AV_REJECT_EVT"),
		std::make_pair(BTA_AV_RC_FEAT_EVT, "BTA_AV_RC_FEAT_EVT"),
		std::make_pair(BTA_AV_RC_PSM_EVT, "BTA_AV_RC_PSM_EVT"),
		std::make_pair(BTA_AV_OFFLOAD_START_RSP_EVT,
		"BTA_AV_OFFLOAD_START_RSP_EVT"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_av_sm_event_name(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN_EVENT";
		ASSERT_STREQ(oss.str().c_str(),
		dump_av_sm_event_name(std::numeric_limits<int>::max()));
		}

		TEST_F(BtifCoreTest, dump_dm_search_event) {
		std::vector<std::pair<uint16_t, std::string>> events = {
		std::make_pair(BTA_DM_INQ_RES_EVT, "BTA_DM_INQ_RES_EVT"),
		std::make_pair(BTA_DM_INQ_CMPL_EVT, "BTA_DM_INQ_CMPL_EVT"),
		std::make_pair(BTA_DM_DISC_RES_EVT, "BTA_DM_DISC_RES_EVT"),
		std::make_pair(BTA_DM_DISC_BLE_RES_EVT, "BTA_DM_DISC_BLE_RES_EVT"),
		std::make_pair(BTA_DM_DISC_CMPL_EVT, "BTA_DM_DISC_CMPL_EVT"),
		std::make_pair(BTA_DM_SEARCH_CANCEL_CMPL_EVT,
		"BTA_DM_SEARCH_CANCEL_CMPL_EVT"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_dm_search_event(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN MSG ID";
		ASSERT_STREQ(oss.str().c_str(),
		dump_dm_search_event(std::numeric_limits<uint16_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_property_type) {
		std::vector<std::pair<bt_property_type_t, std::string>> types = {
		std::make_pair(BT_PROPERTY_BDNAME, "BT_PROPERTY_BDNAME"),
		std::make_pair(BT_PROPERTY_BDADDR, "BT_PROPERTY_BDADDR"),
		std::make_pair(BT_PROPERTY_UUIDS, "BT_PROPERTY_UUIDS"),
		std::make_pair(BT_PROPERTY_CLASS_OF_DEVICE,
		"BT_PROPERTY_CLASS_OF_DEVICE"),
		std::make_pair(BT_PROPERTY_TYPE_OF_DEVICE, "BT_PROPERTY_TYPE_OF_DEVICE"),
		std::make_pair(BT_PROPERTY_REMOTE_RSSI, "BT_PROPERTY_REMOTE_RSSI"),
		std::make_pair(BT_PROPERTY_ADAPTER_DISCOVERABLE_TIMEOUT,
		"BT_PROPERTY_ADAPTER_DISCOVERABLE_TIMEOUT"),
		std::make_pair(BT_PROPERTY_ADAPTER_BONDED_DEVICES,
		"BT_PROPERTY_ADAPTER_BONDED_DEVICES"),
		std::make_pair(BT_PROPERTY_ADAPTER_SCAN_MODE,
		"BT_PROPERTY_ADAPTER_SCAN_MODE"),
		std::make_pair(BT_PROPERTY_REMOTE_FRIENDLY_NAME,
		"BT_PROPERTY_REMOTE_FRIENDLY_NAME"),
		};
		for (const auto& type : types) {
		ASSERT_STREQ(type.second.c_str(), dump_property_type(type.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN PROPERTY ID";
		ASSERT_STREQ(oss.str().c_str(),
		dump_property_type(static_cast<bt_property_type_t>(
		std::numeric_limits<uint16_t>::max())));
		}

		TEST_F(BtifCoreTest, dump_dm_event) {
		std::vector<std::pair<uint8_t, std::string>> events = {
		std::make_pair(BTA_DM_PIN_REQ_EVT, "BTA_DM_PIN_REQ_EVT"),
		std::make_pair(BTA_DM_AUTH_CMPL_EVT, "BTA_DM_AUTH_CMPL_EVT"),
		std::make_pair(BTA_DM_LINK_UP_EVT, "BTA_DM_LINK_UP_EVT"),
		std::make_pair(BTA_DM_LINK_DOWN_EVT, "BTA_DM_LINK_DOWN_EVT"),
		std::make_pair(BTA_DM_BOND_CANCEL_CMPL_EVT,
		"BTA_DM_BOND_CANCEL_CMPL_EVT"),
		std::make_pair(BTA_DM_SP_CFM_REQ_EVT, "BTA_DM_SP_CFM_REQ_EVT"),
		std::make_pair(BTA_DM_SP_KEY_NOTIF_EVT, "BTA_DM_SP_KEY_NOTIF_EVT"),
		std::make_pair(BTA_DM_BLE_KEY_EVT, "BTA_DM_BLE_KEY_EVT"),
		std::make_pair(BTA_DM_BLE_SEC_REQ_EVT, "BTA_DM_BLE_SEC_REQ_EVT"),
		std::make_pair(BTA_DM_BLE_PASSKEY_NOTIF_EVT,
		"BTA_DM_BLE_PASSKEY_NOTIF_EVT"),
		std::make_pair(BTA_DM_BLE_PASSKEY_REQ_EVT, "BTA_DM_BLE_PASSKEY_REQ_EVT"),
		std::make_pair(BTA_DM_BLE_OOB_REQ_EVT, "BTA_DM_BLE_OOB_REQ_EVT"),
		std::make_pair(BTA_DM_BLE_SC_OOB_REQ_EVT, "BTA_DM_BLE_SC_OOB_REQ_EVT"),
		std::make_pair(BTA_DM_BLE_LOCAL_IR_EVT, "BTA_DM_BLE_LOCAL_IR_EVT"),
		std::make_pair(BTA_DM_BLE_LOCAL_ER_EVT, "BTA_DM_BLE_LOCAL_ER_EVT"),
		std::make_pair(BTA_DM_BLE_AUTH_CMPL_EVT, "BTA_DM_BLE_AUTH_CMPL_EVT"),
		std::make_pair(BTA_DM_DEV_UNPAIRED_EVT, "BTA_DM_DEV_UNPAIRED_EVT"),
		std::make_pair(BTA_DM_ENER_INFO_READ, "BTA_DM_ENER_INFO_READ"),
		std::make_pair(BTA_DM_REPORT_BONDING_EVT, "BTA_DM_REPORT_BONDING_EVT"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_dm_event(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN DM EVENT";
		ASSERT_STREQ(oss.str().c_str(),
		dump_dm_event(std::numeric_limits<uint8_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_hf_event) {
		std::vector<std::pair<uint8_t, std::string>> events = {
		std::make_pair(BTA_AG_ENABLE_EVT, "BTA_AG_ENABLE_EVT"),
		std::make_pair(BTA_AG_REGISTER_EVT, "BTA_AG_REGISTER_EVT"),
		std::make_pair(BTA_AG_OPEN_EVT, "BTA_AG_OPEN_EVT"),
		std::make_pair(BTA_AG_CLOSE_EVT, "BTA_AG_CLOSE_EVT"),
		std::make_pair(BTA_AG_CONN_EVT, "BTA_AG_CONN_EVT"),
		std::make_pair(BTA_AG_AUDIO_OPEN_EVT, "BTA_AG_AUDIO_OPEN_EVT"),
		std::make_pair(BTA_AG_AUDIO_CLOSE_EVT, "BTA_AG_AUDIO_CLOSE_EVT"),
		std::make_pair(BTA_AG_SPK_EVT, "BTA_AG_SPK_EVT"),
		std::make_pair(BTA_AG_MIC_EVT, "BTA_AG_MIC_EVT"),
		std::make_pair(BTA_AG_AT_CKPD_EVT, "BTA_AG_AT_CKPD_EVT"),
		std::make_pair(BTA_AG_DISABLE_EVT, "BTA_AG_DISABLE_EVT"),
		std::make_pair(BTA_AG_WBS_EVT, "BTA_AG_WBS_EVT"),
		std::make_pair(BTA_AG_AT_A_EVT, "BTA_AG_AT_A_EVT"),
		std::make_pair(BTA_AG_AT_D_EVT, "BTA_AG_AT_D_EVT"),
		std::make_pair(BTA_AG_AT_CHLD_EVT, "BTA_AG_AT_CHLD_EVT"),
		std::make_pair(BTA_AG_AT_CHUP_EVT, "BTA_AG_AT_CHUP_EVT"),
		std::make_pair(BTA_AG_AT_CIND_EVT, "BTA_AG_AT_CIND_EVT"),
		std::make_pair(BTA_AG_AT_VTS_EVT, "BTA_AG_AT_VTS_EVT"),
		std::make_pair(BTA_AG_AT_BINP_EVT, "BTA_AG_AT_BINP_EVT"),
		std::make_pair(BTA_AG_AT_BLDN_EVT, "BTA_AG_AT_BLDN_EVT"),
		std::make_pair(BTA_AG_AT_BVRA_EVT, "BTA_AG_AT_BVRA_EVT"),
		std::make_pair(BTA_AG_AT_NREC_EVT, "BTA_AG_AT_NREC_EVT"),
		std::make_pair(BTA_AG_AT_CNUM_EVT, "BTA_AG_AT_CNUM_EVT"),
		std::make_pair(BTA_AG_AT_BTRH_EVT, "BTA_AG_AT_BTRH_EVT"),
		std::make_pair(BTA_AG_AT_CLCC_EVT, "BTA_AG_AT_CLCC_EVT"),
		std::make_pair(BTA_AG_AT_COPS_EVT, "BTA_AG_AT_COPS_EVT"),
		std::make_pair(BTA_AG_AT_UNAT_EVT, "BTA_AG_AT_UNAT_EVT"),
		std::make_pair(BTA_AG_AT_CBC_EVT, "BTA_AG_AT_CBC_EVT"),
		std::make_pair(BTA_AG_AT_BAC_EVT, "BTA_AG_AT_BAC_EVT"),
		std::make_pair(BTA_AG_AT_BCS_EVT, "BTA_AG_AT_BCS_EVT"),
		std::make_pair(BTA_AG_AT_BIND_EVT, "BTA_AG_AT_BIND_EVT"),
		std::make_pair(BTA_AG_AT_BIEV_EVT, "BTA_AG_AT_BIEV_EVT"),
		std::make_pair(BTA_AG_AT_BIA_EVT, "BTA_AG_AT_BIA_EVT"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_hf_event(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN MSG ID";
		ASSERT_STREQ(oss.str().c_str(),
		dump_hf_event(std::numeric_limits<uint8_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_hf_client_event) {
		std::vector<std::pair<int, std::string>> events = {
		std::make_pair(BTA_HF_CLIENT_ENABLE_EVT, "BTA_HF_CLIENT_ENABLE_EVT"),
		std::make_pair(BTA_HF_CLIENT_REGISTER_EVT, "BTA_HF_CLIENT_REGISTER_EVT"),
		std::make_pair(BTA_HF_CLIENT_OPEN_EVT, "BTA_HF_CLIENT_OPEN_EVT"),
		std::make_pair(BTA_HF_CLIENT_CLOSE_EVT, "BTA_HF_CLIENT_CLOSE_EVT"),
		std::make_pair(BTA_HF_CLIENT_CONN_EVT, "BTA_HF_CLIENT_CONN_EVT"),
		std::make_pair(BTA_HF_CLIENT_AUDIO_OPEN_EVT,
		"BTA_HF_CLIENT_AUDIO_OPEN_EVT"),
		std::make_pair(BTA_HF_CLIENT_AUDIO_MSBC_OPEN_EVT,
		"BTA_HF_CLIENT_AUDIO_MSBC_OPEN_EVT"),
		std::make_pair(BTA_HF_CLIENT_AUDIO_CLOSE_EVT,
		"BTA_HF_CLIENT_AUDIO_CLOSE_EVT"),
		std::make_pair(BTA_HF_CLIENT_SPK_EVT, "BTA_HF_CLIENT_SPK_EVT"),
		std::make_pair(BTA_HF_CLIENT_MIC_EVT, "BTA_HF_CLIENT_MIC_EVT"),
		std::make_pair(BTA_HF_CLIENT_DISABLE_EVT, "BTA_HF_CLIENT_DISABLE_EVT"),
		std::make_pair(BTA_HF_CLIENT_IND_EVT, "BTA_HF_CLIENT_IND_EVT"),
		std::make_pair(BTA_HF_CLIENT_VOICE_REC_EVT,
		"BTA_HF_CLIENT_VOICE_REC_EVT"),
		std::make_pair(BTA_HF_CLIENT_OPERATOR_NAME_EVT,
		"BTA_HF_CLIENT_OPERATOR_NAME_EVT"),
		std::make_pair(BTA_HF_CLIENT_CLIP_EVT, "BTA_HF_CLIENT_CLIP_EVT"),
		std::make_pair(BTA_HF_CLIENT_CCWA_EVT, "BTA_HF_CLIENT_CCWA_EVT"),
		std::make_pair(BTA_HF_CLIENT_AT_RESULT_EVT,
		"BTA_HF_CLIENT_AT_RESULT_EVT"),
		std::make_pair(BTA_HF_CLIENT_CLCC_EVT, "BTA_HF_CLIENT_CLCC_EVT"),
		std::make_pair(BTA_HF_CLIENT_CNUM_EVT, "BTA_HF_CLIENT_CNUM_EVT"),
		std::make_pair(BTA_HF_CLIENT_BTRH_EVT, "BTA_HF_CLIENT_BTRH_EVT"),
		std::make_pair(BTA_HF_CLIENT_BSIR_EVT, "BTA_HF_CLIENT_BSIR_EVT"),
		std::make_pair(BTA_HF_CLIENT_BINP_EVT, "BTA_HF_CLIENT_BINP_EVT"),
		std::make_pair(BTA_HF_CLIENT_RING_INDICATION,
		"BTA_HF_CLIENT_RING_INDICATION"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_hf_client_event(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN MSG ID";
		ASSERT_STREQ(oss.str().c_str(),
		dump_hf_client_event(std::numeric_limits<uint16_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_hh_event) {
		std::vector<std::pair<int, std::string>> events = {
		std::make_pair(BTA_HH_ENABLE_EVT, "BTA_HH_ENABLE_EVT"),
		std::make_pair(BTA_HH_DISABLE_EVT, "BTA_HH_DISABLE_EVT"),
		std::make_pair(BTA_HH_OPEN_EVT, "BTA_HH_OPEN_EVT"),
		std::make_pair(BTA_HH_CLOSE_EVT, "BTA_HH_CLOSE_EVT"),
		std::make_pair(BTA_HH_GET_DSCP_EVT, "BTA_HH_GET_DSCP_EVT"),
		std::make_pair(BTA_HH_GET_PROTO_EVT, "BTA_HH_GET_PROTO_EVT"),
		std::make_pair(BTA_HH_GET_RPT_EVT, "BTA_HH_GET_RPT_EVT"),
		std::make_pair(BTA_HH_GET_IDLE_EVT, "BTA_HH_GET_IDLE_EVT"),
		std::make_pair(BTA_HH_SET_PROTO_EVT, "BTA_HH_SET_PROTO_EVT"),
		std::make_pair(BTA_HH_SET_RPT_EVT, "BTA_HH_SET_RPT_EVT"),
		std::make_pair(BTA_HH_SET_IDLE_EVT, "BTA_HH_SET_IDLE_EVT"),
		std::make_pair(BTA_HH_VC_UNPLUG_EVT, "BTA_HH_VC_UNPLUG_EVT"),
		std::make_pair(BTA_HH_ADD_DEV_EVT, "BTA_HH_ADD_DEV_EVT"),
		std::make_pair(BTA_HH_RMV_DEV_EVT, "BTA_HH_RMV_DEV_EVT"),
		std::make_pair(BTA_HH_API_ERR_EVT, "BTA_HH_API_ERR_EVT"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_hh_event(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN MSG ID";
		ASSERT_STREQ(oss.str().c_str(),
		dump_hh_event(std::numeric_limits<uint16_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_hd_event) {
		std::vector<std::pair<uint16_t, std::string>> events = {
		std::make_pair(BTA_HD_ENABLE_EVT, "BTA_HD_ENABLE_EVT"),
		std::make_pair(BTA_HD_DISABLE_EVT, "BTA_HD_DISABLE_EVT"),
		std::make_pair(BTA_HD_REGISTER_APP_EVT, "BTA_HD_REGISTER_APP_EVT"),
		std::make_pair(BTA_HD_UNREGISTER_APP_EVT, "BTA_HD_UNREGISTER_APP_EVT"),
		std::make_pair(BTA_HD_OPEN_EVT, "BTA_HD_OPEN_EVT"),
		std::make_pair(BTA_HD_CLOSE_EVT, "BTA_HD_CLOSE_EVT"),
		std::make_pair(BTA_HD_GET_REPORT_EVT, "BTA_HD_GET_REPORT_EVT"),
		std::make_pair(BTA_HD_SET_REPORT_EVT, "BTA_HD_SET_REPORT_EVT"),
		std::make_pair(BTA_HD_SET_PROTOCOL_EVT, "BTA_HD_SET_PROTOCOL_EVT"),
		std::make_pair(BTA_HD_INTR_DATA_EVT, "BTA_HD_INTR_DATA_EVT"),
		std::make_pair(BTA_HD_VC_UNPLUG_EVT, "BTA_HD_VC_UNPLUG_EVT"),
		std::make_pair(BTA_HD_CONN_STATE_EVT, "BTA_HD_CONN_STATE_EVT"),
		std::make_pair(BTA_HD_API_ERR_EVT, "BTA_HD_API_ERR_EVT"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_hd_event(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN MSG ID";
		ASSERT_STREQ(oss.str().c_str(),
		dump_hd_event(std::numeric_limits<uint16_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_thread_evt) {
		std::vector<std::pair<bt_cb_thread_evt, std::string>> events = {
		std::make_pair(ASSOCIATE_JVM, "ASSOCIATE_JVM"),
		std::make_pair(DISASSOCIATE_JVM, "DISASSOCIATE_JVM"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_thread_evt(event.first));
		}
		std::ostringstream oss;
		oss << "unknown thread evt";
		ASSERT_STREQ(oss.str().c_str(), dump_thread_evt(static_cast<bt_cb_thread_evt>(
		std::numeric_limits<uint16_t>::max())));
		}

		TEST_F(BtifCoreTest, dump_av_conn_state) {
		std::vector<std::pair<uint16_t, std::string>> events = {
		std::make_pair(BTAV_CONNECTION_STATE_DISCONNECTED,
		"BTAV_CONNECTION_STATE_DISCONNECTED"),
		std::make_pair(BTAV_CONNECTION_STATE_CONNECTING,
		"BTAV_CONNECTION_STATE_CONNECTING"),
		std::make_pair(BTAV_CONNECTION_STATE_CONNECTED,
		"BTAV_CONNECTION_STATE_CONNECTED"),
		std::make_pair(BTAV_CONNECTION_STATE_DISCONNECTING,
		"BTAV_CONNECTION_STATE_DISCONNECTING"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_av_conn_state(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN MSG ID";
		ASSERT_STREQ(oss.str().c_str(),
		dump_av_conn_state(std::numeric_limits<uint16_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_av_audio_state) {
		std::vector<std::pair<uint16_t, std::string>> events = {
		std::make_pair(BTAV_AUDIO_STATE_REMOTE_SUSPEND,
		"BTAV_AUDIO_STATE_REMOTE_SUSPEND"),
		std::make_pair(BTAV_AUDIO_STATE_STOPPED, "BTAV_AUDIO_STATE_STOPPED"),
		std::make_pair(BTAV_AUDIO_STATE_STARTED, "BTAV_AUDIO_STATE_STARTED"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_av_audio_state(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN MSG ID";
		ASSERT_STREQ(oss.str().c_str(),
		dump_av_audio_state(std::numeric_limits<uint16_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_adapter_scan_mode) {
		std::vector<std::pair<bt_scan_mode_t, std::string>> events = {
		std::make_pair(BT_SCAN_MODE_NONE, "BT_SCAN_MODE_NONE"),
		std::make_pair(BT_SCAN_MODE_CONNECTABLE, "BT_SCAN_MODE_CONNECTABLE"),
		std::make_pair(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE,
		"BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_adapter_scan_mode(event.first));
		}
		std::ostringstream oss;
		oss << "unknown scan mode";
		ASSERT_STREQ(oss.str().c_str(),
		dump_adapter_scan_mode(static_cast<bt_scan_mode_t>(
		std::numeric_limits<int>::max())));
		}

		TEST_F(BtifCoreTest, dump_bt_status) {
		std::vector<std::pair<bt_status_t, std::string>> events = {
		std::make_pair(BT_STATUS_SUCCESS, "BT_STATUS_SUCCESS"),
		std::make_pair(BT_STATUS_FAIL, "BT_STATUS_FAIL"),
		std::make_pair(BT_STATUS_NOT_READY, "BT_STATUS_NOT_READY"),
		std::make_pair(BT_STATUS_NOMEM, "BT_STATUS_NOMEM"),
		std::make_pair(BT_STATUS_BUSY, "BT_STATUS_BUSY"),
		std::make_pair(BT_STATUS_UNSUPPORTED, "BT_STATUS_UNSUPPORTED"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_bt_status(event.first));
		}
		std::ostringstream oss;
		oss << "unknown scan mode";
		ASSERT_STREQ(oss.str().c_str(), dump_bt_status(static_cast<bt_status_t>(
		std::numeric_limits<int>::max())));
		}

		TEST_F(BtifCoreTest, dump_rc_event) {
		std::vector<std::pair<uint8_t, std::string>> events = {
		std::make_pair(BTA_AV_RC_OPEN_EVT, "BTA_AV_RC_OPEN_EVT"),
		std::make_pair(BTA_AV_RC_CLOSE_EVT, "BTA_AV_RC_CLOSE_EVT"),
		std::make_pair(BTA_AV_RC_BROWSE_OPEN_EVT, "BTA_AV_RC_BROWSE_OPEN_EVT"),
		std::make_pair(BTA_AV_RC_BROWSE_CLOSE_EVT, "BTA_AV_RC_BROWSE_CLOSE_EVT"),
		std::make_pair(BTA_AV_REMOTE_CMD_EVT, "BTA_AV_REMOTE_CMD_EVT"),
		std::make_pair(BTA_AV_REMOTE_RSP_EVT, "BTA_AV_REMOTE_RSP_EVT"),
		std::make_pair(BTA_AV_VENDOR_CMD_EVT, "BTA_AV_VENDOR_CMD_EVT"),
		std::make_pair(BTA_AV_VENDOR_RSP_EVT, "BTA_AV_VENDOR_RSP_EVT"),
		std::make_pair(BTA_AV_META_MSG_EVT, "BTA_AV_META_MSG_EVT"),
		std::make_pair(BTA_AV_RC_FEAT_EVT, "BTA_AV_RC_FEAT_EVT"),
		std::make_pair(BTA_AV_RC_PSM_EVT, "BTA_AV_RC_PSM_EVT"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(), dump_rc_event(event.first));
		}
		std::ostringstream oss;
		oss << "UNKNOWN_EVENT";
		ASSERT_STREQ(oss.str().c_str(),
		dump_rc_event(std::numeric_limits<uint8_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_rc_notification_event_id) {
		std::vector<std::pair<uint8_t, std::string>> events = {
		std::make_pair(AVRC_EVT_PLAY_STATUS_CHANGE,
		"AVRC_EVT_PLAY_STATUS_CHANGE"),
		std::make_pair(AVRC_EVT_TRACK_CHANGE, "AVRC_EVT_TRACK_CHANGE"),
		std::make_pair(AVRC_EVT_TRACK_REACHED_END, "AVRC_EVT_TRACK_REACHED_END"),
		std::make_pair(AVRC_EVT_TRACK_REACHED_START,
		"AVRC_EVT_TRACK_REACHED_START"),
		std::make_pair(AVRC_EVT_PLAY_POS_CHANGED, "AVRC_EVT_PLAY_POS_CHANGED"),
		std::make_pair(AVRC_EVT_BATTERY_STATUS_CHANGE,
		"AVRC_EVT_BATTERY_STATUS_CHANGE"),
		std::make_pair(AVRC_EVT_SYSTEM_STATUS_CHANGE,
		"AVRC_EVT_SYSTEM_STATUS_CHANGE"),
		std::make_pair(AVRC_EVT_APP_SETTING_CHANGE,
		"AVRC_EVT_APP_SETTING_CHANGE"),
		std::make_pair(AVRC_EVT_VOLUME_CHANGE, "AVRC_EVT_VOLUME_CHANGE"),
		std::make_pair(AVRC_EVT_ADDR_PLAYER_CHANGE,
		"AVRC_EVT_ADDR_PLAYER_CHANGE"),
		std::make_pair(AVRC_EVT_AVAL_PLAYERS_CHANGE,
		"AVRC_EVT_AVAL_PLAYERS_CHANGE"),
		std::make_pair(AVRC_EVT_NOW_PLAYING_CHANGE,
		"AVRC_EVT_NOW_PLAYING_CHANGE"),
		std::make_pair(AVRC_EVT_UIDS_CHANGE, "AVRC_EVT_UIDS_CHANGE"),
		};
		for (const auto& event : events) {
		ASSERT_STREQ(event.second.c_str(),
		dump_rc_notification_event_id(event.first));
		}
		std::ostringstream oss;
		oss << "Unhandled Event ID";
		ASSERT_STREQ(oss.str().c_str(), dump_rc_notification_event_id(
		std::numeric_limits<uint8_t>::max()));
		}

		TEST_F(BtifCoreTest, dump_rc_pdu) {
		std::vector<std::pair<uint8_t, std::string>> pdus = {
		std::make_pair(AVRC_PDU_LIST_PLAYER_APP_ATTR,
		"AVRC_PDU_LIST_PLAYER_APP_ATTR"),
		std::make_pair(AVRC_PDU_LIST_PLAYER_APP_VALUES,
		"AVRC_PDU_LIST_PLAYER_APP_VALUES"),
		std::make_pair(AVRC_PDU_GET_CUR_PLAYER_APP_VALUE,
		"AVRC_PDU_GET_CUR_PLAYER_APP_VALUE"),
		std::make_pair(AVRC_PDU_SET_PLAYER_APP_VALUE,
		"AVRC_PDU_SET_PLAYER_APP_VALUE"),
		std::make_pair(AVRC_PDU_GET_PLAYER_APP_ATTR_TEXT,
		"AVRC_PDU_GET_PLAYER_APP_ATTR_TEXT"),
		std::make_pair(AVRC_PDU_GET_PLAYER_APP_VALUE_TEXT,
		"AVRC_PDU_GET_PLAYER_APP_VALUE_TEXT"),
		std::make_pair(AVRC_PDU_INFORM_DISPLAY_CHARSET,
		"AVRC_PDU_INFORM_DISPLAY_CHARSET"),
		std::make_pair(AVRC_PDU_INFORM_BATTERY_STAT_OF_CT,
		"AVRC_PDU_INFORM_BATTERY_STAT_OF_CT"),
		std::make_pair(AVRC_PDU_GET_ELEMENT_ATTR, "AVRC_PDU_GET_ELEMENT_ATTR"),
		std::make_pair(AVRC_PDU_GET_PLAY_STATUS, "AVRC_PDU_GET_PLAY_STATUS"),
		std::make_pair(AVRC_PDU_REGISTER_NOTIFICATION,
		"AVRC_PDU_REGISTER_NOTIFICATION"),
		std::make_pair(AVRC_PDU_REQUEST_CONTINUATION_RSP,
		"AVRC_PDU_REQUEST_CONTINUATION_RSP"),
		std::make_pair(AVRC_PDU_ABORT_CONTINUATION_RSP,
		"AVRC_PDU_ABORT_CONTINUATION_RSP"),
		std::make_pair(AVRC_PDU_SET_ABSOLUTE_VOLUME,
		"AVRC_PDU_SET_ABSOLUTE_VOLUME"),
		std::make_pair(AVRC_PDU_SET_ADDRESSED_PLAYER,
		"AVRC_PDU_SET_ADDRESSED_PLAYER"),
		std::make_pair(AVRC_PDU_CHANGE_PATH, "AVRC_PDU_CHANGE_PATH"),
		std::make_pair(AVRC_PDU_GET_CAPABILITIES, "AVRC_PDU_GET_CAPABILITIES"),
		std::make_pair(AVRC_PDU_SET_BROWSED_PLAYER,
		"AVRC_PDU_SET_BROWSED_PLAYER"),
		std::make_pair(AVRC_PDU_GET_FOLDER_ITEMS, "AVRC_PDU_GET_FOLDER_ITEMS"),
		std::make_pair(AVRC_PDU_GET_ITEM_ATTRIBUTES,
		"AVRC_PDU_GET_ITEM_ATTRIBUTES"),
		std::make_pair(AVRC_PDU_PLAY_ITEM, "AVRC_PDU_PLAY_ITEM"),
		std::make_pair(AVRC_PDU_SEARCH, "AVRC_PDU_SEARCH"),
		std::make_pair(AVRC_PDU_ADD_TO_NOW_PLAYING,
		"AVRC_PDU_ADD_TO_NOW_PLAYING"),
		std::make_pair(AVRC_PDU_GET_TOTAL_NUM_OF_ITEMS,
		"AVRC_PDU_GET_TOTAL_NUM_OF_ITEMS"),
		std::make_pair(AVRC_PDU_GENERAL_REJECT, "AVRC_PDU_GENERAL_REJECT"),
		};
		for (const auto& pdu : pdus) {
		ASSERT_STREQ(pdu.second.c_str(), dump_rc_pdu(pdu.first));
		}
		std::ostringstream oss;
		oss << "Unknown PDU";
		ASSERT_STREQ(oss.str().c_str(),
		dump_rc_pdu(std::numeric_limits<uint8_t>::max()));
		}