| # Copyright 2023 Google LLC |
| # |
| # 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 attribute_checker.py.""" |
| |
| import unittest |
| from compiler.back_end.cpp import header_generator |
| from compiler.front_end import glue |
| from compiler.util import error |
| from compiler.util import ir_data |
| from compiler.util import ir_data_utils |
| from compiler.util import test_util |
| |
| |
| def _make_ir_from_emb(emb_text, name="m.emb"): |
| ir, unused_debug_info, errors = glue.parse_emboss_file( |
| name, test_util.dict_file_reader({name: emb_text}) |
| ) |
| assert not errors |
| return ir |
| |
| |
| class NormalizeIrTest(unittest.TestCase): |
| |
| def test_accepts_string_attribute(self): |
| ir = _make_ir_from_emb('[(cpp) namespace: "foo"]\n') |
| self.assertEqual([], header_generator.generate_header(ir)[1]) |
| |
| def test_rejects_wrong_type_for_string_attribute(self): |
| ir = _make_ir_from_emb("[(cpp) namespace: 9]\n") |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.value.source_location, |
| "Attribute '(cpp) namespace' must have a string value.", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_rejects_emboss_internal_attribute_with_back_end_specifier(self): |
| ir = _make_ir_from_emb('[(cpp) byte_order: "LittleEndian"]\n') |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.name.source_location, |
| "Unknown attribute '(cpp) byte_order' on module 'm.emb'.", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_accepts_enum_case(self): |
| mod_ir = _make_ir_from_emb('[(cpp) $default enum_case: "kCamelCase"]') |
| self.assertEqual([], header_generator.generate_header(mod_ir)[1]) |
| enum_ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "kCamelCase"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| self.assertEqual([], header_generator.generate_header(enum_ir)[1]) |
| enum_value_ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' BAR = 1 [(cpp) enum_case: "kCamelCase"]\n' |
| " BAZ = 2\n" |
| ' [(cpp) enum_case: "kCamelCase"]\n' |
| ) |
| self.assertEqual([], header_generator.generate_header(enum_value_ir)[1]) |
| enum_in_struct_ir = _make_ir_from_emb( |
| "struct Outer:\n" |
| ' [(cpp) $default enum_case: "kCamelCase"]\n' |
| " enum Inner:\n" |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| self.assertEqual([], header_generator.generate_header(enum_in_struct_ir)[1]) |
| enum_in_bits_ir = _make_ir_from_emb( |
| "bits Outer:\n" |
| ' [(cpp) $default enum_case: "kCamelCase"]\n' |
| " enum Inner:\n" |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| self.assertEqual([], header_generator.generate_header(enum_in_bits_ir)[1]) |
| enum_ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "SHOUTY_CASE,"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| self.assertEqual([], header_generator.generate_header(enum_ir)[1]) |
| enum_ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "SHOUTY_CASE ,kCamelCase"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| self.assertEqual([], header_generator.generate_header(enum_ir)[1]) |
| |
| def test_rejects_bad_enum_case_at_start(self): |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "SHORTY_CASE, kCamelCase"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| attr = ir.module[0].type[0].attribute[0] |
| |
| bad_case_source_location = ir_data.Location() |
| bad_case_source_location = ir_data_utils.builder(bad_case_source_location) |
| bad_case_source_location.CopyFrom(attr.value.source_location) |
| # Location of SHORTY_CASE in the attribute line. |
| bad_case_source_location.start.column = 30 |
| bad_case_source_location.end.column = 41 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| 'Unsupported enum case "SHORTY_CASE", ' |
| "supported cases are: SHOUTY_CASE, kCamelCase.", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_rejects_bad_enum_case_in_middle(self): |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "SHOUTY_CASE, bad_CASE, kCamelCase"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| attr = ir.module[0].type[0].attribute[0] |
| |
| bad_case_source_location = ir_data.Location() |
| bad_case_source_location = ir_data_utils.builder(bad_case_source_location) |
| bad_case_source_location.CopyFrom(attr.value.source_location) |
| # Location of bad_CASE in the attribute line. |
| bad_case_source_location.start.column = 43 |
| bad_case_source_location.end.column = 51 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| 'Unsupported enum case "bad_CASE", ' |
| "supported cases are: SHOUTY_CASE, kCamelCase.", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_rejects_bad_enum_case_at_end(self): |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "SHOUTY_CASE, kCamelCase, BAD_case"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| attr = ir.module[0].type[0].attribute[0] |
| |
| bad_case_source_location = ir_data.Location() |
| bad_case_source_location = ir_data_utils.builder(bad_case_source_location) |
| bad_case_source_location.CopyFrom(attr.value.source_location) |
| # Location of BAD_case in the attribute line. |
| bad_case_source_location.start.column = 55 |
| bad_case_source_location.end.column = 63 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| 'Unsupported enum case "BAD_case", ' |
| "supported cases are: SHOUTY_CASE, kCamelCase.", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_rejects_duplicate_enum_case(self): |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "SHOUTY_CASE, SHOUTY_CASE"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| attr = ir.module[0].type[0].attribute[0] |
| |
| bad_case_source_location = ir_data.Location() |
| bad_case_source_location = ir_data_utils.builder(bad_case_source_location) |
| bad_case_source_location.CopyFrom(attr.value.source_location) |
| # Location of the second SHOUTY_CASE in the attribute line. |
| bad_case_source_location.start.column = 43 |
| bad_case_source_location.end.column = 54 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| 'Duplicate enum case "SHOUTY_CASE".', |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_rejects_empty_enum_case(self): |
| # Double comma |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "SHOUTY_CASE,, kCamelCase"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| attr = ir.module[0].type[0].attribute[0] |
| |
| bad_case_source_location = ir_data.Location() |
| bad_case_source_location = ir_data_utils.builder(bad_case_source_location) |
| bad_case_source_location.CopyFrom(attr.value.source_location) |
| # Location of excess comma. |
| bad_case_source_location.start.column = 42 |
| bad_case_source_location.end.column = 42 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| "Empty enum case (or excess comma).", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| # Leading comma |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: ", SHOUTY_CASE, kCamelCase"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| |
| bad_case_source_location.start.column = 30 |
| bad_case_source_location.end.column = 30 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| "Empty enum case (or excess comma).", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| # Excess trailing comma |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "SHOUTY_CASE, kCamelCase,,"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| |
| bad_case_source_location.start.column = 54 |
| bad_case_source_location.end.column = 54 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| "Empty enum case (or excess comma).", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| # Whitespace enum case |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: "SHOUTY_CASE, , kCamelCase"]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| |
| bad_case_source_location.start.column = 45 |
| bad_case_source_location.end.column = 45 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| "Empty enum case (or excess comma).", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| # Empty enum_case string |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: ""]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| |
| bad_case_source_location.start.column = 30 |
| bad_case_source_location.end.column = 30 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| "Empty enum case (or excess comma).", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| # Whitespace enum_case string |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: " "]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| |
| bad_case_source_location.start.column = 35 |
| bad_case_source_location.end.column = 35 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| "Empty enum case (or excess comma).", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| # One-character whitespace enum_case string |
| ir = _make_ir_from_emb( |
| "enum Foo:\n" |
| ' [(cpp) $default enum_case: " "]\n' |
| " BAR = 1\n" |
| " BAZ = 2\n" |
| ) |
| |
| bad_case_source_location.start.column = 31 |
| bad_case_source_location.end.column = 31 |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| bad_case_source_location, |
| "Empty enum case (or excess comma).", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_accepts_namespace(self): |
| for test in [ |
| '[(cpp) namespace: "basic"]\n', |
| '[(cpp) namespace: "multiple::components"]\n', |
| '[(cpp) namespace: "::absolute"]\n', |
| '[(cpp) namespace: "::fully::qualified"]\n', |
| '[(cpp) namespace: "CAN::Be::cAPITAL"]\n', |
| '[(cpp) namespace: "trailingNumbers54321"]\n', |
| '[(cpp) namespace: "containing4321numbers"]\n', |
| '[(cpp) namespace: "can_have_underscores"]\n', |
| '[(cpp) namespace: "_initial_underscore"]\n', |
| '[(cpp) namespace: "_initial::_underscore"]\n', |
| '[(cpp) namespace: "::_initial::_underscore"]\n', |
| '[(cpp) namespace: "trailing_underscore_"]\n', |
| '[(cpp) namespace: "trailing_::underscore_"]\n', |
| '[(cpp) namespace: "::trailing_::underscore_"]\n', |
| '[(cpp) namespace: " spaces "]\n', |
| '[(cpp) namespace: "with :: spaces"]\n', |
| '[(cpp) namespace: " ::fully:: qualified :: with::spaces"]\n', |
| ]: |
| ir = _make_ir_from_emb(test) |
| self.assertEqual([], header_generator.generate_header(ir)[1]) |
| |
| def test_rejects_non_namespace_strings(self): |
| for test in [ |
| '[(cpp) namespace: "5th::avenue"]\n', |
| '[(cpp) namespace: "can\'t::have::apostrophe"]\n', |
| '[(cpp) namespace: "cannot-have-dash"]\n', |
| '[(cpp) namespace: "no/slashes"]\n', |
| '[(cpp) namespace: "no\\\\slashes"]\n', |
| '[(cpp) namespace: "apostrophes*are*rejected"]\n', |
| '[(cpp) namespace: "avoid.dot"]\n', |
| '[(cpp) namespace: "does5+5"]\n', |
| '[(cpp) namespace: "=10"]\n', |
| '[(cpp) namespace: "?"]\n', |
| '[(cpp) namespace: "reject::spaces in::components"]\n', |
| '[(cpp) namespace: "totally::valid::but::extra +"]\n', |
| '[(cpp) namespace: "totally::valid::but::extra ::?"]\n', |
| '[(cpp) namespace: "< totally::valid::but::extra"]\n', |
| '[(cpp) namespace: "< ::totally::valid::but::extra"]\n', |
| '[(cpp) namespace: "::totally::valid::but::extra::"]\n', |
| '[(cpp) namespace: ":::extra::colon"]\n', |
| '[(cpp) namespace: "::extra:::colon"]\n', |
| ]: |
| ir = _make_ir_from_emb(test) |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.value.source_location, |
| "Invalid namespace, must be a valid C++ namespace, such " |
| 'as "abc", "abc::def", or "::abc::def::ghi" (ISO/IEC ' |
| "14882:2017 enclosing-namespace-specifier).", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_rejects_empty_namespace(self): |
| for test in [ |
| '[(cpp) namespace: ""]\n', |
| '[(cpp) namespace: " "]\n', |
| '[(cpp) namespace: " "]\n', |
| ]: |
| ir = _make_ir_from_emb(test) |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.value.source_location, |
| "Empty namespace value is not allowed.", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_rejects_global_namespace(self): |
| for test in [ |
| '[(cpp) namespace: "::"]\n', |
| '[(cpp) namespace: " ::"]\n', |
| '[(cpp) namespace: ":: "]\n', |
| '[(cpp) namespace: " :: "]\n', |
| ]: |
| ir = _make_ir_from_emb(test) |
| attr = ir.module[0].attribute[0] |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.value.source_location, |
| "Global namespace is not allowed.", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| def test_rejects_reserved_namespace(self): |
| for test, expected in [ |
| # Only component |
| ('[(cpp) namespace: "class"]\n', "class"), |
| # Only component, fully qualified name |
| ('[(cpp) namespace: "::const"]\n', "const"), |
| # First component |
| ('[(cpp) namespace: "if::valid"]\n', "if"), |
| # First component, fully qualified name |
| ('[(cpp) namespace: "::auto::pilot"]\n', "auto"), |
| # Last component |
| ('[(cpp) namespace: "make::do"]\n', "do"), |
| # Middle component |
| ('[(cpp) namespace: "our::new::product"]\n', "new"), |
| ]: |
| ir = _make_ir_from_emb(test) |
| attr = ir.module[0].attribute[0] |
| |
| self.assertEqual( |
| [ |
| [ |
| error.error( |
| "m.emb", |
| attr.value.source_location, |
| f'Reserved word "{expected}" is not allowed ' |
| f"as a namespace component.", |
| ) |
| ] |
| ], |
| header_generator.generate_header(ir)[1], |
| ) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
