PDL: Enforce ENUM_STYLE (164ef58f) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/hci_packets.pdl

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -1867,7 +1867,7 @@ packet ReadLocalVersionInformation : CommandPacket (op_code = READ_LOCAL_VERSION
	}		}

	enum HciVersion : 8 {		enum HciVersion : 8 {
	V_1_0b = 0x00,		V_1_0B = 0x00,
	V_1_1 = 0x01,		V_1_1 = 0x01,
	V_1_2 = 0x02,		V_1_2 = 0x02,
	V_2_0 = 0x03, // + EDR		V_2_0 = 0x03, // + EDR
	@@ -1881,7 +1881,7 @@ enum HciVersion : 8 {
	}		}

	enum LmpVersion : 8 {		enum LmpVersion : 8 {
	V_1_0b = 0x00, // withdrawn		V_1_0B = 0x00, // withdrawn
	V_1_1 = 0x01, // withdrawn		V_1_1 = 0x01, // withdrawn
	V_1_2 = 0x02, // withdrawn		V_1_2 = 0x02, // withdrawn
	V_2_0 = 0x03, // + EDR		V_2_0 = 0x03, // + EDR

system/gd/packet/parser/enum_def.cc

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -25,6 +25,9 @@
	EnumDef::EnumDef(std::string name, int size) : TypeDef(name, size) {}		EnumDef::EnumDef(std::string name, int size) : TypeDef(name, size) {}

	void EnumDef::AddEntry(std::string name, uint32_t value) {		void EnumDef::AddEntry(std::string name, uint32_t value) {
			if (!util::IsEnumCase(name)) {
			ERROR() << __func__ << ": Enum " << name << "(" << value << ") should be all uppercase with underscores";
			}
	if (value > util::GetMaxValueForBits(size_)) {		if (value > util::GetMaxValueForBits(size_)) {
	ERROR() << __func__ << ": Value of " << name << "(" << value << ") is greater than the max possible value for enum "		ERROR() << __func__ << ": Value of " << name << "(" << value << ") is greater than the max possible value for enum "
	<< name_ << "(" << util::GetMaxValueForBits(size_) << ")\n";		<< name_ << "(" << util::GetMaxValueForBits(size_) << ")\n";

system/gd/packet/parser/test/generated_packet_test.cc

+8 −8

system/gd/packet/parser/test/test_packets.pdl

+11 −10

Original line number	Original line	Diff line number	Diff line
	@@ -278,10 +278,11 @@ packet OneVersionTwoStructPacket : OneVersionedStructPacket(version = 0x02) {
	}		}

	enum StructType : 8 {		enum StructType : 8 {
	ZeroByte = 0x00,		ZERO_BYTE = 0x00,
	TwoByte = 0x02,		TWO_BYTE = 0x02,
	FourByte = 0x04,		FOUR_BYTE = 0x04,
	AtLeastFourByte = 0x05,		AT_LEAST_FOUR_BYTE = 0x05,
			VARIABLE = 0x06,
	}		}

	struct UnusedParentStruct {		struct UnusedParentStruct {
	@@ -289,28 +290,28 @@ struct UnusedParentStruct {
	_body_,		_body_,
	}		}

	struct TwoByteStruct : UnusedParentStruct (struct_type = TwoByte) {		struct TwoByteStruct : UnusedParentStruct (struct_type = TWO_BYTE) {
	two_bytes : 16,		two_bytes : 16,
	}		}

	struct FourByteStruct : UnusedParentStruct (struct_type = FourByte) {		struct FourByteStruct : UnusedParentStruct (struct_type = FOUR_BYTE) {
	four_bytes : 32,		four_bytes : 32,
	}		}

	struct AtLeastFourByteStruct : UnusedParentStruct (struct_type = AtLeastFourByte) {		struct AtLeastFourByteStruct : UnusedParentStruct (struct_type = AT_LEAST_FOUR_BYTE) {
	four_bytes : 32,		four_bytes : 32,
	struct_type : StructType,		struct_type : StructType,
	_body_,		_body_,
	}		}

	struct OnlyFourByteStruct : AtLeastFourByteStruct (struct_type = ZeroByte) {		struct OnlyFourByteStruct : AtLeastFourByteStruct (struct_type = ZERO_BYTE) {
	}		}

	struct SixByteStruct : AtLeastFourByteStruct (struct_type = TwoByte) {		struct SixByteStruct : AtLeastFourByteStruct (struct_type = TWO_BYTE) {
	two_bytes : 16,		two_bytes : 16,
	}		}

	struct EightByteStruct : AtLeastFourByteStruct (struct_type = FourByte) {		struct EightByteStruct : AtLeastFourByteStruct (struct_type = FOUR_BYTE) {
	four_bytes : 32,		four_bytes : 32,
	}		}

system/gd/packet/parser/util.h

+11 −0

Original line number	Original line	Diff line number	Diff line
	@@ -103,4 +103,15 @@ inline std::string UnderscoreToCamelCase(std::string value) {
	return camel_case.str();		return camel_case.str();
	}		}

			inline bool IsEnumCase(std::string value) {
			if (value[0] < 'A' \|\| value[0] > 'Z') {
			return false;
			}

			// Use static to avoid compiling the regex more than once.
			static const std::regex enum_regex("[A-Z][A-Z0-9_]*");

			return std::regex_match(value, enum_regex);
			}

	} // namespace util		} // namespace util

Original line number	Original line	Diff line number	Diff line
	@@ -1483,7 +1483,7 @@ TEST(GeneratedPacketTest, testOneFourByteStruct) {
	PacketView<kLittleEndian> packet_bytes_view(packet_bytes);		PacketView<kLittleEndian> packet_bytes_view(packet_bytes);
	auto view = OneFourByteStructView::Create(packet_bytes_view);		auto view = OneFourByteStructView::Create(packet_bytes_view);
	ASSERT_TRUE(view.IsValid());		ASSERT_TRUE(view.IsValid());
	ASSERT_EQ(StructType::FourByte, view.GetOneStruct().struct_type_);		ASSERT_EQ(StructType::FOUR_BYTE, view.GetOneStruct().struct_type_);
	ASSERT_EQ(four_byte_struct.four_bytes_, view.GetOneStruct().four_bytes_);		ASSERT_EQ(four_byte_struct.four_bytes_, view.GetOneStruct().four_bytes_);
	}		}

	@@ -1552,7 +1552,7 @@ TEST(GeneratedPacketTest, testOneGenericStructFour) {
	ASSERT_TRUE(view.IsValid());		ASSERT_TRUE(view.IsValid());
	auto base_struct = view.GetBaseStruct();		auto base_struct = view.GetBaseStruct();
	ASSERT_NE(nullptr, base_struct);		ASSERT_NE(nullptr, base_struct);
	ASSERT_EQ(StructType::FourByte, base_struct->struct_type_);		ASSERT_EQ(StructType::FOUR_BYTE, base_struct->struct_type_);
	ASSERT_EQ(four_byte_struct.four_bytes_, ((FourByteStruct*)base_struct.get())->four_bytes_);		ASSERT_EQ(four_byte_struct.four_bytes_, ((FourByteStruct*)base_struct.get())->four_bytes_);
	}		}

	@@ -1586,10 +1586,10 @@ TEST(GeneratedPacketTest, testOneGenericStructArray) {

	std::vector<std::unique_ptr<UnusedParentStruct>> vector_copy;		std::vector<std::unique_ptr<UnusedParentStruct>> vector_copy;
	for (auto& s : parent_vector) {		for (auto& s : parent_vector) {
	if (s->struct_type_ == StructType::TwoByte) {		if (s->struct_type_ == StructType::TWO_BYTE) {
	vector_copy.push_back(std::make_unique<TwoByteStruct>((TwoByteStruct)s.get()));		vector_copy.push_back(std::make_unique<TwoByteStruct>((TwoByteStruct)s.get()));
	}		}
	if (s->struct_type_ == StructType::FourByte) {		if (s->struct_type_ == StructType::FOUR_BYTE) {
	vector_copy.push_back(std::make_unique<FourByteStruct>((FourByteStruct)s.get()));		vector_copy.push_back(std::make_unique<FourByteStruct>((FourByteStruct)s.get()));
	}		}
	}		}
	@@ -1614,7 +1614,7 @@ TEST(GeneratedPacketTest, testOneGenericStructArray) {
	for (size_t i = 0; i < vector_copy.size(); i++) {		for (size_t i = 0; i < vector_copy.size(); i++) {
	ASSERT_NE(nullptr, an_array[i]);		ASSERT_NE(nullptr, an_array[i]);
	ASSERT_EQ(vector_copy[i]->struct_type_, an_array[i]->struct_type_);		ASSERT_EQ(vector_copy[i]->struct_type_, an_array[i]->struct_type_);
	if (vector_copy[i]->struct_type_ == StructType::FourByte) {		if (vector_copy[i]->struct_type_ == StructType::FOUR_BYTE) {
	ASSERT_EQ(FourByteStruct::Specialize(vector_copy[i].get())->four_bytes_,		ASSERT_EQ(FourByteStruct::Specialize(vector_copy[i].get())->four_bytes_,
	FourByteStruct::Specialize(an_array[i].get())->four_bytes_);		FourByteStruct::Specialize(an_array[i].get())->four_bytes_);
	} else {		} else {
	@@ -1644,10 +1644,10 @@ TEST(GeneratedPacketTest, testOneGenericStructFourArray) {
	std::array<std::unique_ptr<UnusedParentStruct>, 4> vector_copy;		std::array<std::unique_ptr<UnusedParentStruct>, 4> vector_copy;
	size_t i = 0;		size_t i = 0;
	for (auto& s : parent_vector) {		for (auto& s : parent_vector) {
	if (s->struct_type_ == StructType::TwoByte) {		if (s->struct_type_ == StructType::TWO_BYTE) {