| # Copyright 2026 The Pigweed Authors |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| # use this file except in compliance with the License. You may obtain a copy of |
| # the License at |
| # |
| # https://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations under |
| # the License. |
| """Tests for PW_ENUM() parsing.""" |
| |
| import tempfile |
| import unittest |
| from pathlib import Path |
| |
| from pw_enum.parse import ( |
| ParseError, |
| EnumValue, |
| EnumDescriptor, |
| _parse_preprocessed_header, |
| _parse_evaluation_output, |
| camel_to_upper_snake, |
| _default_display_name, |
| ) |
| |
| # pylint: disable=too-many-public-methods,missing-function-docstring |
| |
| |
| class TestEnumHParser(unittest.TestCase): |
| """Test cases for .enum.h parsing.""" |
| |
| def setUp(self): |
| self.test_dir = ( |
| tempfile.TemporaryDirectory() # pylint: disable=consider-using-with |
| ) |
| self.addCleanup(self.test_dir.cleanup) |
| |
| def test_basic_parse(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"my::ns::MyEnum", "kValueA", "kValueB" ) _PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(len(enums), 1) |
| e = enums[0] |
| self.assertEqual(e.name, "MyEnum") |
| self.assertEqual(e.scopes, ("my", "ns")) |
| self.assertEqual(e.cc_full_name, "::my::ns::MyEnum") |
| self.assertEqual(e.values[0], ("kValueA", "VALUE_A")) |
| self.assertEqual(e.values[1], ("kValueB", "VALUE_B")) |
| |
| # Test evaluation simulation (similar to parse_enums replacement) |
| eval_values = {0: 0, 1: 1} |
| final_descriptors = [] |
| target_idx = 0 |
| for enum in enums: |
| new_values = [] |
| for cc_name, display_name in enum.values: |
| val = eval_values[target_idx] |
| target_idx += 1 |
| new_values.append( |
| EnumValue(cc_name=cc_name, value=val, name=display_name) |
| ) |
| final_descriptors.append( |
| EnumDescriptor( |
| name=enum.name, |
| scopes=enum.scopes, |
| cc_full_name=enum.cc_full_name, |
| line=enum.line, |
| values=tuple(new_values), |
| ) |
| ) |
| |
| self.assertEqual(len(final_descriptors), 1) |
| desc = final_descriptors[0] |
| self.assertEqual(desc.values[0].cc_name, "kValueA") |
| self.assertEqual(desc.values[0].value, 0) |
| self.assertEqual(desc.values[1].cc_name, "kValueB") |
| self.assertEqual(desc.values[1].value, 1) |
| |
| def test_custom_strings(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum(\n' |
| ' "my::ns::MyEnum",\n' |
| ' "kValueA = \\"CUSTOM A\\"",\n' |
| ' "kValueB = \\"custom \\\\\\\"nested\\\\\\\" b\\"",\n' |
| ' "kValueC = \\"a + b - c\\"",\n' |
| ' "kValueD"\n' |
| ') _PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(len(enums), 1) |
| e = enums[0] |
| self.assertEqual(e.values[0], ("kValueA", "CUSTOM A")) |
| self.assertEqual(e.values[1], ("kValueB", 'custom "nested" b')) |
| self.assertEqual(e.values[2], ("kValueC", "a + b - c")) |
| self.assertEqual(e.values[3], ("kValueD", "VALUE_D")) |
| |
| # Test evaluation simulation string resolution |
| eval_values = {0: 1, 1: 2, 2: 3, 3: 4} |
| final_descriptors = [] |
| target_idx = 0 |
| for enum in enums: |
| new_values = [] |
| for cc_name, display_name in enum.values: |
| val = eval_values[target_idx] |
| target_idx += 1 |
| new_values.append( |
| EnumValue(cc_name=cc_name, value=val, name=display_name) |
| ) |
| final_descriptors.append( |
| EnumDescriptor( |
| name=enum.name, |
| scopes=enum.scopes, |
| cc_full_name=enum.cc_full_name, |
| line=enum.line, |
| values=tuple(new_values), |
| ) |
| ) |
| |
| self.assertEqual(final_descriptors[0].values[0].name, "CUSTOM A") |
| self.assertEqual(final_descriptors[0].values[0].value, 1) |
| self.assertEqual( |
| final_descriptors[0].values[1].name, 'custom "nested" b' |
| ) |
| self.assertEqual(final_descriptors[0].values[1].value, 2) |
| self.assertEqual(final_descriptors[0].values[2].name, "a + b - c") |
| self.assertEqual(final_descriptors[0].values[2].value, 3) |
| self.assertEqual(final_descriptors[0].values[3].name, "VALUE_D") |
| self.assertEqual(final_descriptors[0].values[3].value, 4) |
| |
| def test_class_nested_enum(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"my::ns::MyClass::MyEnum", "kValueA", "kValueB" ) ' |
| '_PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| e = enums[0] |
| self.assertEqual(e.name, "MyEnum") |
| self.assertEqual(e.scopes, ("my", "ns", "MyClass")) |
| |
| def test_multiple_enums(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"my::ns::E1", "kA" ) _PW_ENUM_MACRO_END;\n' |
| f'# 3 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"my::ns::E2", "kB" ) _PW_ENUM_MACRO_END;\n' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(len(enums), 2) |
| self.assertEqual(enums[0].name, "E1") |
| self.assertEqual(enums[1].name, "E2") |
| |
| def test_nested_namespaces(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"a::b::E", "kA" ) _PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(enums[0].scopes, ("a", "b")) |
| |
| def test_leading_colon_scopes(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"::a::b::E", "kA" ) _PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(enums[0].name, "E") |
| self.assertEqual(enums[0].scopes, ("a", "b")) |
| self.assertEqual(enums[0].cc_full_name, "::a::b::E") |
| desc = EnumDescriptor( |
| name=enums[0].name, |
| scopes=enums[0].scopes, |
| cc_full_name=enums[0].cc_full_name, |
| line=enums[0].line, |
| values=(), |
| ) |
| self.assertTrue(desc.cc_versioned_name.startswith("::a::b::")) |
| |
| def test_top_level_enum_error(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("PW_ENUM(TopLevel, kA);") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"TopLevel", "kA" ) _PW_ENUM_MACRO_END;' |
| ) |
| with self.assertRaisesRegex( |
| ParseError, |
| "PW_ENUM requires a fully qualified name with at least one " |
| "namespace", |
| ): |
| _parse_preprocessed_header(text, test_file) |
| |
| def test_empty_enum(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::Empty", ) _PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(len(enums), 1) |
| self.assertEqual(enums[0].name, "Empty") |
| self.assertEqual(len(enums[0].values), 0) |
| |
| def test_single_enumerator_enum(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::One", "kVal", ) _PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(len(enums), 1) |
| self.assertEqual(enums[0].name, "One") |
| self.assertEqual( |
| tuple(cc_name for cc_name, _ in enums[0].values), ("kVal",) |
| ) |
| |
| def test_empty_custom_string(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::EmptyCustom", "kVal = \\"\\"", ) _PW_ENUM_MACRO_END;' |
| ) |
| with self.assertRaisesRegex( |
| ParseError, |
| "cannot be empty", |
| ): |
| _parse_preprocessed_header(text, test_file) |
| |
| def test_whitespace_and_nonprintable_custom_strings(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| |
| # Whitespace-only custom string is allowed |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::SpaceCustom", "kVal = \\" \\"", ) _PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(enums[0].values[0][1], " ") |
| |
| # C++ hex escapes are handled correctly |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::HexCustom", "kVal = \\"\\\\x1b\\"", ) _PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(enums[0].values[0][1], "\x1b") |
| |
| # C++ newline escapes become newlines |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::NewlineCustom", "kVal = \\"Foo\\\\nBar\\"", ) ' |
| '_PW_ENUM_MACRO_END;' |
| ) |
| enums = _parse_preprocessed_header(text, test_file) |
| self.assertEqual(enums[0].values[0][1], "Foo\nBar") |
| |
| def test_parse_evaluation_output_error(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("some content line 1\n...\nline 10 | error here") |
| mock_stderr = ( |
| f'{test_file.resolve()}:10:5: error: ' |
| "use of undeclared identifier 'UNKNOWN'\n" |
| ) |
| |
| with self.assertRaises(ParseError) as cm: |
| list( |
| _parse_evaluation_output( |
| mock_stderr, |
| [("kA", "A")], |
| ) |
| ) |
| self.assertIn( |
| "Failed to evaluate value for kA!", |
| str(cm.exception), |
| ) |
| |
| def test_parse_evaluation_output_success(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| mock_stderr = ( |
| "PwEnumValueExtractor<0, 42>\nPwEnumValueExtractor<1, 100>\n" |
| ) |
| targets = [ |
| ("kA", "A"), |
| ("kB", "B"), |
| ] |
| |
| eval_values = list( |
| _parse_evaluation_output( |
| mock_stderr, |
| targets, |
| ) |
| ) |
| self.assertEqual(len(eval_values), 2) |
| self.assertEqual(eval_values[0], EnumValue("kA", 42, "A")) |
| self.assertEqual(eval_values[1], EnumValue("kB", 100, "B")) |
| |
| def test_missing_macro_error(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| with self.assertRaisesRegex( |
| ParseError, |
| "pw_cc_enum headers must contain at least one call to PW_ENUM", |
| ): |
| _parse_preprocessed_header("", test_file) |
| |
| def test_non_utf8_custom_string_error(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| |
| # Hex escape representing invalid UTF-8 byte 0xFF |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::InvalidCustom", "kVal = \\"\\\\xff\\"", ) ' |
| '_PW_ENUM_MACRO_END;' |
| ) |
| with self.assertRaisesRegex( |
| ParseError, |
| "is not valid UTF-8", |
| ): |
| _parse_preprocessed_header(text, test_file) |
| |
| def test_ignore_included_headers_enums(self) -> None: |
| foo_file = Path(self.test_dir.name) / "foo.h" |
| bar_file = Path(self.test_dir.name) / "bar.h" |
| foo_file.write_text("") |
| bar_file.write_text("") |
| |
| # Simulated preprocessed output where foo.h includes bar.h. |
| # Markers for both files are present. |
| text = ( |
| f'# 1 "{foo_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::FooEnum", "kFooVal" ) _PW_ENUM_MACRO_END;\n' |
| f'# 1 "{bar_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::BarEnum", "kBarVal" ) _PW_ENUM_MACRO_END;\n' |
| ) |
| |
| # Parsing foo_file should only return FooEnum and ignore BarEnum. |
| enums = _parse_preprocessed_header(text, foo_file) |
| self.assertEqual(len(enums), 1) |
| self.assertEqual(enums[0].name, "FooEnum") |
| |
| # Parsing bar_file should only return BarEnum and ignore FooEnum. |
| enums = _parse_preprocessed_header(text, bar_file) |
| self.assertEqual(len(enums), 1) |
| self.assertEqual(enums[0].name, "BarEnum") |
| |
| def test_missing_macro_error_with_other_file_enums(self) -> None: |
| foo_file = Path(self.test_dir.name) / "foo.h" |
| bar_file = Path(self.test_dir.name) / "bar.h" |
| foo_file.write_text("") |
| bar_file.write_text("") |
| |
| # Text has enums for bar.h, but we are parsing foo.h. |
| text = ( |
| f'# 1 "{bar_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::BarEnum", "kBarVal" ) _PW_ENUM_MACRO_END;\n' |
| ) |
| |
| with self.assertRaisesRegex( |
| ParseError, |
| "pw_cc_enum headers must contain at least one call to PW_ENUM", |
| ): |
| _parse_preprocessed_header(text, foo_file) |
| |
| def test_empty_enumerator_error(self) -> None: |
| test_file = Path(self.test_dir.name) / "test_enum.h" |
| test_file.write_text("") |
| text = ( |
| f'# 1 "{test_file.resolve()}"\n' |
| '_PW_ENUM_MUST_BE_COMPILED_BY_pw_cc_enum( ' |
| '"ns::MyEnum", "kVal", "", "kVal2" ) _PW_ENUM_MACRO_END;' |
| ) |
| with self.assertRaisesRegex( |
| ParseError, |
| "Invalid enumerator name", |
| ): |
| _parse_preprocessed_header(text, test_file) |
| |
| |
| class TestDefaultDisplayName(unittest.TestCase): |
| """Test default display name resolution logic.""" |
| |
| def test_default_display_name(self) -> None: |
| self.assertEqual(_default_display_name("kFooBar"), "FOO_BAR") |
| self.assertEqual(_default_display_name("FooBar"), "FooBar") |
| self.assertEqual(_default_display_name("kool"), "kool") |
| self.assertEqual(_default_display_name("kO"), "O") |
| self.assertEqual(_default_display_name("k"), "k") |
| |
| |
| class TestCamelToUpperSnake(unittest.TestCase): |
| """Test CamelCase to UPPER_SNAKE_CASE conversion.""" |
| |
| def test_camel_to_upper_snake(self) -> None: |
| self.assertEqual(camel_to_upper_snake("MyEnum"), "MY_ENUM") |
| self.assertEqual(camel_to_upper_snake("myEnum"), "MY_ENUM") |
| self.assertEqual(camel_to_upper_snake("HTTPServer"), "HTTP_SERVER") |
| self.assertEqual(camel_to_upper_snake("JSONParser"), "JSON_PARSER") |
| self.assertEqual(camel_to_upper_snake("URL"), "URL") |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
