Merge "Use conventional CASE for hci_error_code_text" (ced4fffa) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/include/hci_error_code.h

+49 −75

Original line number	Diff line number	Diff line
		@@ -72,87 +72,61 @@ typedef enum : uint8_t {

		#define HCI_ERR_MAX_ERR _HCI_ERR_MAX_ERR // HACK for now for SMP

		#ifndef CASE_RETURN_TEXT
		#define CASE_RETURN_TEXT(code) \
		case code: \
		return #code
		#endif

		inline std::string hci_error_code_text(const tHCI_ERROR_CODE& error_code) {
		switch (error_code) {
		case HCI_SUCCESS:
		return std::string("Success");
		case HCI_ERR_ILLEGAL_COMMAND:
		return std::string("Illegal Command");
		case HCI_ERR_NO_CONNECTION:
		return std::string("Unknown Connection");
		case HCI_ERR_HW_FAILURE:
		return std::string("Hardware Failure");
		case HCI_ERR_PAGE_TIMEOUT:
		return std::string("Page Timeout");
		case HCI_ERR_AUTH_FAILURE:
		return std::string("Authentication Failure");
		case HCI_ERR_KEY_MISSING:
		return std::string("Pin or Key Missing");
		case HCI_ERR_MEMORY_FULL:
		return std::string("Memory Capacity Exceeded");
		case HCI_ERR_CONNECTION_TOUT:
		return std::string("Connection Timeout");
		case HCI_ERR_MAX_NUM_OF_CONNECTIONS:
		return std::string("Connection Limit Exceeded");
		case HCI_ERR_MAX_NUM_OF_SCOS:
		return std::string("Synchronous Connection Limit Exceeded");
		case HCI_ERR_CONNECTION_EXISTS:
		return std::string("Connection Already Exists");
		case HCI_ERR_COMMAND_DISALLOWED:
		return std::string("Command Disallowed");
		case HCI_ERR_HOST_REJECT_RESOURCES:
		return std::string("Connection Rejected Limited Resources");
		case HCI_ERR_HOST_REJECT_SECURITY:
		return std::string("Connection Rejected Security Reasons");
		case HCI_ERR_HOST_REJECT_DEVICE:
		return std::string("Connection Rejected Unacceptable BdAddr");
		case HCI_ERR_HOST_TIMEOUT:
		return std::string("Connection Accept Timeout");
		case HCI_ERR_ILLEGAL_PARAMETER_FMT:
		return std::string("Unsupported Feature or Parameter Value");
		case HCI_ERR_PEER_USER:
		return std::string("Remote Terminated Connection");
		case HCI_ERR_CONN_CAUSE_LOCAL_HOST:
		return std::string("Local Terminated Connection");
		case HCI_ERR_REPEATED_ATTEMPTS:
		return std::string("Repeated Attempts");
		case HCI_ERR_PAIRING_NOT_ALLOWED:
		return std::string("Pairing not Allowed");
		case HCI_ERR_UNSUPPORTED_REM_FEATURE:
		return std::string("Unsupported Remote or Lmp Feature");
		case HCI_ERR_UNSPECIFIED:
		return std::string("Unspecified Error");
		case HCI_ERR_LMP_RESPONSE_TIMEOUT:
		return std::string("Gatt Connection Lmp Timeout");
		case HCI_ERR_LMP_ERR_TRANS_COLLISION:
		return std::string("Link Layer Collision");
		case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE:
		return std::string("Encryption Mode not Acceptable");
		case HCI_ERR_UNIT_KEY_USED:
		return std::string("Unit Key Used");
		case HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED:
		return std::string("Pairing with Unit Key Unsupported");
		case HCI_ERR_DIFF_TRANSACTION_COLLISION:
		return std::string("Diff Transaction Collision");
		case HCI_ERR_INSUFFCIENT_SECURITY:
		return std::string("Insufficient Security");
		case HCI_ERR_ROLE_SWITCH_PENDING:
		return std::string("Role Switch Pending");
		case HCI_ERR_HOST_BUSY_PAIRING:
		return std::string("Host Busy Pairing");
		case HCI_ERR_UNACCEPT_CONN_INTERVAL:
		return std::string("Unacceptable Connection Interval");
		case HCI_ERR_ADVERTISING_TIMEOUT:
		return std::string("Advertising Timeout");
		case HCI_ERR_CONN_FAILED_ESTABLISHMENT:
		return std::string("Connection Failed Establishment");
		case HCI_ERR_LIMIT_REACHED:
		return std::string("Limit Reached");
		CASE_RETURN_TEXT(HCI_SUCCESS);
		CASE_RETURN_TEXT(HCI_ERR_ILLEGAL_COMMAND);
		CASE_RETURN_TEXT(HCI_ERR_NO_CONNECTION);
		CASE_RETURN_TEXT(HCI_ERR_HW_FAILURE);
		CASE_RETURN_TEXT(HCI_ERR_PAGE_TIMEOUT);
		CASE_RETURN_TEXT(HCI_ERR_AUTH_FAILURE);
		CASE_RETURN_TEXT(HCI_ERR_KEY_MISSING);
		CASE_RETURN_TEXT(HCI_ERR_MEMORY_FULL);
		CASE_RETURN_TEXT(HCI_ERR_CONNECTION_TOUT);
		CASE_RETURN_TEXT(HCI_ERR_MAX_NUM_OF_CONNECTIONS);
		CASE_RETURN_TEXT(HCI_ERR_MAX_NUM_OF_SCOS);
		CASE_RETURN_TEXT(HCI_ERR_CONNECTION_EXISTS);
		CASE_RETURN_TEXT(HCI_ERR_COMMAND_DISALLOWED);
		CASE_RETURN_TEXT(HCI_ERR_HOST_REJECT_RESOURCES);
		CASE_RETURN_TEXT(HCI_ERR_HOST_REJECT_SECURITY);
		CASE_RETURN_TEXT(HCI_ERR_HOST_REJECT_DEVICE);
		CASE_RETURN_TEXT(HCI_ERR_HOST_TIMEOUT);
		CASE_RETURN_TEXT(HCI_ERR_ILLEGAL_PARAMETER_FMT);
		CASE_RETURN_TEXT(HCI_ERR_PEER_USER);
		CASE_RETURN_TEXT(HCI_ERR_REMOTE_LOW_RESOURCE);
		CASE_RETURN_TEXT(HCI_ERR_REMOTE_POWER_OFF);
		CASE_RETURN_TEXT(HCI_ERR_CONN_CAUSE_LOCAL_HOST);
		CASE_RETURN_TEXT(HCI_ERR_REPEATED_ATTEMPTS);
		CASE_RETURN_TEXT(HCI_ERR_PAIRING_NOT_ALLOWED);
		CASE_RETURN_TEXT(HCI_ERR_UNSUPPORTED_REM_FEATURE);
		CASE_RETURN_TEXT(HCI_ERR_UNSPECIFIED);
		CASE_RETURN_TEXT(HCI_ERR_LMP_RESPONSE_TIMEOUT);
		CASE_RETURN_TEXT(HCI_ERR_LMP_ERR_TRANS_COLLISION);
		CASE_RETURN_TEXT(HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE);
		CASE_RETURN_TEXT(HCI_ERR_UNIT_KEY_USED);
		CASE_RETURN_TEXT(HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED);
		CASE_RETURN_TEXT(HCI_ERR_DIFF_TRANSACTION_COLLISION);
		CASE_RETURN_TEXT(HCI_ERR_INSUFFCIENT_SECURITY);
		CASE_RETURN_TEXT(HCI_ERR_ROLE_SWITCH_PENDING);
		CASE_RETURN_TEXT(HCI_ERR_ROLE_SWITCH_FAILED);
		CASE_RETURN_TEXT(HCI_ERR_HOST_BUSY_PAIRING);
		CASE_RETURN_TEXT(HCI_ERR_UNACCEPT_CONN_INTERVAL);
		CASE_RETURN_TEXT(HCI_ERR_ADVERTISING_TIMEOUT);
		CASE_RETURN_TEXT(HCI_ERR_CONN_FAILED_ESTABLISHMENT);
		CASE_RETURN_TEXT(HCI_ERR_LIMIT_REACHED);
		default:
		return base::StringPrintf("Unknown Error[%02hx]", error_code);
		return base::StringPrintf("UNKNOWN[0x%02hx]", error_code);
		}
		}

		#undef CASE_RETURN_TEXT

		// Context equivalence
		using tHCI_STATUS = tHCI_ERROR_CODE;
		inline std::string hci_status_code_text(const tHCI_STATUS& status_code) {

system/stack/test/hci/stack_hci_test.cc

+78 −3

Original line number	Diff line number	Diff line
		@@ -19,6 +19,7 @@

		#include <cstring>
		#include <map>
		#include <utility>

		#include "osi/include/log.h"
		#include "stack/include/hcidefs.h"
		@@ -28,8 +29,6 @@

		namespace mock = test::mock::hcic_hcicmds;

		namespace {

		using testing::_;
		using testing::DoAll;
		using testing::NotNull;
		@@ -130,4 +129,80 @@ TEST_F(StackHciTest, hci_preamble) {
		}
		}

		} // namespace
		TEST_F(StackHciTest, hci_error_code_text) {
		std::vector<std::pair<tHCI_ERROR_CODE, std::string>> errors = {
		std::make_pair(HCI_SUCCESS, "HCI_SUCCESS"),
		std::make_pair(HCI_ERR_ILLEGAL_COMMAND, "HCI_ERR_ILLEGAL_COMMAND"),
		std::make_pair(HCI_ERR_NO_CONNECTION, "HCI_ERR_NO_CONNECTION"),
		std::make_pair(HCI_ERR_HW_FAILURE, "HCI_ERR_HW_FAILURE"),
		std::make_pair(HCI_ERR_PAGE_TIMEOUT, "HCI_ERR_PAGE_TIMEOUT"),
		std::make_pair(HCI_ERR_AUTH_FAILURE, "HCI_ERR_AUTH_FAILURE"),
		std::make_pair(HCI_ERR_KEY_MISSING, "HCI_ERR_KEY_MISSING"),
		std::make_pair(HCI_ERR_MEMORY_FULL, "HCI_ERR_MEMORY_FULL"),
		std::make_pair(HCI_ERR_CONNECTION_TOUT, "HCI_ERR_CONNECTION_TOUT"),
		std::make_pair(HCI_ERR_MAX_NUM_OF_CONNECTIONS,
		"HCI_ERR_MAX_NUM_OF_CONNECTIONS"),
		std::make_pair(HCI_ERR_MAX_NUM_OF_SCOS, "HCI_ERR_MAX_NUM_OF_SCOS"),
		std::make_pair(HCI_ERR_CONNECTION_EXISTS, "HCI_ERR_CONNECTION_EXISTS"),
		std::make_pair(HCI_ERR_COMMAND_DISALLOWED, "HCI_ERR_COMMAND_DISALLOWED"),
		std::make_pair(HCI_ERR_HOST_REJECT_RESOURCES,
		"HCI_ERR_HOST_REJECT_RESOURCES"),
		std::make_pair(HCI_ERR_HOST_REJECT_SECURITY,
		"HCI_ERR_HOST_REJECT_SECURITY"),
		std::make_pair(HCI_ERR_HOST_REJECT_DEVICE, "HCI_ERR_HOST_REJECT_DEVICE"),
		std::make_pair(HCI_ERR_HOST_TIMEOUT, "HCI_ERR_HOST_TIMEOUT"),
		std::make_pair(HCI_ERR_ILLEGAL_PARAMETER_FMT,
		"HCI_ERR_ILLEGAL_PARAMETER_FMT"),
		std::make_pair(HCI_ERR_PEER_USER, "HCI_ERR_PEER_USER"),
		std::make_pair(HCI_ERR_REMOTE_LOW_RESOURCE,
		"HCI_ERR_REMOTE_LOW_RESOURCE"),
		std::make_pair(HCI_ERR_REMOTE_POWER_OFF, "HCI_ERR_REMOTE_POWER_OFF"),
		std::make_pair(HCI_ERR_CONN_CAUSE_LOCAL_HOST,
		"HCI_ERR_CONN_CAUSE_LOCAL_HOST"),
		std::make_pair(HCI_ERR_REPEATED_ATTEMPTS, "HCI_ERR_REPEATED_ATTEMPTS"),
		std::make_pair(HCI_ERR_PAIRING_NOT_ALLOWED,
		"HCI_ERR_PAIRING_NOT_ALLOWED"),
		std::make_pair(HCI_ERR_UNSUPPORTED_REM_FEATURE,
		"HCI_ERR_UNSUPPORTED_REM_FEATURE"),
		std::make_pair(HCI_ERR_UNSPECIFIED, "HCI_ERR_UNSPECIFIED"),
		std::make_pair(HCI_ERR_LMP_RESPONSE_TIMEOUT,
		"HCI_ERR_LMP_RESPONSE_TIMEOUT"),
		std::make_pair(HCI_ERR_LMP_ERR_TRANS_COLLISION,
		"HCI_ERR_LMP_ERR_TRANS_COLLISION"),
		std::make_pair(HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE,
		"HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE"),
		std::make_pair(HCI_ERR_UNIT_KEY_USED, "HCI_ERR_UNIT_KEY_USED"),
		std::make_pair(HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED,
		"HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED"),
		std::make_pair(HCI_ERR_DIFF_TRANSACTION_COLLISION,
		"HCI_ERR_DIFF_TRANSACTION_COLLISION"),
		std::make_pair(HCI_ERR_INSUFFCIENT_SECURITY,
		"HCI_ERR_INSUFFCIENT_SECURITY"),
		std::make_pair(HCI_ERR_ROLE_SWITCH_PENDING,
		"HCI_ERR_ROLE_SWITCH_PENDING"),
		std::make_pair(HCI_ERR_ROLE_SWITCH_FAILED, "HCI_ERR_ROLE_SWITCH_FAILED"),
		std::make_pair(HCI_ERR_HOST_BUSY_PAIRING, "HCI_ERR_HOST_BUSY_PAIRING"),
		std::make_pair(HCI_ERR_UNACCEPT_CONN_INTERVAL,
		"HCI_ERR_UNACCEPT_CONN_INTERVAL"),
		std::make_pair(HCI_ERR_ADVERTISING_TIMEOUT,
		"HCI_ERR_ADVERTISING_TIMEOUT"),
		std::make_pair(HCI_ERR_CONN_FAILED_ESTABLISHMENT,
		"HCI_ERR_CONN_FAILED_ESTABLISHMENT"),
		std::make_pair(HCI_ERR_LIMIT_REACHED, "HCI_ERR_LIMIT_REACHED"),
		};
		for (const auto& error : errors) {
		ASSERT_STREQ(error.second.c_str(),
		hci_error_code_text(error.first).c_str());
		}
		for (const auto& error : errors) {
		ASSERT_STREQ(error.second.c_str(),
		hci_error_code_text(error.first).c_str());
		}
		auto unknown = base::StringPrintf("UNKNOWN[0x%02hx]",
		std::numeric_limits<std::uint8_t>::max());
		ASSERT_STREQ(
		unknown.c_str(),
		hci_error_code_text(static_cast<tHCI_ERROR_CODE>(
		std::numeric_limits<std::uint8_t>::max()))
		.c_str());
		}