Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 52305110 authored by Myles Watson's avatar Myles Watson
Browse files

Use string macros for btif_core_test 

Bug: 305066880
Test: mma -j32
Flag: EXEMPT, logging-only change
Change-Id: I733840c10aed3c99a106edcfaa7342df5e6f4843
parent f468c16d

system/bta/include/bta_hh_api.h

+34 −35
Original line number Diff line number Diff line
@@ -146,47 +146,46 @@ inline tBTA_HH_STATUS to_bta_hh_status(uint32_t status) { 


inline std::string bta_hh_status_text(const tBTA_HH_STATUS& status) {

  switch (status) {

    CASE_RETURN_TEXT(BTA_HH_OK);

    CASE_RETURN_TEXT(BTA_HH_HS_HID_NOT_READY);

    CASE_RETURN_TEXT(BTA_HH_HS_INVALID_RPT_ID);

    CASE_RETURN_TEXT(BTA_HH_HS_TRANS_NOT_SPT);

    CASE_RETURN_TEXT(BTA_HH_HS_INVALID_PARAM);

    CASE_RETURN_TEXT(BTA_HH_HS_ERROR);

    CASE_RETURN_TEXT(BTA_HH_ERR);

    CASE_RETURN_TEXT(BTA_HH_ERR_SDP);

    CASE_RETURN_TEXT(BTA_HH_ERR_PROTO);

    CASE_RETURN_TEXT(BTA_HH_ERR_DB_FULL);

    CASE_RETURN_TEXT(BTA_HH_ERR_TOD_UNSPT);

    CASE_RETURN_TEXT(BTA_HH_ERR_NO_RES);

    CASE_RETURN_TEXT(BTA_HH_ERR_AUTH_FAILED);

    CASE_RETURN_TEXT(BTA_HH_ERR_HDL);

    CASE_RETURN_TEXT(BTA_HH_ERR_SEC);

    default:

      return base::StringPrintf("UNKNOWN[%hhu]", status);

    CASE_RETURN_STRING(BTA_HH_OK);

    CASE_RETURN_STRING(BTA_HH_HS_HID_NOT_READY);

    CASE_RETURN_STRING(BTA_HH_HS_INVALID_RPT_ID);

    CASE_RETURN_STRING(BTA_HH_HS_TRANS_NOT_SPT);

    CASE_RETURN_STRING(BTA_HH_HS_INVALID_PARAM);

    CASE_RETURN_STRING(BTA_HH_HS_ERROR);

    CASE_RETURN_STRING(BTA_HH_ERR);

    CASE_RETURN_STRING(BTA_HH_ERR_SDP);

    CASE_RETURN_STRING(BTA_HH_ERR_PROTO);

    CASE_RETURN_STRING(BTA_HH_ERR_DB_FULL);

    CASE_RETURN_STRING(BTA_HH_ERR_TOD_UNSPT);

    CASE_RETURN_STRING(BTA_HH_ERR_NO_RES);

    CASE_RETURN_STRING(BTA_HH_ERR_AUTH_FAILED);

    CASE_RETURN_STRING(BTA_HH_ERR_HDL);

    CASE_RETURN_STRING(BTA_HH_ERR_SEC);

    CASE_RETURN_STRING(BTA_HH_HS_SERVICE_CHANGED);

  }

  RETURN_UNKNOWN_TYPE_STRING(tBTA_HH_STATUS, status);

}



inline std::string bta_hh_event_text(uint16_t event) {

  switch (event) {

    CASE_RETURN_TEXT(BTA_HH_EMPTY_EVT);

    CASE_RETURN_TEXT(BTA_HH_ENABLE_EVT);

    CASE_RETURN_TEXT(BTA_HH_DISABLE_EVT);

    CASE_RETURN_TEXT(BTA_HH_OPEN_EVT);

    CASE_RETURN_TEXT(BTA_HH_CLOSE_EVT);

    CASE_RETURN_TEXT(BTA_HH_GET_DSCP_EVT);

    CASE_RETURN_TEXT(BTA_HH_GET_PROTO_EVT);

    CASE_RETURN_TEXT(BTA_HH_GET_RPT_EVT);

    CASE_RETURN_TEXT(BTA_HH_GET_IDLE_EVT);

    CASE_RETURN_TEXT(BTA_HH_SET_PROTO_EVT);

    CASE_RETURN_TEXT(BTA_HH_SET_RPT_EVT);

    CASE_RETURN_TEXT(BTA_HH_SET_IDLE_EVT);

    CASE_RETURN_TEXT(BTA_HH_VC_UNPLUG_EVT);

    CASE_RETURN_TEXT(BTA_HH_ADD_DEV_EVT);

    CASE_RETURN_TEXT(BTA_HH_RMV_DEV_EVT);

    CASE_RETURN_TEXT(BTA_HH_API_ERR_EVT);

    default:

      return base::StringPrintf("UNKNOWN[%hu]", event);

    CASE_RETURN_STRING(BTA_HH_EMPTY_EVT);

    CASE_RETURN_STRING(BTA_HH_ENABLE_EVT);

    CASE_RETURN_STRING(BTA_HH_DISABLE_EVT);

    CASE_RETURN_STRING(BTA_HH_OPEN_EVT);

    CASE_RETURN_STRING(BTA_HH_CLOSE_EVT);

    CASE_RETURN_STRING(BTA_HH_GET_DSCP_EVT);

    CASE_RETURN_STRING(BTA_HH_GET_PROTO_EVT);

    CASE_RETURN_STRING(BTA_HH_GET_RPT_EVT);

    CASE_RETURN_STRING(BTA_HH_GET_IDLE_EVT);

    CASE_RETURN_STRING(BTA_HH_SET_PROTO_EVT);

    CASE_RETURN_STRING(BTA_HH_SET_RPT_EVT);

    CASE_RETURN_STRING(BTA_HH_SET_IDLE_EVT);

    CASE_RETURN_STRING(BTA_HH_VC_UNPLUG_EVT);

    CASE_RETURN_STRING(BTA_HH_ADD_DEV_EVT);

    CASE_RETURN_STRING(BTA_HH_RMV_DEV_EVT);

    CASE_RETURN_STRING(BTA_HH_API_ERR_EVT);

  }

  RETURN_UNKNOWN_TYPE_STRING(bta_hh_event, event);

}



typedef uint16_t tBTA_HH_ATTR_MASK;

system/btif/include/btif_util.h

+15 −15
Original line number Diff line number Diff line
@@ -42,21 +42,21 @@ 
 *  Functions

 ******************************************************************************/



const char* dump_bt_status(bt_status_t status);

const char* dump_dm_search_event(uint16_t event);

const char* dump_dm_event(uint16_t event);

const char* dump_hf_event(uint16_t event);

const char* dump_hf_client_event(uint16_t event);

const char* dump_hd_event(uint16_t event);

const char* dump_property_type(bt_property_type_t type);

const char* dump_adapter_scan_mode(bt_scan_mode_t mode);

const char* dump_thread_evt(bt_cb_thread_evt evt);

const char* dump_av_conn_state(uint16_t event);

const char* dump_av_audio_state(uint16_t event);

const char* dump_rc_opcode(uint8_t opcode);

const char* dump_rc_event(uint8_t event);

const char* dump_rc_notification_event_id(uint8_t event_id);

const char* dump_rc_pdu(uint8_t pdu);

std::string dump_bt_status(bt_status_t status);

std::string dump_dm_search_event(uint16_t event);

std::string dump_dm_event(uint16_t event);

std::string dump_hf_event(uint16_t event);

std::string dump_hf_client_event(uint16_t event);

std::string dump_hd_event(uint16_t event);

std::string dump_property_type(bt_property_type_t type);

std::string dump_adapter_scan_mode(bt_scan_mode_t mode);

std::string dump_thread_evt(bt_cb_thread_evt evt);

std::string dump_av_conn_state(uint16_t event);

std::string dump_av_audio_state(uint16_t event);

std::string dump_rc_opcode(uint8_t opcode);

std::string dump_rc_event(uint8_t event);

std::string dump_rc_notification_event_id(uint8_t event_id);

std::string dump_rc_pdu(uint8_t pdu);



uint32_t devclass2uint(const DEV_CLASS dev_class);

DEV_CLASS uint2devclass(uint32_t dev);

system/btif/src/btif_util.cc

+212 −231

File changed.

Preview size limit exceeded, changes collapsed.

system/btif/test/btif_core_test.cc

+69 −96
Original line number Diff line number Diff line
@@ -135,6 +135,8 @@ bt_callbacks_t callbacks = { 


}  // namespace



class BtifUtilsTest : public ::testing::Test {};



class BtifCoreTest : public ::testing::Test {

 protected:

  void SetUp() override {
@@ -214,7 +216,7 @@ TEST_F(BtifCoreTest, test_post_on_bt_jni_simple3) { 
}



extern const char* dump_av_sm_event_name(int event);

TEST_F(BtifCoreTest, dump_av_sm_event_name) {

TEST_F(BtifUtilsTest, 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"),
@@ -243,15 +245,14 @@ TEST_F(BtifCoreTest, dump_av_sm_event_name) { 
                     "BTA_AV_OFFLOAD_START_RSP_EVT"),

  };

  for (const auto& event : events) {

    ASSERT_STREQ(event.second.c_str(), dump_av_sm_event_name(event.first));

    ASSERT_EQ(event.second, 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()));

  ASSERT_EQ(oss.str(), dump_av_sm_event_name(std::numeric_limits<int>::max()));

}



TEST_F(BtifCoreTest, dump_dm_search_event) {

TEST_F(BtifUtilsTest, 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"),
@@ -261,15 +262,13 @@ TEST_F(BtifCoreTest, dump_dm_search_event) { 
      std::make_pair(BTA_DM_NAME_READ_EVT, "BTA_DM_NAME_READ_EVT"),

  };

  for (const auto& event : events) {

    ASSERT_STREQ(event.second.c_str(), dump_dm_search_event(event.first));

    ASSERT_TRUE(dump_dm_search_event(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  oss << "UNKNOWN MSG ID";

  ASSERT_STREQ(oss.str().c_str(),

               dump_dm_search_event(std::numeric_limits<uint16_t>::max()));

  ASSERT_TRUE(dump_dm_search_event(std::numeric_limits<uint16_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_property_type) {

TEST_F(BtifUtilsTest, 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"),
@@ -288,16 +287,14 @@ TEST_F(BtifCoreTest, dump_property_type) { 
                     "BT_PROPERTY_REMOTE_FRIENDLY_NAME"),

  };

  for (const auto& type : types) {

    ASSERT_STREQ(type.second.c_str(), dump_property_type(type.first));

    EXPECT_TRUE(dump_property_type(type.first).starts_with(type.second));

  }

  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())));

  EXPECT_TRUE(dump_property_type(static_cast<bt_property_type_t>(

                                     std::numeric_limits<uint16_t>::max()))

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_dm_event) {

TEST_F(BtifUtilsTest, 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"),
@@ -321,15 +318,13 @@ TEST_F(BtifCoreTest, dump_dm_event) { 
      std::make_pair(BTA_DM_ENER_INFO_READ, "BTA_DM_ENER_INFO_READ"),

  };

  for (const auto& event : events) {

    ASSERT_STREQ(event.second.c_str(), dump_dm_event(event.first));

    ASSERT_TRUE(dump_dm_event(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  oss << "UNKNOWN DM EVENT";

  ASSERT_STREQ(oss.str().c_str(),

               dump_dm_event(std::numeric_limits<uint8_t>::max()));

  ASSERT_TRUE(dump_dm_event(std::numeric_limits<uint8_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_hf_event) {

TEST_F(BtifUtilsTest, 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"),
@@ -366,15 +361,13 @@ TEST_F(BtifCoreTest, dump_hf_event) { 
      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));

    ASSERT_TRUE(dump_hf_event(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  oss << "UNKNOWN MSG ID";

  ASSERT_STREQ(oss.str().c_str(),

               dump_hf_event(std::numeric_limits<uint8_t>::max()));

  ASSERT_TRUE(dump_hf_event(std::numeric_limits<uint8_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_hf_client_event) {

TEST_F(BtifUtilsTest, 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"),
@@ -410,12 +403,10 @@ TEST_F(BtifCoreTest, dump_hf_client_event) { 
                     "BTA_HF_CLIENT_RING_INDICATION"),

  };

  for (const auto& event : events) {

    ASSERT_STREQ(event.second.c_str(), dump_hf_client_event(event.first));

    ASSERT_TRUE(dump_hf_client_event(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  oss << "UNKNOWN MSG ID";

  ASSERT_STREQ(oss.str().c_str(),

               dump_hf_client_event(std::numeric_limits<uint16_t>::max()));

  ASSERT_TRUE(dump_hf_client_event(std::numeric_limits<uint16_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, bta_hh_event_text) {
@@ -438,15 +429,13 @@ TEST_F(BtifCoreTest, bta_hh_event_text) { 
      std::make_pair(BTA_HH_API_ERR_EVT, "BTA_HH_API_ERR_EVT"),

  };

  for (const auto& event : events) {

    ASSERT_EQ(event.second, bta_hh_event_text(event.first));

    ASSERT_TRUE(bta_hh_event_text(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  auto unknown_evt = std::numeric_limits<uint16_t>::max();

  oss << "UNKNOWN[" << unknown_evt << "]";

  ASSERT_EQ(oss.str(), bta_hh_event_text(unknown_evt));

  ASSERT_TRUE(bta_hh_event_text(std::numeric_limits<uint16_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_hd_event) {

TEST_F(BtifUtilsTest, 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"),
@@ -463,29 +452,26 @@ TEST_F(BtifCoreTest, dump_hd_event) { 
      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));

    ASSERT_TRUE(dump_hd_event(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  oss << "UNKNOWN MSG ID";

  ASSERT_STREQ(oss.str().c_str(),

               dump_hd_event(std::numeric_limits<uint16_t>::max()));

  ASSERT_TRUE(dump_hd_event(std::numeric_limits<uint16_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_thread_evt) {

TEST_F(BtifUtilsTest, 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));

    ASSERT_TRUE(dump_thread_evt(event.first).starts_with(event.second));

  }

  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())));

  ASSERT_TRUE(dump_thread_evt(static_cast<bt_cb_thread_evt>(

                                  std::numeric_limits<uint16_t>::max()))

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_av_conn_state) {

TEST_F(BtifUtilsTest, dump_av_conn_state) {

  std::vector<std::pair<uint16_t, std::string>> events = {

      std::make_pair(BTAV_CONNECTION_STATE_DISCONNECTED,

                     "BTAV_CONNECTION_STATE_DISCONNECTED"),
@@ -497,15 +483,13 @@ TEST_F(BtifCoreTest, dump_av_conn_state) { 
                     "BTAV_CONNECTION_STATE_DISCONNECTING"),

  };

  for (const auto& event : events) {

    ASSERT_STREQ(event.second.c_str(), dump_av_conn_state(event.first));

    ASSERT_TRUE(dump_av_conn_state(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  oss << "UNKNOWN MSG ID";

  ASSERT_STREQ(oss.str().c_str(),

               dump_av_conn_state(std::numeric_limits<uint16_t>::max()));

  ASSERT_TRUE(dump_av_conn_state(std::numeric_limits<uint16_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_av_audio_state) {

TEST_F(BtifUtilsTest, 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"),
@@ -513,15 +497,13 @@ TEST_F(BtifCoreTest, dump_av_audio_state) { 
      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));

    ASSERT_TRUE(dump_av_audio_state(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  oss << "UNKNOWN MSG ID";

  ASSERT_STREQ(oss.str().c_str(),

               dump_av_audio_state(std::numeric_limits<uint16_t>::max()));

  ASSERT_TRUE(dump_av_audio_state(std::numeric_limits<uint16_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_adapter_scan_mode) {

TEST_F(BtifUtilsTest, 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"),
@@ -529,16 +511,14 @@ TEST_F(BtifCoreTest, dump_adapter_scan_mode) { 
                     "BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE"),

  };

  for (const auto& event : events) {

    ASSERT_STREQ(event.second.c_str(), dump_adapter_scan_mode(event.first));

    ASSERT_TRUE(dump_adapter_scan_mode(event.first).starts_with(event.second));

  }

  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())));

  ASSERT_TRUE(dump_adapter_scan_mode(

                  static_cast<bt_scan_mode_t>(std::numeric_limits<int>::max()))

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_bt_status) {

TEST_F(BtifUtilsTest, 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"),
@@ -548,15 +528,14 @@ TEST_F(BtifCoreTest, dump_bt_status) { 
      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));

    ASSERT_TRUE(dump_bt_status(event.first).starts_with(event.second));

  }

  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())));

  ASSERT_TRUE(

      dump_bt_status(static_cast<bt_status_t>(std::numeric_limits<int>::max()))

          .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_rc_event) {

TEST_F(BtifUtilsTest, 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"),
@@ -571,15 +550,13 @@ TEST_F(BtifCoreTest, dump_rc_event) { 
      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));

    ASSERT_TRUE(dump_rc_event(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  oss << "UNKNOWN_EVENT";

  ASSERT_STREQ(oss.str().c_str(),

               dump_rc_event(std::numeric_limits<uint8_t>::max()));

  ASSERT_TRUE(dump_rc_event(std::numeric_limits<uint8_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_rc_notification_event_id) {

TEST_F(BtifUtilsTest, 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"),
@@ -604,16 +581,14 @@ TEST_F(BtifCoreTest, dump_rc_notification_event_id) { 
      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));

    ASSERT_TRUE(

        dump_rc_notification_event_id(event.first).starts_with(event.second));

  }

  std::ostringstream oss;

  oss << "Unhandled Event ID";

  ASSERT_STREQ(oss.str().c_str(), dump_rc_notification_event_id(

                                      std::numeric_limits<uint8_t>::max()));

  ASSERT_TRUE(dump_rc_notification_event_id(std::numeric_limits<uint8_t>::max())

                  .starts_with("Unknown"));

}



TEST_F(BtifCoreTest, dump_rc_pdu) {

TEST_F(BtifUtilsTest, 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"),
@@ -659,12 +634,10 @@ TEST_F(BtifCoreTest, dump_rc_pdu) { 
      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));

    ASSERT_TRUE(dump_rc_pdu(pdu.first).starts_with(pdu.second));

  }

  std::ostringstream oss;

  oss << "Unknown PDU";

  ASSERT_STREQ(oss.str().c_str(),

               dump_rc_pdu(std::numeric_limits<uint8_t>::max()));

  ASSERT_TRUE(

      dump_rc_pdu(std::numeric_limits<uint8_t>::max()).starts_with("Unknown"));

}



void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport,

system/btif/test/btif_hf_client_service_test.cc

+1 −3
Original line number Diff line number Diff line
@@ -34,9 +34,7 @@ bt_status_t btif_transfer_context(tBTIF_CBACK* p_cback, uint16_t event, 
  return BT_STATUS_SUCCESS;

}

void btif_queue_advance() {}

const char* dump_hf_client_event(uint16_t event) {

  return "UNKNOWN MSG ID";

}

std::string dump_hf_client_event(uint16_t event) { return "UNKNOWN MSG ID"; }



class BtifHfClientTest : public ::testing::Test {

 protected: